Changes to build code

diff --git a/Robust/src/IR/ClassDescriptor.java b/Robust/src/IR/ClassDescriptor.java
index e256baffd3a286670695b243e68ae99f70b2e1fe..c3419d60b46e792a2d0131f5e9fd925419729e13 100644 (file)
--- a/Robust/src/IR/ClassDescriptor.java
+++ b/Robust/src/IR/ClassDescriptor.java
@@ -41,6 +41,10 @@ public class ClassDescriptor extends Descriptor {
        return methods;
     }
 
+    public String getSafeDescriptor() {
+       return "L"+safename.replace('.','/');
+    }
+
     public String printTree(State state) {
        int indent;
        String st=modifiers.toString()+"class "+classname;

diff --git a/Robust/src/IR/Flat/BuildCode.java b/Robust/src/IR/Flat/BuildCode.java
index 4b3df19f8241d9705f1e21a5bf50e46c2e05578d..2e922b4bbef51473e906503aa8327fb62ccb4677 100644 (file)
--- a/Robust/src/IR/Flat/BuildCode.java
+++ b/Robust/src/IR/Flat/BuildCode.java
@@ -9,6 +9,8 @@ public class BuildCode {
     Hashtable paramstable;
     Hashtable tempstable;
     int tag=0;
+    String localsprefix="__locals__";
+    String paramsprefix="__params__";
     private static final boolean GENERATEPRECISEGC=true;
 
     public BuildCode(State st, Hashtable temptovar) {
@@ -23,6 +25,7 @@ public class BuildCode {
        PrintWriter outclassdefs=null;
        PrintWriter outstructs=null;
        PrintWriter outmethodheader=null;
+       PrintWriter outmethod=null;
        try {
            OutputStream str=new FileOutputStream("structdefs.h");
            outstructs=new java.io.PrintWriter(str, true);
@@ -30,6 +33,8 @@ public class BuildCode {
            outmethodheader=new java.io.PrintWriter(str, true);
            str=new FileOutputStream("classdefs.h");
            outclassdefs=new java.io.PrintWriter(str, true);
+           str=new FileOutputStream("methods.c");
+           outmethod=new java.io.PrintWriter(str, true);
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(-1);
@@ -42,6 +47,22 @@ public class BuildCode {
        }
        outstructs.close();
        outmethodheader.close();
+
+       /* Build the actual methods */
+       outmethod.println("#include \"methodheaders.h\"");
+       Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();
+       while(classit.hasNext()) {
+           ClassDescriptor cn=(ClassDescriptor)classit.next();
+           generateCallStructs(cn, outclassdefs, outstructs, outmethodheader);
+           Iterator methodit=cn.getMethods();
+           while(methodit.hasNext()) {
+               /* Classify parameters */
+               MethodDescriptor md=(MethodDescriptor)methodit.next();
+               FlatMethod fm=state.getMethodFlat(md);
+               generateFlatMethod(fm,outmethod);
+           }
+       }
+       outmethod.close();
     }
 
     private void generateTempStructs(FlatMethod fm) {
@@ -97,7 +118,7 @@ public class BuildCode {
 
            /* Output parameter structure */
            if (GENERATEPRECISEGC) {
-               output.println("struct "+cn.getSymbol()+md.getSafeSymbol()+"params {");
+               output.println("struct "+cn.getSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params {");
                output.println("  int type;");
                for(int i=0;i<objectparams.numPointers();i++) {
                    TempDescriptor temp=objectparams.getPointer(i);
@@ -109,7 +130,7 @@ public class BuildCode {
 
            /* Output temp structure */
            if (GENERATEPRECISEGC) {
-               output.println("struct "+cn.getSymbol()+md.getSafeSymbol()+"temps {");
+               output.println("struct "+cn.getSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_temps {");
                output.println("  int type;");
                for(int i=0;i<objecttemps.numPointers();i++) {
                    TempDescriptor temp=objecttemps.getPointer(i);
@@ -125,11 +146,11 @@ public class BuildCode {
            /* Output method declaration */
            if (md.getReturnType()!=null)
                headersout.print(md.getReturnType().getSafeSymbol()+" ");
-           headersout.print(cn.getSafeSymbol()+md.getSafeSymbol()+"(");
+           headersout.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(");
            
            boolean printcomma=false;
            if (GENERATEPRECISEGC) {
-               headersout.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"params * base");
+               headersout.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
                printcomma=true;
            }
            for(int i=0;i<objectparams.numPrimitives();i++) {
@@ -145,12 +166,211 @@ public class BuildCode {
 
     private void generateFlatMethod(FlatMethod fm, PrintWriter output) {
        MethodDescriptor md=fm.getMethod();
+       ClassDescriptor cn=md.getClassDesc();
        ParamsObject objectparams=(ParamsObject)paramstable.get(md);
 
        generateHeader(md,output);
        /* Print code */
+       output.println(" {");
        
-       output.println("}");
+       if (GENERATEPRECISEGC) {
+           output.println("   struct "+cn.getSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_temps "+localsprefix+";");
+       }
+       TempObject objecttemp=(TempObject) tempstable.get(md);
+       for(int i=0;i<objecttemp.numPrimitives();i++) {
+           TempDescriptor td=objecttemp.getPrimitive(i);
+           TypeDescriptor type=td.getType();
+           if (type.isClass())
+               output.println("   struct "+type.getSafeSymbol()+" * "+td.getSafeSymbol()+";");
+           else
+               output.println("   "+type.getSafeSymbol()+" "+td.getSafeSymbol()+";");
+       }
+       
+
+       /* Generate labels first */
+       HashSet tovisit=new HashSet();
+       HashSet visited=new HashSet();
+       int labelindex=0;
+       Hashtable nodetolabel=new Hashtable();
+       tovisit.add(fm.methodEntryNode());
+       FlatNode current_node=null;
+
+
+       //Assign labels 1st
+       //Node needs a label if it is
+       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(i>0) {
+                   //1) Edge >1 of node
+                   nodetolabel.put(nn,new Integer(labelindex++));
+               }
+               if (!visited.contains(nn)) {
+                   tovisit.add(nn);
+               } else {
+                   //2) Join point
+                   nodetolabel.put(nn,new Integer(labelindex++));
+               }
+           }
+       }
+
+       //Do the actual code generation
+       tovisit=new HashSet();
+       visited=new HashSet();
+       tovisit.add(fm.methodEntryNode());
+       while(current_node!=null||!tovisit.isEmpty()) {
+           if (current_node==null) {
+               current_node=(FlatNode)tovisit.iterator().next();
+               tovisit.remove(current_node);
+           }
+           visited.add(current_node);
+           if (nodetolabel.containsKey(current_node))
+               output.println("L"+nodetolabel.get(current_node)+":");
+           if (current_node.numNext()==0) {
+               output.print("   ");
+               generateFlatNode(fm, current_node, output);
+               current_node=null;
+           } else if(current_node.numNext()==1) {
+               output.print("   ");
+               generateFlatNode(fm, current_node, output);
+               FlatNode nextnode=current_node.getNext(0);
+               if (visited.contains(nextnode)) {
+                   output.println("goto L"+nodetolabel.get(nextnode));
+                   current_node=null;
+               } else
+                   current_node=nextnode;
+           } else if (current_node.numNext()==2) {
+               /* Branch */
+               output.print("   ");
+               generateFlatCondBranch(fm, (FlatCondBranch)current_node, "L"+nodetolabel.get(current_node.getNext(1)), output);
+               if (!visited.contains(current_node.getNext(1)))
+                   tovisit.add(current_node.getNext(1));
+               if (visited.contains(current_node.getNext(0))) {
+                   output.println("goto L"+nodetolabel.get(current_node.getNext(0)));
+                   current_node=null;
+               } else
+                   current_node=current_node.getNext(0);
+           } else throw new Error();
+       }
+       output.println("}\n\n");
+    }
+
+    private String generateTemp(FlatMethod fm, TempDescriptor td) {
+       MethodDescriptor md=fm.getMethod();
+       TempObject objecttemps=(TempObject) tempstable.get(md);
+       if (objecttemps.isLocalPrim(td)||objecttemps.isParamPrim(td)) {
+           return td.getSafeSymbol();
+       }
+
+       if (objecttemps.isLocalPtr(td)) {
+           return localsprefix+"."+td.getSafeSymbol();
+       }
+
+       if (objecttemps.isParamPtr(td)) {
+           return paramsprefix+"->"+td.getSafeSymbol();
+       }
+       throw new Error();
+    }
+
+    private void generateFlatNode(FlatMethod fm, FlatNode fn, PrintWriter output) {
+       switch(fn.kind()) {
+       case FKind.FlatCall:
+           generateFlatCall(fm, (FlatCall) fn,output);
+           return;
+       case FKind.FlatFieldNode:
+           generateFlatFieldNode(fm, (FlatFieldNode) fn,output);
+           return;
+       case FKind.FlatSetFieldNode:
+           generateFlatSetFieldNode(fm, (FlatSetFieldNode) fn,output);
+           return;
+       case FKind.FlatNew:
+           generateFlatNew(fm, (FlatNew) fn,output);
+           return;
+       case FKind.FlatOpNode:
+           generateFlatOpNode(fm, (FlatOpNode) fn,output);
+           return;
+       case FKind.FlatCastNode:
+           generateFlatCastNode(fm, (FlatCastNode) fn,output);
+           return;
+       case FKind.FlatLiteralNode:
+           generateFlatLiteralNode(fm, (FlatLiteralNode) fn,output);
+           return;
+       case FKind.FlatReturnNode:
+           generateFlatReturnNode(fm, (FlatReturnNode) fn,output);
+           return;
+       case FKind.FlatNop:
+           output.println("/* nop */");
+           return;
+       }
+       throw new Error();
+
+    }
+
+    private void generateFlatCall(FlatMethod fm, FlatCall fc, PrintWriter output) {
+       MethodDescriptor md=fm.getMethod();
+       ClassDescriptor cn=md.getClassDesc();
+       output.println("   {");
+       boolean needcomma=false;
+       if (GENERATEPRECISEGC) {
+           output.print("       struct "+cn.getSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __paramlist__={");
+           if (fc.getThis()!=null) {
+               output.print(generateTemp(fm,fc.getThis()));
+               needcomma=true;
+           }
+           output.println("};");
+       }
+       output.print("       ");
+
+       /* TODO: Virtual dispatch */
+       if (fc.getReturnType()!=null)
+           output.print(generateTemp(fm,fc.getReturnType())+"=");
+       output.print(cn.getSafeSymbol()+md.getSafeSymbol()++"_"+md.getSafeMethodDescriptor()+"(");
+       needcomma=false;
+       if (GENERATEPRECISEGC) {
+           output.println("__parameterlist__");
+           needcomma=true;
+       }
+       output.println(");");
+       output.println("   }");
+    }
+
+    private void generateFlatFieldNode(FlatMethod fm, FlatFieldNode ffn, PrintWriter output) {
+       output.println(generateTemp(fm, ffn.getDst())+"="+ generateTemp(fm,ffn.getSrc())+"->"+ ffn.getField().getSafeSymbol()+";");
+    }
+
+    private void generateFlatSetFieldNode(FlatMethod fm, FlatSetFieldNode fsfn, PrintWriter output) {
+       output.println(generateTemp(fm, fsfn.getDst())+"->"+ fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc())+";");
+    }
+
+    private void generateFlatNew(FlatMethod fm, FlatNew fn, PrintWriter output) {
+    }
+
+    private void generateFlatOpNode(FlatMethod fm, FlatOpNode fon, PrintWriter output) {
+       if (fon.getOp().getOp()==Operation.ASSIGN)
+           output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+";");
+       else if (fon.getRight()!=null)
+           output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+fon.getOp().toString()+generateTemp(fm,fon.getRight())+";");
+       else
+           output.println(generateTemp(fm, fon.getDest())+fon.getOp().toString()+generateTemp(fm, fon.getLeft())+";");
+    }
+
+    private void generateFlatCastNode(FlatMethod fm, FlatCastNode fcn, PrintWriter output) {
+       /* TODO: Make call into runtime */
+       output.println(fcn.getDst()+"=("+fcn.getType().getSafeSymbol()+")"+fcn.getSrc()+";");
+    }
+
+    private void generateFlatLiteralNode(FlatMethod fm, FlatLiteralNode fln, PrintWriter output) {
+    }
+
+    private void generateFlatReturnNode(FlatMethod fm, FlatReturnNode frn, PrintWriter output) {
+       output.println("return "+generateTemp(fm, frn.getReturnTemp())+";");
+    }
+
+    private void generateFlatCondBranch(FlatMethod fm, FlatCondBranch fcb, String label, PrintWriter output) {
+       output.println("if (!"+generateTemp(fm, fcb.getTest())+") goto "+label+";");
     }
 
     private void generateHeader(MethodDescriptor md, PrintWriter output) {
@@ -160,11 +380,11 @@ public class BuildCode {
        
        if (md.getReturnType()!=null)
            output.print(md.getReturnType().getSafeSymbol()+" ");
-       output.print(cn.getSafeSymbol()+md.getSafeSymbol()+"(");
+       output.print(cn.getSafeSymbol()+md.getSafeSymbol()++"_"+md.getSafeMethodDescriptor()+"(");
        
        boolean printcomma=false;
        if (GENERATEPRECISEGC) {
-           output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"params * base");
+           output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
            printcomma=true;
        }
        for(int i=0;i<objectparams.numPrimitives();i++) {
@@ -174,6 +394,6 @@ public class BuildCode {
            printcomma=true;
            output.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
        }
-       output.println(") {");
+       output.print(")");
     }
 }

diff --git a/Robust/src/IR/Flat/FlatCall.java b/Robust/src/IR/Flat/FlatCall.java
index d11d79d8f6ef3582efe67400bc76dba66b01fa29..99b36cf968e71b406c462bb00aee9ed9f01f84a1 100644 (file)
--- a/Robust/src/IR/Flat/FlatCall.java
+++ b/Robust/src/IR/Flat/FlatCall.java
@@ -14,6 +14,18 @@ public class FlatCall extends FlatNode {
        this.args=args;
     }
 
+    public MethodDescriptor getMethod() {
+       return method;
+    }
+
+    public TempDescriptor getThis() {
+       return this_temp;
+    }
+
+    public TempDescriptor getReturnTemp() {
+       return dst;
+    }
+
     public String toString() {
        String st="";
        if (dst==null)

diff --git a/Robust/src/IR/Flat/FlatCastNode.java b/Robust/src/IR/Flat/FlatCastNode.java
index d8d80b5fe272f825452ec012648cfda491be52da..f7b61f7c720a502ba2e909fde898edc475d0e8b9 100644 (file)
--- a/Robust/src/IR/Flat/FlatCastNode.java
+++ b/Robust/src/IR/Flat/FlatCastNode.java
@@ -20,6 +20,18 @@ public class FlatCastNode extends FlatNode {
        return FKind.FlatCastNode;
     }
 
+    public TypeDescriptor getType() {
+       return type;
+    }
+
+    public TempDescriptor getSrc() {
+       return src;
+    }
+
+    public TempDescriptor getDst() {
+       return dst;
+    }
+
     public TempDescriptor [] writesTemps() {
        return new TempDescriptor[] {dst};
     }

diff --git a/Robust/src/IR/Flat/FlatCondBranch.java b/Robust/src/IR/Flat/FlatCondBranch.java
index f6a885bf1b3995f4554e1b92e222402c2403b8ed..7531acb2cf7db4eae8ebb3d19989fe5358fa750c 100644 (file)
--- a/Robust/src/IR/Flat/FlatCondBranch.java
+++ b/Robust/src/IR/Flat/FlatCondBranch.java
@@ -21,6 +21,10 @@ public class FlatCondBranch extends FlatNode {
        n.addPrev(this);
     }
 
+    public TempDescriptor getTest() {
+       return test_cond;
+    }
+
     public String toString() {
        return "conditional branch";
     }

diff --git a/Robust/src/IR/Flat/FlatFieldNode.java b/Robust/src/IR/Flat/FlatFieldNode.java
index 48054b37ad44defd15ae4e21e920323016123cb7..8f1cf14a13e24e8578afad22f06bef6c75abef22 100644 (file)
--- a/Robust/src/IR/Flat/FlatFieldNode.java
+++ b/Robust/src/IR/Flat/FlatFieldNode.java
@@ -16,6 +16,14 @@ public class FlatFieldNode extends FlatNode {
        return field;
     }
 
+    public TempDescriptor getSrc() {
+       return src;
+    }
+
+    public TempDescriptor getDst() {
+       return dst;
+    }
+
     public String toString() {
        return dst.toString()+"="+src.toString()+"."+field.getSymbol();
     }

diff --git a/Robust/src/IR/Flat/FlatMethod.java b/Robust/src/IR/Flat/FlatMethod.java
index 40550ad78d0ff9080bc0d1ed1dd6cb34b45c6d72..4f8916da3b226bdedb9f79db8c4105595e5cfbaf 100644 (file)
--- a/Robust/src/IR/Flat/FlatMethod.java
+++ b/Robust/src/IR/Flat/FlatMethod.java
@@ -33,6 +33,10 @@ public class FlatMethod extends FlatNode {
        return (TempDescriptor) parameterTemps.get(i);
     }
 
+    public FlatNode methodEntryNode() {
+       return method_entry;
+    }
+
 
     public Set getNodeSet() {
        HashSet tovisit=new HashSet();

diff --git a/Robust/src/IR/Flat/FlatReturnNode.java b/Robust/src/IR/Flat/FlatReturnNode.java
index 313bf84ca2db4e952753b7867504fe4a244d7cd3..ec323f045f6a5ea43a59289dbaa6512663b0113c 100644 (file)
--- a/Robust/src/IR/Flat/FlatReturnNode.java
+++ b/Robust/src/IR/Flat/FlatReturnNode.java
@@ -10,13 +10,19 @@ public class FlatReturnNode extends FlatNode {
     public String toString() {
        return "return "+tempdesc;
     }
+
     public int kind() {
        return FKind.FlatReturnNode;
     }
+
     public TempDescriptor [] readsTemps() {
        if (tempdesc==null)
            return new TempDescriptor [0];
        else
            return new TempDescriptor [] {tempdesc};
     }
+
+    public TempDescriptor getReturnTemp() {
+       return tempdesc;
+    }
 }

diff --git a/Robust/src/IR/Flat/FlatSetFieldNode.java b/Robust/src/IR/Flat/FlatSetFieldNode.java
index 396627ac536b087e82d06969996433a8c32e076f..b1742479e233fea86bc8a05268ee6e25363d72ca 100644 (file)
--- a/Robust/src/IR/Flat/FlatSetFieldNode.java
+++ b/Robust/src/IR/Flat/FlatSetFieldNode.java
@@ -12,6 +12,14 @@ public class FlatSetFieldNode extends FlatNode {
        this.dst=dst;
     }
 
+    public TempDescriptor getSrc() {
+       return src;
+    }
+
+    public TempDescriptor getDst() {
+       return dst;
+    }
+
     public FieldDescriptor getField() {
        return field;
     }

diff --git a/Robust/src/IR/Flat/ParamsObject.java b/Robust/src/IR/Flat/ParamsObject.java
index 26e72966379ff803de184da010d38324cfd51d00..9e546fd521d20f38be8ba5fc16d70f5fd7117798 100644 (file)
--- a/Robust/src/IR/Flat/ParamsObject.java
+++ b/Robust/src/IR/Flat/ParamsObject.java
@@ -8,7 +8,7 @@ public class ParamsObject {
     private MethodDescriptor method;
     private int tag;
     private Hashtable paramtotemp;
-    private Hashtable temptostore;
+    protected Hashtable temptostore;
     private int count;
 
     public ParamsObject(MethodDescriptor md, int tag) {

diff --git a/Robust/src/IR/Flat/TempObject.java b/Robust/src/IR/Flat/TempObject.java
index 1c3cbddbfa6ed3e0aac60e7d8a0f97650e83646d..583c9ed4632f9079990cc8216d21de2a7caa1afc 100644 (file)
--- a/Robust/src/IR/Flat/TempObject.java
+++ b/Robust/src/IR/Flat/TempObject.java
@@ -12,7 +12,6 @@ public class TempObject {
     private Hashtable temptostore;
     private int count;
 
-
     public TempObject(ParamsObject p, MethodDescriptor md, int tag) {
        params=p;
        pointerparams=new Vector();
@@ -42,6 +41,38 @@ public class TempObject {
        }
     }
 
+    public boolean isLocalPtr(TempDescriptor t) {
+       if (!params.containsTemp(t)) {
+           Position p=(Position)temptostore.get(t);
+           return p.inStruct;
+       }
+       return false;
+    }
+
+    public boolean isLocalPrim(TempDescriptor t) {
+       if (!params.containsTemp(t)) {
+           Position p=(Position)temptostore.get(t);
+           return !p.inStruct;
+       }
+       return false;
+    }
+
+    public boolean isParamPtr(TempDescriptor t) {
+       if (params.containsTemp(t)) {
+           ParamsObject.Position p=(ParamsObject.Position)params.temptostore.get(t);
+           return p.inStruct;
+       }
+       return false;
+    }
+
+    public boolean isParamPrim(TempDescriptor t) {
+       if (params.containsTemp(t)) {
+           ParamsObject.Position p=(ParamsObject.Position)params.temptostore.get(t);
+           return !p.inStruct;
+       }
+       return false;
+    }
+
     int numPointers() {
        return pointerparams.size();
     }
@@ -49,12 +80,15 @@ public class TempObject {
     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;

diff --git a/Robust/src/IR/MethodDescriptor.java b/Robust/src/IR/MethodDescriptor.java
index acf3c5d8419fd8b796bb632e9433ae6a31943f45..88fa989d874a89289cec45d3341dad6edd5a272d 100644 (file)
--- a/Robust/src/IR/MethodDescriptor.java
+++ b/Robust/src/IR/MethodDescriptor.java
@@ -53,6 +53,16 @@ public class MethodDescriptor extends Descriptor {
        return thisvd;
     }
 
+    public String getSafeMethodDescriptor() {
+       String st="";
+       for(int i=0;i<numParameters();i++) {
+           st+=getParamType(i).getSafeDescriptor();
+           if ((i+1)<numParameters())
+               st+="_";
+       }
+       return st;
+    }
+
     public boolean isStatic() {
        return modifier.isStatic();
     }

diff --git a/Robust/src/IR/TypeDescriptor.java b/Robust/src/IR/TypeDescriptor.java
index 71978369bb9285cf98254ba3919113b104df0958..c1bbc74c8f2427885587aaa171011f849a045d0c 100644 (file)
--- a/Robust/src/IR/TypeDescriptor.java
+++ b/Robust/src/IR/TypeDescriptor.java
@@ -35,6 +35,8 @@ public class TypeDescriptor extends Descriptor {
            return "short";
        else if (isInt())
            return "int";
+       else if (isBoolean()) //Booleans are ints in C
+           return "int";
        else if (isLong())
            return "long long";
        else if (isVoid())
@@ -46,6 +48,28 @@ public class TypeDescriptor extends Descriptor {
        else throw new Error();
     }
 
+    public String getSafeDescriptor() {
+       if (isClass())
+           return class_desc.getSafeDescriptor();
+       else if (isByte())
+           return "C";
+       else if (isChar())
+           return "C";
+       else if (isShort())
+           return "S";
+       else if (isBoolean())
+           return "Z";
+       else if (isInt())
+           return "I";
+       else if (isLong())
+           return "J";
+       else if (isDouble())
+           return "D";
+       else if (isFloat())
+           return "F";
+       else throw new Error(); 
+    }
+
     public boolean isNumber() {
        return (isIntegerType()||isFloat()||isDouble());
     }