Robust/src/IR/Flat/BuildCodeTran.java

   1 package IR.Flat;
   2 import IR.Tree.Modifiers;
   3 import IR.Tree.FlagExpressionNode;
   4 import IR.Tree.DNFFlag;
   5 import IR.Tree.DNFFlagAtom;
   6 import IR.Tree.TagExpressionList;
   7 import IR.Tree.OffsetNode;
   8 import IR.*;
   9
  10 import java.util.*;
  11 import java.io.*;
  12
  13 import Util.Relation;
  14 import Analysis.TaskStateAnalysis.FlagState;
  15 import Analysis.TaskStateAnalysis.FlagComparator;
  16 import Analysis.TaskStateAnalysis.OptionalTaskDescriptor;
  17 import Analysis.TaskStateAnalysis.Predicate;
  18 import Analysis.TaskStateAnalysis.SafetyAnalysis;
  19 import Analysis.TaskStateAnalysis.TaskIndex;
  20 import Analysis.Locality.LocalityAnalysis;
  21 import Analysis.Locality.LocalityBinding;
  22 import Analysis.Locality.DiscoverConflicts;
  23 import Analysis.Locality.DCWrapper;
  24 import Analysis.Locality.DelayComputation;
  25 import Analysis.Locality.BranchAnalysis;
  26 import Analysis.CallGraph.CallGraph;
  27 import Analysis.Prefetch.*;
  28 import Analysis.Loops.WriteBarrier;
  29 import Analysis.Loops.GlobalFieldType;
  30 import Analysis.Locality.TypeAnalysis;
  31 import Util.CodePrinter;
  32
  33 public class BuildCodeTran extends BuildCode {
  34   String oidstr="___nextobject___";
  35   LocalityAnalysis locality;
  36   Hashtable<LocalityBinding, TempDescriptor> reverttable;
  37   Hashtable<LocalityBinding, Hashtable<TempDescriptor, TempDescriptor>> backuptable;
  38   PrefetchAnalysis pa;
  39   WriteBarrier wb;
  40   DiscoverConflicts dc;
  41   DiscoverConflicts recorddc;
  42   DCWrapper delaycomp;
  43   LocalityBinding currlb;
  44
  45
  46   public BuildCodeTran(State st, Hashtable temptovar, TypeUtil typeutil, SafetyAnalysis sa, PrefetchAnalysis pa, CallGraph callgraph) {
  47     this(st, temptovar, typeutil, null, sa, pa, callgraph);
  48   }
  49
  50   public BuildCodeTran(State st, Hashtable temptovar, TypeUtil typeutil, LocalityAnalysis locality, PrefetchAnalysis pa, CallGraph callgraph) {
  51     this(st, temptovar, typeutil, locality, null, pa, callgraph);
  52   }
  53
  54   public BuildCodeTran(State st, Hashtable temptovar, TypeUtil typeutil, LocalityAnalysis locality, SafetyAnalysis sa, PrefetchAnalysis pa, CallGraph callgraph) {
  55     super(st, temptovar, typeutil, sa, callgraph);
  56     this.sa=sa;
  57     this.virtualcalls=new Virtual(state, locality, callgraph);
  58     if (state.SINGLETM)
  59       oidstr="___objlocation___";
  60     if (locality!=null) {
  61       this.locality=locality;
  62       this.reverttable=new Hashtable<LocalityBinding, TempDescriptor>();
  63       this.backuptable=new Hashtable<LocalityBinding, Hashtable<TempDescriptor, TempDescriptor>>();
  64       this.wb=new WriteBarrier(locality, st);
  65     }
  66     if (state.SINGLETM&&state.DCOPTS) {
  67       TypeAnalysis typeanalysis=new TypeAnalysis(locality, st, typeutil,callgraph);
  68       GlobalFieldType gft=new GlobalFieldType(callgraph, st, typeutil.getMain());
  69       this.dc=new DiscoverConflicts(locality, st, typeanalysis, gft);
  70       dc.doAnalysis();
  71     }
  72     if (state.DELAYCOMP) {
  73       TypeAnalysis typeanalysis=new TypeAnalysis(locality, st, typeutil,callgraph);
  74       GlobalFieldType gft=new GlobalFieldType(callgraph, st, typeutil.getMain());
  75       delaycomp=new DCWrapper(locality, st, typeanalysis, gft);
  76       dc=delaycomp.getConflicts();
  77       recorddc=new DiscoverConflicts(locality, st, typeanalysis, delaycomp.getCannotDelayMap(), true, true, null);
  78       recorddc.doAnalysis();
  79     }
  80   }
  81
  82   /** The buildCode method outputs C code for all the methods.  The Flat
  83    * versions of the methods must already be generated and stored in
  84    * the State object. */
  85
  86   PrintWriter outsandbox=null;
  87
  88   protected void buildCodeSetup() {
  89     try {
  90       if (state.SANDBOX) {
  91         outsandbox=new CodePrinter(new FileOutputStream(PREFIX+"sandboxdefs.c"), true);
  92       }
  93     } catch (Exception e) {
  94       e.printStackTrace();
  95       System.exit(-1);
  96     }
  97   }
  98
  99   protected void additionalIncludesMethodsHeader(PrintWriter outmethodheader) {
 100     if (state.DSM)
 101       outmethodheader.println("#include \"dstm.h\"");
 102     if (state.SANDBOX) {
 103       outmethodheader.println("#include \"sandbox.h\"");
 104     }
 105     if (state.SINGLETM) {
 106       outmethodheader.println("#include \"tm.h\"");
 107       outmethodheader.println("#include \"delaycomp.h\"");
 108       outmethodheader.println("#include \"inlinestm.h\"");
 109     }
 110     if (state.ABORTREADERS) {
 111       outmethodheader.println("#include \"abortreaders.h\"");
 112       outmethodheader.println("#include <setjmp.h>");
 113     }
 114
 115   }
 116
 117
 118   protected void outputMainMethod(PrintWriter outmethod) {
 119     outmethod.println("int main(int argc, const char *argv[]) {");
 120     outmethod.println("  int i;");
 121     outmethod.println("  global_defs_p=calloc(1, sizeof(struct global_defs_t));");
 122     outmethod.println("  global_defsprim_p=calloc(1, sizeof(struct global_defsprim_t));");
 123     if (GENERATEPRECISEGC) {
 124       outmethod.println("  global_defs_p->size="+globaldefscount+";");
 125       outmethod.println("  for(i=0;i<"+globaldefscount+";i++) {");
 126       outmethod.println("    ((struct garbagelist *)global_defs_p)->array[i]=NULL;");
 127       outmethod.println("  }");
 128     }
 129
 130     outputClassObjects(outmethod);
 131     outputStaticBlocks(outmethod);
 132     additionalCodeAtTopOfMain(outmethod);
 133
 134     if (state.DSM) {
 135       if (state.DSMRECOVERYSTATS) {
 136         outmethod.println("#ifdef RECOVERYSTATS \n");
 137         outmethod.println("handle();\n");
 138         outmethod.println("#endif\n");
 139       } else {
 140         outmethod.println("#if defined(TRANSSTATS) || defined(RECOVERYSTATS) \n");
 141         outmethod.println("handle();\n");
 142         outmethod.println("#endif\n");
 143       }
 144     }
 145     outmethod.println("initializethreads();");
 146
 147     if (state.DSM) {
 148       outmethod.println("if (dstmStartup(argv[1])) {");
 149       if (GENERATEPRECISEGC) {
 150         outmethod.println("  struct ArrayObject * stringarray=allocate_newarray(NULL, STRINGARRAYTYPE, argc-2);");
 151       } else {
 152         outmethod.println("  struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc-2);");
 153       }
 154     } else {
 155       if (GENERATEPRECISEGC) {
 156         outmethod.println("  struct ArrayObject * stringarray=allocate_newarray(NULL, STRINGARRAYTYPE, argc-1);");
 157       } else {
 158         outmethod.println("  struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc-1);");
 159       }
 160     }
 161     if (state.DSM) {
 162       outmethod.println("  for(i=2;i<argc;i++) {");
 163     } else
 164       outmethod.println("  for(i=1;i<argc;i++) {");
 165     outmethod.println("    int length=strlen(argv[i]);");
 166     if (GENERATEPRECISEGC) {
 167       outmethod.println("    struct ___String___ *newstring=NewString(NULL, argv[i], length);");
 168     } else {
 169       outmethod.println("    struct ___String___ *newstring=NewString(argv[i], length);");
 170     }
 171     if (state.DSM)
 172       outmethod.println("    ((void **)(((char *)& stringarray->___length___)+sizeof(int)))[i-2]=newstring;");
 173     else
 174       outmethod.println("    ((void **)(((char *)& stringarray->___length___)+sizeof(int)))[i-1]=newstring;");
 175     outmethod.println("  }");
 176
 177     MethodDescriptor md=typeutil.getMain();
 178     ClassDescriptor cd=typeutil.getMainClass();
 179
 180     outmethod.println("   {");
 181     if (GENERATEPRECISEGC) {
 182       outmethod.print("       struct "+cd.getSafeSymbol()+locality.getMain().getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
 183       outmethod.println("1, NULL,"+"stringarray};");
 184       outmethod.println("     "+cd.getSafeSymbol()+locality.getMain().getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(& __parameterlist__);");
 185     } else {
 186       outmethod.println("     "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(stringarray);");
 187     }
 188     outmethod.println("   }");
 189
 190     if (state.DSM) {
 191       outmethod.println("}");
 192     }
 193
 194     outmethod.println("pthread_mutex_lock(&gclistlock);");
 195     outmethod.println("threadcount--;");
 196     outmethod.println("pthread_cond_signal(&gccond);");
 197     outmethod.println("pthread_mutex_unlock(&gclistlock);");
 198
 199     outmethod.println("#if defined(TRANSSTATS) \n");
 200     outmethod.println("printf(\"******  Transaction Stats   ******\\n\");");
 201     outmethod.println("printf(\"numTransCommit= %d\\n\", numTransCommit);");
 202     outmethod.println("printf(\"numTransAbort= %d\\n\", numTransAbort);");
 203     outmethod.println("printf(\"nSoftAbort= %d\\n\", nSoftAbort);");
 204     if (state.DSM) {
 205       outmethod.println("printf(\"nchashSearch= %d\\n\", nchashSearch);");
 206       outmethod.println("printf(\"nmhashSearch= %d\\n\", nmhashSearch);");
 207       outmethod.println("printf(\"nprehashSearch= %d\\n\", nprehashSearch);");
 208       outmethod.println("printf(\"ndirtyCacheObj= %d\\n\", ndirtyCacheObj);");
 209       outmethod.println("printf(\"nRemoteReadSend= %d\\n\", nRemoteSend);");
 210       outmethod.println("printf(\"bytesSent= %d\\n\", bytesSent);");
 211       outmethod.println("printf(\"bytesRecv= %d\\n\", bytesRecv);");
 212       outmethod.println("printf(\"totalObjSize= %d\\n\", totalObjSize);");
 213       outmethod.println("printf(\"sendRemoteReq= %d\\n\", sendRemoteReq);");
 214       outmethod.println("printf(\"getResponse= %d\\n\", getResponse);");
 215     } else if (state.SINGLETM) {
 216       outmethod.println("printf(\"nSoftAbortAbort= %d\\n\", nSoftAbortAbort);");
 217       outmethod.println("printf(\"nSoftAbortCommit= %d\\n\", nSoftAbortCommit);");
 218       outmethod.println("#ifdef STMSTATS\n");
 219       outmethod.println("for(i=0; i<TOTALNUMCLASSANDARRAY; i++) {\n");
 220       outmethod.println("  printf(\"typesCausingAbort[%2d] numaccess= %5d numabort= %3d\\n\", i, typesCausingAbort[i].numaccess, typesCausingAbort[i].numabort);\n");
 221       outmethod.println("}\n");
 222       outmethod.println("#endif\n");
 223       outmethod.println("fflush(stdout);");
 224     }
 225     outmethod.println("#endif\n");
 226
 227
 228     if (state.EVENTMONITOR) {
 229       outmethod.println("dumpdata();");
 230     }
 231
 232     if (state.SINGLETM)
 233       outmethod.println("pthread_exit(NULL);");
 234     additionalCodeAtBottomOfMain(outmethod);
 235     outmethod.println("}");
 236   }
 237
 238   protected void additionalIncludesMethodsImplementation(PrintWriter outmethod) {
 239     if (state.SANDBOX) {
 240       outmethod.println("#include \"sandboxdefs.c\"");
 241     }
 242     if (state.DSM) {
 243       outmethod.println("#include \"addPrefetchEnhance.h\"");
 244       outmethod.println("#include \"localobjects.h\"");
 245     }
 246   }
 247
 248   protected void generateMethods(PrintWriter outmethod) {
 249     for(Iterator<LocalityBinding> lbit=locality.getLocalityBindings().iterator(); lbit.hasNext(); ) {
 250       LocalityBinding lb=lbit.next();
 251       MethodDescriptor md=lb.getMethod();
 252       FlatMethod fm=state.getMethodFlat(md);
 253       wb.analyze(lb);
 254       if (!md.getModifiers().isNative()) {
 255         generateFlatMethod(fm, lb, outmethod);
 256       }
 257     }
 258   }
 259
 260   protected void additionalIncludesStructsHeader(PrintWriter outstructs) {
 261     LocalityBinding lbrun=new LocalityBinding(typeutil.getRun(), false);
 262     if (state.DSM) {
 263       lbrun.setGlobalThis(LocalityAnalysis.GLOBAL);
 264     } else if (state.SINGLETM) {
 265       lbrun.setGlobalThis(LocalityAnalysis.NORMAL);
 266     }
 267     outstructs.println("#define RUNMETHOD "+virtualcalls.getLocalityNumber(lbrun));
 268
 269     if (state.DSMTASK) {
 270       LocalityBinding lbexecute = new LocalityBinding(typeutil.getExecute(), false);
 271       if(state.DSM)
 272         lbexecute.setGlobalThis(LocalityAnalysis.GLOBAL);
 273       else if( state.SINGLETM)
 274         lbexecute.setGlobalThis(LocalityAnalysis.NORMAL);
 275       outstructs.println("#define EXECUTEMETHOD " + virtualcalls.getLocalityNumber(lbexecute));
 276     }
 277   }
 278
 279   protected void printExtraArrayFields(PrintWriter outclassdefs) {
 280     if (state.STMARRAY) {
 281       outclassdefs.println("  int lowindex;");
 282       outclassdefs.println("  int highindex;");
 283     }
 284     if (state.DUALVIEW) {
 285       outclassdefs.println("  int arrayversion;");
 286     }
 287   }
 288
 289   /** The buildVirtualTables method outputs the virtual dispatch
 290    * tables for methods. */
 291
 292   protected void buildVirtualTables(PrintWriter outvirtual) {
 293     Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();
 294     while(classit.hasNext()) {
 295       ClassDescriptor cd=(ClassDescriptor)classit.next();
 296       if (virtualcalls.getMethodCount(cd)>maxcount)
 297         maxcount=virtualcalls.getMethodCount(cd);
 298     }
 299
 300     LocalityBinding[][] lbvirtualtable=null;
 301     lbvirtualtable=new LocalityBinding[state.numClasses()+state.numArrays()][maxcount];
 302
 303     /* Fill in virtual table */
 304     classit=state.getClassSymbolTable().getDescriptorsIterator();
 305     while(classit.hasNext()) {
 306       ClassDescriptor cd=(ClassDescriptor)classit.next();
 307       if(cd.isInterface()) {
 308         continue;
 309       }
 310       fillinRow(cd, lbvirtualtable, cd.getId());
 311     }
 312
 313     ClassDescriptor objectcd=typeutil.getClass(TypeUtil.ObjectClass);
 314     Iterator arrayit=state.getArrayIterator();
 315     while(arrayit.hasNext()) {
 316       TypeDescriptor td=(TypeDescriptor)arrayit.next();
 317       int id=state.getArrayNumber(td);
 318       fillinRow(objectcd, lbvirtualtable, id+state.numClasses());
 319     }
 320
 321     outvirtual.print("void * virtualtable[]={");
 322     boolean needcomma=false;
 323     for(int i=0; i<state.numClasses()+state.numArrays(); i++) {
 324       for(int j=0; j<maxcount; j++) {
 325         if (needcomma)
 326           outvirtual.print(", ");
 327         if (lbvirtualtable[i][j]!=null) {
 328           LocalityBinding lb=lbvirtualtable[i][j];
 329           MethodDescriptor md=lb.getMethod();
 330           outvirtual.print("& "+md.getClassDesc().getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
 331         } else {
 332           outvirtual.print("0");
 333         }
 334         needcomma=true;
 335       }
 336       outvirtual.println("");
 337     }
 338     outvirtual.println("};");
 339     outvirtual.close();
 340   }
 341
 342   protected void fillinRow(ClassDescriptor cd, LocalityBinding[][] virtualtable, int rownum) {
 343     /* Get inherited methods */
 344     if (cd.getSuperDesc()!=null)
 345       fillinRow(cd.getSuperDesc(), virtualtable, rownum);
 346     /* Override them with our methods */
 347     if (locality.getClassBindings(cd)!=null)
 348       for(Iterator<LocalityBinding> lbit=locality.getClassBindings(cd).iterator(); lbit.hasNext(); ) {
 349         LocalityBinding lb=lbit.next();
 350         MethodDescriptor md=lb.getMethod();
 351         //Is the method static or a constructor
 352         if (md.isStatic()||md.getReturnType()==null)
 353           continue;
 354         int methodnum=virtualcalls.getLocalityNumber(lb);
 355         virtualtable[rownum][methodnum]=lb;
 356       }
 357   }
 358
 359   /** Generate array that contains the sizes of class objects.  The
 360    * object allocation functions in the runtime use this
 361    * information. */
 362
 363   protected void generateSizeArrayExtensions(PrintWriter outclassdefs) {
 364     outclassdefs.print("#ifdef TRANSSTATS \n");
 365     outclassdefs.print("extern int numTransAbort;\n");
 366     outclassdefs.print("extern int numTransCommit;\n");
 367     outclassdefs.print("extern int nSoftAbort;\n");
 368     if (state.DSM) {
 369       outclassdefs.print("extern int nchashSearch;\n");
 370       outclassdefs.print("extern int nmhashSearch;\n");
 371       outclassdefs.print("extern int nprehashSearch;\n");
 372       outclassdefs.print("extern int ndirtyCacheObj;\n");
 373       outclassdefs.print("extern int nRemoteSend;\n");
 374       outclassdefs.print("extern int sendRemoteReq;\n");
 375       outclassdefs.print("extern int getResponse;\n");
 376       outclassdefs.print("extern int bytesSent;\n");
 377       outclassdefs.print("extern int bytesRecv;\n");
 378       outclassdefs.print("extern int totalObjSize;\n");
 379       outclassdefs.print("extern void handle();\n");
 380     } else if (state.SINGLETM) {
 381       outclassdefs.println("extern int nSoftAbortAbort;");
 382       outclassdefs.println("extern int nSoftAbortCommit;");
 383       outclassdefs.println("#ifdef STMSTATS\n");
 384       outclassdefs.println("extern objtypestat_t typesCausingAbort[];");
 385       outclassdefs.println("#endif\n");
 386     }
 387     outclassdefs.print("#endif\n");
 388
 389     outclassdefs.print("int numprefetchsites = " + pa.prefetchsiteid + ";\n");
 390   }
 391
 392   /** Constructs params and temp objects for each method or task.
 393    * These objects tell the compiler which temps need to be
 394    * allocated.  */
 395
 396   protected void generateTempStructs(FlatMethod fm, LocalityBinding lb) {
 397     MethodDescriptor md=fm.getMethod();
 398     TaskDescriptor task=fm.getTask();
 399     Set<TempDescriptor> saveset=lb!=null?locality.getTempSet(lb):null;
 400     ParamsObject objectparams=md!=null?new ParamsObject(md,tag++):new ParamsObject(task, tag++);
 401     if (lb!=null) {
 402       paramstable.put(lb, objectparams);
 403       backuptable.put(lb, new Hashtable<TempDescriptor, TempDescriptor>());
 404     } else if (md!=null)
 405       paramstable.put(md, objectparams);
 406     else
 407       paramstable.put(task, objectparams);
 408
 409     for(int i=0; i<fm.numParameters(); i++) {
 410       TempDescriptor temp=fm.getParameter(i);
 411       TypeDescriptor type=temp.getType();
 412       if (type.isPtr()&&((GENERATEPRECISEGC) || (this.state.MULTICOREGC)))
 413         objectparams.addPtr(temp);
 414       else
 415         objectparams.addPrim(temp);
 416       if(lb!=null&&saveset.contains(temp)) {
 417         backuptable.get(lb).put(temp, temp.createNew());
 418       }
 419     }
 420
 421     for(int i=0; i<fm.numTags(); i++) {
 422       TempDescriptor temp=fm.getTag(i);
 423       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC))
 424         objectparams.addPtr(temp);
 425       else
 426         objectparams.addPrim(temp);
 427     }
 428
 429     TempObject objecttemps=md!=null?new TempObject(objectparams,md,tag++):new TempObject(objectparams, task, tag++);
 430     if (lb!=null)
 431       tempstable.put(lb, objecttemps);
 432     else if (md!=null)
 433       tempstable.put(md, objecttemps);
 434     else
 435       tempstable.put(task, objecttemps);
 436
 437     for(Iterator nodeit=fm.getNodeSet().iterator(); nodeit.hasNext(); ) {
 438       FlatNode fn=(FlatNode)nodeit.next();
 439       TempDescriptor[] writes=fn.writesTemps();
 440       for(int i=0; i<writes.length; i++) {
 441         TempDescriptor temp=writes[i];
 442         TypeDescriptor type=temp.getType();
 443         if (type.isPtr()&&((GENERATEPRECISEGC) || (this.state.MULTICOREGC)))
 444           objecttemps.addPtr(temp);
 445         else
 446           objecttemps.addPrim(temp);
 447         if(lb!=null&&saveset.contains(temp)&&
 448            !backuptable.get(lb).containsKey(temp))
 449           backuptable.get(lb).put(temp, temp.createNew());
 450       }
 451     }
 452
 453     /* Create backup temps */
 454     if (lb!=null) {
 455       for(Iterator<TempDescriptor> tmpit=backuptable.get(lb).values().iterator(); tmpit.hasNext(); ) {
 456         TempDescriptor tmp=tmpit.next();
 457         TypeDescriptor type=tmp.getType();
 458         if (type.isPtr()&&((GENERATEPRECISEGC) || (this.state.MULTICOREGC)))
 459           objecttemps.addPtr(tmp);
 460         else
 461           objecttemps.addPrim(tmp);
 462       }
 463       /* Create temp to hold revert table */
 464       if (state.DSM&&(lb.getHasAtomic()||lb.isAtomic())) {
 465         TempDescriptor reverttmp=new TempDescriptor("revertlist", typeutil.getClass(TypeUtil.ObjectClass));
 466         if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC))
 467           objecttemps.addPtr(reverttmp);
 468         else
 469           objecttemps.addPrim(reverttmp);
 470         reverttable.put(lb, reverttmp);
 471       }
 472     }
 473   }
 474
 475   /** This method outputs the following information about classes
 476    * and arrays:
 477    * (1) For classes, what are the locations of pointers.
 478    * (2) For arrays, does the array contain pointers or primitives.
 479    * (3) For classes, does the class contain flags.
 480    */
 481
 482   protected void generateLayoutStructs(PrintWriter output) {
 483     Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
 484     while(it.hasNext()) {
 485       ClassDescriptor cn=(ClassDescriptor)it.next();
 486       output.println("unsigned INTPTR "+cn.getSafeSymbol()+"_pointers[]={");
 487       Iterator allit=cn.getFieldTable().getAllDescriptorsIterator();
 488       int count=0;
 489       while(allit.hasNext()) {
 490         FieldDescriptor fd=(FieldDescriptor)allit.next();
 491         TypeDescriptor type=fd.getType();
 492         if (state.DSM&&fd.isGlobal())         //Don't GC the global objects for now
 493           continue;
 494         if (type.isPtr())
 495           count++;
 496       }
 497       output.print(count);
 498       allit=cn.getFieldTable().getAllDescriptorsIterator();
 499       while(allit.hasNext()) {
 500         FieldDescriptor fd=(FieldDescriptor)allit.next();
 501         TypeDescriptor type=fd.getType();
 502         if (state.DSM&&fd.isGlobal())         //Don't GC the global objects for now
 503           continue;
 504         if (type.isPtr()) {
 505           output.println(",");
 506           output.print("((unsigned INTPTR)&(((struct "+cn.getSafeSymbol() +" *)0)->"+
 507                        fd.getSafeSymbol()+"))");
 508         }
 509       }
 510       output.println("};");
 511     }
 512     output.println("unsigned INTPTR * pointerarray[]={");
 513     boolean needcomma=false;
 514     for(int i=0; i<state.numClasses(); i++) {
 515       ClassDescriptor cn=cdarray[i];
 516       if (needcomma)
 517         output.println(",");
 518       needcomma=true;
 519       if(cn != null) {
 520         output.print(cn.getSafeSymbol()+"_pointers");
 521       } else {
 522         output.print("NULL");
 523       }
 524     }
 525
 526     for(int i=0; i<state.numArrays(); i++) {
 527       if (needcomma)
 528         output.println(", ");
 529       TypeDescriptor tdelement=arraytable[i].dereference();
 530       if (tdelement.isArray()||tdelement.isClass())
 531         output.print("((unsigned INTPTR *)1)");
 532       else
 533         output.print("0");
 534       needcomma=true;
 535     }
 536
 537     output.println("};");
 538     needcomma=false;
 539     output.println("int hasflags[]={");
 540     for(int i=0; i<state.numClasses(); i++) {
 541       ClassDescriptor cn=cdarray[i];
 542       if (needcomma)
 543         output.println(", ");
 544       needcomma=true;
 545       if ((cn != null) && (cn.hasFlags()))
 546         output.print("1");
 547       else
 548         output.print("0");
 549     }
 550     output.println("};");
 551   }
 552
 553
 554   protected void generateCallStructsMethods(ClassDescriptor cn, PrintWriter output, PrintWriter headersout) {
 555     /* Cycle through LocalityBindings */
 556     HashSet<MethodDescriptor> nativemethods=new HashSet<MethodDescriptor>();
 557     Set<LocalityBinding> lbset=locality.getClassBindings(cn);
 558     if (lbset!=null) {
 559       for(Iterator<LocalityBinding> lbit=lbset.iterator(); lbit.hasNext(); ) {
 560         LocalityBinding lb=lbit.next();
 561         MethodDescriptor md=lb.getMethod();
 562         if (md.getModifiers().isNative()) {
 563           //make sure we only print a native method once
 564           if (nativemethods.contains(md)) {
 565             FlatMethod fm=state.getMethodFlat(md);
 566             generateTempStructs(fm, lb);
 567             continue;
 568           } else
 569             nativemethods.add(md);
 570         }
 571         generateMethod(cn, md, lb, headersout, output);
 572       }
 573     }
 574     for(Iterator methodit=cn.getMethods(); methodit.hasNext(); ) {
 575       MethodDescriptor md=(MethodDescriptor)methodit.next();
 576       if (md.getModifiers().isNative()&&!nativemethods.contains(md)) {
 577         //Need to build param structure for library code
 578         FlatMethod fm=state.getMethodFlat(md);
 579         generateTempStructs(fm, null);
 580         generateMethodParam(cn, md, null, output);
 581       }
 582     }
 583   }
 584
 585
 586   protected void generateMethodParam(ClassDescriptor cn, MethodDescriptor md, LocalityBinding lb, PrintWriter output) {
 587     /* Output parameter structure */
 588     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
 589       ParamsObject objectparams=(ParamsObject) paramstable.get(lb!=null?lb:md);
 590       if ((state.DSM||state.SINGLETM)&&lb!=null)
 591         output.println("struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params {");
 592       else
 593         output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params {");
 594       output.println("  int size;");
 595       output.println("  void * next;");
 596       for(int i=0; i<objectparams.numPointers(); i++) {
 597         TempDescriptor temp=objectparams.getPointer(i);
 598         if(state.MGC && temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
 599           output.println("  int " + temp.getSafeSymbol() + ";");
 600         } else {
 601           output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
 602         }
 603       }
 604       output.println("};\n");
 605     }
 606   }
 607
 608   protected void generateMethod(ClassDescriptor cn, MethodDescriptor md, LocalityBinding lb, PrintWriter headersout, PrintWriter output) {
 609     FlatMethod fm=state.getMethodFlat(md);
 610     generateTempStructs(fm, lb);
 611
 612     ParamsObject objectparams=(ParamsObject) paramstable.get(lb);
 613     TempObject objecttemps=(TempObject) tempstable.get(lb);
 614
 615     generateMethodParam(cn, md, lb, output);
 616
 617     /* Output temp structure */
 618     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
 619       output.println("struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals {");
 620       output.println("  int size;");
 621       output.println("  void * next;");
 622       for(int i=0; i<objecttemps.numPointers(); i++) {
 623         TempDescriptor temp=objecttemps.getPointer(i);
 624         if (temp.getType().isNull())
 625           output.println("  void * "+temp.getSafeSymbol()+";");
 626         else
 627           output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
 628       }
 629       output.println("};\n");
 630     }
 631
 632     /********* Output method declaration ***********/
 633     headersout.println("#define D"+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+" 1");
 634
 635     /* First the return type */
 636     if (md.getReturnType()!=null) {
 637       if(state.MGC && md.getReturnType().isClass() && md.getReturnType().getClassDesc().isEnum()) {
 638         headersout.println("  int ");
 639       } else if (md.getReturnType().isClass()||md.getReturnType().isArray())
 640         headersout.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
 641       else
 642         headersout.print(md.getReturnType().getSafeSymbol()+" ");
 643     } else
 644       //catch the constructor case
 645       headersout.print("void ");
 646
 647     /* Next the method name */
 648     headersout.print(cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(");
 649
 650     boolean printcomma=false;
 651     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
 652       headersout.print("struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
 653       printcomma=true;
 654     }
 655
 656     /*  Output parameter list*/
 657     for(int i=0; i<objectparams.numPrimitives(); i++) {
 658       TempDescriptor temp=objectparams.getPrimitive(i);
 659       if (printcomma)
 660         headersout.print(", ");
 661       printcomma=true;
 662       if(state.MGC && temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
 663         headersout.print("int " + temp.getSafeSymbol());
 664       } else if (temp.getType().isClass()||temp.getType().isArray())
 665         headersout.print("struct " + temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol());
 666       else
 667         headersout.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
 668     }
 669     headersout.println(");\n");
 670   }
 671
 672   /***** Generate code for FlatMethod fm. *****/
 673
 674   Hashtable<FlatAtomicEnterNode, AtomicRecord> atomicmethodmap;
 675   static int atomicmethodcount=0;
 676
 677
 678   BranchAnalysis branchanalysis;
 679   protected void generateFlatMethod(FlatMethod fm, LocalityBinding lb, PrintWriter output) {
 680     if (State.PRINTFLAT)
 681       System.out.println(fm.printMethod());
 682     MethodDescriptor md=fm.getMethod();
 683     TaskDescriptor task=fm.getTask();
 684     ClassDescriptor cn=md!=null?md.getClassDesc():null;
 685     ParamsObject objectparams=(ParamsObject)paramstable.get(lb!=null?lb:md!=null?md:task);
 686
 687     HashSet<AtomicRecord> arset=null;
 688     branchanalysis=null;
 689
 690     if (state.DELAYCOMP&&!lb.isAtomic()&&lb.getHasAtomic()) {
 691       //create map
 692       if (atomicmethodmap==null)
 693         atomicmethodmap=new Hashtable<FlatAtomicEnterNode, AtomicRecord>();
 694
 695       //fix these so we get right strings for local variables
 696       localsprefixaddr=localsprefix;
 697       localsprefixderef=localsprefix+"->";
 698       arset=new HashSet<AtomicRecord>();
 699
 700       //build branchanalysis
 701       branchanalysis=new BranchAnalysis(locality, lb, delaycomp.getNotReady(lb), delaycomp.livecode(lb), state);
 702
 703       //Generate commit methods here
 704       for(Iterator<FlatNode> fnit=fm.getNodeSet().iterator(); fnit.hasNext(); ) {
 705         FlatNode fn=fnit.next();
 706         if (fn.kind()==FKind.FlatAtomicEnterNode&&
 707             locality.getAtomic(lb).get(fn.getPrev(0)).intValue()==0&&
 708             delaycomp.needsFission(lb, (FlatAtomicEnterNode) fn)) {
 709           //We have an atomic enter
 710           FlatAtomicEnterNode faen=(FlatAtomicEnterNode) fn;
 711           Set<FlatNode> exitset=faen.getExits();
 712           //generate header
 713           String methodname=md.getSymbol()+(atomicmethodcount++);
 714           AtomicRecord ar=new AtomicRecord();
 715           ar.name=methodname;
 716           arset.add(ar);
 717
 718           atomicmethodmap.put(faen, ar);
 719
 720           //build data structure declaration
 721           output.println("struct atomicprimitives_"+methodname+" {");
 722
 723           Set<FlatNode> recordset=delaycomp.livecode(lb);
 724           Set<TempDescriptor> liveinto=delaycomp.liveinto(lb, faen, recordset);
 725           Set<TempDescriptor> liveout=delaycomp.liveout(lb, faen);
 726           Set<TempDescriptor> liveoutvirtualread=delaycomp.liveoutvirtualread(lb, faen);
 727           ar.livein=liveinto;
 728           ar.reallivein=new HashSet(liveinto);
 729           ar.liveout=liveout;
 730           ar.liveoutvirtualread=liveoutvirtualread;
 731
 732
 733           for(Iterator<TempDescriptor> it=liveinto.iterator(); it.hasNext(); ) {
 734             TempDescriptor tmp=it.next();
 735             //remove the pointers
 736             if (tmp.getType().isPtr()) {
 737               it.remove();
 738             } else {
 739               //let's print it here
 740               output.println(tmp.getType().getSafeSymbol()+" "+tmp.getSafeSymbol()+";");
 741             }
 742           }
 743           for(Iterator<TempDescriptor> it=liveout.iterator(); it.hasNext(); ) {
 744             TempDescriptor tmp=it.next();
 745             //remove the pointers
 746             if (tmp.getType().isPtr()) {
 747               it.remove();
 748             } else if (!liveinto.contains(tmp)) {
 749               //let's print it here
 750               output.println(tmp.getType().getSafeSymbol()+" "+tmp.getSafeSymbol()+";");
 751             }
 752           }
 753           output.println("};");
 754
 755           //print out method name
 756           output.println("void "+methodname+"(struct "+ cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix+", struct "+ cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals *"+localsprefix+", struct atomicprimitives_"+methodname+" * primitives) {");
 757           //build code for commit method
 758
 759           //first define local primitives
 760           Set<TempDescriptor> alltemps=delaycomp.alltemps(lb, faen, recordset);
 761           for(Iterator<TempDescriptor> tmpit=alltemps.iterator(); tmpit.hasNext(); ) {
 762             TempDescriptor tmp=tmpit.next();
 763             if (!tmp.getType().isPtr()) {
 764               if (liveinto.contains(tmp)||liveoutvirtualread.contains(tmp)) {
 765                 //read from live into set
 766                 output.println(tmp.getType().getSafeSymbol()+" "+tmp.getSafeSymbol()+"=primitives->"+tmp.getSafeSymbol()+";");
 767               } else {
 768                 //just define
 769                 output.println(tmp.getType().getSafeSymbol()+" "+tmp.getSafeSymbol()+";");
 770               }
 771             }
 772           }
 773           //turn off write barrier generation
 774           wb.turnoff();
 775           state.SINGLETM=false;
 776           generateCode(faen, fm, lb, exitset, output, false);
 777           state.SINGLETM=true;
 778           //turn on write barrier generation
 779           wb.turnon();
 780           output.println("}\n\n");
 781         }
 782       }
 783     }
 784     //redefine these back to normal
 785
 786     localsprefixaddr="&"+localsprefix;
 787     localsprefixderef=localsprefix+".";
 788
 789     generateHeader(fm, lb, md!=null?md:task,output);
 790     TempObject objecttemp=(TempObject) tempstable.get(lb!=null?lb:md!=null?md:task);
 791
 792     if (state.DELAYCOMP&&!lb.isAtomic()&&lb.getHasAtomic()) {
 793       for(Iterator<AtomicRecord> arit=arset.iterator(); arit.hasNext(); ) {
 794         AtomicRecord ar=arit.next();
 795         output.println("struct atomicprimitives_"+ar.name+" primitives_"+ar.name+";");
 796       }
 797     }
 798
 799     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
 800       if (md!=null&&(state.DSM||state.SINGLETM))
 801         output.print("   struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals "+localsprefix+"={");
 802       else if (md!=null&&!(state.DSM||state.SINGLETM))
 803         output.print("   struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals "+localsprefix+"={");
 804       else
 805         output.print("   struct "+task.getSafeSymbol()+"_locals "+localsprefix+"={");
 806       output.print(objecttemp.numPointers()+",");
 807       output.print(paramsprefix);
 808       for(int j=0; j<objecttemp.numPointers(); j++)
 809         output.print(", NULL");
 810       output.println("};");
 811     }
 812
 813     for(int i=0; i<objecttemp.numPrimitives(); i++) {
 814       TempDescriptor td=objecttemp.getPrimitive(i);
 815       TypeDescriptor type=td.getType();
 816       if (type.isNull() && !type.isArray())
 817         output.println("   void * "+td.getSafeSymbol()+";");
 818       else if (state.MGC && type.isClass() && type.getClassDesc().isEnum()) {
 819         output.println("   int " + td.getSafeSymbol() + ";");
 820       } else if (type.isClass()||type.isArray())
 821         output.println("   struct "+type.getSafeSymbol()+" * "+td.getSafeSymbol()+";");
 822       else
 823         output.println("   "+type.getSafeSymbol()+" "+td.getSafeSymbol()+";");
 824     }
 825
 826
 827
 828     additionalCodeAtTopFlatMethodBody(output, fm);
 829
 830
 831
 832     /* Check to see if we need to do a GC if this is a
 833      * multi-threaded program...*/
 834
 835     if (((state.THREAD||state.DSM||state.SINGLETM)&&GENERATEPRECISEGC)) {
 836       //Don't bother if we aren't in recursive methods...The loops case will catch it
 837       if (callgraph.getAllMethods(md).contains(md)) {
 838         if (state.DSM&&lb.isAtomic())
 839           output.println("if (needtocollect) checkcollect2("+localsprefixaddr+");");
 840         else {
 841           output.println("if (unlikely(needtocollect)) checkcollect("+localsprefixaddr+");");
 842         }
 843       }
 844     }
 845     generateCode(fm.getNext(0), fm, lb, null, output, true);
 846     output.println("}\n\n");
 847   }
 848
 849
 850
 851   protected void generateCode(FlatNode first,
 852                               FlatMethod fm,
 853                               LocalityBinding lb,
 854                               Set<FlatNode> stopset,
 855                               PrintWriter output,
 856                               boolean firstpass) {
 857
 858     /* Assign labels to FlatNode's if necessary.*/
 859
 860     Hashtable<FlatNode, Integer> nodetolabel;
 861     currlb=lb;
 862     if (state.DELAYCOMP&&!firstpass)
 863       nodetolabel=dcassignLabels(first, stopset);
 864     else
 865       nodetolabel=assignLabels(first, stopset);
 866
 867     Set<FlatNode> storeset=null;
 868     HashSet<FlatNode> genset=null;
 869     HashSet<FlatNode> refset=null;
 870     Set<FlatNode> unionset=null;
 871
 872     if (state.DELAYCOMP&&!lb.isAtomic()&&lb.getHasAtomic()) {
 873       storeset=delaycomp.livecode(lb);
 874       genset=new HashSet<FlatNode>();
 875       if (state.STMARRAY&&!state.DUALVIEW) {
 876         refset=new HashSet<FlatNode>();
 877         refset.addAll(delaycomp.getDeref(lb));
 878         refset.removeAll(delaycomp.getCannotDelay(lb));
 879         refset.removeAll(delaycomp.getOther(lb));
 880       }
 881       if (firstpass) {
 882         genset.addAll(delaycomp.getCannotDelay(lb));
 883         genset.addAll(delaycomp.getOther(lb));
 884       } else {
 885         genset.addAll(delaycomp.getNotReady(lb));
 886         if (state.STMARRAY&&!state.DUALVIEW) {
 887           genset.removeAll(refset);
 888         }
 889       }
 890       unionset=new HashSet<FlatNode>();
 891       unionset.addAll(storeset);
 892       unionset.addAll(genset);
 893       if (state.STMARRAY&&!state.DUALVIEW)
 894         unionset.addAll(refset);
 895     }
 896
 897     /* Do the actual code generation */
 898     FlatNode current_node=null;
 899     HashSet tovisit=new HashSet();
 900     HashSet visited=new HashSet();
 901     if (!firstpass)
 902       tovisit.add(first.getNext(0));
 903     else
 904       tovisit.add(first);
 905     while(current_node!=null||!tovisit.isEmpty()) {
 906       if (current_node==null) {
 907         current_node=(FlatNode)tovisit.iterator().next();
 908         tovisit.remove(current_node);
 909       } else if (tovisit.contains(current_node)) {
 910         tovisit.remove(current_node);
 911       }
 912       visited.add(current_node);
 913       if (nodetolabel.containsKey(current_node)) {
 914         output.println("L"+nodetolabel.get(current_node)+":");
 915       }
 916       if (state.INSTRUCTIONFAILURE) {
 917         if (state.THREAD||state.DSM||state.SINGLETM) {
 918           output.println("if ((++instructioncount)>failurecount) {instructioncount=0;injectinstructionfailure();}");
 919         } else
 920           output.println("if ((--instructioncount)==0) injectinstructionfailure();");
 921       }
 922       if (current_node.numNext()==0||stopset!=null&&stopset.contains(current_node)) {
 923         output.print("   ");
 924         if (!state.DELAYCOMP||firstpass) {
 925           generateFlatNode(fm, current_node, output);
 926         } else {
 927           //store primitive variables in out set
 928           AtomicRecord ar=atomicmethodmap.get((FlatAtomicEnterNode)first);
 929           Set<TempDescriptor> liveout=ar.liveout;
 930           for(Iterator<TempDescriptor> tmpit=liveout.iterator(); tmpit.hasNext(); ) {
 931             TempDescriptor tmp=tmpit.next();
 932             output.println("primitives->"+tmp.getSafeSymbol()+"="+tmp.getSafeSymbol()+";");
 933           }
 934         }
 935
 936         if (current_node.kind()!=FKind.FlatReturnNode) {
 937           if(state.MGC) {
 938             // TODO add version for normal Java later
 939             if((fm.getMethod() != null) && (fm.getMethod().isStaticBlock())) {
 940               // a static block, check if it has been executed
 941               output.println("  global_defsprim_p->" + fm.getMethod().getClassDesc().getSafeSymbol()+"static_block_exe_flag = 1;");
 942               output.println("");
 943             }
 944           }
 945           output.println("   return;");
 946         }
 947         current_node=null;
 948       } else if(current_node.numNext()==1) {
 949         FlatNode nextnode;
 950         if (state.DELAYCOMP) {
 951           boolean specialprimitive=false;
 952           //skip literals...no need to add extra overhead
 953           if (storeset!=null&&storeset.contains(current_node)&&current_node.kind()==FKind.FlatLiteralNode) {
 954             TypeDescriptor typedesc=((FlatLiteralNode)current_node).getType();
 955             if (!typedesc.isClass()&&!typedesc.isArray()) {
 956               specialprimitive=true;
 957             }
 958           }
 959
 960           if (genset==null||genset.contains(current_node)||specialprimitive) {
 961             generateFlatNode(fm, current_node, output);
 962           }
 963           if (state.STMARRAY&&!state.DUALVIEW&&refset!=null&&refset.contains(current_node)) {
 964             //need to acquire lock
 965             handleArrayDeref(fm, lb, current_node, output, firstpass);
 966           }
 967           if (storeset!=null&&storeset.contains(current_node)&&!specialprimitive) {
 968             TempDescriptor wrtmp=current_node.writesTemps()[0];
 969             if (firstpass) {
 970               //need to store value written by previous node
 971               if (wrtmp.getType().isPtr()) {
 972                 //only lock the objects that may actually need locking
 973                 if (recorddc.getNeedTrans(lb, current_node)&&
 974                     (!state.STMARRAY||state.DUALVIEW||!wrtmp.getType().isArray()||
 975                      wrtmp.getType().getSymbol().equals(TypeUtil.ObjectClass))) {
 976                   output.println("STOREPTR("+generateTemp(fm, wrtmp)+");/* "+current_node.nodeid+" */");
 977                 } else {
 978                   output.println("STOREPTRNOLOCK("+generateTemp(fm, wrtmp)+");/* "+current_node.nodeid+" */");
 979                 }
 980               } else {
 981                 output.println("STORE"+wrtmp.getType().getSafeDescriptor()+"("+generateTemp(fm, wrtmp)+");/* "+current_node.nodeid+" */");
 982               }
 983             } else {
 984               //need to read value read by previous node
 985               if (wrtmp.getType().isPtr()) {
 986                 output.println("RESTOREPTR("+generateTemp(fm, wrtmp)+");/* "+current_node.nodeid+" */");
 987               } else {
 988                 output.println("RESTORE"+wrtmp.getType().getSafeDescriptor()+"("+generateTemp(fm, wrtmp)+"); /* "+current_node.nodeid+" */");
 989               }
 990             }
 991           }
 992           nextnode=current_node.getNext(0);
 993         } else {
 994           output.print("   ");
 995           generateFlatNode(fm, current_node, output);
 996           nextnode=current_node.getNext(0);
 997         }
 998         if (visited.contains(nextnode)) {
 999           output.println("goto L"+nodetolabel.get(nextnode)+";");
1000           current_node=null;
1001         } else
1002           current_node=nextnode;
1003       } else if (current_node.numNext()==2) {
1004         /* Branch */
1005         if (state.DELAYCOMP) {
1006           boolean computeside=false;
1007           if (firstpass) {
1008             //need to record which way it should go
1009             if (genset==null||genset.contains(current_node)) {
1010               if (storeset!=null&&storeset.contains(current_node)) {
1011                 //need to store which way branch goes
1012                 generateStoreFlatCondBranch(fm, lb, (FlatCondBranch)current_node, "L"+nodetolabel.get(current_node.getNext(1)), output);
1013               } else
1014                 generateFlatCondBranch(fm, (FlatCondBranch)current_node, "L"+nodetolabel.get(current_node.getNext(1)), output);
1015             } else {
1016               //which side to execute
1017               computeside=true;
1018             }
1019           } else {
1020             if (genset.contains(current_node)) {
1021               generateFlatCondBranch(fm, (FlatCondBranch)current_node, "L"+nodetolabel.get(current_node.getNext(1)), output);
1022             } else if (storeset.contains(current_node)) {
1023               //need to do branch
1024               branchanalysis.generateGroupCode(current_node, output, nodetolabel);
1025             } else {
1026               //which side to execute
1027               computeside=true;
1028             }
1029           }
1030           if (computeside) {
1031             Set<FlatNode> leftset=DelayComputation.getNext(current_node, 0, unionset, lb,locality, true);
1032             int branch=0;
1033             if (leftset.size()==0)
1034               branch=1;
1035             if (visited.contains(current_node.getNext(branch))) {
1036               //already visited -- build jump
1037               output.println("goto L"+nodetolabel.get(current_node.getNext(branch))+";");
1038               current_node=null;
1039             } else {
1040               current_node=current_node.getNext(branch);
1041             }
1042           } else {
1043             if (!visited.contains(current_node.getNext(1)))
1044               tovisit.add(current_node.getNext(1));
1045             if (visited.contains(current_node.getNext(0))) {
1046               output.println("goto L"+nodetolabel.get(current_node.getNext(0))+";");
1047               current_node=null;
1048             } else
1049               current_node=current_node.getNext(0);
1050           }
1051         } else {
1052           output.print("   ");
1053           generateFlatCondBranch(fm, (FlatCondBranch)current_node, "L"+nodetolabel.get(current_node.getNext(1)), output);
1054           if (!visited.contains(current_node.getNext(1)))
1055             tovisit.add(current_node.getNext(1));
1056           if (visited.contains(current_node.getNext(0))) {
1057             output.println("goto L"+nodetolabel.get(current_node.getNext(0))+";");
1058             current_node=null;
1059           } else
1060             current_node=current_node.getNext(0);
1061         }
1062       } else throw new Error();
1063     }
1064   }
1065
1066   protected void handleArrayDeref(FlatMethod fm, LocalityBinding lb, FlatNode fn, PrintWriter output, boolean firstpass) {
1067     if (fn.kind()==FKind.FlatSetElementNode) {
1068       FlatSetElementNode fsen=(FlatSetElementNode) fn;
1069       String dst=generateTemp(fm, fsen.getDst());
1070       String src=generateTemp(fm, fsen.getSrc());
1071       String index=generateTemp(fm, fsen.getIndex());
1072       TypeDescriptor elementtype=fsen.getDst().getType().dereference();
1073       String type="";
1074       if (elementtype.isArray()||elementtype.isClass())
1075         type="void *";
1076       else
1077         type=elementtype.getSafeSymbol()+" ";
1078       if (firstpass) {
1079         output.println("STOREARRAY("+dst+","+index+","+type+")");
1080       } else {
1081         output.println("{");
1082         output.println("  struct ArrayObject *array;");
1083         output.println("  int index;");
1084         output.println("  RESTOREARRAY(array,index);");
1085         output.println("  (("+type+"*)(((char *)&array->___length___)+sizeof(int)))[index]="+src+";");
1086         output.println("}");
1087       }
1088     } else if (fn.kind()==FKind.FlatElementNode) {
1089       FlatElementNode fen=(FlatElementNode) fn;
1090       String src=generateTemp(fm, fen.getSrc());
1091       String index=generateTemp(fm, fen.getIndex());
1092       TypeDescriptor elementtype=fen.getSrc().getType().dereference();
1093       String dst=generateTemp(fm, fen.getDst());
1094       String type="";
1095       if (elementtype.isArray()||elementtype.isClass())
1096         type="void *";
1097       else
1098         type=elementtype.getSafeSymbol()+" ";
1099       if (firstpass) {
1100         output.println("STOREARRAY("+src+","+index+","+type+")");
1101       } else {
1102         output.println("{");
1103         output.println("  struct ArrayObject *array;");
1104         output.println("  int index;");
1105         output.println("  RESTOREARRAY(array,index);");
1106         output.println("  "+dst+"=(("+type+"*)(((char *)&array->___length___)+sizeof(int)))[index];");
1107         output.println("}");
1108       }
1109     }
1110   }
1111   /** Special label assignment for delaycomputation */
1112   protected Hashtable<FlatNode, Integer> dcassignLabels(FlatNode first, Set<FlatNode> lastset) {
1113     HashSet tovisit=new HashSet();
1114     HashSet visited=new HashSet();
1115     int labelindex=0;
1116     Hashtable<FlatNode, Integer> nodetolabel=new Hashtable<FlatNode, Integer>();
1117
1118     //Label targets of branches
1119     Set<FlatNode> targets=branchanalysis.getTargets();
1120     for(Iterator<FlatNode> it=targets.iterator(); it.hasNext(); ) {
1121       nodetolabel.put(it.next(), new Integer(labelindex++));
1122     }
1123
1124
1125     tovisit.add(first);
1126     /*Assign labels first.  A node needs a label if the previous
1127      * node has two exits or this node is a join point. */
1128
1129     while(!tovisit.isEmpty()) {
1130       FlatNode fn=(FlatNode)tovisit.iterator().next();
1131       tovisit.remove(fn);
1132       visited.add(fn);
1133
1134
1135       if(lastset!=null&&lastset.contains(fn)) {
1136         // if last is not null and matches, don't go
1137         // any further for assigning labels
1138         continue;
1139       }
1140
1141       for(int i=0; i<fn.numNext(); i++) {
1142         FlatNode nn=fn.getNext(i);
1143
1144         if(i>0) {
1145           //1) Edge >1 of node
1146           nodetolabel.put(nn,new Integer(labelindex++));
1147         }
1148         if (!visited.contains(nn)&&!tovisit.contains(nn)) {
1149           tovisit.add(nn);
1150         } else {
1151           //2) Join point
1152           nodetolabel.put(nn,new Integer(labelindex++));
1153         }
1154       }
1155     }
1156     return nodetolabel;
1157
1158   }
1159
1160   /** Generate text string that corresponds to the TempDescriptor td. */
1161   protected String generateTemp(FlatMethod fm, TempDescriptor td) {
1162     MethodDescriptor md=fm.getMethod();
1163     TaskDescriptor task=fm.getTask();
1164     TempObject objecttemps=(TempObject) tempstable.get(currlb!=null?currlb:md!=null?md:task);
1165
1166     if (objecttemps.isLocalPrim(td)||objecttemps.isParamPrim(td)) {
1167       return td.getSafeSymbol();
1168     }
1169
1170     if (objecttemps.isLocalPtr(td)) {
1171       return localsprefixderef+td.getSafeSymbol();
1172     }
1173
1174     if (objecttemps.isParamPtr(td)) {
1175       return paramsprefix+"->"+td.getSafeSymbol();
1176     }
1177
1178     throw new Error();
1179   }
1180
1181   public void generateFlatBackEdge(FlatMethod fm, FlatBackEdge fn, PrintWriter output) {
1182     if (state.SINGLETM&&state.SANDBOX&&(locality.getAtomic(currlb).get(fn).intValue()>0)) {
1183       output.println("if (unlikely((--transaction_check_counter)<=0)) checkObjects();");
1184     }
1185     if(state.DSM&&state.SANDBOX&&(locality.getAtomic(currlb).get(fn).intValue()>0)) {
1186       output.println("if (unlikely((--transaction_check_counter)<=0)) checkObjects();");
1187     }
1188     if (((state.THREAD||state.DSM||state.SINGLETM)&&GENERATEPRECISEGC)) {
1189       if(state.DSM&&locality.getAtomic(currlb).get(fn).intValue()>0) {
1190         output.println("if (needtocollect) checkcollect2("+localsprefixaddr+");");
1191       } else {
1192         output.println("if (unlikely(needtocollect)) checkcollect("+localsprefixaddr+");");
1193       }
1194     } else
1195       output.println("/* nop */");
1196   }
1197
1198
1199   public void generateFlatPrefetchNode(FlatMethod fm, FlatPrefetchNode fpn, PrintWriter output) {
1200     if (state.PREFETCH) {
1201       Vector oids = new Vector();
1202       Vector fieldoffset = new Vector();
1203       Vector endoffset = new Vector();
1204       int tuplecount = 0;        //Keeps track of number of prefetch tuples that need to be generated
1205       for(Iterator it = fpn.hspp.iterator(); it.hasNext(); ) {
1206         PrefetchPair pp = (PrefetchPair) it.next();
1207         Integer statusbase = locality.getNodePreTempInfo(currlb,fpn).get(pp.base);
1208         /* Find prefetches that can generate oid */
1209         if(statusbase == LocalityAnalysis.GLOBAL) {
1210           generateTransCode(fm, currlb, pp, oids, fieldoffset, endoffset, tuplecount, locality.getAtomic(currlb).get(fpn).intValue()>0, false);
1211           tuplecount++;
1212         } else if (statusbase == LocalityAnalysis.LOCAL) {
1213           generateTransCode(fm,currlb,pp,oids,fieldoffset,endoffset,tuplecount,false,true);
1214         } else {
1215           continue;
1216         }
1217       }
1218       if (tuplecount==0)
1219         return;
1220       System.out.println("Adding prefetch "+fpn+ " to method:" +fm);
1221       output.println("{");
1222       output.println("/* prefetch */");
1223       output.println("/* prefetchid_" + fpn.siteid + " */");
1224       output.println("void * prefptr;");
1225       output.println("int tmpindex;");
1226
1227       output.println("if((evalPrefetch["+fpn.siteid+"].operMode) || (evalPrefetch["+fpn.siteid+"].retrycount <= 0)) {");
1228       /*Create C code for oid array */
1229       output.print("   unsigned int oidarray_[] = {");
1230       boolean needcomma=false;
1231       for (Iterator it = oids.iterator(); it.hasNext(); ) {
1232         if (needcomma)
1233           output.print(", ");
1234         output.print(it.next());
1235         needcomma=true;
1236       }
1237       output.println("};");
1238
1239       /*Create C code for endoffset values */
1240       output.print("   unsigned short endoffsetarry_[] = {");
1241       needcomma=false;
1242       for (Iterator it = endoffset.iterator(); it.hasNext(); ) {
1243         if (needcomma)
1244           output.print(", ");
1245         output.print(it.next());
1246         needcomma=true;
1247       }
1248       output.println("};");
1249
1250       /*Create C code for Field Offset Values */
1251       output.print("   short fieldarry_[] = {");
1252       needcomma=false;
1253       for (Iterator it = fieldoffset.iterator(); it.hasNext(); ) {
1254         if (needcomma)
1255           output.print(", ");
1256         output.print(it.next());
1257         needcomma=true;
1258       }
1259       output.println("};");
1260       /* make the prefetch call to Runtime */
1261       output.println("   if(!evalPrefetch["+fpn.siteid+"].operMode) {");
1262       output.println("     evalPrefetch["+fpn.siteid+"].retrycount = RETRYINTERVAL;");
1263       output.println("   }");
1264       output.println("   prefetch("+fpn.siteid+" ,"+tuplecount+", oidarray_, endoffsetarry_, fieldarry_);");
1265       output.println(" } else {");
1266       output.println("   evalPrefetch["+fpn.siteid+"].retrycount--;");
1267       output.println(" }");
1268       output.println("}");
1269     }
1270   }
1271
1272   public void generateTransCode(FlatMethod fm, LocalityBinding lb,PrefetchPair pp, Vector oids, Vector fieldoffset, Vector endoffset, int tuplecount, boolean inside, boolean localbase) {
1273     short offsetcount = 0;
1274     int breakindex=0;
1275     if (inside) {
1276       breakindex=1;
1277     } else if (localbase) {
1278       for(; breakindex<pp.desc.size(); breakindex++) {
1279         Descriptor desc=pp.getDescAt(breakindex);
1280         if (desc instanceof FieldDescriptor) {
1281           FieldDescriptor fd=(FieldDescriptor)desc;
1282           if (fd.isGlobal()) {
1283             break;
1284           }
1285         }
1286       }
1287       breakindex++;
1288     }
1289
1290     if (breakindex>pp.desc.size())     //all local
1291       return;
1292
1293     TypeDescriptor lasttype=pp.base.getType();
1294     String basestr=generateTemp(fm, pp.base);
1295     String teststr="";
1296     boolean maybenull=fm.getMethod().isStatic()||
1297                        !pp.base.equals(fm.getParameter(0));
1298
1299     for(int i=0; i<breakindex; i++) {
1300       String indexcheck="";
1301
1302       Descriptor desc=pp.getDescAt(i);
1303       if (desc instanceof FieldDescriptor) {
1304         FieldDescriptor fd=(FieldDescriptor)desc;
1305         if (maybenull) {
1306           if (!teststr.equals(""))
1307             teststr+="&&";
1308           teststr+="((prefptr="+basestr+")!=NULL)";
1309           basestr="((struct "+lasttype.getSafeSymbol()+" *)prefptr)->"+
1310                    fd.getSafeSymbol();
1311         } else {
1312           basestr=basestr+"->"+
1313                    fd.getSafeSymbol();
1314           maybenull=true;
1315         }
1316         lasttype=fd.getType();
1317       } else {
1318         IndexDescriptor id=(IndexDescriptor)desc;
1319         indexcheck="((tmpindex=";
1320         for(int j=0; j<id.tddesc.size(); j++) {
1321           indexcheck+=generateTemp(fm, id.getTempDescAt(j))+"+";
1322         }
1323         indexcheck+=id.offset+")>=0)&(tmpindex<((struct ArrayObject *)prefptr)->___length___)";
1324
1325         if (!teststr.equals(""))
1326           teststr+="&&";
1327         teststr+="((prefptr="+basestr+")!= NULL) &&"+indexcheck;
1328         basestr="((void **)(((char *) &(((struct ArrayObject *)prefptr)->___length___))+sizeof(int)))[tmpindex]";
1329         maybenull=true;
1330         lasttype=lasttype.dereference();
1331       }
1332     }
1333
1334     String oid;
1335     if (teststr.equals("")) {
1336       oid="((unsigned int)"+basestr+")";
1337     } else {
1338       oid="((unsigned int)(("+teststr+")?"+basestr+":NULL))";
1339     }
1340     oids.add(oid);
1341
1342     for(int i = breakindex; i < pp.desc.size(); i++) {
1343       String newfieldoffset;
1344       Object desc = pp.getDescAt(i);
1345       if(desc instanceof FieldDescriptor) {
1346         FieldDescriptor fd=(FieldDescriptor)desc;
1347         newfieldoffset = new String("(unsigned int)(&(((struct "+ lasttype.getSafeSymbol()+" *)0)->"+ fd.getSafeSymbol()+ "))");
1348         lasttype=fd.getType();
1349       } else {
1350         newfieldoffset = "";
1351         IndexDescriptor id=(IndexDescriptor)desc;
1352         for(int j = 0; j < id.tddesc.size(); j++) {
1353           newfieldoffset += generateTemp(fm, id.getTempDescAt(j)) + "+";
1354         }
1355         newfieldoffset += id.offset.toString();
1356         lasttype=lasttype.dereference();
1357       }
1358       fieldoffset.add(newfieldoffset);
1359     }
1360
1361     int base=(tuplecount>0)?((Short)endoffset.get(tuplecount-1)).intValue():0;
1362     base+=pp.desc.size()-breakindex;
1363     endoffset.add(new Short((short)base));
1364   }
1365
1366
1367
1368   public void generateFlatGlobalConvNode(FlatMethod fm, FlatGlobalConvNode fgcn, PrintWriter output) {
1369     if (currlb!=fgcn.getLocality())
1370       return;
1371     /* Have to generate flat globalconv */
1372     if (fgcn.getMakePtr()) {
1373       if (state.DSM) {
1374         output.println("TRANSREAD("+generateTemp(fm, fgcn.getSrc())+", (unsigned int) "+generateTemp(fm, fgcn.getSrc())+");");
1375       } else {
1376         if ((dc==null)||!state.READSET&&dc.getNeedTrans(currlb, fgcn)||state.READSET&&dc.getNeedWriteTrans(currlb, fgcn)) {
1377           //need to do translation
1378           output.println("TRANSREAD("+generateTemp(fm, fgcn.getSrc())+", "+generateTemp(fm, fgcn.getSrc())+", (void *)("+localsprefixaddr+"));");
1379         } else if (state.READSET&&dc.getNeedTrans(currlb, fgcn)) {
1380           if (state.HYBRID&&delaycomp.getConv(currlb).contains(fgcn)) {
1381             output.println("TRANSREADRDFISSION("+generateTemp(fm, fgcn.getSrc())+", "+generateTemp(fm, fgcn.getSrc())+");");
1382           } else
1383             output.println("TRANSREADRD("+generateTemp(fm, fgcn.getSrc())+", "+generateTemp(fm, fgcn.getSrc())+");");
1384         }
1385       }
1386     } else {
1387       /* Need to convert to OID */
1388       if ((dc==null)||dc.getNeedSrcTrans(currlb,fgcn)) {
1389         if (fgcn.doConvert()||(delaycomp!=null&&delaycomp.needsFission(currlb, fgcn.getAtomicEnter())&&atomicmethodmap.get(fgcn.getAtomicEnter()).reallivein.contains(fgcn.getSrc()))) {
1390           output.println(generateTemp(fm, fgcn.getSrc())+"=(void *)COMPOID("+generateTemp(fm, fgcn.getSrc())+");");
1391         } else {
1392           output.println(generateTemp(fm, fgcn.getSrc())+"=NULL;");
1393         }
1394       }
1395     }
1396   }
1397
1398   int sandboxcounter=0;
1399   public void generateFlatAtomicEnterNode(FlatMethod fm,  FlatAtomicEnterNode faen, PrintWriter output) {
1400     /* Check to see if we need to generate code for this atomic */
1401     if (locality==null) {
1402       if (GENERATEPRECISEGC) {
1403         output.println("if (pthread_mutex_trylock(&atomiclock)!=0) {");
1404         output.println("stopforgc((struct garbagelist *) &___locals___);");
1405         output.println("pthread_mutex_lock(&atomiclock);");
1406         output.println("restartaftergc();");
1407         output.println("}");
1408       } else {
1409         output.println("pthread_mutex_lock(&atomiclock);");
1410       }
1411       return;
1412     }
1413
1414     if (locality.getAtomic(currlb).get(faen.getPrev(0)).intValue()>0)
1415       return;
1416
1417
1418     if (state.SANDBOX) {
1419       outsandbox.println("int atomiccounter"+sandboxcounter+"=LOW_CHECK_FREQUENCY;");
1420       output.println("counter_reset_pointer=&atomiccounter"+sandboxcounter+";");
1421     }
1422
1423     if (state.DELAYCOMP&&delaycomp.needsFission(currlb, faen)) {
1424       AtomicRecord ar=atomicmethodmap.get(faen);
1425       //copy in
1426       for(Iterator<TempDescriptor> tmpit=ar.livein.iterator(); tmpit.hasNext(); ) {
1427         TempDescriptor tmp=tmpit.next();
1428         output.println("primitives_"+ar.name+"."+tmp.getSafeSymbol()+"="+tmp.getSafeSymbol()+";");
1429       }
1430
1431       //copy outs that depend on path
1432       for(Iterator<TempDescriptor> tmpit=ar.liveoutvirtualread.iterator(); tmpit.hasNext(); ) {
1433         TempDescriptor tmp=tmpit.next();
1434         if (!ar.livein.contains(tmp))
1435           output.println("primitives_"+ar.name+"."+tmp.getSafeSymbol()+"="+tmp.getSafeSymbol()+";");
1436       }
1437     }
1438
1439     /* Backup the temps. */
1440     for(Iterator<TempDescriptor> tmpit=locality.getTemps(currlb).get(faen).iterator(); tmpit.hasNext(); ) {
1441       TempDescriptor tmp=tmpit.next();
1442       output.println(generateTemp(fm, backuptable.get(currlb).get(tmp))+"="+generateTemp(fm,tmp)+";");
1443     }
1444
1445     output.println("goto transstart"+faen.getIdentifier()+";");
1446
1447     /******* Print code to retry aborted transaction *******/
1448     output.println("transretry"+faen.getIdentifier()+":");
1449
1450     /* Restore temps */
1451     for(Iterator<TempDescriptor> tmpit=locality.getTemps(currlb).get(faen).iterator(); tmpit.hasNext(); ) {
1452       TempDescriptor tmp=tmpit.next();
1453       output.println(generateTemp(fm, tmp)+"="+generateTemp(fm,backuptable.get(currlb).get(tmp))+";");
1454     }
1455
1456     if (state.DSM) {
1457       /********* Need to revert local object store ********/
1458       String revertptr=generateTemp(fm, reverttable.get(currlb));
1459
1460       output.println("while ("+revertptr+") {");
1461       output.println("struct ___Object___ * tmpptr;");
1462       output.println("tmpptr="+revertptr+"->"+nextobjstr+";");
1463       output.println("REVERT_OBJ("+revertptr+");");
1464       output.println(revertptr+"=tmpptr;");
1465       output.println("}");
1466     }
1467     /******* Tell the runtime to start the transaction *******/
1468
1469     output.println("transstart"+faen.getIdentifier()+":");
1470     if (state.SANDBOX) {
1471       output.println("transaction_check_counter=*counter_reset_pointer;");
1472       sandboxcounter++;
1473     }
1474     output.println("transStart();");
1475
1476     if (state.ABORTREADERS||state.SANDBOX) {
1477       if (state.SANDBOX)
1478         output.println("abortenabled=1;");
1479       output.println("if (_setjmp(aborttrans)) {");
1480       output.println("  goto transretry"+faen.getIdentifier()+"; }");
1481     }
1482   }
1483
1484   public void generateFlatAtomicExitNode(FlatMethod fm, FlatAtomicExitNode faen, PrintWriter output) {
1485     /* Check to see if we need to generate code for this atomic */
1486     if (locality==null) {
1487       output.println("pthread_mutex_unlock(&atomiclock);");
1488       return;
1489     }
1490     if (locality.getAtomic(currlb).get(faen).intValue()>0)
1491       return;
1492     //store the revert list before we lose the transaction object
1493
1494     if (state.DSM) {
1495       String revertptr=generateTemp(fm, reverttable.get(currlb));
1496       output.println(revertptr+"=revertlist;");
1497       output.println("if (transCommit()) {");
1498       output.println("if (unlikely(needtocollect)) checkcollect("+localsprefixaddr+");");
1499       output.println("goto transretry"+faen.getAtomicEnter().getIdentifier()+";");
1500       output.println("} else {");
1501       /* Need to commit local object store */
1502       output.println("while ("+revertptr+") {");
1503       output.println("struct ___Object___ * tmpptr;");
1504       output.println("tmpptr="+revertptr+"->"+nextobjstr+";");
1505       output.println("COMMIT_OBJ("+revertptr+");");
1506       output.println(revertptr+"=tmpptr;");
1507       output.println("}");
1508       output.println("}");
1509       return;
1510     }
1511
1512     if (!state.DELAYCOMP) {
1513       //Normal STM stuff
1514       output.println("if (transCommit()) {");
1515       /* Transaction aborts if it returns true */
1516       output.println("if (unlikely(needtocollect)) checkcollect("+localsprefixaddr+");");
1517       output.println("goto transretry"+faen.getAtomicEnter().getIdentifier()+";");
1518       output.println("}");
1519     } else {
1520       if (delaycomp.optimizeTrans(currlb, faen.getAtomicEnter())&&(!state.STMARRAY||state.DUALVIEW)) {
1521         AtomicRecord ar=atomicmethodmap.get(faen.getAtomicEnter());
1522         output.println("LIGHTWEIGHTCOMMIT("+ar.name+", &primitives_"+ar.name+", &"+localsprefix+", "+paramsprefix+", transretry"+faen.getAtomicEnter().getIdentifier()+");");
1523         //copy out
1524         for(Iterator<TempDescriptor> tmpit=ar.liveout.iterator(); tmpit.hasNext(); ) {
1525           TempDescriptor tmp=tmpit.next();
1526           output.println(tmp.getSafeSymbol()+"=primitives_"+ar.name+"."+tmp.getSafeSymbol()+";");
1527         }
1528       } else if (delaycomp.needsFission(currlb, faen.getAtomicEnter())) {
1529         AtomicRecord ar=atomicmethodmap.get(faen.getAtomicEnter());
1530         //do call
1531         output.println("if (transCommit((void (*)(void *, void *, void *))&"+ar.name+", &primitives_"+ar.name+", &"+localsprefix+", "+paramsprefix+")) {");
1532         output.println("if (unlikely(needtocollect)) checkcollect("+localsprefixaddr+");");
1533         output.println("goto transretry"+faen.getAtomicEnter().getIdentifier()+";");
1534         output.println("}");
1535         //copy out
1536         output.println("else {");
1537         for(Iterator<TempDescriptor> tmpit=ar.liveout.iterator(); tmpit.hasNext(); ) {
1538           TempDescriptor tmp=tmpit.next();
1539           output.println(tmp.getSafeSymbol()+"=primitives_"+ar.name+"."+tmp.getSafeSymbol()+";");
1540         }
1541         output.println("}");
1542       } else {
1543         output.println("if (transCommit(NULL, NULL, NULL, NULL)) {");
1544         output.println("if (unlikely(needtocollect)) checkcollect("+localsprefixaddr+");");
1545         output.println("goto transretry"+faen.getAtomicEnter().getIdentifier()+";");
1546         output.println("}");
1547       }
1548     }
1549   }
1550
1551   protected void generateFlatCall(FlatMethod fm, FlatCall fc, PrintWriter output) {
1552     MethodDescriptor md=fc.getMethod();
1553     ParamsObject objectparams=(ParamsObject)paramstable.get(currlb!=null?locality.getBinding(currlb, fc):md);
1554     ClassDescriptor cn=md.getClassDesc();
1555
1556     // if the called method is a static block or a static method or a constructor
1557     // need to check if it can be invoked inside some static block
1558     if(state.MGC) {
1559       // TODO add version for normal Java later
1560       if((md.isStatic() || md.isStaticBlock() || md.isConstructor()) &&
1561          ((fm.getMethod().isStaticBlock()) || (fm.getMethod().isInvokedByStatic()))) {
1562         if(!md.isInvokedByStatic()) {
1563           System.err.println("Error: a method that is invoked inside a static block is not tagged!");
1564         }
1565         // is a static block or is invoked in some static block
1566         ClassDescriptor cd = fm.getMethod().getClassDesc();
1567         if(cd == cn) {
1568           // the same class, do nothing
1569           // TODO may want to invoke static field initialization here
1570         } else {
1571           if((cn.getNumStaticFields() != 0) || (cn.getNumStaticBlocks() != 0)) {
1572             // need to check if the class' static fields have been initialized and/or
1573             // its static blocks have been executed
1574             output.println("#ifdef MGC_STATIC_INIT_CHECK");
1575             output.println("if(global_defsprim_p->" + cn.getSafeSymbol()+"static_block_exe_flag == 0) {");
1576             if(cn.getNumStaticBlocks() != 0) {
1577               MethodDescriptor t_md = (MethodDescriptor)cn.getMethodTable().get("staticblocks");
1578               output.println("  "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"();");
1579             } else {
1580               output.println("  global_defsprim_p->" + cn.getSafeSymbol()+"static_block_exe_flag = 1;");
1581             }
1582             output.println("}");
1583             output.println("#endif // MGC_STATIC_INIT_CHECK");
1584           }
1585         }
1586       }
1587       if((md.getSymbol().equals("MonitorEnter") || md.getSymbol().equals("MonitorExit")) && fc.getThis().getSymbol().equals("classobj")) {
1588         // call MonitorEnter/MonitorExit on a class obj
1589         output.println("       " + cn.getSafeSymbol()+md.getSafeSymbol()+"_"
1590                        + md.getSafeMethodDescriptor() + "((struct ___Object___*)(((void **)(((char *) &(global_defs_p->classobjs->___length___))+sizeof(int)))["
1591                        + fc.getThis().getType().getClassDesc().getId() + "]));");
1592         return;
1593       }
1594     }
1595
1596     output.println("{");
1597     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1598       if (currlb!=null) {
1599         LocalityBinding fclb=locality.getBinding(currlb, fc);
1600         output.print("       struct "+cn.getSafeSymbol()+fclb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
1601       } else
1602         output.print("       struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
1603       output.print(objectparams.numPointers());
1604       output.print(", "+localsprefixaddr);
1605       if (md.getThis()!=null) {
1606         output.print(", ");
1607         output.print("(struct "+md.getThis().getType().getSafeSymbol() +" *)"+ generateTemp(fm,fc.getThis()));
1608       }
1609       if (fc.getThis()!=null&&md.getThis()==null) {
1610         System.out.println("WARNING!!!!!!!!!!!!");
1611         System.out.println("Source code calls static method "+md+" on an object in "+fm.getMethod()+"!");
1612       }
1613
1614
1615       for(int i=0; i<fc.numArgs(); i++) {
1616         Descriptor var=md.getParameter(i);
1617         TempDescriptor paramtemp=(TempDescriptor)temptovar.get(var);
1618         if (objectparams.isParamPtr(paramtemp)) {
1619           TempDescriptor targ=fc.getArg(i);
1620           output.print(", ");
1621           TypeDescriptor td=md.getParamType(i);
1622           if (td.isTag())
1623             output.print("(struct "+(new TypeDescriptor(typeutil.getClass(TypeUtil.TagClass))).getSafeSymbol()  +" *)"+generateTemp(fm, targ));
1624           else
1625             output.print("(struct "+md.getParamType(i).getSafeSymbol()  +" *)"+generateTemp(fm, targ));
1626         }
1627       }
1628       output.println("};");
1629     }
1630     output.print("       ");
1631
1632
1633     if (fc.getReturnTemp()!=null)
1634       output.print(generateTemp(fm,fc.getReturnTemp())+"=");
1635
1636     /* Do we need to do virtual dispatch? */
1637     if (md.isStatic()||md.getReturnType()==null||singleCall(fc.getThis().getType().getClassDesc(),md)) {
1638       //no
1639       if (currlb!=null) {
1640         LocalityBinding fclb=locality.getBinding(currlb, fc);
1641         output.print(cn.getSafeSymbol()+fclb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
1642       } else {
1643         output.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
1644       }
1645     } else {
1646       //yes
1647       output.print("((");
1648       if (state.MGC && md.getReturnType().isClass() && md.getReturnType().getClassDesc().isEnum()) {
1649         output.print("int ");
1650       } else if (md.getReturnType().isClass()||md.getReturnType().isArray())
1651         output.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
1652       else
1653         output.print(md.getReturnType().getSafeSymbol()+" ");
1654       output.print("(*)(");
1655
1656       boolean printcomma=false;
1657       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1658         if (currlb!=null) {
1659           LocalityBinding fclb=locality.getBinding(currlb, fc);
1660           output.print("struct "+cn.getSafeSymbol()+fclb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * ");
1661         } else
1662           output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * ");
1663         printcomma=true;
1664       }
1665
1666       for(int i=0; i<objectparams.numPrimitives(); i++) {
1667         TempDescriptor temp=objectparams.getPrimitive(i);
1668         if (printcomma)
1669           output.print(", ");
1670         printcomma=true;
1671         if (state.MGC && temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
1672           output.print("int ");
1673         } else if (temp.getType().isClass()||temp.getType().isArray())
1674           output.print("struct " + temp.getType().getSafeSymbol()+" * ");
1675         else
1676           output.print(temp.getType().getSafeSymbol());
1677       }
1678
1679
1680       if (currlb!=null) {
1681         LocalityBinding fclb=locality.getBinding(currlb, fc);
1682         output.print("))virtualtable["+generateTemp(fm,fc.getThis())+"->type*"+maxcount+"+"+virtualcalls.getLocalityNumber(fclb)+"])");
1683       } else
1684         output.print("))virtualtable["+generateTemp(fm,fc.getThis())+"->type*"+maxcount+"+"+virtualcalls.getMethodNumber(md)+"])");
1685     }
1686
1687     output.print("(");
1688     boolean needcomma=false;
1689     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1690       output.print("&__parameterlist__");
1691       needcomma=true;
1692     }
1693
1694     if (!GENERATEPRECISEGC && !this.state.MULTICOREGC) {
1695       if (fc.getThis()!=null) {
1696         TypeDescriptor ptd=null;
1697         if(md.getThis() != null) {
1698           ptd = md.getThis().getType();
1699         } else {
1700           ptd = fc.getThis().getType();
1701         }
1702         if (needcomma)
1703           output.print(",");
1704         if(state.MGC && ptd.isClass() && ptd.getClassDesc().isEnum()) {
1705           // do nothing
1706         } else if (ptd.isClass()&&!ptd.isArray())
1707           output.print("(struct "+ptd.getSafeSymbol()+" *) ");
1708         output.print(generateTemp(fm,fc.getThis()));
1709         needcomma=true;
1710       }
1711     }
1712
1713     for(int i=0; i<fc.numArgs(); i++) {
1714       Descriptor var=md.getParameter(i);
1715       TempDescriptor paramtemp=(TempDescriptor)temptovar.get(var);
1716       if (objectparams.isParamPrim(paramtemp)) {
1717         TempDescriptor targ=fc.getArg(i);
1718         if (needcomma)
1719           output.print(", ");
1720
1721         TypeDescriptor ptd=md.getParamType(i);
1722         if (state.MGC && ptd.isClass() && ptd.getClassDesc().isEnum()) {
1723           // do nothing
1724         } else if (ptd.isClass()&&!ptd.isArray())
1725           output.print("(struct "+ptd.getSafeSymbol()+" *) ");
1726         output.print(generateTemp(fm, targ));
1727         needcomma=true;
1728       }
1729     }
1730     output.println(");");
1731     output.println("   }");
1732   }
1733
1734
1735   protected void generateFlatFieldNode(FlatMethod fm, FlatFieldNode ffn, PrintWriter output) {
1736     if (state.SINGLETM) {
1737       //single machine transactional memory case
1738       String field=ffn.getField().getSafeSymbol();
1739       String src=generateTemp(fm, ffn.getSrc());
1740       String dst=generateTemp(fm, ffn.getDst());
1741
1742       output.println(dst+"="+ src +"->"+field+ ";");
1743       if (ffn.getField().getType().isPtr()&&locality.getAtomic(currlb).get(ffn).intValue()>0&&
1744           locality.getNodePreTempInfo(currlb, ffn).get(ffn.getSrc())!=LocalityAnalysis.SCRATCH) {
1745         if ((dc==null)||(!state.READSET&&dc.getNeedTrans(currlb, ffn))||
1746             (state.READSET&&dc.getNeedWriteTrans(currlb, ffn))) {
1747           output.println("TRANSREAD("+dst+", "+dst+", (void *) (" + localsprefixaddr + "));");
1748         } else if (state.READSET&&dc.getNeedTrans(currlb, ffn)) {
1749           if (state.HYBRID&&delaycomp.getConv(currlb).contains(ffn)) {
1750             output.println("TRANSREADRDFISSION("+dst+", "+dst+");");
1751           } else
1752             output.println("TRANSREADRD("+dst+", "+dst+");");
1753         }
1754       }
1755     } else if (state.DSM) {
1756       Integer status=locality.getNodePreTempInfo(currlb,ffn).get(ffn.getSrc());
1757       if (status==LocalityAnalysis.GLOBAL) {
1758         String field=ffn.getField().getSafeSymbol();
1759         String src=generateTemp(fm, ffn.getSrc());
1760         String dst=generateTemp(fm, ffn.getDst());
1761
1762         if (ffn.getField().getType().isPtr()) {
1763           output.println(dst+"="+ src +"->"+field+ ";");
1764           output.println("TRANSREAD("+dst+", (unsigned int) "+dst+");");
1765         } else {
1766           output.println(dst+"="+ src+"->"+field+";");
1767         }
1768       } else if (status==LocalityAnalysis.LOCAL) {
1769         if (ffn.getField().getType().isPtr()&&
1770             ffn.getField().isGlobal()) {
1771           String field=ffn.getField().getSafeSymbol();
1772           String src=generateTemp(fm, ffn.getSrc());
1773           String dst=generateTemp(fm, ffn.getDst());
1774           output.println(dst+"="+ src +"->"+field+ ";");
1775           if (locality.getAtomic(currlb).get(ffn).intValue()>0)
1776             output.println("TRANSREAD("+dst+", (unsigned int) "+dst+");");
1777         } else
1778           output.println(generateTemp(fm, ffn.getDst())+"="+ generateTemp(fm,ffn.getSrc())+"->"+ ffn.getField().getSafeSymbol()+";");
1779       } else if (status==LocalityAnalysis.EITHER) {
1780         //Code is reading from a null pointer
1781         output.println("if ("+generateTemp(fm, ffn.getSrc())+") {");
1782         output.println("#ifndef RAW");
1783         output.println("printf(\"BIG ERROR\\n\");exit(-1);}");
1784         output.println("#endif");
1785         //This should throw a suitable null pointer error
1786         output.println(generateTemp(fm, ffn.getDst())+"="+ generateTemp(fm,ffn.getSrc())+"->"+ ffn.getField().getSafeSymbol()+";");
1787       } else
1788         throw new Error("Read from non-global/non-local in:"+currlb.getExplanation());
1789     }
1790   }
1791
1792   protected void generateFlatSetFieldNode(FlatMethod fm, FlatSetFieldNode fsfn, PrintWriter output) {
1793     if (fsfn.getField().getSymbol().equals("length")&&fsfn.getDst().getType().isArray())
1794       throw new Error("Can't set array length");
1795     if (state.SINGLETM && locality.getAtomic(currlb).get(fsfn).intValue()>0) {
1796       //Single Machine Transaction Case
1797       boolean srcptr=fsfn.getSrc().getType().isPtr();
1798       String src=generateTemp(fm,fsfn.getSrc());
1799       String dst=generateTemp(fm,fsfn.getDst());
1800       output.println("//"+srcptr+" "+fsfn.getSrc().getType().isNull());
1801       if (srcptr&&!fsfn.getSrc().getType().isNull()) {
1802         output.println("{");
1803         if ((dc==null)||dc.getNeedSrcTrans(currlb, fsfn)&&
1804             locality.getNodePreTempInfo(currlb, fsfn).get(fsfn.getSrc())!=LocalityAnalysis.SCRATCH) {
1805           output.println("INTPTR srcoid=("+src+"!=NULL?((INTPTR)"+src+"->"+oidstr+"):0);");
1806         } else {
1807           output.println("INTPTR srcoid=(INTPTR)"+src+";");
1808         }
1809       }
1810       if (wb.needBarrier(fsfn)&&
1811           locality.getNodePreTempInfo(currlb, fsfn).get(fsfn.getDst())!=LocalityAnalysis.SCRATCH) {
1812         if (state.EVENTMONITOR) {
1813           output.println("if ("+dst+"->___objstatus___&DIRTY) EVLOGEVENTOBJ(EV_WRITE,"+dst+"->objuid)");
1814         }
1815         output.println("*((unsigned int *)&("+dst+"->___objstatus___))|=DIRTY;");
1816       }
1817       if (srcptr&!fsfn.getSrc().getType().isNull()) {
1818         output.println("*((unsigned INTPTR *)&("+dst+"->"+
1819                        fsfn.getField().getSafeSymbol()+"))=srcoid;");
1820         output.println("}");
1821       } else {
1822         output.println(dst+"->"+
1823                        fsfn.getField().getSafeSymbol()+"="+ src+";");
1824       }
1825     } else if (state.DSM && locality.getAtomic(currlb).get(fsfn).intValue()>0) {
1826       Integer statussrc=locality.getNodePreTempInfo(currlb,fsfn).get(fsfn.getSrc());
1827       Integer statusdst=locality.getNodeTempInfo(currlb).get(fsfn).get(fsfn.getDst());
1828       boolean srcglobal=statussrc==LocalityAnalysis.GLOBAL;
1829
1830       String src=generateTemp(fm,fsfn.getSrc());
1831       String dst=generateTemp(fm,fsfn.getDst());
1832       if (srcglobal) {
1833         output.println("{");
1834         output.println("INTPTR srcoid=("+src+"!=NULL?((INTPTR)"+src+"->"+oidstr+"):0);");
1835       }
1836       if (statusdst.equals(LocalityAnalysis.GLOBAL)) {
1837         String glbdst=dst;
1838         //mark it dirty
1839         if (wb.needBarrier(fsfn))
1840           output.println("*((unsigned int *)&("+dst+"->___localcopy___))|=DIRTY;");
1841         if (srcglobal) {
1842           output.println("*((unsigned INTPTR *)&("+glbdst+"->"+
1843                          fsfn.getField().getSafeSymbol()+"))=srcoid;");
1844         } else
1845           output.println(glbdst+"->"+
1846                          fsfn.getField().getSafeSymbol()+"="+ src+";");
1847       } else if (statusdst.equals(LocalityAnalysis.LOCAL)) {
1848         /** Check if we need to copy */
1849         output.println("if(!"+dst+"->"+localcopystr+") {");
1850         /* Link object into list */
1851         String revertptr=generateTemp(fm, reverttable.get(currlb));
1852         output.println(revertptr+"=revertlist;");
1853         if (GENERATEPRECISEGC || this.state.MULTICOREGC)
1854           output.println("COPY_OBJ((struct garbagelist *)"+localsprefixaddr+",(struct ___Object___ *)"+dst+");");
1855         else
1856           output.println("COPY_OBJ("+dst+");");
1857         output.println(dst+"->"+nextobjstr+"="+revertptr+";");
1858         output.println("revertlist=(struct ___Object___ *)"+dst+";");
1859         output.println("}");
1860         if (srcglobal)
1861           output.println(dst+"->"+
1862                          fsfn.getField().getSafeSymbol()+"=(void *) srcoid;");
1863         else
1864           output.println(dst+"->"+
1865                          fsfn.getField().getSafeSymbol()+"="+ src+";");
1866       } else if (statusdst.equals(LocalityAnalysis.EITHER)) {
1867         //writing to a null...bad
1868         output.println("if ("+dst+") {");
1869         output.println("printf(\"BIG ERROR 2\\n\");exit(-1);}");
1870         if (srcglobal)
1871           output.println(dst+"->"+
1872                          fsfn.getField().getSafeSymbol()+"=(void *) srcoid;");
1873         else
1874           output.println(dst+"->"+
1875                          fsfn.getField().getSafeSymbol()+"="+ src+";");
1876       }
1877       if (srcglobal) {
1878         output.println("}");
1879       }
1880     }
1881   }
1882
1883   protected void generateFlatElementNode(FlatMethod fm, FlatElementNode fen, PrintWriter output) {
1884     TypeDescriptor elementtype=fen.getSrc().getType().dereference();
1885     String type="";
1886
1887     if (state.MGC && elementtype.isClass() && elementtype.getClassDesc().isEnum()) {
1888       type="int ";
1889     } else if (elementtype.isArray()||elementtype.isClass())
1890       type="void *";
1891     else
1892       type=elementtype.getSafeSymbol()+" ";
1893
1894     if (this.state.ARRAYBOUNDARYCHECK && fen.needsBoundsCheck()) {
1895       output.println("if (unlikely(((unsigned int)"+generateTemp(fm, fen.getIndex())+") >= "+generateTemp(fm,fen.getSrc()) + "->___length___))");
1896       output.println("failedboundschk();");
1897     }
1898     if (state.SINGLETM) {
1899       //Single machine transaction case
1900       String dst=generateTemp(fm, fen.getDst());
1901       if ((!state.STMARRAY)||(!wb.needBarrier(fen))||locality.getNodePreTempInfo(currlb, fen).get(fen.getSrc())==LocalityAnalysis.SCRATCH||locality.getAtomic(currlb).get(fen).intValue()==0||(state.READSET&&!dc.getNeedGet(currlb, fen))) {
1902         output.println(dst +"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc())+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex())+"];");
1903       } else {
1904         output.println("STMGETARRAY("+dst+", "+ generateTemp(fm,fen.getSrc())+", "+generateTemp(fm, fen.getIndex())+", "+type+");");
1905       }
1906
1907       if (elementtype.isPtr()&&locality.getAtomic(currlb).get(fen).intValue()>0&&
1908           locality.getNodePreTempInfo(currlb, fen).get(fen.getSrc())!=LocalityAnalysis.SCRATCH) {
1909         if ((dc==null)||!state.READSET&&dc.getNeedTrans(currlb, fen)||state.READSET&&dc.getNeedWriteTrans(currlb, fen)) {
1910           output.println("TRANSREAD("+dst+", "+dst+", (void *)(" + localsprefixaddr+"));");
1911         } else if (state.READSET&&dc.getNeedTrans(currlb, fen)) {
1912           if (state.HYBRID&&delaycomp.getConv(currlb).contains(fen)) {
1913             output.println("TRANSREADRDFISSION("+dst+", "+dst+");");
1914           } else
1915             output.println("TRANSREADRD("+dst+", "+dst+");");
1916         }
1917       }
1918     } else if (state.DSM) {
1919       Integer status=locality.getNodePreTempInfo(currlb,fen).get(fen.getSrc());
1920       if (status==LocalityAnalysis.GLOBAL) {
1921         String dst=generateTemp(fm, fen.getDst());
1922         if (elementtype.isPtr()) {
1923           output.println(dst +"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc())+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex())+"];");
1924           output.println("TRANSREAD("+dst+", "+dst+");");
1925         } else {
1926           output.println(dst +"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc())+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex())+"];");
1927         }
1928       } else if (status==LocalityAnalysis.LOCAL) {
1929         output.println(generateTemp(fm, fen.getDst())+"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc())+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex())+"];");
1930       } else if (status==LocalityAnalysis.EITHER) {
1931         //Code is reading from a null pointer
1932         output.println("if ("+generateTemp(fm, fen.getSrc())+") {");
1933         output.println("#ifndef RAW");
1934         output.println("printf(\"BIG ERROR\\n\");exit(-1);}");
1935         output.println("#endif");
1936         //This should throw a suitable null pointer error
1937         output.println(generateTemp(fm, fen.getDst())+"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc())+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex())+"];");
1938       } else
1939         throw new Error("Read from non-global/non-local in:"+currlb.getExplanation());
1940     }
1941   }
1942
1943   protected void generateFlatSetElementNode(FlatMethod fm, FlatSetElementNode fsen, PrintWriter output) {
1944     //TODO: need dynamic check to make sure this assignment is actually legal
1945     //Because Object[] could actually be something more specific...ie. Integer[]
1946
1947     TypeDescriptor elementtype=fsen.getDst().getType().dereference();
1948     String type="";
1949
1950     if (state.MGC && elementtype.isClass() && elementtype.getClassDesc().isEnum()) {
1951       type="int ";
1952     } else if (elementtype.isArray()||elementtype.isClass() || (state.MGC && elementtype.isNull()))
1953       type="void *";
1954     else
1955       type=elementtype.getSafeSymbol()+" ";
1956
1957     if (this.state.ARRAYBOUNDARYCHECK && fsen.needsBoundsCheck()) {
1958       output.println("if (unlikely(((unsigned int)"+generateTemp(fm, fsen.getIndex())+") >= "+generateTemp(fm,fsen.getDst()) + "->___length___))");
1959       output.println("failedboundschk();");
1960     }
1961
1962     if (state.SINGLETM && locality.getAtomic(currlb).get(fsen).intValue()>0) {
1963       //Transaction set element case
1964       if (wb.needBarrier(fsen)&&
1965           locality.getNodePreTempInfo(currlb, fsen).get(fsen.getDst())!=LocalityAnalysis.SCRATCH) {
1966         output.println("*((unsigned int *)&("+generateTemp(fm,fsen.getDst())+"->___objstatus___))|=DIRTY;");
1967       }
1968       if (fsen.getSrc().getType().isPtr()&&!fsen.getSrc().getType().isNull()) {
1969         output.println("{");
1970         String src=generateTemp(fm, fsen.getSrc());
1971         if ((dc==null)||dc.getNeedSrcTrans(currlb, fsen)&&
1972             locality.getNodePreTempInfo(currlb, fsen).get(fsen.getSrc())!=LocalityAnalysis.SCRATCH) {
1973           output.println("INTPTR srcoid=("+src+"!=NULL?((INTPTR)"+src+"->"+oidstr+"):0);");
1974         } else {
1975           output.println("INTPTR srcoid=(INTPTR)"+src+";");
1976         }
1977         if (state.STMARRAY&&locality.getNodePreTempInfo(currlb, fsen).get(fsen.getDst())!=LocalityAnalysis.SCRATCH&&wb.needBarrier(fsen)&&locality.getAtomic(currlb).get(fsen).intValue()>0) {
1978           output.println("STMSETARRAY("+generateTemp(fm, fsen.getDst())+", "+generateTemp(fm, fsen.getIndex())+", srcoid, INTPTR);");
1979         } else {
1980           output.println("((INTPTR*)(((char *) &("+ generateTemp(fm,fsen.getDst())+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex())+"]=srcoid;");
1981         }
1982         output.println("}");
1983       } else {
1984         if (state.STMARRAY&&locality.getNodePreTempInfo(currlb, fsen).get(fsen.getDst())!=LocalityAnalysis.SCRATCH&&wb.needBarrier(fsen)&&locality.getAtomic(currlb).get(fsen).intValue()>0) {
1985           output.println("STMSETARRAY("+generateTemp(fm, fsen.getDst())+", "+generateTemp(fm, fsen.getIndex())+", "+ generateTemp(fm, fsen.getSrc()) +", "+type+");");
1986         } else {
1987           output.println("(("+type +"*)(((char *) &("+ generateTemp(fm,fsen.getDst())+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex())+"]="+generateTemp(fm,fsen.getSrc())+";");
1988         }
1989       }
1990     } else if (state.DSM && locality.getAtomic(currlb).get(fsen).intValue()>0) {
1991       Integer statussrc=locality.getNodePreTempInfo(currlb,fsen).get(fsen.getSrc());
1992       Integer statusdst=locality.getNodePreTempInfo(currlb,fsen).get(fsen.getDst());
1993       boolean srcglobal=statussrc==LocalityAnalysis.GLOBAL;
1994       boolean dstglobal=statusdst==LocalityAnalysis.GLOBAL;
1995       boolean dstlocal=(statusdst==LocalityAnalysis.LOCAL)||(statusdst==LocalityAnalysis.EITHER);
1996
1997       if (dstglobal) {
1998         if (wb.needBarrier(fsen))
1999           output.println("*((unsigned int *)&("+generateTemp(fm,fsen.getDst())+"->___localcopy___))|=DIRTY;");
2000       } else if (dstlocal) {
2001         /** Check if we need to copy */
2002         String dst=generateTemp(fm, fsen.getDst());
2003         output.println("if(!"+dst+"->"+localcopystr+") {");
2004         /* Link object into list */
2005         String revertptr=generateTemp(fm, reverttable.get(currlb));
2006         output.println(revertptr+"=revertlist;");
2007         if ((GENERATEPRECISEGC) || this.state.MULTICOREGC)
2008           output.println("COPY_OBJ((struct garbagelist *)"+localsprefixaddr+",(struct ___Object___ *)"+dst+");");
2009         else
2010           output.println("COPY_OBJ("+dst+");");
2011         output.println(dst+"->"+nextobjstr+"="+revertptr+";");
2012         output.println("revertlist=(struct ___Object___ *)"+dst+";");
2013         output.println("}");
2014       } else {
2015         System.out.println("Node: "+fsen);
2016         System.out.println(currlb);
2017         System.out.println("statusdst="+statusdst);
2018         System.out.println(fm.printMethod());
2019         throw new Error("Unknown array type");
2020       }
2021       if (srcglobal) {
2022         output.println("{");
2023         String src=generateTemp(fm, fsen.getSrc());
2024         output.println("INTPTR srcoid=("+src+"!=NULL?((INTPTR)"+src+"->"+oidstr+"):0);");
2025         output.println("((INTPTR*)(((char *) &("+ generateTemp(fm,fsen.getDst())+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex())+"]=srcoid;");
2026         output.println("}");
2027       } else {
2028         output.println("(("+type +"*)(((char *) &("+ generateTemp(fm,fsen.getDst())+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex())+"]="+generateTemp(fm,fsen.getSrc())+";");
2029       }
2030     } else {
2031       if (state.FASTCHECK) {
2032         String dst=generateTemp(fm, fsen.getDst());
2033         output.println("if(!"+dst+"->"+localcopystr+") {");
2034         /* Link object into list */
2035         if (GENERATEPRECISEGC || this.state.MULTICOREGC)
2036           output.println("COPY_OBJ((struct garbagelist *)"+localsprefixaddr+",(struct ___Object___ *)"+dst+");");
2037         else
2038           output.println("COPY_OBJ("+dst+");");
2039         output.println(dst+"->"+nextobjstr+"="+fcrevert+";");
2040         output.println(fcrevert+"=(struct ___Object___ *)"+dst+";");
2041         output.println("}");
2042       }
2043       output.println("(("+type +"*)(((char *) &("+ generateTemp(fm,fsen.getDst())+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex())+"]="+generateTemp(fm,fsen.getSrc())+";");
2044     }
2045   }
2046
2047
2048   protected void generateFlatNew(FlatMethod fm, FlatNew fn, PrintWriter output) {
2049     if (state.DSM && locality.getAtomic(currlb).get(fn).intValue()>0&&!fn.isGlobal()) {
2050       //Stash pointer in case of GC
2051       String revertptr=generateTemp(fm, reverttable.get(currlb));
2052       output.println(revertptr+"=revertlist;");
2053     }
2054     if (state.SINGLETM) {
2055       if (fn.getType().isArray()) {
2056         int arrayid=state.getArrayNumber(fn.getType())+state.numClasses();
2057         if (locality.getAtomic(currlb).get(fn).intValue()>0) {
2058           //inside transaction
2059           output.println(generateTemp(fm,fn.getDst())+"=allocate_newarraytrans("+localsprefixaddr+", "+arrayid+", "+generateTemp(fm, fn.getSize())+");");
2060         } else {
2061           //outside transaction
2062           output.println(generateTemp(fm,fn.getDst())+"=allocate_newarray("+localsprefixaddr+", "+arrayid+", "+generateTemp(fm, fn.getSize())+");");
2063         }
2064       } else {
2065         if (locality.getAtomic(currlb).get(fn).intValue()>0) {
2066           //inside transaction
2067           output.println(generateTemp(fm,fn.getDst())+"=allocate_newtrans("+localsprefixaddr+", "+fn.getType().getClassDesc().getId()+");");
2068         } else {
2069           //outside transaction
2070           output.println(generateTemp(fm,fn.getDst())+"=allocate_new("+localsprefixaddr+", "+fn.getType().getClassDesc().getId()+");");
2071         }
2072       }
2073     } else if (fn.getType().isArray()) {
2074       int arrayid=state.getArrayNumber(fn.getType())+state.numClasses();
2075       if (fn.isGlobal()) {
2076         output.println(generateTemp(fm,fn.getDst())+"=allocate_newarrayglobal("+arrayid+", "+generateTemp(fm, fn.getSize())+");");
2077       } else if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2078         output.println(generateTemp(fm,fn.getDst())+"=allocate_newarray("+localsprefixaddr+", "+arrayid+", "+generateTemp(fm, fn.getSize())+");");
2079       } else {
2080         output.println(generateTemp(fm,fn.getDst())+"=allocate_newarray("+arrayid+", "+generateTemp(fm, fn.getSize())+");");
2081       }
2082     } else {
2083       if (fn.isGlobal()) {
2084         output.println(generateTemp(fm,fn.getDst())+"=allocate_newglobal("+fn.getType().getClassDesc().getId()+");");
2085       } else if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2086         output.println(generateTemp(fm,fn.getDst())+"=allocate_new("+localsprefixaddr+", "+fn.getType().getClassDesc().getId()+");");
2087       } else {
2088         output.println(generateTemp(fm,fn.getDst())+"=allocate_new("+fn.getType().getClassDesc().getId()+");");
2089       }
2090     }
2091     if (state.DSM && locality.getAtomic(currlb).get(fn).intValue()>0&&!fn.isGlobal()) {
2092       String revertptr=generateTemp(fm, reverttable.get(currlb));
2093       String dst=generateTemp(fm,fn.getDst());
2094       output.println(dst+"->___localcopy___=(struct ___Object___*)1;");
2095       output.println(dst+"->"+nextobjstr+"="+revertptr+";");
2096       output.println("revertlist=(struct ___Object___ *)"+dst+";");
2097     }
2098     if (state.FASTCHECK) {
2099       String dst=generateTemp(fm,fn.getDst());
2100       output.println(dst+"->___localcopy___=(struct ___Object___*)1;");
2101       output.println(dst+"->"+nextobjstr+"="+fcrevert+";");
2102       output.println(fcrevert+"=(struct ___Object___ *)"+dst+";");
2103     }
2104   }
2105
2106   protected void generateFlatOpNode(FlatMethod fm, FlatOpNode fon, PrintWriter output) {
2107     if (fon.getRight()!=null) {
2108       if (fon.getOp().getOp()==Operation.URIGHTSHIFT) {
2109         if (fon.getLeft().getType().isLong())
2110           output.println(generateTemp(fm, fon.getDest())+" = ((unsigned long long)"+generateTemp(fm, fon.getLeft())+")>>"+generateTemp(fm,fon.getRight())+";");
2111         else
2112           output.println(generateTemp(fm, fon.getDest())+" = ((unsigned int)"+generateTemp(fm, fon.getLeft())+")>>"+generateTemp(fm,fon.getRight())+";");
2113
2114       } else if (dc!=null) {
2115         output.print(generateTemp(fm, fon.getDest())+" = (");
2116         if (fon.getLeft().getType().isPtr()&&(fon.getOp().getOp()==Operation.EQUAL||fon.getOp().getOp()==Operation.NOTEQUAL))
2117           output.print("(void *)");
2118         if (dc.getNeedLeftSrcTrans(currlb, fon))
2119           output.print("("+generateTemp(fm, fon.getLeft())+"!=NULL?"+generateTemp(fm, fon.getLeft())+"->"+oidstr+":NULL)");
2120         else
2121           output.print(generateTemp(fm, fon.getLeft()));
2122         output.print(")"+fon.getOp().toString()+"(");
2123         if (fon.getRight().getType().isPtr()&&(fon.getOp().getOp()==Operation.EQUAL||fon.getOp().getOp()==Operation.NOTEQUAL))
2124           output.print("(void *)");
2125         if (dc.getNeedRightSrcTrans(currlb, fon))
2126           output.println("("+generateTemp(fm, fon.getRight())+"!=NULL?"+generateTemp(fm, fon.getRight())+"->"+oidstr+":NULL));");
2127         else
2128           output.println(generateTemp(fm,fon.getRight())+");");
2129       } else
2130         output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+fon.getOp().toString()+generateTemp(fm,fon.getRight())+";");
2131     } else if (fon.getOp().getOp()==Operation.ASSIGN)
2132       output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+";");
2133     else if (fon.getOp().getOp()==Operation.UNARYPLUS)
2134       output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+";");
2135     else if (fon.getOp().getOp()==Operation.UNARYMINUS)
2136       output.println(generateTemp(fm, fon.getDest())+" = -"+generateTemp(fm, fon.getLeft())+";");
2137     else if (fon.getOp().getOp()==Operation.LOGIC_NOT)
2138       output.println(generateTemp(fm, fon.getDest())+" = !"+generateTemp(fm, fon.getLeft())+";");
2139     else if (fon.getOp().getOp()==Operation.COMP)
2140       output.println(generateTemp(fm, fon.getDest())+" = ~"+generateTemp(fm, fon.getLeft())+";");
2141     else if (fon.getOp().getOp()==Operation.ISAVAILABLE) {
2142       output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+"->fses==NULL;");
2143     } else
2144       output.println(generateTemp(fm, fon.getDest())+fon.getOp().toString()+generateTemp(fm, fon.getLeft())+";");
2145   }
2146
2147   protected void generateFlatLiteralNode(FlatMethod fm, FlatLiteralNode fln, PrintWriter output) {
2148     if (fln.getValue()==null)
2149       output.println(generateTemp(fm, fln.getDst())+"=0;");
2150     else if (fln.getType().getSymbol().equals(TypeUtil.StringClass)) {
2151       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2152         if (state.DSM && locality.getAtomic(currlb).get(fln).intValue()>0) {
2153           //Stash pointer in case of GC
2154           String revertptr=generateTemp(fm, reverttable.get(currlb));
2155           output.println(revertptr+"=revertlist;");
2156         }
2157         output.println(generateTemp(fm, fln.getDst())+"=NewString("+localsprefixaddr+", \""+FlatLiteralNode.escapeString((String)fln.getValue())+"\","+((String)fln.getValue()).length()+");");
2158         if (state.DSM && locality.getAtomic(currlb).get(fln).intValue()>0) {
2159           //Stash pointer in case of GC
2160           String revertptr=generateTemp(fm, reverttable.get(currlb));
2161           output.println("revertlist="+revertptr+";");
2162         }
2163       } else {
2164         output.println(generateTemp(fm, fln.getDst())+"=NewString(\""+FlatLiteralNode.escapeString((String)fln.getValue())+"\","+((String)fln.getValue()).length()+");");
2165       }
2166     } else if (fln.getType().isBoolean()) {
2167       if (((Boolean)fln.getValue()).booleanValue())
2168         output.println(generateTemp(fm, fln.getDst())+"=1;");
2169       else
2170         output.println(generateTemp(fm, fln.getDst())+"=0;");
2171     } else if (fln.getType().isChar()) {
2172       String st=FlatLiteralNode.escapeString(fln.getValue().toString());
2173       output.println(generateTemp(fm, fln.getDst())+"='"+st+"';");
2174     } else if (fln.getType().isLong()) {
2175       output.println(generateTemp(fm, fln.getDst())+"="+fln.getValue()+"LL;");
2176     } else
2177       output.println(generateTemp(fm, fln.getDst())+"="+fln.getValue()+";");
2178   }
2179
2180   protected void generateStoreFlatCondBranch(FlatMethod fm, LocalityBinding lb, FlatCondBranch fcb, String label, PrintWriter output) {
2181     int left=-1;
2182     int right=-1;
2183     //only record if this group has more than one exit
2184     if (branchanalysis.numJumps(fcb)>1) {
2185       left=branchanalysis.jumpValue(fcb, 0);
2186       right=branchanalysis.jumpValue(fcb, 1);
2187     }
2188     output.println("if (!"+generateTemp(fm, fcb.getTest())+") {");
2189     if (right!=-1)
2190       output.println("STOREBRANCH("+right+");");
2191     output.println("goto "+label+";");
2192     output.println("}");
2193     if (left!=-1)
2194       output.println("STOREBRANCH("+left+");");
2195   }
2196
2197   /** This method generates header information for the method or
2198    * task referenced by the Descriptor des. */
2199   protected void generateHeader(FlatMethod fm, LocalityBinding lb, Descriptor des, PrintWriter output) {
2200     /* Print header */
2201     ParamsObject objectparams=(ParamsObject)paramstable.get(lb!=null?lb:des);
2202     MethodDescriptor md=null;
2203     TaskDescriptor task=null;
2204     if (des instanceof MethodDescriptor)
2205       md=(MethodDescriptor) des;
2206     else
2207       task=(TaskDescriptor) des;
2208
2209     ClassDescriptor cn=md!=null?md.getClassDesc():null;
2210
2211     if (md!=null&&md.getReturnType()!=null) {
2212       if (state.MGC && md.getReturnType().isClass() && md.getReturnType().getClassDesc().isEnum()) {
2213         output.print("int ");
2214       } else if (md.getReturnType().isClass()||md.getReturnType().isArray())
2215         output.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
2216       else
2217         output.print(md.getReturnType().getSafeSymbol()+" ");
2218     } else
2219       //catch the constructor case
2220       output.print("void ");
2221     if (md!=null) {
2222       output.print(cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(");
2223     } else
2224       output.print(task.getSafeSymbol()+"(");
2225
2226     boolean printcomma=false;
2227     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2228       if (md!=null) {
2229         output.print("struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
2230       } else
2231         output.print("struct "+task.getSafeSymbol()+"_params * "+paramsprefix);
2232       printcomma=true;
2233     }
2234
2235     if (md!=null) {
2236       /* Method */
2237       for(int i=0; i<objectparams.numPrimitives(); i++) {
2238         TempDescriptor temp=objectparams.getPrimitive(i);
2239         if (printcomma)
2240           output.print(", ");
2241         printcomma=true;
2242         if(state.MGC && temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
2243           output.print("int " + temp.getSafeSymbol());
2244         } else if (temp.getType().isClass()||temp.getType().isArray())
2245           output.print("struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol());
2246         else
2247           output.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
2248       }
2249       output.println(") {");
2250     } else if (!GENERATEPRECISEGC && !this.state.MULTICOREGC) {
2251       /* Imprecise Task */
2252       output.println("void * parameterarray[]) {");
2253       /* Unpack variables */
2254       for(int i=0; i<objectparams.numPrimitives(); i++) {
2255         TempDescriptor temp=objectparams.getPrimitive(i);
2256         if(state.MGC && temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
2257           output.print("int " + temp.getSafeSymbol() + "=parameterarray["+i+"];");
2258         } else {
2259           output.println("struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+"=parameterarray["+i+"];");
2260         }
2261       }
2262       for(int i=0; i<fm.numTags(); i++) {
2263         TempDescriptor temp=fm.getTag(i);
2264         int offset=i+objectparams.numPrimitives();
2265         output.println("struct ___TagDescriptor___ * "+temp.getSafeSymbol()+"=parameterarray["+offset+"];");
2266       }
2267
2268       if ((objectparams.numPrimitives()+fm.numTags())>maxtaskparams)
2269         maxtaskparams=objectparams.numPrimitives()+fm.numTags();
2270     } else output.println(") {");
2271   }
2272 }
2273
2274
2275
2276
2277
2278