From: bdemsky <bdemsky>
Date: Mon, 13 Mar 2006 18:54:22 +0000 (+0000)
Subject: more code
X-Git-Tag: preEdgeChange~956
X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=5aa8ae8815bcc36a81f4abdd601895749a313870;p=IRC.git

more code
---

diff --git a/Robust/src/IR/Flat/BuildCode.java b/Robust/src/IR/Flat/BuildCode.java
index 996eb55d..4b3df19f 100644
--- a/Robust/src/IR/Flat/BuildCode.java
+++ b/Robust/src/IR/Flat/BuildCode.java
@@ -1,29 +1,179 @@
 package IR.Flat;
 import IR.*;
 import java.util.*;
+import java.io.*;
 
 public class BuildCode {
     State state;
     Hashtable temptovar;
+    Hashtable paramstable;
+    Hashtable tempstable;
+    int tag=0;
+    private static final boolean GENERATEPRECISEGC=true;
 
     public BuildCode(State st, Hashtable temptovar) {
 	state=st;
 	this.temptovar=temptovar;
+	paramstable=new Hashtable();	
+	tempstable=new Hashtable();
     }
-    
+
     public void buildCode() {
 	Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
+	PrintWriter outclassdefs=null;
+	PrintWriter outstructs=null;
+	PrintWriter outmethodheader=null;
+	try {
+	    OutputStream str=new FileOutputStream("structdefs.h");
+	    outstructs=new java.io.PrintWriter(str, true);
+	    str=new FileOutputStream("methodheaders.h");
+	    outmethodheader=new java.io.PrintWriter(str, true);
+	    str=new FileOutputStream("classdefs.h");
+	    outclassdefs=new java.io.PrintWriter(str, true);
+	} catch (Exception e) {
+	    e.printStackTrace();
+	    System.exit(-1);
+	}
+	outstructs.println("#include \"classdefs.h\"");
+	outmethodheader.println("#include \"structdefs.h\"");
 	while(it.hasNext()) {
 	    ClassDescriptor cn=(ClassDescriptor)it.next();
-	    generateCallStructs(cn);
+	    generateCallStructs(cn, outclassdefs, outstructs, outmethodheader);
+	}
+	outstructs.close();
+	outmethodheader.close();
+    }
+
+    private void generateTempStructs(FlatMethod fm) {
+	MethodDescriptor md=fm.getMethod();
+	ParamsObject objectparams=new ParamsObject(md,tag++);
+	paramstable.put(md, objectparams);
+	for(int i=0;i<fm.numParameters();i++) {
+	    TempDescriptor temp=fm.getParameter(i);
+	    TypeDescriptor type=temp.getType();
+	    if (type.isPtr()&&GENERATEPRECISEGC)
+		objectparams.addPtr(temp);
+	    else
+		objectparams.addPrim(temp);
+	}
+
+	TempObject objecttemps=new TempObject(objectparams,md,tag++);
+	tempstable.put(md, objecttemps);
+	for(Iterator nodeit=fm.getNodeSet().iterator();nodeit.hasNext();) {
+	    FlatNode fn=(FlatNode)nodeit.next();
+	    TempDescriptor[] writes=fn.writesTemps();
+	    for(int i=0;i<writes.length;i++) {
+		TempDescriptor temp=writes[i];
+		TypeDescriptor type=temp.getType();
+		if (type.isPtr()&&GENERATEPRECISEGC)
+		    objecttemps.addPtr(temp);
+		else
+		    objecttemps.addPrim(temp);		
+	    }
 	}
     }
 
-    private void generateCallStructs(ClassDescriptor cn) {
+    private void generateCallStructs(ClassDescriptor cn, PrintWriter classdefout, PrintWriter output, PrintWriter headersout) {
+	/* Output class structure */
+	Iterator fieldit=cn.getFields();
+	classdefout.println("struct "+cn.getSafeSymbol()+" {");
+	classdefout.println("  int type;");
+	while(fieldit.hasNext()) {
+	    FieldDescriptor fd=(FieldDescriptor)fieldit.next();
+	    classdefout.println("  "+fd.getType().getSafeSymbol()+" "+fd.getSafeSymbol()+";");
+	}
+	classdefout.println("};\n");
+
+	/* Cycle through methods */
 	Iterator methodit=cn.getMethods();
 	while(methodit.hasNext()) {
+	    /* Classify parameters */
 	    MethodDescriptor md=(MethodDescriptor)methodit.next();
+	    FlatMethod fm=state.getMethodFlat(md);
+	    generateTempStructs(fm);
+
+	    ParamsObject objectparams=(ParamsObject) paramstable.get(md);
+	    TempObject objecttemps=(TempObject) tempstable.get(md);
+
+	    /* Output parameter structure */
+	    if (GENERATEPRECISEGC) {
+		output.println("struct "+cn.getSymbol()+md.getSafeSymbol()+"params {");
+		output.println("  int type;");
+		for(int i=0;i<objectparams.numPointers();i++) {
+		    TempDescriptor temp=objectparams.getPointer(i);
+		    output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSymbol()+";");
+		}
+		output.println("  void * next;");
+		output.println("};\n");
+	    }
+
+	    /* Output temp structure */
+	    if (GENERATEPRECISEGC) {
+		output.println("struct "+cn.getSymbol()+md.getSafeSymbol()+"temps {");
+		output.println("  int type;");
+		for(int i=0;i<objecttemps.numPointers();i++) {
+		    TempDescriptor temp=objecttemps.getPointer(i);
+		    if (temp.getType().isNull())
+			output.println("  void * "+temp.getSymbol()+";");
+		    else 
+			output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSymbol()+";");
+		}
+		output.println("  void * next;");
+		output.println("};\n");
+	    }
+	    
+	    /* Output method declaration */
+	    if (md.getReturnType()!=null)
+		headersout.print(md.getReturnType().getSafeSymbol()+" ");
+	    headersout.print(cn.getSafeSymbol()+md.getSafeSymbol()+"(");
 	    
+	    boolean printcomma=false;
+	    if (GENERATEPRECISEGC) {
+		headersout.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"params * base");
+		printcomma=true;
+	    }
+	    for(int i=0;i<objectparams.numPrimitives();i++) {
+		TempDescriptor temp=objectparams.getPrimitive(i);
+		if (printcomma)
+		    headersout.print(", ");
+		printcomma=true;
+		headersout.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
+	    }
+	    headersout.println(");\n");
+   	}
+    }
+
+    private void generateFlatMethod(FlatMethod fm, PrintWriter output) {
+	MethodDescriptor md=fm.getMethod();
+	ParamsObject objectparams=(ParamsObject)paramstable.get(md);
+
+	generateHeader(md,output);
+	/* Print code */
+	
+	output.println("}");
+    }
+
+    private void generateHeader(MethodDescriptor md, PrintWriter output) {
+	/* Print header */
+	ParamsObject objectparams=(ParamsObject)paramstable.get(md);
+	ClassDescriptor cn=md.getClassDesc();
+	
+	if (md.getReturnType()!=null)
+	    output.print(md.getReturnType().getSafeSymbol()+" ");
+	output.print(cn.getSafeSymbol()+md.getSafeSymbol()+"(");
+	
+	boolean printcomma=false;
+	if (GENERATEPRECISEGC) {
+	    output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"params * base");
+	    printcomma=true;
+	}
+	for(int i=0;i<objectparams.numPrimitives();i++) {
+	    TempDescriptor temp=objectparams.getPrimitive(i);
+	    if (printcomma)
+		output.print(", ");
+	    printcomma=true;
+	    output.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
 	}
+	output.println(") {");
     }
 }
diff --git a/Robust/src/IR/Flat/FlatMethod.java b/Robust/src/IR/Flat/FlatMethod.java
index fc444128..40550ad7 100644
--- a/Robust/src/IR/Flat/FlatMethod.java
+++ b/Robust/src/IR/Flat/FlatMethod.java
@@ -16,11 +16,41 @@ public class FlatMethod extends FlatNode {
     public String toString() {
 	return method.toString();
     }
+
+    public MethodDescriptor getMethod() {
+	return method;
+    }
     
     public void addParameterTemp(TempDescriptor t) {
 	parameterTemps.add(t);
     }
 
+    public int numParameters() {
+	return parameterTemps.size();
+    }
+
+    public TempDescriptor getParameter(int i) {
+	return (TempDescriptor) parameterTemps.get(i);
+    }
+
+
+    public Set getNodeSet() {
+	HashSet tovisit=new HashSet();
+	HashSet visited=new HashSet();
+	tovisit.add(method_entry);
+	while(!tovisit.isEmpty()) {
+	    FlatNode fn=(FlatNode)tovisit.iterator().next();
+	    tovisit.remove(fn);
+	    visited.add(fn);
+	    for(int i=0;i<fn.numNext();i++) {
+		FlatNode nn=fn.getNext(i);
+		if (!visited.contains(nn))
+		    tovisit.add(nn);
+	    }
+	}
+	return visited;
+    }
+    
     public String printMethod() {
 	String st=method+" {\n";
 	HashSet tovisit=new HashSet();
diff --git a/Robust/src/IR/Flat/ParamsObject.java b/Robust/src/IR/Flat/ParamsObject.java
new file mode 100644
index 00000000..26e72966
--- /dev/null
+++ b/Robust/src/IR/Flat/ParamsObject.java
@@ -0,0 +1,64 @@
+package IR.Flat;
+import IR.*;
+import java.util.*;
+
+public class ParamsObject {
+    private Vector pointerparams;
+    private Vector primitiveparams;
+    private MethodDescriptor method;
+    private int tag;
+    private Hashtable paramtotemp;
+    private Hashtable temptostore;
+    private int count;
+
+    public ParamsObject(MethodDescriptor md, int tag) {
+	pointerparams=new Vector();
+	primitiveparams=new Vector();
+	paramtotemp=new Hashtable();
+	temptostore=new Hashtable();
+	this.method=md;
+	this.tag=tag;
+	count=0;
+    }
+
+    public void addPtr(TempDescriptor t) {
+	Position p=new Position(true, pointerparams.size());
+	pointerparams.add(t);
+	paramtotemp.put(new Integer(count++), t);
+	temptostore.put(t,p);
+    }
+
+    public boolean containsTemp(TempDescriptor t) {
+	return temptostore.containsKey(t);
+    }
+
+    public void addPrim(TempDescriptor t) {
+	Position p=new Position(false, primitiveparams.size());
+	primitiveparams.add(t);
+	paramtotemp.put(new Integer(count++), t);
+	temptostore.put(t,p);
+    }
+
+    int numPointers() {
+	return pointerparams.size();
+    }
+
+    TempDescriptor getPointer(int i) {
+	return (TempDescriptor) pointerparams.get(i);
+    }
+    int numPrimitives() {
+	return primitiveparams.size();
+    }
+
+    TempDescriptor getPrimitive(int i) {
+	return (TempDescriptor) primitiveparams.get(i);
+    }
+    static class Position {
+	boolean inStruct;
+	int position;
+	Position(boolean inStruct, int position) {
+	    this.inStruct=inStruct;
+	    this.position=position;
+	}
+    }
+}
diff --git a/Robust/src/IR/Flat/TempDescriptor.java b/Robust/src/IR/Flat/TempDescriptor.java
index 22daa688..a287cf4b 100644
--- a/Robust/src/IR/Flat/TempDescriptor.java
+++ b/Robust/src/IR/Flat/TempDescriptor.java
@@ -1,14 +1,14 @@
 package IR.Flat;
 import IR.*;
 
-public class TempDescriptor {
+public class TempDescriptor extends Descriptor {
     static int currentid=0;
     int id;
-    String safename;
+    //    String safename;
     TypeDescriptor type;
 
     public TempDescriptor(String name) {
-	safename="__"+name+"__";
+	super(name);
 	id=currentid++;
     }
 
diff --git a/Robust/src/IR/Flat/TempObject.java b/Robust/src/IR/Flat/TempObject.java
new file mode 100644
index 00000000..1c3cbddb
--- /dev/null
+++ b/Robust/src/IR/Flat/TempObject.java
@@ -0,0 +1,66 @@
+package IR.Flat;
+import IR.*;
+import java.util.*;
+
+public class TempObject {
+    ParamsObject params;
+    private Vector pointerparams;
+    private Vector primitiveparams;
+    private MethodDescriptor method;
+    private int tag;
+    private Hashtable paramtotemp;
+    private Hashtable temptostore;
+    private int count;
+
+
+    public TempObject(ParamsObject p, MethodDescriptor md, int tag) {
+	params=p;
+	pointerparams=new Vector();
+	primitiveparams=new Vector();
+	paramtotemp=new Hashtable();
+	temptostore=new Hashtable();
+	this.method=md;
+	this.tag=tag;
+	count=0;
+    }
+
+    public void addPtr(TempDescriptor t) {
+	if (!params.containsTemp(t)) {
+	    Position p=new Position(true, pointerparams.size());
+	    pointerparams.add(t);
+	    paramtotemp.put(new Integer(count++), t);
+	    temptostore.put(t,p);
+	}
+    }
+
+    public void addPrim(TempDescriptor t) {
+	if (!params.containsTemp(t)) {
+	    Position p=new Position(false, primitiveparams.size());
+	    primitiveparams.add(t);
+	    paramtotemp.put(new Integer(count++), t);
+	    temptostore.put(t,p);
+	}
+    }
+
+    int numPointers() {
+	return pointerparams.size();
+    }
+
+    TempDescriptor getPointer(int i) {
+	return (TempDescriptor) pointerparams.get(i);
+    }
+    int numPrimitives() {
+	return primitiveparams.size();
+    }
+    TempDescriptor getPrimitive(int i) {
+	return (TempDescriptor) primitiveparams.get(i);
+    }
+    static class Position {
+	boolean inStruct;
+	int position;
+	Position(boolean inStruct, int position) {
+	    this.inStruct=inStruct;
+	    this.position=position;
+	}
+    }
+}
diff --git a/Robust/src/IR/Tree/AssignmentNode.java b/Robust/src/IR/Tree/AssignmentNode.java
index 31f5b4fa..b383430c 100644
--- a/Robust/src/IR/Tree/AssignmentNode.java
+++ b/Robust/src/IR/Tree/AssignmentNode.java
@@ -1,5 +1,6 @@
 package IR.Tree;
 import IR.AssignOperation;
+import IR.TypeDescriptor;
 
 public class AssignmentNode extends ExpressionNode {
     ExpressionNode left;
@@ -28,6 +29,10 @@ public class AssignmentNode extends ExpressionNode {
 	return left.printNode(indent)+" "+op.toString()+" "+right.printNode(indent);
     }
 
+    public TypeDescriptor getType() {
+	return left.getType();
+    }
+
     public int kind() {
 	return Kind.AssignmentNode;
     }
diff --git a/Robust/src/IR/Tree/MethodInvokeNode.java b/Robust/src/IR/Tree/MethodInvokeNode.java
index fe757fe0..48cb38bb 100644
--- a/Robust/src/IR/Tree/MethodInvokeNode.java
+++ b/Robust/src/IR/Tree/MethodInvokeNode.java
@@ -2,6 +2,7 @@ package IR.Tree;
 import java.util.Vector;
 import IR.NameDescriptor;
 import IR.MethodDescriptor;
+import IR.TypeDescriptor;
 
 public class MethodInvokeNode extends ExpressionNode {
     Vector argumentlist;
@@ -40,6 +41,10 @@ public class MethodInvokeNode extends ExpressionNode {
 	return en;
     }
 
+    public TypeDescriptor getType() {
+	return md.getReturnType();
+    }
+
     public void setExpression(ExpressionNode en) {
 	this.en=en;
     }
diff --git a/Robust/src/IR/TypeDescriptor.java b/Robust/src/IR/TypeDescriptor.java
index 493ea9c2..71978369 100644
--- a/Robust/src/IR/TypeDescriptor.java
+++ b/Robust/src/IR/TypeDescriptor.java
@@ -24,6 +24,28 @@ public class TypeDescriptor extends Descriptor {
     int type;
     ClassDescriptor class_desc;
 
+    public String getSafeSymbol() {
+	if (isClass())
+	    return class_desc.getSafeSymbol();
+	else if (isByte())
+	    return "char";
+	else if (isChar())
+	    return "short";
+	else if (isShort())
+	    return "short";
+	else if (isInt())
+	    return "int";
+	else if (isLong())
+	    return "long long";
+	else if (isVoid())
+	    return "void";
+	else if (isDouble())
+	    return "double";
+	else if (isFloat())
+	    return "float";
+	else throw new Error();
+    }
+
     public boolean isNumber() {
 	return (isIntegerType()||isFloat()||isDouble());
     }
diff --git a/Robust/src/Main/Main.java b/Robust/src/Main/Main.java
index e49e2112..874d3138 100644
--- a/Robust/src/Main/Main.java
+++ b/Robust/src/Main/Main.java
@@ -36,7 +36,7 @@ public class Main {
     bf.buildFlat();
 
     BuildCode bc=new BuildCode(state, bf.getMap());
-    
+    bc.buildCode();
 
     System.exit(l.numErrors());
   }