X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=Robust%2Fsrc%2FIR%2FFlat%2FBuildCode.java;h=e636a025e60d0dbbca1c8d7a0ecb489732eda8c6;hb=31d75680e8e88360b032ba965e4e64c886071cc4;hp=be5f1ca4679d1153caba54158ebfaeab38812b9c;hpb=f385d42656169b5b1be21a8d608140b96de1fb89;p=IRC.git

diff --git a/Robust/src/IR/Flat/BuildCode.java b/Robust/src/IR/Flat/BuildCode.java
index be5f1ca4..e636a025 100644
--- a/Robust/src/IR/Flat/BuildCode.java
+++ b/Robust/src/IR/Flat/BuildCode.java
@@ -37,22 +37,26 @@ public class BuildCode {
     TypeDescriptor[] arraytable;
     LocalityAnalysis locality;
     Hashtable<TempDescriptor, TempDescriptor> backuptable;
+    Hashtable<LocalityBinding, TempDescriptor> reverttable;
 
     public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil) {
+	this(st, temptovar, typeutil, null);
+    }
+
+    public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, LocalityAnalysis locality) {
 	state=st;
 	this.temptovar=temptovar;
-	paramstable=new Hashtable();	
+	paramstable=new Hashtable();
 	tempstable=new Hashtable();
 	fieldorder=new Hashtable();
 	flagorder=new Hashtable();
 	this.typeutil=typeutil;
-	virtualcalls=new Virtual(state);
-    }
-
-    public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, LocalityAnalysis locality) {
-	this(st, temptovar, typeutil);
-	this.locality=locality;
-	this.backuptable=new Hashtable<TempDescriptor, TempDescriptor>();
+	virtualcalls=new Virtual(state,locality);
+	if (locality!=null) {
+	    this.locality=locality;
+	    this.backuptable=new Hashtable<TempDescriptor, TempDescriptor>();
+	    this.reverttable=new Hashtable<LocalityBinding, TempDescriptor>();
+	}
     }
 
     /** The buildCode method outputs C code for all the methods.  The Flat
@@ -101,6 +105,8 @@ public class BuildCode {
 	outmethodheader.println("#ifndef METHODHEADERS_H");
 	outmethodheader.println("#define METHODHEADERS_H");
 	outmethodheader.println("#include \"structdefs.h\"");
+	if (state.DSM)
+	    outmethodheader.println("#include \"dstm.h\"");
 
 	/* Output Structures */
 	outputStructs(outstructs);
@@ -174,22 +180,37 @@ public class BuildCode {
     private void outputMainMethod(PrintWriter outmethod) {
 	outmethod.println("int main(int argc, const char *argv[]) {");
 	outmethod.println("  int i;");
-	if (GENERATEPRECISEGC) {
-	    outmethod.println("  struct ArrayObject * stringarray=allocate_newarray(NULL, STRINGARRAYTYPE, argc-1);");
+	if (state.DSM) {
+	    outmethod.println("if (dstmStartup(argv[1])) {");
+	    if (GENERATEPRECISEGC) {
+		outmethod.println("  struct ArrayObject * stringarray=allocate_newarray(NULL, STRINGARRAYTYPE, argc-2);");
+	    } else {
+		outmethod.println("  struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc-2);");
+	    }
 	} else {
-	    outmethod.println("  struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc-1);");
+	    if (GENERATEPRECISEGC) {
+		outmethod.println("  struct ArrayObject * stringarray=allocate_newarray(NULL, STRINGARRAYTYPE, argc-1);");
+	    } else {
+		outmethod.println("  struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc-1);");
+	    }
 	}
 	if (state.THREAD) {
 	    outmethod.println("initializethreads();");
 	}
-	outmethod.println("  for(i=1;i<argc;i++) {");
+	if (state.DSM) {
+	    outmethod.println("  for(i=2;i<argc;i++) {");
+	} else 
+	    outmethod.println("  for(i=1;i<argc;i++) {");
 	outmethod.println("    int length=strlen(argv[i]);");
 	if (GENERATEPRECISEGC) {
 	    outmethod.println("    struct ___String___ *newstring=NewString(NULL, argv[i], length);");
 	} else {
 	    outmethod.println("    struct ___String___ *newstring=NewString(argv[i], length);");
 	}
-	outmethod.println("    ((void **)(((char *)& stringarray->___length___)+sizeof(int)))[i-1]=newstring;");
+	if (state.DSM)
+	    outmethod.println("    ((void **)(((char *)& stringarray->___length___)+sizeof(int)))[i-2]=newstring;");
+	else
+	    outmethod.println("    ((void **)(((char *)& stringarray->___length___)+sizeof(int)))[i-1]=newstring;");
 	outmethod.println("  }");
 	
 	
@@ -198,13 +219,27 @@ public class BuildCode {
 	
 	outmethod.println("   {");
 	if (GENERATEPRECISEGC) {
-	    outmethod.print("       struct "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
+	    if (state.DSM) {
+		outmethod.print("       struct "+cd.getSafeSymbol()+locality.getMain().getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
+	    } else
+		outmethod.print("       struct "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
 	    outmethod.println("1, NULL,"+"stringarray};");
-	    outmethod.println("     "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(& __parameterlist__);");
-	} else
-	    outmethod.println("     "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(stringarray);");
+	    if (state.DSM)
+		outmethod.println("     "+cd.getSafeSymbol()+locality.getMain().getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(& __parameterlist__);");
+	    else
+		outmethod.println("     "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(& __parameterlist__);");
+	} else {
+	    if (state.DSM)
+		outmethod.println("     "+cd.getSafeSymbol()+locality.getMain().getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(stringarray);");
+	    else
+		outmethod.println("     "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(stringarray);");
+	}
 	outmethod.println("   }");
-	
+
+	if (state.DSM) {
+	    outmethod.println("}");
+	}
+
 	if (state.THREAD) {
 	    outmethod.println("pthread_mutex_lock(&gclistlock);");
 	    outmethod.println("threadcount--;");
@@ -212,6 +247,8 @@ public class BuildCode {
 	    outmethod.println("pthread_mutex_unlock(&gclistlock);");
 	    outmethod.println("pthread_exit(NULL);");
 	}
+
+
 	outmethod.println("}");
     }
 
@@ -255,6 +292,9 @@ public class BuildCode {
 	outmethod.println("#include \"methodheaders.h\"");
 	outmethod.println("#include \"virtualtable.h\"");
 	outmethod.println("#include <runtime.h>");
+	if (state.DSM) {
+	    outmethod.println("#include \"localobjects.h\"");
+	}
 	if (state.THREAD)
 	    outmethod.println("#include <thread.h>");
 	if (state.main!=null) {
@@ -556,13 +596,21 @@ public class BuildCode {
 	    if (virtualcalls.getMethodCount(cd)>maxcount)
 		maxcount=virtualcalls.getMethodCount(cd);
 	}
-	MethodDescriptor[][] virtualtable=new MethodDescriptor[state.numClasses()+state.numArrays()][maxcount];
+	MethodDescriptor[][] virtualtable=null;
+	LocalityBinding[][] lbvirtualtable=null;
+	if (state.DSM)
+	    lbvirtualtable=new LocalityBinding[state.numClasses()+state.numArrays()][maxcount];
+	else
+	    virtualtable=new MethodDescriptor[state.numClasses()+state.numArrays()][maxcount];
 
 	/* Fill in virtual table */
 	classit=state.getClassSymbolTable().getDescriptorsIterator();
 	while(classit.hasNext()) {
 	    ClassDescriptor cd=(ClassDescriptor)classit.next();
-	    fillinRow(cd, virtualtable, cd.getId());
+	    if (state.DSM)
+		fillinRow(cd, lbvirtualtable, cd.getId());
+	    else
+		fillinRow(cd, virtualtable, cd.getId());
 	}
 
 	ClassDescriptor objectcd=typeutil.getClass(TypeUtil.ObjectClass);
@@ -570,7 +618,10 @@ public class BuildCode {
 	while(arrayit.hasNext()) {
 	    TypeDescriptor td=(TypeDescriptor)arrayit.next();
 	    int id=state.getArrayNumber(td);
-	    fillinRow(objectcd, virtualtable, id+state.numClasses());
+	    if (state.DSM)
+		fillinRow(objectcd, lbvirtualtable, id+state.numClasses());
+	    else
+		fillinRow(objectcd, virtualtable, id+state.numClasses());
 	}
 	
 	outvirtual.print("void * virtualtable[]={");
@@ -579,7 +630,11 @@ public class BuildCode {
 	    for(int j=0;j<maxcount;j++) {
 		if (needcomma)
 		    outvirtual.print(", ");
-		if (virtualtable[i][j]!=null) {
+		if (state.DSM&&lbvirtualtable[i][j]!=null) {
+		    LocalityBinding lb=lbvirtualtable[i][j];
+		    MethodDescriptor md=lb.getMethod();
+		    outvirtual.print("& "+md.getClassDesc().getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
+		} else if (!state.DSM&&virtualtable[i][j]!=null) {
 		    MethodDescriptor md=virtualtable[i][j];
 		    outvirtual.print("& "+md.getClassDesc().getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
 		} else {
@@ -607,6 +662,24 @@ public class BuildCode {
 	}
     }
 
+    private void fillinRow(ClassDescriptor cd, LocalityBinding[][] virtualtable, int rownum) {
+	/* Get inherited methods */
+	if (cd.getSuperDesc()!=null)
+	    fillinRow(cd.getSuperDesc(), virtualtable, rownum);
+	/* Override them with our methods */
+	if (locality.getClassBindings(cd)!=null)
+	    for(Iterator<LocalityBinding> lbit=locality.getClassBindings(cd).iterator();lbit.hasNext();) {
+		LocalityBinding lb=lbit.next();
+		MethodDescriptor md=lb.getMethod();
+		//Is the method static or a constructor
+		if (md.isStatic()||md.getReturnType()==null)
+		    continue;
+		int methodnum=virtualcalls.getLocalityNumber(lb);
+		virtualtable[rownum][methodnum]=lb;
+	    }
+    }
+
+
     /** Generate array that contains the sizes of class objects.  The
      * object allocation functions in the runtime use this
      * information. */
@@ -657,10 +730,12 @@ public class BuildCode {
     private void generateTempStructs(FlatMethod fm, LocalityBinding lb) {
 	MethodDescriptor md=fm.getMethod();
 	TaskDescriptor task=fm.getTask();
-	Set<TempDescriptor> saveset=state.DSM?locality.getTempSet(lb):null;
+	Set<TempDescriptor> saveset=lb!=null?locality.getTempSet(lb):null;
 	ParamsObject objectparams=md!=null?new ParamsObject(md,tag++):new ParamsObject(task, tag++);
 
-	if (md!=null)
+	if (lb!=null)
+	    paramstable.put(lb, objectparams);
+	else if (md!=null)
 	    paramstable.put(md, objectparams);
 	else
 	    paramstable.put(task, objectparams);
@@ -672,7 +747,7 @@ public class BuildCode {
 		objectparams.addPtr(temp);
 	    else
 		objectparams.addPrim(temp);
-	    if(state.DSM&&saveset.contains(temp)) {
+	    if(lb!=null&&saveset.contains(temp)) {
 		backuptable.put(temp, temp.createNew());
 	    }
 	}
@@ -686,7 +761,9 @@ public class BuildCode {
 	}
 
 	TempObject objecttemps=md!=null?new TempObject(objectparams,md,tag++):new TempObject(objectparams, task, tag++);
-	if (md!=null)
+	if (lb!=null)
+	    tempstable.put(lb, objecttemps);
+	else if (md!=null)
 	    tempstable.put(md, objecttemps);
 	else
 	    tempstable.put(task, objecttemps);
@@ -701,14 +778,14 @@ public class BuildCode {
 		    objecttemps.addPtr(temp);
 		else
 		    objecttemps.addPrim(temp);
-		if(state.DSM&&saveset.contains(temp)&&
+		if(lb!=null&&saveset.contains(temp)&&
 		   !backuptable.containsKey(temp))
 		    backuptable.put(temp, temp.createNew());
 	    }
 	}
 
 	/* Create backup temps */
-	if (state.DSM)
+	if (lb!=null) {
 	    for(Iterator<TempDescriptor> tmpit=backuptable.values().iterator();tmpit.hasNext();) {
 		TempDescriptor tmp=tmpit.next();
 		TypeDescriptor type=tmp.getType();
@@ -717,6 +794,16 @@ public class BuildCode {
 		else
 		    objecttemps.addPrim(tmp);
 	    }
+	    /* Create temp to hold revert table */
+	    if (lb.getHasAtomic()) {
+		TempDescriptor reverttmp=new TempDescriptor("revertlist", typeutil.getClass(TypeUtil.ObjectClass));
+		if (GENERATEPRECISEGC)
+		    objecttemps.addPtr(reverttmp);
+		else
+		    objecttemps.addPrim(reverttmp);
+		reverttable.put(lb, reverttmp);
+	    }
+	}
     }
 
     /** This method outputs the following information about classes
@@ -736,6 +823,8 @@ public class BuildCode {
 	    while(allit.hasNext()) {
 		FieldDescriptor fd=(FieldDescriptor)allit.next();
 		TypeDescriptor type=fd.getType();
+		if (state.DSM&&fd.isGlobal()) //Don't GC the global objects for now
+		    continue;
 		if (type.isPtr()||type.isArray())
 		    count++;
 	    }
@@ -744,6 +833,8 @@ public class BuildCode {
 	    while(allit.hasNext()) {
 		FieldDescriptor fd=(FieldDescriptor)allit.next();
 		TypeDescriptor type=fd.getType();
+		if (state.DSM&&fd.isGlobal()) //Don't GC the global objects for now
+		    continue;
 		if (type.isPtr()||type.isArray()) {
 		    output.println(",");
 		    output.print("((unsigned int)&(((struct "+cn.getSafeSymbol() +" *)0)->"+fd.getSafeSymbol()+"))");
@@ -766,7 +857,7 @@ public class BuildCode {
 		output.println(", ");
 	    TypeDescriptor tdelement=arraytable[i].dereference();
 	    if (tdelement.isArray()||tdelement.isClass())
-		output.print("((int *)1)");
+		output.print("((unsigned int *)1)");
 	    else
 		output.print("0");
 	    needcomma=true;
@@ -900,31 +991,49 @@ public class BuildCode {
 
 	if (state.DSM) {
 	    /* Cycle through LocalityBindings */
-	    for(Iterator<LocalityBinding> lbit=locality.getClassBindings(cn).iterator();lbit.hasNext();) {
-		LocalityBinding lb=lbit.next();
-		MethodDescriptor md=lb.getMethod();
-		generateMethod(cn, md, lb, headersout, output);
+	    HashSet<MethodDescriptor> nativemethods=new HashSet<MethodDescriptor>();
+	    Set<LocalityBinding> lbset=locality.getClassBindings(cn);
+	    if (lbset!=null) {
+		for(Iterator<LocalityBinding> lbit=lbset.iterator();lbit.hasNext();) {
+		    LocalityBinding lb=lbit.next();
+		    MethodDescriptor md=lb.getMethod();
+		    if (md.getModifiers().isNative()) {
+			//make sure we only print a native method once
+			if (nativemethods.contains(md)) {
+			    FlatMethod fm=state.getMethodFlat(md);
+			    generateTempStructs(fm, lb);
+			    continue;
+			} else
+			    nativemethods.add(md);
+		    }
+		    generateMethod(cn, md, lb, headersout, output);
+		}
 	    }
-	} else {
-	    /* Cycle through methods */
 	    for(Iterator methodit=cn.getMethods();methodit.hasNext();) {
-		/* Classify parameters */
+		MethodDescriptor md=(MethodDescriptor)methodit.next();
+		if (md.getModifiers().isNative()&&!nativemethods.contains(md)) {
+		    //Need to build param structure for library code
+		    FlatMethod fm=state.getMethodFlat(md);
+		    generateTempStructs(fm, null);
+		    generateMethodParam(cn, md, null, output);
+		}
+	    }
+
+	} else
+	    for(Iterator methodit=cn.getMethods();methodit.hasNext();) {
 		MethodDescriptor md=(MethodDescriptor)methodit.next();
 		generateMethod(cn, md, null, headersout, output);
 	    }
-	}
     }
 
-    private void generateMethod(ClassDescriptor cn, MethodDescriptor md, LocalityBinding lb, PrintWriter headersout, PrintWriter output) {
-	FlatMethod fm=state.getMethodFlat(md);
-	generateTempStructs(fm, null);
-	
-	ParamsObject objectparams=(ParamsObject) paramstable.get(md);
-	TempObject objecttemps=(TempObject) tempstable.get(md);
-	
+    private void generateMethodParam(ClassDescriptor cn, MethodDescriptor md, LocalityBinding lb, PrintWriter output) {
 	/* Output parameter structure */
 	if (GENERATEPRECISEGC) {
-	    output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params {");
+	    ParamsObject objectparams=(ParamsObject) paramstable.get(lb!=null?lb:md);
+	    if (state.DSM&&lb!=null)
+		output.println("struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params {");
+	    else
+		output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params {");
 	    output.println("  int size;");
 	    output.println("  void * next;");
 	    for(int i=0;i<objectparams.numPointers();i++) {
@@ -933,10 +1042,24 @@ public class BuildCode {
 	    }
 	    output.println("};\n");
 	}
+    }
+
+
+    private void generateMethod(ClassDescriptor cn, MethodDescriptor md, LocalityBinding lb, PrintWriter headersout, PrintWriter output) {
+	FlatMethod fm=state.getMethodFlat(md);
+	generateTempStructs(fm, lb);
+	
+	ParamsObject objectparams=(ParamsObject) paramstable.get(lb!=null?lb:md);
+	TempObject objecttemps=(TempObject) tempstable.get(lb!=null?lb:md);
+	
+	generateMethodParam(cn, md, lb, output);
 	
 	/* Output temp structure */
 	if (GENERATEPRECISEGC) {
-	    output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals {");
+	    if (state.DSM)
+		output.println("struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals {");
+	    else
+		output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals {");
 	    output.println("  int size;");
 	    output.println("  void * next;");
 	    for(int i=0;i<objecttemps.numPointers();i++) {
@@ -969,7 +1092,10 @@ public class BuildCode {
 	
 	boolean printcomma=false;
 	if (GENERATEPRECISEGC) {
-	    headersout.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
+	    if (state.DSM) {
+		headersout.print("struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
+	    } else
+		headersout.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
 	    printcomma=true;
 	}
 	
@@ -1059,7 +1185,7 @@ public class BuildCode {
    	}
     }
 
-    /** Generate code for FlatMethod fm. */
+    /***** Generate code for FlatMethod fm. *****/
 
     private void generateFlatMethod(FlatMethod fm, LocalityBinding lb, PrintWriter output) {
 	MethodDescriptor md=fm.getMethod();
@@ -1067,15 +1193,17 @@ public class BuildCode {
 
        	ClassDescriptor cn=md!=null?md.getClassDesc():null;
 
-	ParamsObject objectparams=(ParamsObject)paramstable.get(md!=null?md:task);
+	ParamsObject objectparams=(ParamsObject)paramstable.get(lb!=null?lb:md!=null?md:task);
 	generateHeader(fm, lb, md!=null?md:task,output);
-	TempObject objecttemp=(TempObject) tempstable.get(md!=null?md:task);
+	TempObject objecttemp=(TempObject) tempstable.get(lb!=null?lb:md!=null?md:task);
 	if (state.DSM&&lb.getHasAtomic()) {
 	    output.println("transrecord_t * trans;");
 	}
 
 	if (GENERATEPRECISEGC) {
-	    if (md!=null)
+	    if (md!=null&&state.DSM)
+		output.print("   struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals "+localsprefix+"={");
+	    else if (md!=null&&!state.DSM)
 		output.print("   struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals "+localsprefix+"={");
 	    else
 		output.print("   struct "+task.getSafeSymbol()+"_locals "+localsprefix+"={");
@@ -1148,7 +1276,7 @@ public class BuildCode {
 	    } else if (current_node.numNext()==2) {
 		/* Branch */
 		output.print("   ");
-		generateFlatCondBranch(fm, (FlatCondBranch)current_node, "L"+nodetolabel.get(current_node.getNext(1)), output);
+		generateFlatCondBranch(fm, lb, (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))) {
@@ -1197,10 +1325,10 @@ public class BuildCode {
 
 
     /** Generate text string that corresponds to the TempDescriptor td. */
-    private String generateTemp(FlatMethod fm, TempDescriptor td) {
+    private String generateTemp(FlatMethod fm, TempDescriptor td, LocalityBinding lb) {
 	MethodDescriptor md=fm.getMethod();
 	TaskDescriptor task=fm.getTask();
-	TempObject objecttemps=(TempObject) tempstable.get(md!=null?md:task);
+	TempObject objecttemps=(TempObject) tempstable.get(lb!=null?lb:md!=null?md:task);
 
 	if (objecttemps.isLocalPrim(td)||objecttemps.isParamPrim(td)) {
 	    return td.getSafeSymbol();
@@ -1224,38 +1352,41 @@ public class BuildCode {
 	case FKind.FlatAtomicExitNode:
 	    generateFlatAtomicExitNode(fm, lb, (FlatAtomicExitNode) fn, output);
 	    return;
+	case FKind.FlatGlobalConvNode:
+	    generateFlatGlobalConvNode(fm, lb, (FlatGlobalConvNode) fn, output);
+	    return;
 	case FKind.FlatTagDeclaration:
-	    generateFlatTagDeclaration(fm, (FlatTagDeclaration) fn,output);
+	    generateFlatTagDeclaration(fm, lb, (FlatTagDeclaration) fn,output);
 	    return;
 	case FKind.FlatCall:
-	    generateFlatCall(fm, (FlatCall) fn,output);
+	    generateFlatCall(fm, lb, (FlatCall) fn,output);
 	    return;
 	case FKind.FlatFieldNode:
 	    generateFlatFieldNode(fm, lb, (FlatFieldNode) fn,output);
 	    return;
 	case FKind.FlatElementNode:
-	    generateFlatElementNode(fm, (FlatElementNode) fn,output);
+	    generateFlatElementNode(fm, lb, (FlatElementNode) fn,output);
 	    return;
 	case FKind.FlatSetElementNode:
-	    generateFlatSetElementNode(fm, (FlatSetElementNode) fn,output);
+	    generateFlatSetElementNode(fm, lb, (FlatSetElementNode) fn,output);
 	    return;
 	case FKind.FlatSetFieldNode:
 	    generateFlatSetFieldNode(fm, lb, (FlatSetFieldNode) fn,output);
 	    return;
 	case FKind.FlatNew:
-	    generateFlatNew(fm, (FlatNew) fn,output);
+	    generateFlatNew(fm, lb, (FlatNew) fn,output);
 	    return;
 	case FKind.FlatOpNode:
-	    generateFlatOpNode(fm, (FlatOpNode) fn,output);
+	    generateFlatOpNode(fm, lb, (FlatOpNode) fn,output);
 	    return;
 	case FKind.FlatCastNode:
-	    generateFlatCastNode(fm, (FlatCastNode) fn,output);
+	    generateFlatCastNode(fm, lb, (FlatCastNode) fn,output);
 	    return;
 	case FKind.FlatLiteralNode:
-	    generateFlatLiteralNode(fm, (FlatLiteralNode) fn,output);
+	    generateFlatLiteralNode(fm, lb, (FlatLiteralNode) fn,output);
 	    return;
 	case FKind.FlatReturnNode:
-	    generateFlatReturnNode(fm, (FlatReturnNode) fn,output);
+	    generateFlatReturnNode(fm, lb, (FlatReturnNode) fn,output);
 	    return;
 	case FKind.FlatNop:
 	    output.println("/* nop */");
@@ -1267,16 +1398,28 @@ public class BuildCode {
 		output.println("/* nop */");
 	    return;
 	case FKind.FlatCheckNode:
-	    generateFlatCheckNode(fm, (FlatCheckNode) fn, output);
+	    generateFlatCheckNode(fm, lb, (FlatCheckNode) fn, output);
 	    return;
 	case FKind.FlatFlagActionNode:
-	    generateFlatFlagActionNode(fm, (FlatFlagActionNode) fn, output);
+	    generateFlatFlagActionNode(fm, lb, (FlatFlagActionNode) fn, output);
 	    return;
 	}
 	throw new Error();
 
     }
     
+    public void generateFlatGlobalConvNode(FlatMethod fm, LocalityBinding lb, FlatGlobalConvNode fgcn, PrintWriter output) {
+	if (lb!=fgcn.getLocality())
+	    return;
+	/* Have to generate flat globalconv */
+	if (fgcn.getMakePtr()) {
+	    output.println(generateTemp(fm, fgcn.getSrc(),lb)+"=(void *)transRead(trans, (unsigned int) "+generateTemp(fm, fgcn.getSrc(),lb)+");");
+	} else {
+	    /* Need to convert to OID */
+	    output.println(generateTemp(fm, fgcn.getSrc(),lb)+"=OID("+generateTemp(fm, fgcn.getSrc(),lb)+");");
+	}
+    }
+
     public void generateFlatAtomicEnterNode(FlatMethod fm,  LocalityBinding lb, FlatAtomicEnterNode faen, PrintWriter output) {
 	/* Check to see if we need to generate code for this atomic */
 	if (locality.getAtomic(lb).get(faen.getPrev(0)).intValue()>0)
@@ -1284,7 +1427,7 @@ public class BuildCode {
 	/* Backup the temps. */
 	for(Iterator<TempDescriptor> tmpit=locality.getTemps(lb).get(faen).iterator();tmpit.hasNext();) {
 	    TempDescriptor tmp=tmpit.next();
-	    output.println(generateTemp(fm, backuptable.get(tmp))+"="+generateTemp(fm,tmp)+";");
+	    output.println(generateTemp(fm, backuptable.get(tmp),lb)+"="+generateTemp(fm,tmp,lb)+";");
 	}
 	output.println("goto transstart"+faen.getIdentifier()+";");
 
@@ -1294,10 +1437,18 @@ public class BuildCode {
 	/* Restore temps */
 	for(Iterator<TempDescriptor> tmpit=locality.getTemps(lb).get(faen).iterator();tmpit.hasNext();) {
 	    TempDescriptor tmp=tmpit.next();
-	    output.println(generateTemp(fm, tmp)+"="+generateTemp(fm,backuptable.get(tmp))+";");
+	    output.println(generateTemp(fm, tmp,lb)+"="+generateTemp(fm,backuptable.get(tmp),lb)+";");
 	}
 
-	/* Need to revert local object store */
+	/********* Need to revert local object store ********/
+	String revertptr=generateTemp(fm, reverttable.get(lb),lb);
+	
+	output.println("while ("+revertptr+") {");
+	output.println("struct ___Object___ * tmpptr;");
+	output.println("tmpptr="+revertptr+"->"+nextobjstr+";");
+	output.println("REVERT_OBJ("+revertptr+");");
+	output.println(revertptr+"=tmpptr;");
+	output.println("}");
 
 	/******* Tell the runtime to start the transaction *******/
 	
@@ -1309,14 +1460,24 @@ public class BuildCode {
 	/* Check to see if we need to generate code for this atomic */
 	if (locality.getAtomic(lb).get(faen).intValue()>0)
 	    return;
-	output.println("if (transCommit(trans))");
+	//store the revert list before we lose the transaction object
+	String revertptr=generateTemp(fm, reverttable.get(lb),lb);
+	output.println(revertptr+"=trans->revertlist;");
+	output.println("if (transCommit(trans)) {");
 	/* Transaction aborts if it returns true */
 	output.println("goto transretry"+faen.getAtomicEnter().getIdentifier()+";");
+	output.println("} else {");
 	/* Need to commit local object store */
-	//TODO
+	output.println("while ("+revertptr+") {");
+	output.println("struct ___Object___ * tmpptr;");
+	output.println("tmpptr="+revertptr+"->"+nextobjstr+";");
+	output.println("COMMIT_OBJ("+revertptr+");");
+	output.println(revertptr+"=tmpptr;");
+	output.println("}");
+	output.println("}");
     }
 
-    private void generateFlatCheckNode(FlatMethod fm,  FlatCheckNode fcn, PrintWriter output) {
+    private void generateFlatCheckNode(FlatMethod fm,  LocalityBinding lb, FlatCheckNode fcn, PrintWriter output) {
 	if (state.CONSCHECK) {
 	    String specname=fcn.getSpec();
 	    String varname="repairstate___";
@@ -1326,7 +1487,7 @@ public class BuildCode {
 	    TempDescriptor[] temps=fcn.getTemps();
 	    String[] vars=fcn.getVars();
 	    for(int i=0;i<temps.length;i++) {
-		output.println(varname+"->"+vars[i]+"=(unsigned int)"+generateTemp(fm, temps[i])+";");
+		output.println(varname+"->"+vars[i]+"=(unsigned int)"+generateTemp(fm, temps[i],lb)+";");
 	    }
 
 	    output.println("if (doanalysis"+specname+"("+varname+")) {");
@@ -1340,20 +1501,23 @@ public class BuildCode {
 	}
     }
 
-    private void generateFlatCall(FlatMethod fm, FlatCall fc, PrintWriter output) {
+    private void generateFlatCall(FlatMethod fm, LocalityBinding lb, FlatCall fc, PrintWriter output) {
 	MethodDescriptor md=fc.getMethod();
-	ParamsObject objectparams=(ParamsObject) paramstable.get(md);
+	ParamsObject objectparams=(ParamsObject)paramstable.get(state.DSM?locality.getBinding(lb, fc):md);
 	ClassDescriptor cn=md.getClassDesc();
 	output.println("{");
 	if (GENERATEPRECISEGC) {
-	    output.print("       struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
+	    if (state.DSM) {
+		LocalityBinding fclb=locality.getBinding(lb, fc);
+		output.print("       struct "+cn.getSafeSymbol()+fclb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
+	    } else
+		output.print("       struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
 	    
 	    output.print(objectparams.numPointers());
-	    //	    output.print(objectparams.getUID());
 	    output.print(", & "+localsprefix);
 	    if (fc.getThis()!=null) {
 		output.print(", ");
-		output.print("(struct "+md.getThis().getType().getSafeSymbol() +" *)"+ generateTemp(fm,fc.getThis()));
+		output.print("(struct "+md.getThis().getType().getSafeSymbol() +" *)"+ generateTemp(fm,fc.getThis(),lb));
 	    }
 	    for(int i=0;i<fc.numArgs();i++) {
 		Descriptor var=md.getParameter(i);
@@ -1363,9 +1527,9 @@ public class BuildCode {
 		    output.print(", ");
 		    TypeDescriptor td=md.getParamType(i);
 		    if (td.isTag())
-			output.print("(struct "+(new TypeDescriptor(typeutil.getClass(TypeUtil.TagClass))).getSafeSymbol()  +" *)"+generateTemp(fm, targ));
+			output.print("(struct "+(new TypeDescriptor(typeutil.getClass(TypeUtil.TagClass))).getSafeSymbol()  +" *)"+generateTemp(fm, targ,lb));
 		    else
-			output.print("(struct "+md.getParamType(i).getSafeSymbol()  +" *)"+generateTemp(fm, targ));
+			output.print("(struct "+md.getParamType(i).getSafeSymbol()  +" *)"+generateTemp(fm, targ,lb));
 		}
 	    }
 	    output.println("};");
@@ -1374,12 +1538,19 @@ public class BuildCode {
 
 
 	if (fc.getReturnTemp()!=null)
-	    output.print(generateTemp(fm,fc.getReturnTemp())+"=");
+	    output.print(generateTemp(fm,fc.getReturnTemp(),lb)+"=");
 
 	/* Do we need to do virtual dispatch? */
 	if (md.isStatic()||md.getReturnType()==null||singleCall(fc.getThis().getType().getClassDesc(),md)) {
-	    output.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
+	    //no
+	    if (state.DSM) {
+		LocalityBinding fclb=locality.getBinding(lb, fc);
+		output.print(cn.getSafeSymbol()+fclb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
+	    } else {
+		output.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
+	    }
 	} else {
+	    //yes
 	    output.print("((");
 	    if (md.getReturnType().isClass()||md.getReturnType().isArray())
 		output.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
@@ -1389,7 +1560,11 @@ public class BuildCode {
 
 	    boolean printcomma=false;
 	    if (GENERATEPRECISEGC) {
-		output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * ");
+		if (state.DSM) {
+		    LocalityBinding fclb=locality.getBinding(lb, fc);
+		    output.print("struct "+cn.getSafeSymbol()+fclb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * ");
+		} else
+		    output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * ");
 		printcomma=true;
 	    }
 
@@ -1404,7 +1579,11 @@ public class BuildCode {
 		    output.print(temp.getType().getSafeSymbol());
 	    }
 
-	    output.print("))virtualtable["+generateTemp(fm,fc.getThis())+"->type*"+maxcount+"+"+virtualcalls.getMethodNumber(md)+"])");
+	    if (state.DSM) {
+		LocalityBinding fclb=locality.getBinding(lb, fc);
+		output.print("))virtualtable["+generateTemp(fm,fc.getThis(),lb)+"->type*"+maxcount+"+"+virtualcalls.getLocalityNumber(fclb)+"])");
+	    } else
+		output.print("))virtualtable["+generateTemp(fm,fc.getThis(),lb)+"->type*"+maxcount+"+"+virtualcalls.getMethodNumber(md)+"])");
 	}
 
 	output.print("(");
@@ -1412,15 +1591,27 @@ public class BuildCode {
 	if (GENERATEPRECISEGC) {
 	    output.print("&__parameterlist__");
 	    needcomma=true;
-	} else {
+	}
+
+	if (state.DSM&&locality.getBinding(lb,fc).isAtomic()) {
+	    if (needcomma)
+		output.print(",");
+	    output.print("trans");
+	    needcomma=true;
+	}
+
+	if (!GENERATEPRECISEGC) {
 	    if (fc.getThis()!=null) {
 		TypeDescriptor ptd=md.getThis().getType();
+		if (needcomma)
+		    output.print(",");
 		if (ptd.isClass()&&!ptd.isArray())
 		    output.print("(struct "+ptd.getSafeSymbol()+" *) ");
-		output.print(generateTemp(fm,fc.getThis()));
+		output.print(generateTemp(fm,fc.getThis(),lb));
 		needcomma=true;
 	    }
 	}
+
 	for(int i=0;i<fc.numArgs();i++) {
 	    Descriptor var=md.getParameter(i);
 	    TempDescriptor paramtemp=(TempDescriptor)temptovar.get(var);
@@ -1432,7 +1623,7 @@ public class BuildCode {
 		TypeDescriptor ptd=md.getParamType(i);
 		if (ptd.isClass()&&!ptd.isArray())
 		    output.print("(struct "+ptd.getSafeSymbol()+" *) ");
-		output.print(generateTemp(fm, targ));
+		output.print(generateTemp(fm, targ,lb));
 		needcomma=true;
 	    }
 	}
@@ -1461,8 +1652,8 @@ public class BuildCode {
 	    Integer status=locality.getNodeTempInfo(lb).get(ffn).get(ffn.getSrc());
 	    if (status==LocalityAnalysis.GLOBAL) {
 		String field=ffn.getField().getSafeSymbol();
-		String src="((struct "+ffn.getSrc().getType().getSafeSymbol()+" *)((unsigned int)"+generateTemp(fm, ffn.getSrc())+"+sizeof(objheader_t)))";
-		String dst=generateTemp(fm, ffn.getDst());
+		String src="((struct "+ffn.getSrc().getType().getSafeSymbol()+" *)((unsigned int)"+generateTemp(fm, ffn.getSrc(),lb)+"+sizeof(objheader_t)))";
+		String dst=generateTemp(fm, ffn.getDst(),lb);
 		    
 		if (ffn.getField().getType().isPtr()||
 		    ffn.getField().getType().isArray()) {
@@ -1472,7 +1663,7 @@ public class BuildCode {
 		    //output.println("{");
 		    //output.println("void * temp="+src+";");
 		    //output.println("if (temp&0x1) {");
-		    //output.println("temp=transRead(trans, temp);");
+		    //output.println("temp=(void *) transRead(trans, (unsigned int) temp);");
 		    //output.println(src+"->"+field+"="+temp+";");
 		    //output.println("}");
 		    //output.println(dst+"=temp;");
@@ -1480,7 +1671,7 @@ public class BuildCode {
 		    //} else {
 		    output.println(dst+"="+ src +"->"+field+ ";");
 		    //output.println("if ("+dst+"&0x1) {");
-		    output.println(dst+"=transRead(trans,"+dst+");");
+		    output.println(dst+"=(void *) transRead(trans, (unsigned int) "+dst+");");
 		    //output.println(src+"->"+field+"="+src+"->"+field+";");
 		    //output.println("}");
 		    //}
@@ -1488,40 +1679,41 @@ public class BuildCode {
 		    output.println(dst+"="+ src+"->"+field+";");
 		}
 	    } else if (status==LocalityAnalysis.LOCAL) {
-		output.println(generateTemp(fm, ffn.getDst())+"="+ generateTemp(fm,ffn.getSrc())+"->"+ ffn.getField().getSafeSymbol()+";");
+		output.println(generateTemp(fm, ffn.getDst(),lb)+"="+ generateTemp(fm,ffn.getSrc(),lb)+"->"+ ffn.getField().getSafeSymbol()+";");
 	    } else if (status==LocalityAnalysis.EITHER) {
 		//Code is reading from a null pointer
- 		output.println("if ("+generateTemp(fm, ffn.getSrc())+") {");
+ 		output.println("if ("+generateTemp(fm, ffn.getSrc(),lb)+") {");
 		output.println("printf(\"BIG ERROR\n\");exit(-1);}");
 		//This should throw a suitable null pointer error
-		output.println(generateTemp(fm, ffn.getDst())+"="+ generateTemp(fm,ffn.getSrc())+"->"+ ffn.getField().getSafeSymbol()+";");
+		output.println(generateTemp(fm, ffn.getDst(),lb)+"="+ generateTemp(fm,ffn.getSrc(),lb)+"->"+ ffn.getField().getSafeSymbol()+";");
 	    } else
 		throw new Error("Read from non-global/non-local in:"+lb.getExplanation());
 	} else
-	    output.println(generateTemp(fm, ffn.getDst())+"="+ generateTemp(fm,ffn.getSrc())+"->"+ ffn.getField().getSafeSymbol()+";");
+	    output.println(generateTemp(fm, ffn.getDst(),lb)+"="+ generateTemp(fm,ffn.getSrc(),lb)+"->"+ ffn.getField().getSafeSymbol()+";");
     }
 
     private void generateFlatSetFieldNode(FlatMethod fm, LocalityBinding lb, FlatSetFieldNode fsfn, PrintWriter output) {
 	if (fsfn.getField().getSymbol().equals("length")&&fsfn.getDst().getType().isArray())
 	    throw new Error("Can't set array length");
-	if (state.DSM) {
-	    Integer statussrc=locality.getNodeTempInfo(lb).get(fsfn).get(fsfn.getDst());
+	if (state.DSM && locality.getAtomic(lb).get(fsfn).intValue()>0) {
+	    Integer statussrc=locality.getNodeTempInfo(lb).get(fsfn).get(fsfn.getSrc());
 	    Integer statusdst=locality.getNodeTempInfo(lb).get(fsfn).get(fsfn.getDst());
-	    boolean srcglobal=statusdst==LocalityAnalysis.GLOBAL;
+	    boolean srcglobal=statussrc==LocalityAnalysis.GLOBAL;
 
-	    String src=generateTemp(fm,fsfn.getSrc());
-	    String dst=generateTemp(fm,fsfn.getDst());
+	    String src=generateTemp(fm,fsfn.getSrc(),lb);
+	    String dst=generateTemp(fm,fsfn.getDst(),lb);
 	    if (srcglobal) {
 		output.println("{");
 		output.println("int srcoid="+src+"->"+oidstr+";");
 	    }
 	    if (statusdst.equals(LocalityAnalysis.GLOBAL)) {
-		String glbdst="(struct "+fsfn.getDst().getType().getSafeSymbol()+" *)((unsigned int)"+dst+" +sizeof(objheader_t)))";
+		String glbdst="((struct "+fsfn.getDst().getType().getSafeSymbol()+" *)((unsigned int)"+dst+" +sizeof(objheader_t)))";
 		//mark it dirty
-		output.println("((objheader_t *)"+dst+")->status|=DIRTY;");
-		if (srcglobal)
-		    output.println(glbdst+"->"+ fsfn.getField().getSafeSymbol()+"=srcoid;");
-		else
+		output.println("*((unsigned int *)&("+dst+"->___localcopy___))|=DIRTY;");
+		if (srcglobal) {
+		    output.println("*((unsigned int *)&("+glbdst+"->"+ fsfn.getField().getSafeSymbol()+"))=srcoid;");
+		    output.println("}");
+		} else
 		    output.println(glbdst+"->"+ fsfn.getField().getSafeSymbol()+"="+ src+";");		
 	    } else if (statusdst.equals(LocalityAnalysis.LOCAL)) {
 		/** Check if we need to copy */
@@ -1529,7 +1721,10 @@ public class BuildCode {
 		/* Link object into list */
 		output.println(dst+"->"+nextobjstr+"=trans->localtrans;");
 		output.println("trans->localtrans="+dst+";");
-		output.println("OBJECT_COPY("+dst+");");
+		if (GENERATEPRECISEGC)
+		    output.println("COPY_OBJ((struct garbagelist *)&"+localsprefix+",(struct ___Object___ *)"+dst+");");
+		else
+		    output.println("COPY_OBJ("+dst+");");
 		output.println("}");
 		if (srcglobal)
 		    output.println(dst+"->"+ fsfn.getField().getSafeSymbol()+"=srcoid;");
@@ -1548,11 +1743,11 @@ public class BuildCode {
 		output.println("}");
 	    }
 	} else {
-	    output.println(generateTemp(fm, fsfn.getDst())+"->"+ fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc())+";");
+	    output.println(generateTemp(fm, fsfn.getDst(),lb)+"->"+ fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc(),lb)+";");
 	}
     }
 
-    private void generateFlatElementNode(FlatMethod fm, FlatElementNode fen, PrintWriter output) {
+    private void generateFlatElementNode(FlatMethod fm, LocalityBinding lb, FlatElementNode fen, PrintWriter output) {
 	TypeDescriptor elementtype=fen.getSrc().getType().dereference();
 	String type="";
 
@@ -1562,14 +1757,14 @@ public class BuildCode {
 	    type=elementtype.getSafeSymbol()+" ";
 
 	if (fen.needsBoundsCheck()) {
-	    output.println("if ("+generateTemp(fm, fen.getIndex())+"< 0 || "+generateTemp(fm, fen.getIndex())+" >= "+generateTemp(fm,fen.getSrc()) + "->___length___)");
+	    output.println("if ("+generateTemp(fm, fen.getIndex(),lb)+"< 0 || "+generateTemp(fm, fen.getIndex(),lb)+" >= "+generateTemp(fm,fen.getSrc(),lb) + "->___length___)");
 	    output.println("failedboundschk();");
 	}
 
-	output.println(generateTemp(fm, fen.getDst())+"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc())+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex())+"];");
+	output.println(generateTemp(fm, fen.getDst(),lb)+"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex(),lb)+"];");
     }
 
-    private void generateFlatSetElementNode(FlatMethod fm, FlatSetElementNode fsen, PrintWriter output) {
+    private void generateFlatSetElementNode(FlatMethod fm, LocalityBinding lb, FlatSetElementNode fsen, PrintWriter output) {
 	//TODO: need dynamic check to make sure this assignment is actually legal
 	//Because Object[] could actually be something more specific...ie. Integer[]
 
@@ -1582,93 +1777,97 @@ public class BuildCode {
 	    type=elementtype.getSafeSymbol()+" ";
 
 	if (fsen.needsBoundsCheck()) {
-	    output.println("if ("+generateTemp(fm, fsen.getIndex())+"< 0 || "+generateTemp(fm, fsen.getIndex())+" >= "+generateTemp(fm,fsen.getDst()) + "->___length___)");
+	    output.println("if ("+generateTemp(fm, fsen.getIndex(),lb)+"< 0 || "+generateTemp(fm, fsen.getIndex(),lb)+" >= "+generateTemp(fm,fsen.getDst(),lb) + "->___length___)");
 	    output.println("failedboundschk();");
 	}
 
-	output.println("(("+type +"*)(((char *) &("+ generateTemp(fm,fsen.getDst())+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex())+"]="+generateTemp(fm,fsen.getSrc())+";");
+	output.println("(("+type +"*)(((char *) &("+ generateTemp(fm,fsen.getDst(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex(),lb)+"]="+generateTemp(fm,fsen.getSrc(),lb)+";");
     }
 
-    private void generateFlatNew(FlatMethod fm, FlatNew fn, PrintWriter output) {
+    private void generateFlatNew(FlatMethod fm, LocalityBinding lb, FlatNew fn, PrintWriter output) {
 	if (fn.getType().isArray()) {
 	    int arrayid=state.getArrayNumber(fn.getType())+state.numClasses();
-	    if (GENERATEPRECISEGC) {
-		output.println(generateTemp(fm,fn.getDst())+"=allocate_newarray(&"+localsprefix+", "+arrayid+", "+generateTemp(fm, fn.getSize())+");");
+	    if (fn.isGlobal()) {
+		output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_newarrayglobal(trans, "+arrayid+", "+generateTemp(fm, fn.getSize(),lb)+");");
+	    } else if (GENERATEPRECISEGC) {
+		output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_newarray(&"+localsprefix+", "+arrayid+", "+generateTemp(fm, fn.getSize(),lb)+");");
 	    } else {
-		output.println(generateTemp(fm,fn.getDst())+"=allocate_newarray("+arrayid+", "+generateTemp(fm, fn.getSize())+");");
+		output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_newarray("+arrayid+", "+generateTemp(fm, fn.getSize(),lb)+");");
 	    }
 	} else {
-	    if (GENERATEPRECISEGC) {
-		output.println(generateTemp(fm,fn.getDst())+"=allocate_new(&"+localsprefix+", "+fn.getType().getClassDesc().getId()+");");
+	    if (fn.isGlobal()) {
+		output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_newglobal(trans, "+fn.getType().getClassDesc().getId()+");");
+	    } else if (GENERATEPRECISEGC) {
+		output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_new(&"+localsprefix+", "+fn.getType().getClassDesc().getId()+");");
 	    } else {
-		output.println(generateTemp(fm,fn.getDst())+"=allocate_new("+fn.getType().getClassDesc().getId()+");");
+		output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_new("+fn.getType().getClassDesc().getId()+");");
 	    }
 	}
     }
 
-    private void generateFlatTagDeclaration(FlatMethod fm, FlatTagDeclaration fn, PrintWriter output) {
+    private void generateFlatTagDeclaration(FlatMethod fm, LocalityBinding lb, FlatTagDeclaration fn, PrintWriter output) {
 	if (GENERATEPRECISEGC) {
-	    output.println(generateTemp(fm,fn.getDst())+"=allocate_tag(&"+localsprefix+", "+state.getTagId(fn.getType())+");");
+	    output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_tag(&"+localsprefix+", "+state.getTagId(fn.getType())+");");
 	} else {
-	    output.println(generateTemp(fm,fn.getDst())+"=allocate_tag("+state.getTagId(fn.getType())+");");
+	    output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_tag("+state.getTagId(fn.getType())+");");
 	}
     }
 
-    private void generateFlatOpNode(FlatMethod fm, FlatOpNode fon, PrintWriter output) {
+    private void generateFlatOpNode(FlatMethod fm, LocalityBinding lb, FlatOpNode fon, PrintWriter output) {
 	if (fon.getRight()!=null)
-	    output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+fon.getOp().toString()+generateTemp(fm,fon.getRight())+";");
+	    output.println(generateTemp(fm, fon.getDest(),lb)+" = "+generateTemp(fm, fon.getLeft(),lb)+fon.getOp().toString()+generateTemp(fm,fon.getRight(),lb)+";");
 	else if (fon.getOp().getOp()==Operation.ASSIGN)
-	    output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+";");
+	    output.println(generateTemp(fm, fon.getDest(),lb)+" = "+generateTemp(fm, fon.getLeft(),lb)+";");
 	else if (fon.getOp().getOp()==Operation.UNARYPLUS)
-	    output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+";");
+	    output.println(generateTemp(fm, fon.getDest(),lb)+" = "+generateTemp(fm, fon.getLeft(),lb)+";");
 	else if (fon.getOp().getOp()==Operation.UNARYMINUS)
-	    output.println(generateTemp(fm, fon.getDest())+" = -"+generateTemp(fm, fon.getLeft())+";");
+	    output.println(generateTemp(fm, fon.getDest(),lb)+" = -"+generateTemp(fm, fon.getLeft(),lb)+";");
 	else if (fon.getOp().getOp()==Operation.LOGIC_NOT)
-	    output.println(generateTemp(fm, fon.getDest())+" = !"+generateTemp(fm, fon.getLeft())+";");
+	    output.println(generateTemp(fm, fon.getDest(),lb)+" = !"+generateTemp(fm, fon.getLeft(),lb)+";");
 	else
-	    output.println(generateTemp(fm, fon.getDest())+fon.getOp().toString()+generateTemp(fm, fon.getLeft())+";");
+	    output.println(generateTemp(fm, fon.getDest(),lb)+fon.getOp().toString()+generateTemp(fm, fon.getLeft(),lb)+";");
     }
 
-    private void generateFlatCastNode(FlatMethod fm, FlatCastNode fcn, PrintWriter output) {
+    private void generateFlatCastNode(FlatMethod fm, LocalityBinding lb, FlatCastNode fcn, PrintWriter output) {
 	/* TODO: Do type check here */
 	if (fcn.getType().isArray()) {
 	    throw new Error();
 	} else if (fcn.getType().isClass())
-	    output.println(generateTemp(fm,fcn.getDst())+"=(struct "+fcn.getType().getSafeSymbol()+" *)"+generateTemp(fm,fcn.getSrc())+";");
+	    output.println(generateTemp(fm,fcn.getDst(),lb)+"=(struct "+fcn.getType().getSafeSymbol()+" *)"+generateTemp(fm,fcn.getSrc(),lb)+";");
 	else
-	    output.println(generateTemp(fm,fcn.getDst())+"=("+fcn.getType().getSafeSymbol()+")"+generateTemp(fm,fcn.getSrc())+";");
+	    output.println(generateTemp(fm,fcn.getDst(),lb)+"=("+fcn.getType().getSafeSymbol()+")"+generateTemp(fm,fcn.getSrc(),lb)+";");
     }
 
-    private void generateFlatLiteralNode(FlatMethod fm, FlatLiteralNode fln, PrintWriter output) {
+    private void generateFlatLiteralNode(FlatMethod fm, LocalityBinding lb, FlatLiteralNode fln, PrintWriter output) {
 	if (fln.getValue()==null)
-	    output.println(generateTemp(fm, fln.getDst())+"=0;");
+	    output.println(generateTemp(fm, fln.getDst(),lb)+"=0;");
 	else if (fln.getType().getSymbol().equals(TypeUtil.StringClass)) {
 	    if (GENERATEPRECISEGC) {
-		output.println(generateTemp(fm, fln.getDst())+"=NewString(&"+localsprefix+", \""+FlatLiteralNode.escapeString((String)fln.getValue())+"\","+((String)fln.getValue()).length()+");");
+		output.println(generateTemp(fm, fln.getDst(),lb)+"=NewString(&"+localsprefix+", \""+FlatLiteralNode.escapeString((String)fln.getValue())+"\","+((String)fln.getValue()).length()+");");
 	    } else {
-		output.println(generateTemp(fm, fln.getDst())+"=NewString(\""+FlatLiteralNode.escapeString((String)fln.getValue())+"\","+((String)fln.getValue()).length()+");");
+		output.println(generateTemp(fm, fln.getDst(),lb)+"=NewString(\""+FlatLiteralNode.escapeString((String)fln.getValue())+"\","+((String)fln.getValue()).length()+");");
 	    }
 	} else if (fln.getType().isBoolean()) {
 	    if (((Boolean)fln.getValue()).booleanValue())
-		output.println(generateTemp(fm, fln.getDst())+"=1;");
+		output.println(generateTemp(fm, fln.getDst(),lb)+"=1;");
 	    else
-		output.println(generateTemp(fm, fln.getDst())+"=0;");
+		output.println(generateTemp(fm, fln.getDst(),lb)+"=0;");
 	} else if (fln.getType().isChar()) {
 	    String st=FlatLiteralNode.escapeString(fln.getValue().toString());
-	    output.println(generateTemp(fm, fln.getDst())+"='"+st+"';");
+	    output.println(generateTemp(fm, fln.getDst(),lb)+"='"+st+"';");
 	} else
-	    output.println(generateTemp(fm, fln.getDst())+"="+fln.getValue()+";");
+	    output.println(generateTemp(fm, fln.getDst(),lb)+"="+fln.getValue()+";");
     }
 
-    private void generateFlatReturnNode(FlatMethod fm, FlatReturnNode frn, PrintWriter output) {
+    private void generateFlatReturnNode(FlatMethod fm, LocalityBinding lb, FlatReturnNode frn, PrintWriter output) {
 	if (frn.getReturnTemp()!=null)
-	    output.println("return "+generateTemp(fm, frn.getReturnTemp())+";");
+	    output.println("return "+generateTemp(fm, frn.getReturnTemp(), lb)+";");
 	else
 	    output.println("return;");
     }
 
-    private void generateFlatCondBranch(FlatMethod fm, FlatCondBranch fcb, String label, PrintWriter output) {
-	output.println("if (!"+generateTemp(fm, fcb.getTest())+") goto "+label+";");
+    private void generateFlatCondBranch(FlatMethod fm, LocalityBinding lb, FlatCondBranch fcb, String label, PrintWriter output) {
+	output.println("if (!"+generateTemp(fm, fcb.getTest(),lb)+") goto "+label+";");
     }
 
     /** This method generates header information for the method or
@@ -1676,7 +1875,7 @@ public class BuildCode {
 
     private void generateHeader(FlatMethod fm, LocalityBinding lb, Descriptor des, PrintWriter output) {
 	/* Print header */
-	ParamsObject objectparams=(ParamsObject)paramstable.get(des);
+	ParamsObject objectparams=(ParamsObject)paramstable.get(lb!=null?lb:des);
 	MethodDescriptor md=null;
 	TaskDescriptor task=null;
 	if (des instanceof MethodDescriptor)
@@ -1704,9 +1903,12 @@ public class BuildCode {
 	
 	boolean printcomma=false;
 	if (GENERATEPRECISEGC) {
-	    if (md!=null)
-		output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
-	    else
+	    if (md!=null) {
+		if (state.DSM) {
+		    output.print("struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
+		} else
+		    output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
+	    } else
 		output.print("struct "+task.getSafeSymbol()+"_params * "+paramsprefix);
 	    printcomma=true;
 	}
@@ -1750,7 +1952,7 @@ public class BuildCode {
 	} else output.println(") {");
     }
     
-    public void generateFlatFlagActionNode(FlatMethod fm, FlatFlagActionNode ffan, PrintWriter output) {
+    public void generateFlatFlagActionNode(FlatMethod fm, LocalityBinding lb, FlatFlagActionNode ffan, PrintWriter output) {
 	output.println("/* FlatFlagActionNode */");
 
 
@@ -1829,9 +2031,9 @@ public class BuildCode {
 		while(tagit.hasNext()) {
 		    TempDescriptor tagtmp=(TempDescriptor)tagit.next();
 		    if (GENERATEPRECISEGC) 
-			output.println("tagclear(&"+localsprefix+", (struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
+			output.println("tagclear(&"+localsprefix+", (struct ___Object___ *)"+generateTemp(fm, temp,lb)+", "+generateTemp(fm,tagtmp,lb)+");");
 		    else
-			output.println("tagclear((struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
+			output.println("tagclear((struct ___Object___ *)"+generateTemp(fm, temp,lb)+", "+generateTemp(fm,tagtmp,lb)+");");
 		}
 	    }
 
@@ -1841,9 +2043,9 @@ public class BuildCode {
 		while(tagit.hasNext()) {
 		    TempDescriptor tagtmp=(TempDescriptor)tagit.next();
 		    if (GENERATEPRECISEGC)
-			output.println("tagset(&"+localsprefix+", (struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
+			output.println("tagset(&"+localsprefix+", (struct ___Object___ *)"+generateTemp(fm, temp,lb)+", "+generateTemp(fm,tagtmp,lb)+");");
 		    else
-			output.println("tagset((struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
+			output.println("tagset((struct ___Object___ *)"+generateTemp(fm, temp, lb)+", "+generateTemp(fm,tagtmp, lb)+");");
 		}
 	    }
 
@@ -1855,9 +2057,9 @@ public class BuildCode {
 	    if (flagandtable.containsKey(temp))
 		andmask=((Integer)flagandtable.get(temp)).intValue();
 	    if (ffan.getTaskType()==FlatFlagActionNode.NEWOBJECT) {
-		output.println("flagorandinit("+generateTemp(fm, temp)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
+		output.println("flagorandinit("+generateTemp(fm, temp, lb)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
 	    } else {
-		output.println("flagorand("+generateTemp(fm, temp)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
+		output.println("flagorand("+generateTemp(fm, temp, lb)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
 	    }
 	}
     }
@@ -1911,11 +2113,9 @@ public class BuildCode {
 	 headers.println("int numotd;");
 	 headers.println("struct optionaltaskdescriptor ** otdarray;");
 	 headers.println("int numfsanalysiswrappers;");
-	 headers.println("struct fsanalysiswrapper ** fsanalysiswrapperarray;\n};\n\n");
+	 headers.println("struct fsanalysiswrapper ** fsanalysiswrapperarray;\n};");
 	 
-	 headers.println("struct classanalysiswrapper * classanalysiswrapperarray[];\n");
-
-	
+	 headers.println("extern struct classanalysiswrapper * classanalysiswrapperarray[];");
 
 	 Iterator taskit=state.getTaskSymbolTable().getDescriptorsIterator();
 	 while(taskit.hasNext()) {
@@ -1924,9 +2124,9 @@ public class BuildCode {
 	 }
 	 
 	 
-	 
 	 //GENERATE STRUCTS
-	 output.println("#include \"optionalstruct.h\"\n\n");	 
+	 if (state.OPTIONAL)
+	     output.println("#include \"optionalstruct.h\"\n\n");	 
 	 HashSet processedcd = new HashSet();
 	
 	 int maxotd=0;
@@ -2216,11 +2416,15 @@ public class BuildCode {
 	 
 	 //build an array containing every classes for which code has been build
 	 output.println("struct classanalysiswrapper * classanalysiswrapperarray[]={");
+	 boolean needcomma=false;
 	 for(Iterator classit = processedcd.iterator(); classit.hasNext();){
 	     ClassDescriptor cdtemp=(ClassDescriptor)classit.next();
-	     if(!classit.hasNext()) output.println("&classanalysiswrapper_"+cdtemp.getSafeSymbol()+"};\n");
-	     else output.println("&classanalysiswrapper_"+cdtemp.getSafeSymbol()+",");
+	     if (needcomma)
+		 output.println(", ");
+	     needcomma=true;
+	     output.println("&classanalysiswrapper_"+cdtemp.getSafeSymbol());
 	 }
+	 output.println("};");
 	 
 	 output.println("int numclasses="+processedcd.size()+";");
 	 headers.println("extern numclasses;");