X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=Robust%2Fsrc%2FIR%2FFlat%2FBuildCode.java;h=8781ff4e3ca832db40545acb02f3d86ce2a20c59;hb=4cb63e913202459da4fe9d01feb7c02f1b98dd6f;hp=7d484a856952492d8cc0cf222a3f8a9e71c72b2d;hpb=54556cfb48d1f818947461881b1de2e7bc1f1375;p=IRC.git

diff --git a/Robust/src/IR/Flat/BuildCode.java b/Robust/src/IR/Flat/BuildCode.java
index 7d484a85..8781ff4e 100644
--- a/Robust/src/IR/Flat/BuildCode.java
+++ b/Robust/src/IR/Flat/BuildCode.java
@@ -6,6 +6,7 @@ import IR.Tree.TagExpressionList;
 import IR.*;
 import java.util.*;
 import java.io.*;
+
 import Util.Relation;
 import Analysis.TaskStateAnalysis.FlagState;
 import Analysis.TaskStateAnalysis.FlagComparator;
@@ -33,9 +34,10 @@ public class BuildCode {
     public static boolean GENERATEPRECISEGC=false;
     public static String PREFIX="";
     public static String arraytype="ArrayObject";
+    public static int flagcount = 0;
     Virtual virtualcalls;
     TypeUtil typeutil;
-    private int maxtaskparams=0;
+    protected int maxtaskparams=0;
     private int maxcount=0;
     ClassDescriptor[] cdarray;
     TypeDescriptor[] arraytable;
@@ -43,17 +45,19 @@ public class BuildCode {
     Hashtable<TempDescriptor, TempDescriptor> backuptable;
     Hashtable<LocalityBinding, TempDescriptor> reverttable;
     SafetyAnalysis sa;
+    PrefetchAnalysis pa;
 
-    public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, SafetyAnalysis sa) {
-	this(st, temptovar, typeutil, null, sa);
+    public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, SafetyAnalysis sa, PrefetchAnalysis pa) {
+	this(st, temptovar, typeutil, null, sa, pa);
     }
 
-    public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, LocalityAnalysis locality) {
-	this(st, temptovar, typeutil, locality, null);
+    public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, LocalityAnalysis locality, PrefetchAnalysis pa) {
+	this(st, temptovar, typeutil, locality, null, pa);
     }
 
-    public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, LocalityAnalysis locality, SafetyAnalysis sa) {
+    public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, LocalityAnalysis locality, SafetyAnalysis sa, PrefetchAnalysis pa) {
 	this.sa=sa;
+	this.pa=pa;
 	state=st;
 	this.temptovar=temptovar;
 	paramstable=new Hashtable();
@@ -190,6 +194,12 @@ public class BuildCode {
     private void outputMainMethod(PrintWriter outmethod) {
 	outmethod.println("int main(int argc, const char *argv[]) {");
 	outmethod.println("  int i;");
+    outmethod.println("#ifdef TRANSSTATS \n");
+    outmethod.println("handle();\n");
+    outmethod.println("#endif\n");
+	if (state.THREAD||state.DSM) {
+	    outmethod.println("initializethreads();");
+	}
 	if (state.DSM) {
 	    outmethod.println("if (dstmStartup(argv[1])) {");
 	    if (GENERATEPRECISEGC) {
@@ -204,9 +214,6 @@ public class BuildCode {
 		outmethod.println("  struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc-1);");
 	    }
 	}
-	if (state.THREAD) {
-	    outmethod.println("initializethreads();");
-	}
 	if (state.DSM) {
 	    outmethod.println("  for(i=2;i<argc;i++) {");
 	} else 
@@ -250,16 +257,26 @@ public class BuildCode {
 	    outmethod.println("}");
 	}
 
-	if (state.THREAD) {
+	if (state.THREAD||state.DSM) {
 	    outmethod.println("pthread_mutex_lock(&gclistlock);");
 	    outmethod.println("threadcount--;");
 	    outmethod.println("pthread_cond_signal(&gccond);");
 	    outmethod.println("pthread_mutex_unlock(&gclistlock);");
-	    outmethod.println("pthread_exit(NULL);");
-	}
-
-
+	    if (state.THREAD)
+		outmethod.println("pthread_exit(NULL);");
+	}
+
+    outmethod.println("#ifdef TRANSSTATS \n");
+    outmethod.println("printf(\"******  Transaction Stats   ******\\n\");");
+    outmethod.println("printf(\"numTransAbort= %d\\n\", numTransAbort);");
+    outmethod.println("printf(\"numTransCommit= %d\\n\", numTransCommit);");
+    outmethod.println("printf(\"nchashSearch= %d\\n\", nchashSearch);");
+    outmethod.println("printf(\"nmhashSearch= %d\\n\", nmhashSearch);");
+    outmethod.println("printf(\"nprehashSearch= %d\\n\", nprehashSearch);");
+    outmethod.println("printf(\"nRemoteReadSend= %d\\n\", nRemoteSend);");
+    outmethod.println("#endif\n");
 	outmethod.println("}");
+
     }
 
     /* This method outputs code for each task. */
@@ -298,14 +315,18 @@ public class BuildCode {
      * objets and array that stores supertype and then the code for
      * the Java methods.. */
 
-    private void outputMethods(PrintWriter outmethod) {
+    protected void outputMethods(PrintWriter outmethod) {
 	outmethod.println("#include \"methodheaders.h\"");
 	outmethod.println("#include \"virtualtable.h\"");
-	outmethod.println("#include <runtime.h>");
+	outmethod.println("#include \"runtime.h\"");
 	if (state.DSM) {
+	    outmethod.println("#include \"addPrefetchEnhance.h\"");
 	    outmethod.println("#include \"localobjects.h\"");
 	}
-	if (state.THREAD)
+	if(state.MULTICORE) {
+	    outmethod.println("#include \"task.h\"");
+	}
+	if (state.THREAD||state.DSM)
 	    outmethod.println("#include <thread.h>");
 	if (state.main!=null) {
 	    outmethod.println("#include <string.h>");	    
@@ -349,7 +370,7 @@ public class BuildCode {
 	} 
     }
 
-    private void outputStructs(PrintWriter outstructs) {
+    protected void outputStructs(PrintWriter outstructs) {
 	outstructs.println("#ifndef STRUCTDEFS_H");
 	outstructs.println("#define STRUCTDEFS_H");
 	outstructs.println("#include \"classdefs.h\"");
@@ -391,8 +412,8 @@ public class BuildCode {
 	}
     }
 
-    private void outputClassDeclarations(PrintWriter outclassdefs) {
-	if (state.THREAD)
+    protected void outputClassDeclarations(PrintWriter outclassdefs) {
+	if (state.THREAD||state.DSM)
 	    outclassdefs.println("#include <pthread.h>");
 	if(state.OPTIONAL)
 	    outclassdefs.println("#include \"optionalstruct.h\"");
@@ -414,7 +435,13 @@ public class BuildCode {
 	}
 	if (state.TASK) {
 	    outclassdefs.println("  int flag;");
-	    outclassdefs.println("  void * flagptr;");
+	    if(!state.MULTICORE) {
+		outclassdefs.println("  void * flagptr;");
+	    } else {
+		outclassdefs.println("  int isolate;"); // indicate if this object is shared or not
+		outclassdefs.println("  int version;");
+		outclassdefs.println("  struct ___Object___ * original;");
+	    }
 	    if(state.OPTIONAL){
 		outclassdefs.println("  int numfses;");
 		outclassdefs.println("  int * fses;");
@@ -447,7 +474,7 @@ public class BuildCode {
 	outtask.println("struct taskdescriptor {");
 	outtask.println("void * taskptr;");
 	outtask.println("int numParameters;");
-	outtask.println("int numTotal;");
+	outtask.println("  int numTotal;");
 	outtask.println("struct parameterdescriptor **descriptorarray;");
 	outtask.println("char * name;");
 	outtask.println("};");
@@ -465,7 +492,9 @@ public class BuildCode {
 	    outrepairstructs.println("  int __type__;");
 	    if (state.TASK) {
 		outrepairstructs.println("  int __flag__;");
-		outrepairstructs.println("  int __flagptr__;");
+		if(!state.MULTICORE) {
+		    outrepairstructs.println("  int __flagptr__;");
+		}
 	    }
 	    printRepairStruct(cn, outrepairstructs);
 	    outrepairstructs.println("}\n");
@@ -510,7 +539,7 @@ public class BuildCode {
     }
 
     /** This method outputs TaskDescriptor information */
-    void generateTaskDescriptor(PrintWriter output, FlatMethod fm, TaskDescriptor task) {
+    private void generateTaskDescriptor(PrintWriter output, FlatMethod fm, TaskDescriptor task) {
 	for (int i=0;i<task.numParameters();i++) {
 	    VarDescriptor param_var=task.getParameter(i);
 	    TypeDescriptor param_type=task.getParamType(i);
@@ -601,8 +630,8 @@ public class BuildCode {
 
     /** The buildVirtualTables method outputs the virtual dispatch
      * tables for methods. */
-
-    private void buildVirtualTables(PrintWriter outvirtual) {
+    
+    protected void buildVirtualTables(PrintWriter outvirtual) {
     	Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();
 	while(classit.hasNext()) {
 	    ClassDescriptor cd=(ClassDescriptor)classit.next();
@@ -698,7 +727,19 @@ public class BuildCode {
      * information. */
 
     private void generateSizeArray(PrintWriter outclassdefs) {
-	outclassdefs.print("int classsize[]={");
+      outclassdefs.print("extern struct prefetchCountStats * evalPrefetch;\n");
+      outclassdefs.print("#ifdef TRANSSTATS \n");
+      outclassdefs.print("extern int numTransAbort;\n");
+      outclassdefs.print("extern int numTransCommit;\n");
+      outclassdefs.print("extern int nchashSearch;\n");
+      outclassdefs.print("extern int nmhashSearch;\n");
+      outclassdefs.print("extern int nprehashSearch;\n");
+      outclassdefs.print("extern int nRemoteSend;\n");
+      outclassdefs.print("extern void handle();\n");
+      outclassdefs.print("#endif\n");
+      outclassdefs.print("int numprefetchsites = " + pa.prefetchsiteid + ";\n");
+
+      outclassdefs.print("int classsize[]={");
 	Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
 	cdarray=new ClassDescriptor[state.numClasses()];
 	while(it.hasNext()) {
@@ -740,7 +781,7 @@ public class BuildCode {
      * These objects tell the compiler which temps need to be
      * allocated.  */
 
-    private void generateTempStructs(FlatMethod fm, LocalityBinding lb) {
+    protected void generateTempStructs(FlatMethod fm, LocalityBinding lb) {
 	MethodDescriptor md=fm.getMethod();
 	TaskDescriptor task=fm.getTask();
 	Set<TempDescriptor> saveset=lb!=null?locality.getTempSet(lb):null;
@@ -808,7 +849,7 @@ public class BuildCode {
 		    objecttemps.addPrim(tmp);
 	    }
 	    /* Create temp to hold revert table */
-	    if (lb.getHasAtomic()) {
+	    if (lb.getHasAtomic()||lb.isAtomic()) {
 		TempDescriptor reverttmp=new TempDescriptor("revertlist", typeutil.getClass(TypeUtil.ObjectClass));
 		if (GENERATEPRECISEGC)
 		    objecttemps.addPtr(reverttmp);
@@ -921,10 +962,14 @@ public class BuildCode {
 	if (!fieldorder.containsKey(cn)) {
 	    Vector fields=new Vector();
 	    fieldorder.put(cn,fields);
+	    if (sp==null&&!state.TASK) {
+		fields.add(cn.getFieldTable().get("cachedCode"));
+	    }
 	    Iterator fieldit=cn.getFields();
 	    while(fieldit.hasNext()) {
 		FieldDescriptor fd=(FieldDescriptor)fieldit.next();
-		if (sp==null||!sp.getFieldTable().contains(fd.getSymbol()))
+		if ((sp==null||!sp.getFieldTable().contains(fd.getSymbol()))&&
+		    (!fd.getSymbol().equals("cachedCode")||state.TASK))
 		    fields.add(fd);
 	    }
 	}
@@ -943,7 +988,7 @@ public class BuildCode {
     /* Map flags to integers consistently between inherited
      * classes. */
 
-    private void mapFlags(ClassDescriptor cn) {
+    protected void mapFlags(ClassDescriptor cn) {
 	ClassDescriptor sp=cn.getSuperDesc();
 	if (sp!=null)
 	    mapFlags(sp);
@@ -977,7 +1022,7 @@ public class BuildCode {
      * passed in (when PRECISE GC is enabled) and (2) function
      * prototypes for the methods */
 
-    private void generateCallStructs(ClassDescriptor cn, PrintWriter classdefout, PrintWriter output, PrintWriter headersout) {
+    protected void generateCallStructs(ClassDescriptor cn, PrintWriter classdefout, PrintWriter output, PrintWriter headersout) {
 	/* Output class structure */
 	classdefout.println("struct "+cn.getSafeSymbol()+" {");
 	classdefout.println("  int type;");
@@ -989,7 +1034,13 @@ public class BuildCode {
 
 	if (state.TASK) {
 	    classdefout.println("  int flag;");
-	    classdefout.println("  void * flagptr;");
+	    if((!state.MULTICORE) || (cn.getSymbol().equals("TagDescriptor"))) {
+		classdefout.println("  void * flagptr;");
+	    } else if (state.MULTICORE){
+		classdefout.println("  int isolate;"); // indicate if this object is shared or not
+		classdefout.println("  int version;");
+		classdefout.println("  struct ___Object___ * original;");
+	    }
 	    if (state.OPTIONAL){
 		classdefout.println("  int numfses;");
 		classdefout.println("  int * fses;");
@@ -1108,7 +1159,7 @@ public class BuildCode {
 	    printcomma=true;
 	}
 	
-	if (state.DSM&&lb.isAtomic()) {
+	if (state.DSM&&lb.isAtomic()&&!md.getModifiers().isNative()) {
 	    if (printcomma)
 		headersout.print(", ");
 	    headersout.print("transrecord_t * trans");
@@ -1197,6 +1248,8 @@ public class BuildCode {
     /***** Generate code for FlatMethod fm. *****/
 
     private void generateFlatMethod(FlatMethod fm, LocalityBinding lb, PrintWriter output) {
+	if (State.PRINTFLAT)
+	    System.out.println(fm.printMethod());
 	MethodDescriptor md=fm.getMethod();
 	
 	TaskDescriptor task=fm.getTask();
@@ -1243,8 +1296,11 @@ public class BuildCode {
 	/* Check to see if we need to do a GC if this is a
 	 * multi-threaded program...*/
 
-	if (state.THREAD&&GENERATEPRECISEGC) {
-	    output.println("checkcollect(&"+localsprefix+");");
+	if ((state.THREAD||state.DSM)&&GENERATEPRECISEGC) {
+	    if (state.DSM&&lb.isAtomic())
+		output.println("checkcollect2(&"+localsprefix+",trans);");
+	    else
+		output.println("checkcollect(&"+localsprefix+");");
 	}
 	
 	/* Do the actual code generation */
@@ -1261,7 +1317,7 @@ public class BuildCode {
 	    if (nodetolabel.containsKey(current_node))
 		output.println("L"+nodetolabel.get(current_node)+":");
 	    if (state.INSTRUCTIONFAILURE) {
-		if (state.THREAD) {
+		if (state.THREAD||state.DSM) {
 		    output.println("if ((++instructioncount)>failurecount) {instructioncount=0;injectinstructionfailure();}");
 		}
 		else
@@ -1296,13 +1352,12 @@ public class BuildCode {
 		    current_node=current_node.getNext(0);
 	    } else throw new Error();
 	}
-
 	output.println("}\n\n");
     }
 
     /** This method assigns labels to FlatNodes */
 
-    private Hashtable<FlatNode, Integer> assignLabels(FlatMethod fm) {
+    protected Hashtable<FlatNode, Integer> assignLabels(FlatMethod fm) {
 	HashSet tovisit=new HashSet();
 	HashSet visited=new HashSet();
 	int labelindex=0;
@@ -1335,7 +1390,7 @@ public class BuildCode {
 
 
     /** Generate text string that corresponds to the TempDescriptor td. */
-    private String generateTemp(FlatMethod fm, TempDescriptor td, LocalityBinding lb) {
+    protected String generateTemp(FlatMethod fm, TempDescriptor td, LocalityBinding lb) {
 	MethodDescriptor md=fm.getMethod();
 	TaskDescriptor task=fm.getTask();
 	TempObject objecttemps=(TempObject) tempstable.get(lb!=null?lb:md!=null?md:task);
@@ -1354,7 +1409,7 @@ public class BuildCode {
 	throw new Error();
     }
 
-    private void generateFlatNode(FlatMethod fm, LocalityBinding lb, FlatNode fn, PrintWriter output) {
+    protected void generateFlatNode(FlatMethod fm, LocalityBinding lb, FlatNode fn, PrintWriter output) {
 	switch(fn.kind()) {
 	case FKind.FlatAtomicEnterNode:
 	    generateFlatAtomicEnterNode(fm, lb, (FlatAtomicEnterNode) fn, output);
@@ -1403,7 +1458,10 @@ public class BuildCode {
 	    return;
 	case FKind.FlatBackEdge:
 	    if ((state.THREAD||state.DSM)&&GENERATEPRECISEGC) {
-		output.println("checkcollect(&"+localsprefix+");");
+		if(state.DSM&&locality.getAtomic(lb).get(fn).intValue()>0) {
+		    output.println("checkcollect2(&"+localsprefix+",trans);");
+		} else
+		    output.println("checkcollect(&"+localsprefix+");");
 	    } else
 		output.println("/* nop */");
 	    return;
@@ -1421,74 +1479,206 @@ public class BuildCode {
     }
  
     public void generateFlatPrefetchNode(FlatMethod fm, LocalityBinding lb, FlatPrefetchNode fpn, PrintWriter output) {
-	System.out.println("Inside generateFlatPrefetchNode()");
-    	if (state.PREFETCH) {
-	    System.out.println("The Prefetch pairs to be fetched are "+ fpn.hspp);
-	    Iterator it = fpn.hspp.iterator();
-	    for(;it.hasNext();) {
-		 PrefetchPair pp = (PrefetchPair) it.next();
-		 //TODO handle arrays in prefetch tuples, currently only handle fields
-		 Integer statusbase = locality.getNodePreTempInfo(lb,fpn).get(pp.base);
-		 System.out.println("DEBUG-> generateFlatPrefetchNode()" + statusbase);
-		 if(statusbase == LocalityAnalysis.GLOBAL) {
-		     // Generate oid for base
-	         } else {
-		     for(int i = 0; i<pp.desc.size(); i++) {
-		 	Object o = pp.desc.get(i);
-		 	if(!(o instanceof IndexDescriptor)) {
-				FieldDescriptor fd = (FieldDescriptor) o;
-				Integer statusfd = locality.getNodePreTempInfo(lb,fpn).get(fd);
-				System.out.println("DEBUG-> generateFlatPrefetchNode() fd" + statusfd);
-				//find out the locality of the fieldDescriptor
-				if(statusfd == LocalityAnalysis.GLOBAL) {
-					//generate oid for it
-				}
-		 	}
-		     }
-	  	 }
-             }
-             //Each temp descriptor can be an oid
-	     //Find locality of each prefetch tuple in the FLatPrefetchNode
-	     //Separate them as Local or Global
-	     //generate oids and offset value for prefetch tuple
-	}
+	if (state.PREFETCH) {
+	    Vector oids = new Vector();
+	    Vector fieldoffset = new Vector();
+	    Vector endoffset = new Vector();
+	    int tuplecount = 0;  //Keeps track of number of prefetch tuples that need to be generated
+	    for(Iterator it = fpn.hspp.iterator();it.hasNext();) {
+		PrefetchPair pp = (PrefetchPair) it.next();
+		Integer statusbase = locality.getNodePreTempInfo(lb,fpn).get(pp.base);
+		/* Find prefetches that can generate oid */
+		if(statusbase == LocalityAnalysis.GLOBAL) {
+		    generateTransCode(fm, lb, pp, oids, fieldoffset, endoffset, tuplecount, locality.getAtomic(lb).get(fpn).intValue()>0, false);
+		    tuplecount++;
+		} else if (statusbase == LocalityAnalysis.LOCAL) {
+		    generateTransCode(fm,lb,pp,oids,fieldoffset,endoffset,tuplecount,false,true);
+		} else {
+		    continue;
+		}
+	    }
+	    if (tuplecount==0)
+		return;
+	    output.println("{");
+	    output.println("/* prefetch */");
+        output.println("/* prefetchid_" + fpn.siteid + " */");
+	    output.println("void * prefptr;");
+	    output.println("int tmpindex;");
+
+        output.println("if((evalPrefetch["+fpn.siteid+"].operMode) || (evalPrefetch["+fpn.siteid+"].retrycount <= 0)) {");
+	    /*Create C code for oid array */
+	    output.print("   unsigned int oidarray_[] = {");
+	    boolean needcomma=false;
+	    for (Iterator it = oids.iterator();it.hasNext();) {
+		if (needcomma)
+		    output.print(", ");
+		output.print(it.next());
+		needcomma=true;
+	    }
+	    output.println("};");
+	    
+	    /*Create C code for endoffset values */
+	    output.print("   unsigned short endoffsetarry_[] = {");
+	    needcomma=false;
+	    for (Iterator it = endoffset.iterator();it.hasNext();) {
+		if (needcomma)
+		    output.print(", ");
+		output.print(it.next());
+		needcomma=true;
+	    }
+	    output.println("};");
+	    
+	    /*Create C code for Field Offset Values */
+	    output.print("   short fieldarry_[] = {");
+	    needcomma=false;
+	    for (Iterator it = fieldoffset.iterator();it.hasNext();) {
+		if (needcomma)
+		    output.print(", ");
+		output.print(it.next());
+		needcomma=true;
+	    }
+	    output.println("};");
+	    /* make the prefetch call to Runtime */
+        output.println("   if(!evalPrefetch["+fpn.siteid+"].operMode) {"); 
+	    output.println("     evalPrefetch["+fpn.siteid+"].retrycount = RETRYINTERVAL;");
+	    output.println("   }");
+	    output.println("   prefetch("+fpn.siteid+" ,"+tuplecount+", oidarray_, endoffsetarry_, fieldarry_);");
+	    output.println(" } else {");
+	    output.println("   evalPrefetch["+fpn.siteid+"].retrycount--;");
+	    output.println(" }");
+	    output.println("}");
+	}   
     }   
+    
+    public void generateTransCode(FlatMethod fm, LocalityBinding lb,PrefetchPair pp, Vector oids, Vector fieldoffset, Vector endoffset, int tuplecount, boolean inside, boolean localbase) {
+	short offsetcount = 0;
+	int breakindex=0;
+	if (inside) {
+	    breakindex=1;
+	} else if (localbase) {
+	    for(;breakindex<pp.desc.size();breakindex++) {
+		Descriptor desc=pp.getDescAt(breakindex);
+		if (desc instanceof FieldDescriptor) {
+		    FieldDescriptor fd=(FieldDescriptor)desc;
+		    if (fd.isGlobal()) {
+			break;
+		    }
+		}
+	    }
+	    breakindex++;
+	}
 
-    public void generateFlatGlobalConvNode(FlatMethod fm, LocalityBinding lb, FlatGlobalConvNode fgcn, PrintWriter output) {
-	if (lb!=fgcn.getLocality())
+	if (breakindex>pp.desc.size()) //all local
 	    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)+");");
+
+	TypeDescriptor lasttype=pp.base.getType();
+	String basestr=generateTemp(fm, pp.base, lb);
+	String teststr="";
+	boolean maybenull=fm.getMethod().isStatic()||
+	    !pp.base.equals(fm.getParameter(0));
+			    
+	for(int i=0;i<breakindex;i++) {
+	    String indexcheck="";
+
+	    Descriptor desc=pp.getDescAt(i);
+	    if (desc instanceof FieldDescriptor) {
+		FieldDescriptor fd=(FieldDescriptor)desc;
+		if (maybenull) {
+		    if (!teststr.equals(""))
+			teststr+="&&";
+		    teststr+="((prefptr="+basestr+")!=NULL)";
+		    basestr="((struct "+lasttype.getSafeSymbol()+" *)prefptr)->"+fd.getSafeSymbol();
+		} else {
+		    basestr=basestr+"->"+fd.getSafeSymbol();
+		    maybenull=true;
+		}
+		lasttype=fd.getType();
+	    } else {
+		IndexDescriptor id=(IndexDescriptor)desc;
+		indexcheck="((tmpindex=";
+		for(int j=0;j<id.tddesc.size();j++) {
+		    indexcheck+=generateTemp(fm, id.getTempDescAt(j), lb)+"+";
+		}
+		indexcheck+=id.offset+")>=0)&&(tmpindex<((struct ArrayObject *)prefptr)->___length___)";
+
+		if (!teststr.equals(""))
+		    teststr+="&&";
+		teststr+="((prefptr="+basestr+")!= NULL) &&"+indexcheck;
+		basestr="((void **)(((char *) &(((struct ArrayObject *)prefptr)->___length___))+sizeof(int)))[tmpindex]";
+		maybenull=true;
+		lasttype=lasttype.dereference();
+	    }
+	}
+	
+	String oid;
+	if (teststr.equals("")) {
+	    oid="((unsigned int)"+basestr+")";
 	} else {
-	    /* Need to convert to OID */
-	    output.println(generateTemp(fm, fgcn.getSrc(),lb)+"=(void *)COMPOID("+generateTemp(fm, fgcn.getSrc(),lb)+");");
+	    oid="((unsigned int)(("+teststr+")?"+basestr+":NULL))";
+	}
+	oids.add(oid);
+	
+	for(int i = breakindex; i < pp.desc.size(); i++) {
+	    String newfieldoffset;
+	    Object desc = pp.getDescAt(i);
+	    if(desc instanceof FieldDescriptor) {
+		FieldDescriptor fd=(FieldDescriptor)desc;
+		newfieldoffset = new String("(unsigned int)(&(((struct "+ lasttype.getSafeSymbol()+" *)0)->"+ fd.getSafeSymbol()+ "))");
+		lasttype=fd.getType();
+	    } else {
+		newfieldoffset = "";
+		IndexDescriptor id=(IndexDescriptor)desc;
+		for(int j = 0; j < id.tddesc.size(); j++) {
+		    newfieldoffset += generateTemp(fm, id.getTempDescAt(j), lb) + "+";
+		}
+		newfieldoffset += id.offset.toString();
+		lasttype=lasttype.dereference();
+	    }
+	    fieldoffset.add(newfieldoffset);
 	}
+
+	int base=(tuplecount>0)?((Short)endoffset.get(tuplecount-1)).intValue():0;
+	base+=pp.desc.size()-breakindex;
+	endoffset.add(new Short((short)base));
+    }
+
+
+  
+    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)+"=(void *)COMPOID("+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)
-	    return;
-	/* 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),lb)+"="+generateTemp(fm,tmp,lb)+";");
-	}
-	output.println("goto transstart"+faen.getIdentifier()+";");
+	    /* Check to see if we need to generate code for this atomic */
+	    if (locality.getAtomic(lb).get(faen.getPrev(0)).intValue()>0)
+		    return;
+	    /* 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),lb)+"="+generateTemp(fm,tmp,lb)+";");
+	    }
+	    output.println("goto transstart"+faen.getIdentifier()+";");
 
-	/******* Print code to retry aborted transaction *******/
-	output.println("transretry"+faen.getIdentifier()+":");
+	    /******* Print code to retry aborted transaction *******/
+	    output.println("transretry"+faen.getIdentifier()+":");
 
-	/* Restore temps */
-	for(Iterator<TempDescriptor> tmpit=locality.getTemps(lb).get(faen).iterator();tmpit.hasNext();) {
-	    TempDescriptor tmp=tmpit.next();
-	    output.println(generateTemp(fm, tmp,lb)+"="+generateTemp(fm,backuptable.get(tmp),lb)+";");
-	}
+	    /* Restore temps */
+	    for(Iterator<TempDescriptor> tmpit=locality.getTemps(lb).get(faen).iterator();tmpit.hasNext();) {
+		    TempDescriptor tmp=tmpit.next();
+		    output.println(generateTemp(fm, tmp,lb)+"="+generateTemp(fm,backuptable.get(tmp),lb)+";");
+	    }
+
+	    /********* Need to revert local object store ********/
+	    String revertptr=generateTemp(fm, reverttable.get(lb),lb);
 
-	/********* 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+";");
@@ -1561,10 +1751,16 @@ public class BuildCode {
 	    
 	    output.print(objectparams.numPointers());
 	    output.print(", & "+localsprefix);
-	    if (fc.getThis()!=null) {
+	    if (md.getThis()!=null) {
 		output.print(", ");
 		output.print("(struct "+md.getThis().getType().getSafeSymbol() +" *)"+ generateTemp(fm,fc.getThis(),lb));
 	    }
+	    if (fc.getThis()!=null&&md.getThis()==null) {
+		System.out.println("WARNING!!!!!!!!!!!!");
+		System.out.println("Source code calls static method"+md+"on an object in "+fm.getMethod()+"!");		
+	    }
+	    
+
 	    for(int i=0;i<fc.numArgs();i++) {
 		Descriptor var=md.getParameter(i);
 		TempDescriptor paramtemp=(TempDescriptor)temptovar.get(var);
@@ -1625,6 +1821,14 @@ public class BuildCode {
 		    output.print(temp.getType().getSafeSymbol());
 	    }
 
+	    if (state.DSM&&locality.getBinding(lb,fc).isAtomic()&&!fc.getMethod().getModifiers().isNative()) {
+		LocalityBinding fclb=locality.getBinding(lb, fc);
+		if (printcomma)
+		    output.print(", ");
+		output.print("transrecord_t *");
+		printcomma=true;
+	    }
+
 	    if (state.DSM) {
 		LocalityBinding fclb=locality.getBinding(lb, fc);
 		output.print("))virtualtable["+generateTemp(fm,fc.getThis(),lb)+"->type*"+maxcount+"+"+virtualcalls.getLocalityNumber(fclb)+"])");
@@ -1639,7 +1843,7 @@ public class BuildCode {
 	    needcomma=true;
 	}
 
-	if (state.DSM&&locality.getBinding(lb,fc).isAtomic()) {
+	if (state.DSM&&locality.getBinding(lb,fc).isAtomic()&&!fc.getMethod().getModifiers().isNative()) {
 	    if (needcomma)
 		output.print(",");
 	    output.print("trans");
@@ -1728,7 +1932,9 @@ public class BuildCode {
 	    } else if (status==LocalityAnalysis.EITHER) {
 		//Code is reading from a null pointer
  		output.println("if ("+generateTemp(fm, ffn.getSrc(),lb)+") {");
-		output.println("printf(\"BIG ERROR\n\");exit(-1);}");
+ 		output.println("#ifndef RAW");
+ 		output.println("printf(\"BIG ERROR\\n\");exit(-1);}");
+ 		output.println("#endif");
 		//This should throw a suitable null pointer error
 		output.println(generateTemp(fm, ffn.getDst(),lb)+"="+ generateTemp(fm,ffn.getSrc(),lb)+"->"+ ffn.getField().getSafeSymbol()+";");
 	    } else
@@ -1764,12 +1970,14 @@ public class BuildCode {
 		/** Check if we need to copy */
 		output.println("if(!"+dst+"->"+localcopystr+") {");
 		/* Link object into list */
-		output.println(dst+"->"+nextobjstr+"=trans->revertlist;");
-		output.println("trans->revertlist=(struct ___Object___ *)"+dst+";");
+		String revertptr=generateTemp(fm, reverttable.get(lb),lb);
+		output.println(revertptr+"=trans->revertlist;");
 		if (GENERATEPRECISEGC)
 		    output.println("COPY_OBJ((struct garbagelist *)&"+localsprefix+",(struct ___Object___ *)"+dst+");");
 		else
 		    output.println("COPY_OBJ("+dst+");");
+		output.println(dst+"->"+nextobjstr+"="+revertptr+";");
+		output.println("trans->revertlist=(struct ___Object___ *)"+dst+";");
 		output.println("}");
 		if (srcglobal)
 		    output.println(dst+"->"+ fsfn.getField().getSafeSymbol()+"=srcoid;");
@@ -1778,7 +1986,9 @@ public class BuildCode {
 	    } else if (statusdst.equals(LocalityAnalysis.EITHER)) {
 		//writing to a null...bad
 		output.println("if ("+dst+") {");
-		output.println("printf(\"BIG ERROR 2\n\");exit(-1);}");
+		output.println("#ifndef RAW");
+ 		output.println("printf(\"BIG ERROR 2\\n\");exit(-1);}");
+ 		output.println("#endif");
 		if (srcglobal)
 		    output.println(dst+"->"+ fsfn.getField().getSafeSymbol()+"=srcoid;");
 		else
@@ -1805,8 +2015,32 @@ public class BuildCode {
 	    output.println("if ("+generateTemp(fm, fen.getIndex(),lb)+"< 0 || "+generateTemp(fm, fen.getIndex(),lb)+" >= "+generateTemp(fm,fen.getSrc(),lb) + "->___length___)");
 	    output.println("failedboundschk();");
 	}
+	if (state.DSM) {
+	    Integer status=locality.getNodePreTempInfo(lb,fen).get(fen.getSrc());
+	    if (status==LocalityAnalysis.GLOBAL) {
+		String dst=generateTemp(fm, fen.getDst(),lb);
 
-	output.println(generateTemp(fm, fen.getDst(),lb)+"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex(),lb)+"];");
+		if (elementtype.isPtr()) {
+		    output.println(dst +"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex(),lb)+"];");
+		    output.println(dst+"=(void *) transRead(trans, (unsigned int) "+dst+");");
+		} else {
+		    output.println(dst +"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex(),lb)+"];");
+		}
+	    } else if (status==LocalityAnalysis.LOCAL) {
+		output.println(generateTemp(fm, fen.getDst(),lb)+"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex(),lb)+"];");
+	    } else if (status==LocalityAnalysis.EITHER) {
+		//Code is reading from a null pointer
+ 		output.println("if ("+generateTemp(fm, fen.getSrc(),lb)+") {");
+ 		output.println("#ifndef RAW");
+ 		output.println("printf(\"BIG ERROR\\n\");exit(-1);}");
+ 		output.println("#endif");
+		//This should throw a suitable null pointer error
+		output.println(generateTemp(fm, fen.getDst(),lb)+"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex(),lb)+"];");
+	    } else
+		throw new Error("Read from non-global/non-local in:"+lb.getExplanation());
+	} else {
+	    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, LocalityBinding lb, FlatSetElementNode fsen, PrintWriter output) {
@@ -1821,15 +2055,55 @@ public class BuildCode {
 	else 
 	    type=elementtype.getSafeSymbol()+" ";
 
+
 	if (fsen.needsBoundsCheck()) {
 	    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(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex(),lb)+"]="+generateTemp(fm,fsen.getSrc(),lb)+";");
+	if (state.DSM && locality.getAtomic(lb).get(fsen).intValue()>0) {
+	    Integer statussrc=locality.getNodePreTempInfo(lb,fsen).get(fsen.getSrc());
+	    Integer statusdst=locality.getNodePreTempInfo(lb,fsen).get(fsen.getDst());
+	    boolean srcglobal=statussrc==LocalityAnalysis.GLOBAL;
+	    boolean dstglobal=statusdst==LocalityAnalysis.GLOBAL;
+	    boolean dstlocal=statusdst==LocalityAnalysis.LOCAL;
+	    
+	    if (dstglobal) {
+		output.println("*((unsigned int *)&("+generateTemp(fm,fsen.getDst(),lb)+"->___localcopy___))|=DIRTY;");
+	    } else if (dstlocal) {
+		/** Check if we need to copy */
+		String dst=generateTemp(fm, fsen.getDst(),lb);
+		output.println("if(!"+dst+"->"+localcopystr+") {");
+		/* Link object into list */
+		String revertptr=generateTemp(fm, reverttable.get(lb),lb);
+		output.println(revertptr+"=trans->revertlist;");
+		if (GENERATEPRECISEGC)
+		    output.println("COPY_OBJ((struct garbagelist *)&"+localsprefix+",(struct ___Object___ *)"+dst+");");
+		else
+		    output.println("COPY_OBJ("+dst+");");
+		output.println(dst+"->"+nextobjstr+"="+revertptr+";");
+		output.println("trans->revertlist=(struct ___Object___ *)"+dst+";");
+		output.println("}");
+	    } else throw new Error("Unknown array type");
+	    if (srcglobal) {
+		output.println("{");
+		String src=generateTemp(fm, fsen.getSrc(), lb);
+		output.println("int srcoid=(int)"+src+"->"+oidstr+";");
+		output.println("((int*)(((char *) &("+ generateTemp(fm,fsen.getDst(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex(),lb)+"]=srcoid;");
+		output.println("}");
+	    } else {
+		output.println("(("+type +"*)(((char *) &("+ generateTemp(fm,fsen.getDst(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex(),lb)+"]="+generateTemp(fm,fsen.getSrc(),lb)+";");
+	    }
+	} else
+	    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, LocalityBinding lb, FlatNew fn, PrintWriter output) {
+	if (state.DSM && locality.getAtomic(lb).get(fn).intValue()>0&&!fn.isGlobal()) {
+	    //Stash pointer in case of GC
+	    String revertptr=generateTemp(fm, reverttable.get(lb),lb);
+	    output.println(revertptr+"=trans->revertlist;");
+	}
 	if (fn.getType().isArray()) {
 	    int arrayid=state.getArrayNumber(fn.getType())+state.numClasses();
 	    if (fn.isGlobal()) {
@@ -1848,6 +2122,10 @@ public class BuildCode {
 		output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_new("+fn.getType().getClassDesc().getId()+");");
 	    }
 	}
+	if (state.DSM && locality.getAtomic(lb).get(fn).intValue()>0&&!fn.isGlobal()) {
+	    String revertptr=generateTemp(fm, reverttable.get(lb),lb);
+	    output.println("trans->revertlist="+revertptr+";");
+	}
     }
 
     private void generateFlatTagDeclaration(FlatMethod fm, LocalityBinding lb, FlatTagDeclaration fn, PrintWriter output) {
@@ -1859,9 +2137,16 @@ public class BuildCode {
     }
 
     private void generateFlatOpNode(FlatMethod fm, LocalityBinding lb, FlatOpNode fon, PrintWriter output) {
-	if (fon.getRight()!=null)
-	    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)
+	if (fon.getRight()!=null) {
+	    if (fon.getOp().getOp()==Operation.URIGHTSHIFT) {
+		if (fon.getLeft().getType().isLong())
+		    output.println(generateTemp(fm, fon.getDest(),lb)+" = ((unsigned long long)"+generateTemp(fm, fon.getLeft(),lb)+")>>"+generateTemp(fm,fon.getRight(),lb)+";");
+		else
+		    output.println(generateTemp(fm, fon.getDest(),lb)+" = ((unsigned int)"+generateTemp(fm, fon.getLeft(),lb)+")>>"+generateTemp(fm,fon.getRight(),lb)+";");
+
+	    } else
+		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(),lb)+" = "+generateTemp(fm, fon.getLeft(),lb)+";");
 	else if (fon.getOp().getOp()==Operation.UNARYPLUS)
 	    output.println(generateTemp(fm, fon.getDest(),lb)+" = "+generateTemp(fm, fon.getLeft(),lb)+";");
@@ -1869,6 +2154,8 @@ public class BuildCode {
 	    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(),lb)+" = !"+generateTemp(fm, fon.getLeft(),lb)+";");
+	else if (fon.getOp().getOp()==Operation.COMP)
+	    output.println(generateTemp(fm, fon.getDest(),lb)+" = ~"+generateTemp(fm, fon.getLeft(),lb)+";");
 	else if (fon.getOp().getOp()==Operation.ISAVAILABLE) {
 	    output.println(generateTemp(fm, fon.getDest(),lb)+" = "+generateTemp(fm, fon.getLeft(),lb)+"->fses==NULL;");
 	} else
@@ -1890,7 +2177,17 @@ public class BuildCode {
 	    output.println(generateTemp(fm, fln.getDst(),lb)+"=0;");
 	else if (fln.getType().getSymbol().equals(TypeUtil.StringClass)) {
 	    if (GENERATEPRECISEGC) {
+		if (state.DSM && locality.getAtomic(lb).get(fln).intValue()>0) {
+		    //Stash pointer in case of GC
+		    String revertptr=generateTemp(fm, reverttable.get(lb),lb);
+		    output.println(revertptr+"=trans->revertlist;");
+		}
 		output.println(generateTemp(fm, fln.getDst(),lb)+"=NewString(&"+localsprefix+", \""+FlatLiteralNode.escapeString((String)fln.getValue())+"\","+((String)fln.getValue()).length()+");");
+		if (state.DSM && locality.getAtomic(lb).get(fln).intValue()>0) {
+		    //Stash pointer in case of GC
+		    String revertptr=generateTemp(fm, reverttable.get(lb),lb);
+		    output.println("trans->revertlist="+revertptr+";");
+		}
 	    } else {
 		output.println(generateTemp(fm, fln.getDst(),lb)+"=NewString(\""+FlatLiteralNode.escapeString((String)fln.getValue())+"\","+((String)fln.getValue()).length()+");");
 	    }
@@ -1902,21 +2199,24 @@ public class BuildCode {
 	} else if (fln.getType().isChar()) {
 	    String st=FlatLiteralNode.escapeString(fln.getValue().toString());
 	    output.println(generateTemp(fm, fln.getDst(),lb)+"='"+st+"';");
+	} else if (fln.getType().isLong()) {
+	    output.println(generateTemp(fm, fln.getDst(),lb)+"="+fln.getValue()+"LL;");
 	} else
 	    output.println(generateTemp(fm, fln.getDst(),lb)+"="+fln.getValue()+";");
     }
 
-    private void generateFlatReturnNode(FlatMethod fm, LocalityBinding lb, FlatReturnNode frn, PrintWriter output) {
+    protected void generateFlatReturnNode(FlatMethod fm, LocalityBinding lb, FlatReturnNode frn, PrintWriter output) {
 	if (frn.getReturnTemp()!=null) {
 	    if (frn.getReturnTemp().getType().isPtr())
 		output.println("return (struct "+fm.getMethod().getReturnType().getSafeSymbol()+"*)"+generateTemp(fm, frn.getReturnTemp(), lb)+";");
 	    else
 		output.println("return "+generateTemp(fm, frn.getReturnTemp(), lb)+";");
-	} else
+	} else {
 	    output.println("return;");
+	}
     }
 
-    private void generateFlatCondBranch(FlatMethod fm, LocalityBinding lb, FlatCondBranch fcb, String label, PrintWriter output) {
+    protected void generateFlatCondBranch(FlatMethod fm, LocalityBinding lb, FlatCondBranch fcb, String label, PrintWriter output) {
 	output.println("if (!"+generateTemp(fm, fcb.getTest(),lb)+") goto "+label+";");
     }
 
@@ -2106,14 +2406,24 @@ public class BuildCode {
 		ormask=((Integer)flagortable.get(temp)).intValue();
 	    if (flagandtable.containsKey(temp))
 		andmask=((Integer)flagandtable.get(temp)).intValue();
-	    if (ffan.getTaskType()==FlatFlagActionNode.NEWOBJECT) {
-		output.println("flagorandinit("+generateTemp(fm, temp, lb)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
-	    } else {
-		output.println("flagorand("+generateTemp(fm, temp, lb)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
-	    }
+	    generateFlagOrAnd(ffan, fm, lb, temp, output, ormask, andmask);
+	    generateObjectDistribute(ffan, fm, lb, temp, output);
+	}
+    }
+    
+    protected void generateFlagOrAnd(FlatFlagActionNode ffan, FlatMethod fm, LocalityBinding lb, TempDescriptor temp, 
+	                             PrintWriter output, int ormask, int andmask) {
+	if (ffan.getTaskType()==FlatFlagActionNode.NEWOBJECT) {
+	    output.println("flagorandinit("+generateTemp(fm, temp, lb)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
+	} else {
+	    output.println("flagorand("+generateTemp(fm, temp, lb)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
 	}
     }
 
+    protected void generateObjectDistribute(FlatFlagActionNode ffan, FlatMethod fm, LocalityBinding lb, TempDescriptor temp, PrintWriter output) {
+	output.println("enqueueObject("+generateTemp(fm, temp, lb)+");");
+    }
+    
     void generateOptionalHeader(PrintWriter headers) {
 
 	 //GENERATE HEADERS
@@ -2514,6 +2824,9 @@ public class BuildCode {
 	
 	return l;
     }
+    
+    protected void outputTransCode(PrintWriter output) {
+    }
 }