more code

diff --git a/Robust/src/IR/Flat/BuildCode.java b/Robust/src/IR/Flat/BuildCode.java
index 996eb55d81d07ef867e278c43837979385818258..4b3df19f8241d9705f1e21a5bf50e46c2e05578d 100644 (file)
--- 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 fc444128d53b5e8db459fddf43700031e9f93117..40550ad78d0ff9080bc0d1ed1dd6cb34b45c6d72 100644 (file)
--- 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 (file)
index 0000000..26e7296
--- /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 22daa68850c434f767e323277ee27f8ad71f7b89..a287cf4be697e99110e5875a7f34b92902dead99 100644 (file)
--- 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 (file)
index 0000000..1c3cbdd
--- /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 31f5b4fa5adfe9d3a98c7be6e41461a535a094a5..b383430c248cc3149d95792287e2cc4c65a1bbdb 100644 (file)
--- 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 fe757fe0ba63c05d50bfd6cedfde0a41fe5d63ff..48cb38bb1cc621445b6ff0eae18bcadfb9fb4e9e 100644 (file)
--- 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 493ea9c26046baa0c27dc9b721667632140f71a8..71978369bb9285cf98254ba3919113b104df0958 100644 (file)
--- 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 e49e21122c2d3ce0d0ca5270de210136969e046e..874d31384135367f8c0a77bdc651b31e073c9d29 100644 (file)
--- 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());
   }