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