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;
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;
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;
41 DiscoverConflicts recorddc;
43 LocalityBinding currlb;
46 public BuildCodeTran(State st, Hashtable temptovar, TypeUtil typeutil, SafetyAnalysis sa, PrefetchAnalysis pa, CallGraph callgraph) {
47 this(st, temptovar, typeutil, null, sa, pa, callgraph);
50 public BuildCodeTran(State st, Hashtable temptovar, TypeUtil typeutil, LocalityAnalysis locality, PrefetchAnalysis pa, CallGraph callgraph) {
51 this(st, temptovar, typeutil, locality, null, pa, callgraph);
54 public BuildCodeTran(State st, Hashtable temptovar, TypeUtil typeutil, LocalityAnalysis locality, SafetyAnalysis sa, PrefetchAnalysis pa, CallGraph callgraph) {
55 super(st, temptovar, typeutil, sa, callgraph);
57 this.virtualcalls=new Virtual(state, locality, callgraph);
59 oidstr="___objlocation___";
61 this.locality=locality;
62 this.reverttable=new Hashtable<LocalityBinding, TempDescriptor>();
63 this.backuptable=new Hashtable<LocalityBinding, Hashtable<TempDescriptor, TempDescriptor>>();
64 this.wb=new WriteBarrier(locality, st);
66 if (state.SINGLETM&&state.DCOPTS) {
67 TypeAnalysis typeanalysis=new TypeAnalysis(locality, st, typeutil,callgraph);
68 GlobalFieldType gft=new GlobalFieldType(callgraph, st, typeutil.getMain());
69 this.dc=new DiscoverConflicts(locality, st, typeanalysis, gft);
72 if (state.DELAYCOMP) {
73 TypeAnalysis typeanalysis=new TypeAnalysis(locality, st, typeutil,callgraph);
74 GlobalFieldType gft=new GlobalFieldType(callgraph, st, typeutil.getMain());
75 delaycomp=new DCWrapper(locality, st, typeanalysis, gft);
76 dc=delaycomp.getConflicts();
77 recorddc=new DiscoverConflicts(locality, st, typeanalysis, delaycomp.getCannotDelayMap(), true, true, null);
78 recorddc.doAnalysis();
82 /** The buildCode method outputs C code for all the methods. The Flat
83 * versions of the methods must already be generated and stored in
84 * the State object. */
86 PrintWriter outsandbox=null;
88 protected void buildCodeSetup() {
91 outsandbox=new CodePrinter(new FileOutputStream(PREFIX+"sandboxdefs.c"), true);
93 } catch (Exception e) {
99 protected void additionalIncludesMethodsHeader(PrintWriter outmethodheader) {
101 outmethodheader.println("#include \"dstm.h\"");
103 outmethodheader.println("#include \"sandbox.h\"");
105 if (state.SINGLETM) {
106 outmethodheader.println("#include \"tm.h\"");
107 outmethodheader.println("#include \"delaycomp.h\"");
108 outmethodheader.println("#include \"inlinestm.h\"");
110 if (state.ABORTREADERS) {
111 outmethodheader.println("#include \"abortreaders.h\"");
112 outmethodheader.println("#include <setjmp.h>");
118 protected void outputMainMethod(PrintWriter outmethod) {
119 outmethod.println("int main(int argc, const char *argv[]) {");
120 outmethod.println(" int i;");
121 outmethod.println(" global_defs_p=calloc(1, sizeof(struct global_defs_t));");
122 outmethod.println(" global_defsprim_p=calloc(1, sizeof(struct global_defsprim_t));");
123 if (GENERATEPRECISEGC) {
124 outmethod.println(" global_defs_p->size="+globaldefscount+";");
125 outmethod.println(" for(i=0;i<"+globaldefscount+";i++) {");
126 outmethod.println(" ((struct garbagelist *)global_defs_p)->array[i]=NULL;");
127 outmethod.println(" }");
130 outputStaticBlocks(outmethod);
131 outputClassObjects(outmethod);
132 additionalCodeAtTopOfMain(outmethod);
135 if (state.DSMRECOVERYSTATS) {
136 outmethod.println("#ifdef RECOVERYSTATS \n");
137 outmethod.println("handle();\n");
138 outmethod.println("#endif\n");
140 outmethod.println("#if defined(TRANSSTATS) || defined(RECOVERYSTATS) \n");
141 outmethod.println("handle();\n");
142 outmethod.println("#endif\n");
145 outmethod.println("initializethreads();");
148 outmethod.println("if (dstmStartup(argv[1])) {");
149 if (GENERATEPRECISEGC) {
150 outmethod.println(" struct ArrayObject * stringarray=allocate_newarray(NULL, STRINGARRAYTYPE, argc-2);");
152 outmethod.println(" struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc-2);");
155 if (GENERATEPRECISEGC) {
156 outmethod.println(" struct ArrayObject * stringarray=allocate_newarray(NULL, STRINGARRAYTYPE, argc-1);");
158 outmethod.println(" struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc-1);");
162 outmethod.println(" for(i=2;i<argc;i++) {");
164 outmethod.println(" for(i=1;i<argc;i++) {");
165 outmethod.println(" int length=strlen(argv[i]);");
166 if (GENERATEPRECISEGC) {
167 outmethod.println(" struct ___String___ *newstring=NewString(NULL, argv[i], length);");
169 outmethod.println(" struct ___String___ *newstring=NewString(argv[i], length);");
172 outmethod.println(" ((void **)(((char *)& stringarray->___length___)+sizeof(int)))[i-2]=newstring;");
174 outmethod.println(" ((void **)(((char *)& stringarray->___length___)+sizeof(int)))[i-1]=newstring;");
175 outmethod.println(" }");
177 MethodDescriptor md=typeutil.getMain();
178 ClassDescriptor cd=typeutil.getMainClass();
180 outmethod.println(" {");
181 if (GENERATEPRECISEGC) {
182 outmethod.print(" struct "+cd.getSafeSymbol()+locality.getMain().getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
183 outmethod.println("1, NULL,"+"stringarray};");
184 outmethod.println(" "+cd.getSafeSymbol()+locality.getMain().getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(& __parameterlist__);");
186 outmethod.println(" "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(stringarray);");
188 outmethod.println(" }");
191 outmethod.println("}");
194 outmethod.println("pthread_mutex_lock(&gclistlock);");
195 outmethod.println("threadcount--;");
196 outmethod.println("pthread_cond_signal(&gccond);");
197 outmethod.println("pthread_mutex_unlock(&gclistlock);");
199 outmethod.println("#if defined(TRANSSTATS) \n");
200 outmethod.println("printf(\"****** Transaction Stats ******\\n\");");
201 outmethod.println("printf(\"numTransCommit= %d\\n\", numTransCommit);");
202 outmethod.println("printf(\"numTransAbort= %d\\n\", numTransAbort);");
203 outmethod.println("printf(\"nSoftAbort= %d\\n\", nSoftAbort);");
205 outmethod.println("printf(\"nchashSearch= %d\\n\", nchashSearch);");
206 outmethod.println("printf(\"nmhashSearch= %d\\n\", nmhashSearch);");
207 outmethod.println("printf(\"nprehashSearch= %d\\n\", nprehashSearch);");
208 outmethod.println("printf(\"ndirtyCacheObj= %d\\n\", ndirtyCacheObj);");
209 outmethod.println("printf(\"nRemoteReadSend= %d\\n\", nRemoteSend);");
210 outmethod.println("printf(\"bytesSent= %d\\n\", bytesSent);");
211 outmethod.println("printf(\"bytesRecv= %d\\n\", bytesRecv);");
212 outmethod.println("printf(\"totalObjSize= %d\\n\", totalObjSize);");
213 outmethod.println("printf(\"sendRemoteReq= %d\\n\", sendRemoteReq);");
214 outmethod.println("printf(\"getResponse= %d\\n\", getResponse);");
215 } else if (state.SINGLETM) {
216 outmethod.println("printf(\"nSoftAbortAbort= %d\\n\", nSoftAbortAbort);");
217 outmethod.println("printf(\"nSoftAbortCommit= %d\\n\", nSoftAbortCommit);");
218 outmethod.println("#ifdef STMSTATS\n");
219 outmethod.println("for(i=0; i<TOTALNUMCLASSANDARRAY; i++) {\n");
220 outmethod.println(" printf(\"typesCausingAbort[%2d] numaccess= %5d numabort= %3d\\n\", i, typesCausingAbort[i].numaccess, typesCausingAbort[i].numabort);\n");
221 outmethod.println("}\n");
222 outmethod.println("#endif\n");
223 outmethod.println("fflush(stdout);");
225 outmethod.println("#endif\n");
228 if (state.EVENTMONITOR) {
229 outmethod.println("dumpdata();");
233 outmethod.println("pthread_exit(NULL);");
234 additionalCodeAtBottomOfMain(outmethod);
235 outmethod.println("}");
238 protected void additionalIncludesMethodsImplementation(PrintWriter outmethod) {
240 outmethod.println("#include \"sandboxdefs.c\"");
243 outmethod.println("#include \"addPrefetchEnhance.h\"");
244 outmethod.println("#include \"localobjects.h\"");
248 protected void generateMethods(PrintWriter outmethod) {
249 for(Iterator<LocalityBinding> lbit=locality.getLocalityBindings().iterator(); lbit.hasNext(); ) {
250 LocalityBinding lb=lbit.next();
251 MethodDescriptor md=lb.getMethod();
252 FlatMethod fm=state.getMethodFlat(md);
254 if (!md.getModifiers().isNative()) {
255 generateFlatMethod(fm, lb, outmethod);
260 protected void additionalIncludesStructsHeader(PrintWriter outstructs) {
261 LocalityBinding lbrun=new LocalityBinding(typeutil.getRun(), false);
263 lbrun.setGlobalThis(LocalityAnalysis.GLOBAL);
264 } else if (state.SINGLETM) {
265 lbrun.setGlobalThis(LocalityAnalysis.NORMAL);
267 outstructs.println("#define RUNMETHOD "+virtualcalls.getLocalityNumber(lbrun));
270 LocalityBinding lbexecute = new LocalityBinding(typeutil.getExecute(), false);
272 lbexecute.setGlobalThis(LocalityAnalysis.GLOBAL);
273 else if( state.SINGLETM)
274 lbexecute.setGlobalThis(LocalityAnalysis.NORMAL);
275 outstructs.println("#define EXECUTEMETHOD " + virtualcalls.getLocalityNumber(lbexecute));
279 protected void printExtraArrayFields(PrintWriter outclassdefs) {
280 if (state.STMARRAY) {
281 outclassdefs.println(" int lowindex;");
282 outclassdefs.println(" int highindex;");
284 if (state.DUALVIEW) {
285 outclassdefs.println(" int arrayversion;");
289 /** The buildVirtualTables method outputs the virtual dispatch
290 * tables for methods. */
292 protected void buildVirtualTables(PrintWriter outvirtual) {
293 Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();
294 while(classit.hasNext()) {
295 ClassDescriptor cd=(ClassDescriptor)classit.next();
296 if (virtualcalls.getMethodCount(cd)>maxcount)
297 maxcount=virtualcalls.getMethodCount(cd);
300 LocalityBinding[][] lbvirtualtable=null;
301 lbvirtualtable=new LocalityBinding[state.numClasses()+state.numArrays()][maxcount];
303 /* Fill in virtual table */
304 classit=state.getClassSymbolTable().getDescriptorsIterator();
305 while(classit.hasNext()) {
306 ClassDescriptor cd=(ClassDescriptor)classit.next();
307 if(cd.isInterface()) {
310 fillinRow(cd, lbvirtualtable, cd.getId());
313 ClassDescriptor objectcd=typeutil.getClass(TypeUtil.ObjectClass);
314 Iterator arrayit=state.getArrayIterator();
315 while(arrayit.hasNext()) {
316 TypeDescriptor td=(TypeDescriptor)arrayit.next();
317 int id=state.getArrayNumber(td);
318 fillinRow(objectcd, lbvirtualtable, id+state.numClasses());
321 outvirtual.print("void * virtualtable[]={");
322 boolean needcomma=false;
323 for(int i=0; i<state.numClasses()+state.numArrays(); i++) {
324 for(int j=0; j<maxcount; j++) {
326 outvirtual.print(", ");
327 if (lbvirtualtable[i][j]!=null) {
328 LocalityBinding lb=lbvirtualtable[i][j];
329 MethodDescriptor md=lb.getMethod();
330 outvirtual.print("& "+md.getClassDesc().getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
332 outvirtual.print("0");
336 outvirtual.println("");
338 outvirtual.println("};");
342 protected void fillinRow(ClassDescriptor cd, LocalityBinding[][] virtualtable, int rownum) {
343 /* Get inherited methods */
344 if (cd.getSuperDesc()!=null)
345 fillinRow(cd.getSuperDesc(), virtualtable, rownum);
346 /* Override them with our methods */
347 if (locality.getClassBindings(cd)!=null)
348 for(Iterator<LocalityBinding> lbit=locality.getClassBindings(cd).iterator(); lbit.hasNext(); ) {
349 LocalityBinding lb=lbit.next();
350 MethodDescriptor md=lb.getMethod();
351 //Is the method static or a constructor
352 if (md.isStatic()||md.getReturnType()==null)
354 int methodnum=virtualcalls.getLocalityNumber(lb);
355 virtualtable[rownum][methodnum]=lb;
359 /** Generate array that contains the sizes of class objects. The
360 * object allocation functions in the runtime use this
363 protected void generateSizeArrayExtensions(PrintWriter outclassdefs) {
364 outclassdefs.print("#ifdef TRANSSTATS \n");
365 outclassdefs.print("extern int numTransAbort;\n");
366 outclassdefs.print("extern int numTransCommit;\n");
367 outclassdefs.print("extern int nSoftAbort;\n");
369 outclassdefs.print("extern int nchashSearch;\n");
370 outclassdefs.print("extern int nmhashSearch;\n");
371 outclassdefs.print("extern int nprehashSearch;\n");
372 outclassdefs.print("extern int ndirtyCacheObj;\n");
373 outclassdefs.print("extern int nRemoteSend;\n");
374 outclassdefs.print("extern int sendRemoteReq;\n");
375 outclassdefs.print("extern int getResponse;\n");
376 outclassdefs.print("extern int bytesSent;\n");
377 outclassdefs.print("extern int bytesRecv;\n");
378 outclassdefs.print("extern int totalObjSize;\n");
379 outclassdefs.print("extern void handle();\n");
380 } else if (state.SINGLETM) {
381 outclassdefs.println("extern int nSoftAbortAbort;");
382 outclassdefs.println("extern int nSoftAbortCommit;");
383 outclassdefs.println("#ifdef STMSTATS\n");
384 outclassdefs.println("extern objtypestat_t typesCausingAbort[];");
385 outclassdefs.println("#endif\n");
387 outclassdefs.print("#endif\n");
389 outclassdefs.print("int numprefetchsites = " + pa.prefetchsiteid + ";\n");
392 /** Constructs params and temp objects for each method or task.
393 * These objects tell the compiler which temps need to be
396 protected void generateTempStructs(FlatMethod fm, LocalityBinding lb) {
397 MethodDescriptor md=fm.getMethod();
398 TaskDescriptor task=fm.getTask();
399 Set<TempDescriptor> saveset=lb!=null?locality.getTempSet(lb):null;
400 ParamsObject objectparams=md!=null?new ParamsObject(md,tag++):new ParamsObject(task, tag++);
402 paramstable.put(lb, objectparams);
403 backuptable.put(lb, new Hashtable<TempDescriptor, TempDescriptor>());
405 paramstable.put(md, objectparams);
407 paramstable.put(task, objectparams);
409 for(int i=0; i<fm.numParameters(); i++) {
410 TempDescriptor temp=fm.getParameter(i);
411 TypeDescriptor type=temp.getType();
412 if (type.isPtr()&&((GENERATEPRECISEGC) || (this.state.MULTICOREGC)))
413 objectparams.addPtr(temp);
415 objectparams.addPrim(temp);
416 if(lb!=null&&saveset.contains(temp)) {
417 backuptable.get(lb).put(temp, temp.createNew());
421 for(int i=0; i<fm.numTags(); i++) {
422 TempDescriptor temp=fm.getTag(i);
423 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC))
424 objectparams.addPtr(temp);
426 objectparams.addPrim(temp);
429 TempObject objecttemps=md!=null?new TempObject(objectparams,md,tag++):new TempObject(objectparams, task, tag++);
431 tempstable.put(lb, objecttemps);
433 tempstable.put(md, objecttemps);
435 tempstable.put(task, objecttemps);
437 for(Iterator nodeit=fm.getNodeSet().iterator(); nodeit.hasNext(); ) {
438 FlatNode fn=(FlatNode)nodeit.next();
439 TempDescriptor[] writes=fn.writesTemps();
440 for(int i=0; i<writes.length; i++) {
441 TempDescriptor temp=writes[i];
442 TypeDescriptor type=temp.getType();
443 if (type.isPtr()&&((GENERATEPRECISEGC) || (this.state.MULTICOREGC)))
444 objecttemps.addPtr(temp);
446 objecttemps.addPrim(temp);
447 if(lb!=null&&saveset.contains(temp)&&
448 !backuptable.get(lb).containsKey(temp))
449 backuptable.get(lb).put(temp, temp.createNew());
453 /* Create backup temps */
455 for(Iterator<TempDescriptor> tmpit=backuptable.get(lb).values().iterator(); tmpit.hasNext(); ) {
456 TempDescriptor tmp=tmpit.next();
457 TypeDescriptor type=tmp.getType();
458 if (type.isPtr()&&((GENERATEPRECISEGC) || (this.state.MULTICOREGC)))
459 objecttemps.addPtr(tmp);
461 objecttemps.addPrim(tmp);
463 /* Create temp to hold revert table */
464 if (state.DSM&&(lb.getHasAtomic()||lb.isAtomic())) {
465 TempDescriptor reverttmp=new TempDescriptor("revertlist", typeutil.getClass(TypeUtil.ObjectClass));
466 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC))
467 objecttemps.addPtr(reverttmp);
469 objecttemps.addPrim(reverttmp);
470 reverttable.put(lb, reverttmp);
475 /** This method outputs the following information about classes
477 * (1) For classes, what are the locations of pointers.
478 * (2) For arrays, does the array contain pointers or primitives.
479 * (3) For classes, does the class contain flags.
482 protected void generateLayoutStructs(PrintWriter output) {
483 Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
484 while(it.hasNext()) {
485 ClassDescriptor cn=(ClassDescriptor)it.next();
486 output.println("unsigned INTPTR "+cn.getSafeSymbol()+"_pointers[]={");
487 Iterator allit=cn.getFieldTable().getAllDescriptorsIterator();
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
498 allit=cn.getFieldTable().getAllDescriptorsIterator();
499 while(allit.hasNext()) {
500 FieldDescriptor fd=(FieldDescriptor)allit.next();
501 TypeDescriptor type=fd.getType();
502 if (state.DSM&&fd.isGlobal()) //Don't GC the global objects for now
506 output.print("((unsigned INTPTR)&(((struct "+cn.getSafeSymbol() +" *)0)->"+
507 fd.getSafeSymbol()+"))");
510 output.println("};");
512 output.println("unsigned INTPTR * pointerarray[]={");
513 boolean needcomma=false;
514 for(int i=0; i<state.numClasses(); i++) {
515 ClassDescriptor cn=cdarray[i];
520 output.print(cn.getSafeSymbol()+"_pointers");
522 output.print("NULL");
526 for(int i=0; i<state.numArrays(); i++) {
528 output.println(", ");
529 TypeDescriptor tdelement=arraytable[i].dereference();
530 if (tdelement.isArray()||tdelement.isClass())
531 output.print("((unsigned INTPTR *)1)");
537 output.println("};");
539 output.println("int hasflags[]={");
540 for(int i=0; i<state.numClasses(); i++) {
541 ClassDescriptor cn=cdarray[i];
543 output.println(", ");
545 if ((cn != null) && (cn.hasFlags()))
550 output.println("};");
554 protected void generateCallStructsMethods(ClassDescriptor cn, PrintWriter output, PrintWriter headersout) {
555 /* Cycle through LocalityBindings */
556 HashSet<MethodDescriptor> nativemethods=new HashSet<MethodDescriptor>();
557 Set<LocalityBinding> lbset=locality.getClassBindings(cn);
559 for(Iterator<LocalityBinding> lbit=lbset.iterator(); lbit.hasNext(); ) {
560 LocalityBinding lb=lbit.next();
561 MethodDescriptor md=lb.getMethod();
562 if (md.getModifiers().isNative()) {
563 //make sure we only print a native method once
564 if (nativemethods.contains(md)) {
565 FlatMethod fm=state.getMethodFlat(md);
566 generateTempStructs(fm, lb);
569 nativemethods.add(md);
571 generateMethod(cn, md, lb, headersout, output);
574 for(Iterator methodit=cn.getMethods(); methodit.hasNext(); ) {
575 MethodDescriptor md=(MethodDescriptor)methodit.next();
576 if (md.getModifiers().isNative()&&!nativemethods.contains(md)) {
577 //Need to build param structure for library code
578 FlatMethod fm=state.getMethodFlat(md);
579 generateTempStructs(fm, null);
580 generateMethodParam(cn, md, null, output);
586 protected void generateMethodParam(ClassDescriptor cn, MethodDescriptor md, LocalityBinding lb, PrintWriter output) {
587 /* Output parameter structure */
588 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
589 ParamsObject objectparams=(ParamsObject) paramstable.get(lb!=null?lb:md);
590 if ((state.DSM||state.SINGLETM)&&lb!=null)
591 output.println("struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params {");
593 output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params {");
594 output.println(" int size;");
595 output.println(" void * next;");
596 for(int i=0; i<objectparams.numPointers(); i++) {
597 TempDescriptor temp=objectparams.getPointer(i);
598 if(state.MGC && temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
599 output.println(" int " + temp.getSafeSymbol() + ";");
601 output.println(" struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
604 output.println("};\n");
608 protected void generateMethod(ClassDescriptor cn, MethodDescriptor md, LocalityBinding lb, PrintWriter headersout, PrintWriter output) {
609 FlatMethod fm=state.getMethodFlat(md);
610 generateTempStructs(fm, lb);
612 ParamsObject objectparams=(ParamsObject) paramstable.get(lb);
613 TempObject objecttemps=(TempObject) tempstable.get(lb);
615 generateMethodParam(cn, md, lb, output);
617 /* Output temp structure */
618 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
619 output.println("struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals {");
620 output.println(" int size;");
621 output.println(" void * next;");
622 for(int i=0; i<objecttemps.numPointers(); i++) {
623 TempDescriptor temp=objecttemps.getPointer(i);
624 if (temp.getType().isNull())
625 output.println(" void * "+temp.getSafeSymbol()+";");
627 output.println(" struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
629 output.println("};\n");
632 /********* Output method declaration ***********/
633 headersout.println("#define D"+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+" 1");
635 /* First the return type */
636 if (md.getReturnType()!=null) {
637 if(state.MGC && md.getReturnType().isClass() && md.getReturnType().getClassDesc().isEnum()) {
638 headersout.println(" int ");
639 } else if (md.getReturnType().isClass()||md.getReturnType().isArray())
640 headersout.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
642 headersout.print(md.getReturnType().getSafeSymbol()+" ");
644 //catch the constructor case
645 headersout.print("void ");
647 /* Next the method name */
648 headersout.print(cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(");
650 boolean printcomma=false;
651 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
652 headersout.print("struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
656 /* Output parameter list*/
657 for(int i=0; i<objectparams.numPrimitives(); i++) {
658 TempDescriptor temp=objectparams.getPrimitive(i);
660 headersout.print(", ");
662 if(state.MGC && temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
663 headersout.print("int " + temp.getSafeSymbol());
664 } else if (temp.getType().isClass()||temp.getType().isArray())
665 headersout.print("struct " + temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol());
667 headersout.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
669 headersout.println(");\n");
672 /***** Generate code for FlatMethod fm. *****/
674 Hashtable<FlatAtomicEnterNode, AtomicRecord> atomicmethodmap;
675 static int atomicmethodcount=0;
678 BranchAnalysis branchanalysis;
679 protected void generateFlatMethod(FlatMethod fm, LocalityBinding lb, PrintWriter output) {
681 System.out.println(fm.printMethod());
682 MethodDescriptor md=fm.getMethod();
683 TaskDescriptor task=fm.getTask();
684 ClassDescriptor cn=md!=null?md.getClassDesc():null;
685 ParamsObject objectparams=(ParamsObject)paramstable.get(lb!=null?lb:md!=null?md:task);
687 HashSet<AtomicRecord> arset=null;
690 if (state.DELAYCOMP&&!lb.isAtomic()&&lb.getHasAtomic()) {
692 if (atomicmethodmap==null)
693 atomicmethodmap=new Hashtable<FlatAtomicEnterNode, AtomicRecord>();
695 //fix these so we get right strings for local variables
696 localsprefixaddr=localsprefix;
697 localsprefixderef=localsprefix+"->";
698 arset=new HashSet<AtomicRecord>();
700 //build branchanalysis
701 branchanalysis=new BranchAnalysis(locality, lb, delaycomp.getNotReady(lb), delaycomp.livecode(lb), state);
703 //Generate commit methods here
704 for(Iterator<FlatNode> fnit=fm.getNodeSet().iterator(); fnit.hasNext(); ) {
705 FlatNode fn=fnit.next();
706 if (fn.kind()==FKind.FlatAtomicEnterNode&&
707 locality.getAtomic(lb).get(fn.getPrev(0)).intValue()==0&&
708 delaycomp.needsFission(lb, (FlatAtomicEnterNode) fn)) {
709 //We have an atomic enter
710 FlatAtomicEnterNode faen=(FlatAtomicEnterNode) fn;
711 Set<FlatNode> exitset=faen.getExits();
713 String methodname=md.getSymbol()+(atomicmethodcount++);
714 AtomicRecord ar=new AtomicRecord();
718 atomicmethodmap.put(faen, ar);
720 //build data structure declaration
721 output.println("struct atomicprimitives_"+methodname+" {");
723 Set<FlatNode> recordset=delaycomp.livecode(lb);
724 Set<TempDescriptor> liveinto=delaycomp.liveinto(lb, faen, recordset);
725 Set<TempDescriptor> liveout=delaycomp.liveout(lb, faen);
726 Set<TempDescriptor> liveoutvirtualread=delaycomp.liveoutvirtualread(lb, faen);
728 ar.reallivein=new HashSet(liveinto);
730 ar.liveoutvirtualread=liveoutvirtualread;
733 for(Iterator<TempDescriptor> it=liveinto.iterator(); it.hasNext(); ) {
734 TempDescriptor tmp=it.next();
735 //remove the pointers
736 if (tmp.getType().isPtr()) {
739 //let's print it here
740 output.println(tmp.getType().getSafeSymbol()+" "+tmp.getSafeSymbol()+";");
743 for(Iterator<TempDescriptor> it=liveout.iterator(); it.hasNext(); ) {
744 TempDescriptor tmp=it.next();
745 //remove the pointers
746 if (tmp.getType().isPtr()) {
748 } else if (!liveinto.contains(tmp)) {
749 //let's print it here
750 output.println(tmp.getType().getSafeSymbol()+" "+tmp.getSafeSymbol()+";");
753 output.println("};");
755 //print out method name
756 output.println("void "+methodname+"(struct "+ cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix+", struct "+ cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals *"+localsprefix+", struct atomicprimitives_"+methodname+" * primitives) {");
757 //build code for commit method
759 //first define local primitives
760 Set<TempDescriptor> alltemps=delaycomp.alltemps(lb, faen, recordset);
761 for(Iterator<TempDescriptor> tmpit=alltemps.iterator(); tmpit.hasNext(); ) {
762 TempDescriptor tmp=tmpit.next();
763 if (!tmp.getType().isPtr()) {
764 if (liveinto.contains(tmp)||liveoutvirtualread.contains(tmp)) {
765 //read from live into set
766 output.println(tmp.getType().getSafeSymbol()+" "+tmp.getSafeSymbol()+"=primitives->"+tmp.getSafeSymbol()+";");
769 output.println(tmp.getType().getSafeSymbol()+" "+tmp.getSafeSymbol()+";");
773 //turn off write barrier generation
775 state.SINGLETM=false;
776 generateCode(faen, fm, lb, exitset, output, false);
778 //turn on write barrier generation
780 output.println("}\n\n");
784 //redefine these back to normal
786 localsprefixaddr="&"+localsprefix;
787 localsprefixderef=localsprefix+".";
789 generateHeader(fm, lb, md!=null?md:task,output);
790 TempObject objecttemp=(TempObject) tempstable.get(lb!=null?lb:md!=null?md:task);
792 if (state.DELAYCOMP&&!lb.isAtomic()&&lb.getHasAtomic()) {
793 for(Iterator<AtomicRecord> arit=arset.iterator(); arit.hasNext(); ) {
794 AtomicRecord ar=arit.next();
795 output.println("struct atomicprimitives_"+ar.name+" primitives_"+ar.name+";");
799 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
800 if (md!=null&&(state.DSM||state.SINGLETM))
801 output.print(" struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals "+localsprefix+"={");
802 else if (md!=null&&!(state.DSM||state.SINGLETM))
803 output.print(" struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals "+localsprefix+"={");
805 output.print(" struct "+task.getSafeSymbol()+"_locals "+localsprefix+"={");
806 output.print(objecttemp.numPointers()+",");
807 output.print(paramsprefix);
808 for(int j=0; j<objecttemp.numPointers(); j++)
809 output.print(", NULL");
810 output.println("};");
813 for(int i=0; i<objecttemp.numPrimitives(); i++) {
814 TempDescriptor td=objecttemp.getPrimitive(i);
815 TypeDescriptor type=td.getType();
816 if (type.isNull() && !type.isArray())
817 output.println(" void * "+td.getSafeSymbol()+";");
818 else if (state.MGC && type.isClass() && type.getClassDesc().isEnum()) {
819 output.println(" int " + td.getSafeSymbol() + ";");
820 } else if (type.isClass()||type.isArray())
821 output.println(" struct "+type.getSafeSymbol()+" * "+td.getSafeSymbol()+";");
823 output.println(" "+type.getSafeSymbol()+" "+td.getSafeSymbol()+";");
828 additionalCodeAtTopFlatMethodBody(output, fm);
832 /* Check to see if we need to do a GC if this is a
833 * multi-threaded program...*/
835 if (((state.THREAD||state.DSM||state.SINGLETM)&&GENERATEPRECISEGC)) {
836 //Don't bother if we aren't in recursive methods...The loops case will catch it
837 if (callgraph.getAllMethods(md).contains(md)) {
838 if (state.DSM&&lb.isAtomic())
839 output.println("if (needtocollect) checkcollect2("+localsprefixaddr+");");
841 output.println("if (unlikely(needtocollect)) checkcollect("+localsprefixaddr+");");
845 generateCode(fm.getNext(0), fm, lb, null, output, true);
846 output.println("}\n\n");
851 protected void generateCode(FlatNode first,
854 Set<FlatNode> stopset,
858 /* Assign labels to FlatNode's if necessary.*/
860 Hashtable<FlatNode, Integer> nodetolabel;
862 if (state.DELAYCOMP&&!firstpass)
863 nodetolabel=dcassignLabels(first, stopset);
865 nodetolabel=assignLabels(first, stopset);
867 Set<FlatNode> storeset=null;
868 HashSet<FlatNode> genset=null;
869 HashSet<FlatNode> refset=null;
870 Set<FlatNode> unionset=null;
872 if (state.DELAYCOMP&&!lb.isAtomic()&&lb.getHasAtomic()) {
873 storeset=delaycomp.livecode(lb);
874 genset=new HashSet<FlatNode>();
875 if (state.STMARRAY&&!state.DUALVIEW) {
876 refset=new HashSet<FlatNode>();
877 refset.addAll(delaycomp.getDeref(lb));
878 refset.removeAll(delaycomp.getCannotDelay(lb));
879 refset.removeAll(delaycomp.getOther(lb));
882 genset.addAll(delaycomp.getCannotDelay(lb));
883 genset.addAll(delaycomp.getOther(lb));
885 genset.addAll(delaycomp.getNotReady(lb));
886 if (state.STMARRAY&&!state.DUALVIEW) {
887 genset.removeAll(refset);
890 unionset=new HashSet<FlatNode>();
891 unionset.addAll(storeset);
892 unionset.addAll(genset);
893 if (state.STMARRAY&&!state.DUALVIEW)
894 unionset.addAll(refset);
897 /* Do the actual code generation */
898 FlatNode current_node=null;
899 HashSet tovisit=new HashSet();
900 HashSet visited=new HashSet();
902 tovisit.add(first.getNext(0));
905 while(current_node!=null||!tovisit.isEmpty()) {
906 if (current_node==null) {
907 current_node=(FlatNode)tovisit.iterator().next();
908 tovisit.remove(current_node);
909 } else if (tovisit.contains(current_node)) {
910 tovisit.remove(current_node);
912 visited.add(current_node);
913 if (nodetolabel.containsKey(current_node)) {
914 output.println("L"+nodetolabel.get(current_node)+":");
916 if (state.INSTRUCTIONFAILURE) {
917 if (state.THREAD||state.DSM||state.SINGLETM) {
918 output.println("if ((++instructioncount)>failurecount) {instructioncount=0;injectinstructionfailure();}");
920 output.println("if ((--instructioncount)==0) injectinstructionfailure();");
922 if (current_node.numNext()==0||stopset!=null&&stopset.contains(current_node)) {
924 if (!state.DELAYCOMP||firstpass) {
925 generateFlatNode(fm, current_node, output);
927 //store primitive variables in out set
928 AtomicRecord ar=atomicmethodmap.get((FlatAtomicEnterNode)first);
929 Set<TempDescriptor> liveout=ar.liveout;
930 for(Iterator<TempDescriptor> tmpit=liveout.iterator(); tmpit.hasNext(); ) {
931 TempDescriptor tmp=tmpit.next();
932 output.println("primitives->"+tmp.getSafeSymbol()+"="+tmp.getSafeSymbol()+";");
936 if (current_node.kind()!=FKind.FlatReturnNode) {
938 // TODO add version for normal Java later
939 if((fm.getMethod() != null) && (fm.getMethod().isStaticBlock())) {
940 // a static block, check if it has been executed
941 output.println(" global_defsprim_p->" + fm.getMethod().getClassDesc().getSafeSymbol()+"static_block_exe_flag = 1;");
945 output.println(" return;");
948 } else if(current_node.numNext()==1) {
950 if (state.DELAYCOMP) {
951 boolean specialprimitive=false;
952 //skip literals...no need to add extra overhead
953 if (storeset!=null&&storeset.contains(current_node)&¤t_node.kind()==FKind.FlatLiteralNode) {
954 TypeDescriptor typedesc=((FlatLiteralNode)current_node).getType();
955 if (!typedesc.isClass()&&!typedesc.isArray()) {
956 specialprimitive=true;
960 if (genset==null||genset.contains(current_node)||specialprimitive) {
961 generateFlatNode(fm, current_node, output);
963 if (state.STMARRAY&&!state.DUALVIEW&&refset!=null&&refset.contains(current_node)) {
964 //need to acquire lock
965 handleArrayDeref(fm, lb, current_node, output, firstpass);
967 if (storeset!=null&&storeset.contains(current_node)&&!specialprimitive) {
968 TempDescriptor wrtmp=current_node.writesTemps()[0];
970 //need to store value written by previous node
971 if (wrtmp.getType().isPtr()) {
972 //only lock the objects that may actually need locking
973 if (recorddc.getNeedTrans(lb, current_node)&&
974 (!state.STMARRAY||state.DUALVIEW||!wrtmp.getType().isArray()||
975 wrtmp.getType().getSymbol().equals(TypeUtil.ObjectClass))) {
976 output.println("STOREPTR("+generateTemp(fm, wrtmp)+");/* "+current_node.nodeid+" */");
978 output.println("STOREPTRNOLOCK("+generateTemp(fm, wrtmp)+");/* "+current_node.nodeid+" */");
981 output.println("STORE"+wrtmp.getType().getSafeDescriptor()+"("+generateTemp(fm, wrtmp)+");/* "+current_node.nodeid+" */");
984 //need to read value read by previous node
985 if (wrtmp.getType().isPtr()) {
986 output.println("RESTOREPTR("+generateTemp(fm, wrtmp)+");/* "+current_node.nodeid+" */");
988 output.println("RESTORE"+wrtmp.getType().getSafeDescriptor()+"("+generateTemp(fm, wrtmp)+"); /* "+current_node.nodeid+" */");
992 nextnode=current_node.getNext(0);
995 generateFlatNode(fm, current_node, output);
996 nextnode=current_node.getNext(0);
998 if (visited.contains(nextnode)) {
999 output.println("goto L"+nodetolabel.get(nextnode)+";");
1002 current_node=nextnode;
1003 } else if (current_node.numNext()==2) {
1005 if (state.DELAYCOMP) {
1006 boolean computeside=false;
1008 //need to record which way it should go
1009 if (genset==null||genset.contains(current_node)) {
1010 if (storeset!=null&&storeset.contains(current_node)) {
1011 //need to store which way branch goes
1012 generateStoreFlatCondBranch(fm, lb, (FlatCondBranch)current_node, "L"+nodetolabel.get(current_node.getNext(1)), output);
1014 generateFlatCondBranch(fm, (FlatCondBranch)current_node, "L"+nodetolabel.get(current_node.getNext(1)), output);
1016 //which side to execute
1020 if (genset.contains(current_node)) {
1021 generateFlatCondBranch(fm, (FlatCondBranch)current_node, "L"+nodetolabel.get(current_node.getNext(1)), output);
1022 } else if (storeset.contains(current_node)) {
1024 branchanalysis.generateGroupCode(current_node, output, nodetolabel);
1026 //which side to execute
1031 Set<FlatNode> leftset=DelayComputation.getNext(current_node, 0, unionset, lb,locality, true);
1033 if (leftset.size()==0)
1035 if (visited.contains(current_node.getNext(branch))) {
1036 //already visited -- build jump
1037 output.println("goto L"+nodetolabel.get(current_node.getNext(branch))+";");
1040 current_node=current_node.getNext(branch);
1043 if (!visited.contains(current_node.getNext(1)))
1044 tovisit.add(current_node.getNext(1));
1045 if (visited.contains(current_node.getNext(0))) {
1046 output.println("goto L"+nodetolabel.get(current_node.getNext(0))+";");
1049 current_node=current_node.getNext(0);
1053 generateFlatCondBranch(fm, (FlatCondBranch)current_node, "L"+nodetolabel.get(current_node.getNext(1)), output);
1054 if (!visited.contains(current_node.getNext(1)))
1055 tovisit.add(current_node.getNext(1));
1056 if (visited.contains(current_node.getNext(0))) {
1057 output.println("goto L"+nodetolabel.get(current_node.getNext(0))+";");
1060 current_node=current_node.getNext(0);
1062 } else throw new Error();
1066 protected void handleArrayDeref(FlatMethod fm, LocalityBinding lb, FlatNode fn, PrintWriter output, boolean firstpass) {
1067 if (fn.kind()==FKind.FlatSetElementNode) {
1068 FlatSetElementNode fsen=(FlatSetElementNode) fn;
1069 String dst=generateTemp(fm, fsen.getDst());
1070 String src=generateTemp(fm, fsen.getSrc());
1071 String index=generateTemp(fm, fsen.getIndex());
1072 TypeDescriptor elementtype=fsen.getDst().getType().dereference();
1074 if (elementtype.isArray()||elementtype.isClass())
1077 type=elementtype.getSafeSymbol()+" ";
1079 output.println("STOREARRAY("+dst+","+index+","+type+")");
1081 output.println("{");
1082 output.println(" struct ArrayObject *array;");
1083 output.println(" int index;");
1084 output.println(" RESTOREARRAY(array,index);");
1085 output.println(" (("+type+"*)(((char *)&array->___length___)+sizeof(int)))[index]="+src+";");
1086 output.println("}");
1088 } else if (fn.kind()==FKind.FlatElementNode) {
1089 FlatElementNode fen=(FlatElementNode) fn;
1090 String src=generateTemp(fm, fen.getSrc());
1091 String index=generateTemp(fm, fen.getIndex());
1092 TypeDescriptor elementtype=fen.getSrc().getType().dereference();
1093 String dst=generateTemp(fm, fen.getDst());
1095 if (elementtype.isArray()||elementtype.isClass())
1098 type=elementtype.getSafeSymbol()+" ";
1100 output.println("STOREARRAY("+src+","+index+","+type+")");
1102 output.println("{");
1103 output.println(" struct ArrayObject *array;");
1104 output.println(" int index;");
1105 output.println(" RESTOREARRAY(array,index);");
1106 output.println(" "+dst+"=(("+type+"*)(((char *)&array->___length___)+sizeof(int)))[index];");
1107 output.println("}");
1111 /** Special label assignment for delaycomputation */
1112 protected Hashtable<FlatNode, Integer> dcassignLabels(FlatNode first, Set<FlatNode> lastset) {
1113 HashSet tovisit=new HashSet();
1114 HashSet visited=new HashSet();
1116 Hashtable<FlatNode, Integer> nodetolabel=new Hashtable<FlatNode, Integer>();
1118 //Label targets of branches
1119 Set<FlatNode> targets=branchanalysis.getTargets();
1120 for(Iterator<FlatNode> it=targets.iterator(); it.hasNext(); ) {
1121 nodetolabel.put(it.next(), new Integer(labelindex++));
1126 /*Assign labels first. A node needs a label if the previous
1127 * node has two exits or this node is a join point. */
1129 while(!tovisit.isEmpty()) {
1130 FlatNode fn=(FlatNode)tovisit.iterator().next();
1135 if(lastset!=null&&lastset.contains(fn)) {
1136 // if last is not null and matches, don't go
1137 // any further for assigning labels
1141 for(int i=0; i<fn.numNext(); i++) {
1142 FlatNode nn=fn.getNext(i);
1145 //1) Edge >1 of node
1146 nodetolabel.put(nn,new Integer(labelindex++));
1148 if (!visited.contains(nn)&&!tovisit.contains(nn)) {
1152 nodetolabel.put(nn,new Integer(labelindex++));
1160 /** Generate text string that corresponds to the TempDescriptor td. */
1161 protected String generateTemp(FlatMethod fm, TempDescriptor td) {
1162 MethodDescriptor md=fm.getMethod();
1163 TaskDescriptor task=fm.getTask();
1164 TempObject objecttemps=(TempObject) tempstable.get(currlb!=null?currlb:md!=null?md:task);
1166 if (objecttemps.isLocalPrim(td)||objecttemps.isParamPrim(td)) {
1167 return td.getSafeSymbol();
1170 if (objecttemps.isLocalPtr(td)) {
1171 return localsprefixderef+td.getSafeSymbol();
1174 if (objecttemps.isParamPtr(td)) {
1175 return paramsprefix+"->"+td.getSafeSymbol();
1181 public void generateFlatBackEdge(FlatMethod fm, FlatBackEdge fn, PrintWriter output) {
1182 if (state.SINGLETM&&state.SANDBOX&&(locality.getAtomic(currlb).get(fn).intValue()>0)) {
1183 output.println("if (unlikely((--transaction_check_counter)<=0)) checkObjects();");
1185 if(state.DSM&&state.SANDBOX&&(locality.getAtomic(currlb).get(fn).intValue()>0)) {
1186 output.println("if (unlikely((--transaction_check_counter)<=0)) checkObjects();");
1188 if (((state.THREAD||state.DSM||state.SINGLETM)&&GENERATEPRECISEGC)) {
1189 if(state.DSM&&locality.getAtomic(currlb).get(fn).intValue()>0) {
1190 output.println("if (needtocollect) checkcollect2("+localsprefixaddr+");");
1192 output.println("if (unlikely(needtocollect)) checkcollect("+localsprefixaddr+");");
1195 output.println("/* nop */");
1199 public void generateFlatPrefetchNode(FlatMethod fm, FlatPrefetchNode fpn, PrintWriter output) {
1200 if (state.PREFETCH) {
1201 Vector oids = new Vector();
1202 Vector fieldoffset = new Vector();
1203 Vector endoffset = new Vector();
1204 int tuplecount = 0; //Keeps track of number of prefetch tuples that need to be generated
1205 for(Iterator it = fpn.hspp.iterator(); it.hasNext(); ) {
1206 PrefetchPair pp = (PrefetchPair) it.next();
1207 Integer statusbase = locality.getNodePreTempInfo(currlb,fpn).get(pp.base);
1208 /* Find prefetches that can generate oid */
1209 if(statusbase == LocalityAnalysis.GLOBAL) {
1210 generateTransCode(fm, currlb, pp, oids, fieldoffset, endoffset, tuplecount, locality.getAtomic(currlb).get(fpn).intValue()>0, false);
1212 } else if (statusbase == LocalityAnalysis.LOCAL) {
1213 generateTransCode(fm,currlb,pp,oids,fieldoffset,endoffset,tuplecount,false,true);
1220 System.out.println("Adding prefetch "+fpn+ " to method:" +fm);
1221 output.println("{");
1222 output.println("/* prefetch */");
1223 output.println("/* prefetchid_" + fpn.siteid + " */");
1224 output.println("void * prefptr;");
1225 output.println("int tmpindex;");
1227 output.println("if((evalPrefetch["+fpn.siteid+"].operMode) || (evalPrefetch["+fpn.siteid+"].retrycount <= 0)) {");
1228 /*Create C code for oid array */
1229 output.print(" unsigned int oidarray_[] = {");
1230 boolean needcomma=false;
1231 for (Iterator it = oids.iterator(); it.hasNext(); ) {
1234 output.print(it.next());
1237 output.println("};");
1239 /*Create C code for endoffset values */
1240 output.print(" unsigned short endoffsetarry_[] = {");
1242 for (Iterator it = endoffset.iterator(); it.hasNext(); ) {
1245 output.print(it.next());
1248 output.println("};");
1250 /*Create C code for Field Offset Values */
1251 output.print(" short fieldarry_[] = {");
1253 for (Iterator it = fieldoffset.iterator(); it.hasNext(); ) {
1256 output.print(it.next());
1259 output.println("};");
1260 /* make the prefetch call to Runtime */
1261 output.println(" if(!evalPrefetch["+fpn.siteid+"].operMode) {");
1262 output.println(" evalPrefetch["+fpn.siteid+"].retrycount = RETRYINTERVAL;");
1263 output.println(" }");
1264 output.println(" prefetch("+fpn.siteid+" ,"+tuplecount+", oidarray_, endoffsetarry_, fieldarry_);");
1265 output.println(" } else {");
1266 output.println(" evalPrefetch["+fpn.siteid+"].retrycount--;");
1267 output.println(" }");
1268 output.println("}");
1272 public void generateTransCode(FlatMethod fm, LocalityBinding lb,PrefetchPair pp, Vector oids, Vector fieldoffset, Vector endoffset, int tuplecount, boolean inside, boolean localbase) {
1273 short offsetcount = 0;
1277 } else if (localbase) {
1278 for(; breakindex<pp.desc.size(); breakindex++) {
1279 Descriptor desc=pp.getDescAt(breakindex);
1280 if (desc instanceof FieldDescriptor) {
1281 FieldDescriptor fd=(FieldDescriptor)desc;
1282 if (fd.isGlobal()) {
1290 if (breakindex>pp.desc.size()) //all local
1293 TypeDescriptor lasttype=pp.base.getType();
1294 String basestr=generateTemp(fm, pp.base);
1296 boolean maybenull=fm.getMethod().isStatic()||
1297 !pp.base.equals(fm.getParameter(0));
1299 for(int i=0; i<breakindex; i++) {
1300 String indexcheck="";
1302 Descriptor desc=pp.getDescAt(i);
1303 if (desc instanceof FieldDescriptor) {
1304 FieldDescriptor fd=(FieldDescriptor)desc;
1306 if (!teststr.equals(""))
1308 teststr+="((prefptr="+basestr+")!=NULL)";
1309 basestr="((struct "+lasttype.getSafeSymbol()+" *)prefptr)->"+
1312 basestr=basestr+"->"+
1316 lasttype=fd.getType();
1318 IndexDescriptor id=(IndexDescriptor)desc;
1319 indexcheck="((tmpindex=";
1320 for(int j=0; j<id.tddesc.size(); j++) {
1321 indexcheck+=generateTemp(fm, id.getTempDescAt(j))+"+";
1323 indexcheck+=id.offset+")>=0)&(tmpindex<((struct ArrayObject *)prefptr)->___length___)";
1325 if (!teststr.equals(""))
1327 teststr+="((prefptr="+basestr+")!= NULL) &&"+indexcheck;
1328 basestr="((void **)(((char *) &(((struct ArrayObject *)prefptr)->___length___))+sizeof(int)))[tmpindex]";
1330 lasttype=lasttype.dereference();
1335 if (teststr.equals("")) {
1336 oid="((unsigned int)"+basestr+")";
1338 oid="((unsigned int)(("+teststr+")?"+basestr+":NULL))";
1342 for(int i = breakindex; i < pp.desc.size(); i++) {
1343 String newfieldoffset;
1344 Object desc = pp.getDescAt(i);
1345 if(desc instanceof FieldDescriptor) {
1346 FieldDescriptor fd=(FieldDescriptor)desc;
1347 newfieldoffset = new String("(unsigned int)(&(((struct "+ lasttype.getSafeSymbol()+" *)0)->"+ fd.getSafeSymbol()+ "))");
1348 lasttype=fd.getType();
1350 newfieldoffset = "";
1351 IndexDescriptor id=(IndexDescriptor)desc;
1352 for(int j = 0; j < id.tddesc.size(); j++) {
1353 newfieldoffset += generateTemp(fm, id.getTempDescAt(j)) + "+";
1355 newfieldoffset += id.offset.toString();
1356 lasttype=lasttype.dereference();
1358 fieldoffset.add(newfieldoffset);
1361 int base=(tuplecount>0)?((Short)endoffset.get(tuplecount-1)).intValue():0;
1362 base+=pp.desc.size()-breakindex;
1363 endoffset.add(new Short((short)base));
1368 public void generateFlatGlobalConvNode(FlatMethod fm, FlatGlobalConvNode fgcn, PrintWriter output) {
1369 if (currlb!=fgcn.getLocality())
1371 /* Have to generate flat globalconv */
1372 if (fgcn.getMakePtr()) {
1374 output.println("TRANSREAD("+generateTemp(fm, fgcn.getSrc())+", (unsigned int) "+generateTemp(fm, fgcn.getSrc())+");");
1376 if ((dc==null)||!state.READSET&&dc.getNeedTrans(currlb, fgcn)||state.READSET&&dc.getNeedWriteTrans(currlb, fgcn)) {
1377 //need to do translation
1378 output.println("TRANSREAD("+generateTemp(fm, fgcn.getSrc())+", "+generateTemp(fm, fgcn.getSrc())+", (void *)("+localsprefixaddr+"));");
1379 } else if (state.READSET&&dc.getNeedTrans(currlb, fgcn)) {
1380 if (state.HYBRID&&delaycomp.getConv(currlb).contains(fgcn)) {
1381 output.println("TRANSREADRDFISSION("+generateTemp(fm, fgcn.getSrc())+", "+generateTemp(fm, fgcn.getSrc())+");");
1383 output.println("TRANSREADRD("+generateTemp(fm, fgcn.getSrc())+", "+generateTemp(fm, fgcn.getSrc())+");");
1387 /* Need to convert to OID */
1388 if ((dc==null)||dc.getNeedSrcTrans(currlb,fgcn)) {
1389 if (fgcn.doConvert()||(delaycomp!=null&&delaycomp.needsFission(currlb, fgcn.getAtomicEnter())&&atomicmethodmap.get(fgcn.getAtomicEnter()).reallivein.contains(fgcn.getSrc()))) {
1390 output.println(generateTemp(fm, fgcn.getSrc())+"=(void *)COMPOID("+generateTemp(fm, fgcn.getSrc())+");");
1392 output.println(generateTemp(fm, fgcn.getSrc())+"=NULL;");
1398 int sandboxcounter=0;
1399 public void generateFlatAtomicEnterNode(FlatMethod fm, FlatAtomicEnterNode faen, PrintWriter output) {
1400 /* Check to see if we need to generate code for this atomic */
1401 if (locality==null) {
1402 if (GENERATEPRECISEGC) {
1403 output.println("if (pthread_mutex_trylock(&atomiclock)!=0) {");
1404 output.println("stopforgc((struct garbagelist *) &___locals___);");
1405 output.println("pthread_mutex_lock(&atomiclock);");
1406 output.println("restartaftergc();");
1407 output.println("}");
1409 output.println("pthread_mutex_lock(&atomiclock);");
1414 if (locality.getAtomic(currlb).get(faen.getPrev(0)).intValue()>0)
1418 if (state.SANDBOX) {
1419 outsandbox.println("int atomiccounter"+sandboxcounter+"=LOW_CHECK_FREQUENCY;");
1420 output.println("counter_reset_pointer=&atomiccounter"+sandboxcounter+";");
1423 if (state.DELAYCOMP&&delaycomp.needsFission(currlb, faen)) {
1424 AtomicRecord ar=atomicmethodmap.get(faen);
1426 for(Iterator<TempDescriptor> tmpit=ar.livein.iterator(); tmpit.hasNext(); ) {
1427 TempDescriptor tmp=tmpit.next();
1428 output.println("primitives_"+ar.name+"."+tmp.getSafeSymbol()+"="+tmp.getSafeSymbol()+";");
1431 //copy outs that depend on path
1432 for(Iterator<TempDescriptor> tmpit=ar.liveoutvirtualread.iterator(); tmpit.hasNext(); ) {
1433 TempDescriptor tmp=tmpit.next();
1434 if (!ar.livein.contains(tmp))
1435 output.println("primitives_"+ar.name+"."+tmp.getSafeSymbol()+"="+tmp.getSafeSymbol()+";");
1439 /* Backup the temps. */
1440 for(Iterator<TempDescriptor> tmpit=locality.getTemps(currlb).get(faen).iterator(); tmpit.hasNext(); ) {
1441 TempDescriptor tmp=tmpit.next();
1442 output.println(generateTemp(fm, backuptable.get(currlb).get(tmp))+"="+generateTemp(fm,tmp)+";");
1445 output.println("goto transstart"+faen.getIdentifier()+";");
1447 /******* Print code to retry aborted transaction *******/
1448 output.println("transretry"+faen.getIdentifier()+":");
1451 for(Iterator<TempDescriptor> tmpit=locality.getTemps(currlb).get(faen).iterator(); tmpit.hasNext(); ) {
1452 TempDescriptor tmp=tmpit.next();
1453 output.println(generateTemp(fm, tmp)+"="+generateTemp(fm,backuptable.get(currlb).get(tmp))+";");
1457 /********* Need to revert local object store ********/
1458 String revertptr=generateTemp(fm, reverttable.get(currlb));
1460 output.println("while ("+revertptr+") {");
1461 output.println("struct ___Object___ * tmpptr;");
1462 output.println("tmpptr="+revertptr+"->"+nextobjstr+";");
1463 output.println("REVERT_OBJ("+revertptr+");");
1464 output.println(revertptr+"=tmpptr;");
1465 output.println("}");
1467 /******* Tell the runtime to start the transaction *******/
1469 output.println("transstart"+faen.getIdentifier()+":");
1470 if (state.SANDBOX) {
1471 output.println("transaction_check_counter=*counter_reset_pointer;");
1474 output.println("transStart();");
1476 if (state.ABORTREADERS||state.SANDBOX) {
1478 output.println("abortenabled=1;");
1479 output.println("if (_setjmp(aborttrans)) {");
1480 output.println(" goto transretry"+faen.getIdentifier()+"; }");
1484 public void generateFlatAtomicExitNode(FlatMethod fm, FlatAtomicExitNode faen, PrintWriter output) {
1485 /* Check to see if we need to generate code for this atomic */
1486 if (locality==null) {
1487 output.println("pthread_mutex_unlock(&atomiclock);");
1490 if (locality.getAtomic(currlb).get(faen).intValue()>0)
1492 //store the revert list before we lose the transaction object
1495 String revertptr=generateTemp(fm, reverttable.get(currlb));
1496 output.println(revertptr+"=revertlist;");
1497 output.println("if (transCommit()) {");
1498 output.println("if (unlikely(needtocollect)) checkcollect("+localsprefixaddr+");");
1499 output.println("goto transretry"+faen.getAtomicEnter().getIdentifier()+";");
1500 output.println("} else {");
1501 /* Need to commit local object store */
1502 output.println("while ("+revertptr+") {");
1503 output.println("struct ___Object___ * tmpptr;");
1504 output.println("tmpptr="+revertptr+"->"+nextobjstr+";");
1505 output.println("COMMIT_OBJ("+revertptr+");");
1506 output.println(revertptr+"=tmpptr;");
1507 output.println("}");
1508 output.println("}");
1512 if (!state.DELAYCOMP) {
1514 output.println("if (transCommit()) {");
1515 /* Transaction aborts if it returns true */
1516 output.println("if (unlikely(needtocollect)) checkcollect("+localsprefixaddr+");");
1517 output.println("goto transretry"+faen.getAtomicEnter().getIdentifier()+";");
1518 output.println("}");
1520 if (delaycomp.optimizeTrans(currlb, faen.getAtomicEnter())&&(!state.STMARRAY||state.DUALVIEW)) {
1521 AtomicRecord ar=atomicmethodmap.get(faen.getAtomicEnter());
1522 output.println("LIGHTWEIGHTCOMMIT("+ar.name+", &primitives_"+ar.name+", &"+localsprefix+", "+paramsprefix+", transretry"+faen.getAtomicEnter().getIdentifier()+");");
1524 for(Iterator<TempDescriptor> tmpit=ar.liveout.iterator(); tmpit.hasNext(); ) {
1525 TempDescriptor tmp=tmpit.next();
1526 output.println(tmp.getSafeSymbol()+"=primitives_"+ar.name+"."+tmp.getSafeSymbol()+";");
1528 } else if (delaycomp.needsFission(currlb, faen.getAtomicEnter())) {
1529 AtomicRecord ar=atomicmethodmap.get(faen.getAtomicEnter());
1531 output.println("if (transCommit((void (*)(void *, void *, void *))&"+ar.name+", &primitives_"+ar.name+", &"+localsprefix+", "+paramsprefix+")) {");
1532 output.println("if (unlikely(needtocollect)) checkcollect("+localsprefixaddr+");");
1533 output.println("goto transretry"+faen.getAtomicEnter().getIdentifier()+";");
1534 output.println("}");
1536 output.println("else {");
1537 for(Iterator<TempDescriptor> tmpit=ar.liveout.iterator(); tmpit.hasNext(); ) {
1538 TempDescriptor tmp=tmpit.next();
1539 output.println(tmp.getSafeSymbol()+"=primitives_"+ar.name+"."+tmp.getSafeSymbol()+";");
1541 output.println("}");
1543 output.println("if (transCommit(NULL, NULL, NULL, NULL)) {");
1544 output.println("if (unlikely(needtocollect)) checkcollect("+localsprefixaddr+");");
1545 output.println("goto transretry"+faen.getAtomicEnter().getIdentifier()+";");
1546 output.println("}");
1551 protected void generateFlatCall(FlatMethod fm, FlatCall fc, PrintWriter output) {
1552 MethodDescriptor md=fc.getMethod();
1553 ParamsObject objectparams=(ParamsObject)paramstable.get(currlb!=null?locality.getBinding(currlb, fc):md);
1554 ClassDescriptor cn=md.getClassDesc();
1556 // if the called method is a static block or a static method or a constructor
1557 // need to check if it can be invoked inside some static block
1559 // TODO add version for normal Java later
1560 if((md.isStatic() || md.isStaticBlock() || md.isConstructor()) &&
1561 ((fm.getMethod().isStaticBlock()) || (fm.getMethod().isInvokedByStatic()))) {
1562 if(!md.isInvokedByStatic()) {
1563 System.err.println("Error: a method that is invoked inside a static block is not tagged!");
1565 // is a static block or is invoked in some static block
1566 ClassDescriptor cd = fm.getMethod().getClassDesc();
1568 // the same class, do nothing
1569 // TODO may want to invoke static field initialization here
1571 if((cn.getNumStaticFields() != 0) || (cn.getNumStaticBlocks() != 0)) {
1572 // need to check if the class' static fields have been initialized and/or
1573 // its static blocks have been executed
1574 output.println("#ifdef MGC_STATIC_INIT_CHECK");
1575 output.println("if(global_defsprim_p->" + cn.getSafeSymbol()+"static_block_exe_flag == 0) {");
1576 if(cn.getNumStaticBlocks() != 0) {
1577 MethodDescriptor t_md = (MethodDescriptor)cn.getMethodTable().get("staticblocks");
1578 output.println(" "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"();");
1580 output.println(" global_defsprim_p->" + cn.getSafeSymbol()+"static_block_exe_flag = 1;");
1582 output.println("}");
1583 output.println("#endif // MGC_STATIC_INIT_CHECK");
1587 if((md.getSymbol().equals("MonitorEnter") || md.getSymbol().equals("MonitorExit")) && fc.getThis().getSymbol().equals("classobj")) {
1588 // call MonitorEnter/MonitorExit on a class obj
1589 output.println(" " + cn.getSafeSymbol()+md.getSafeSymbol()+"_"
1590 + md.getSafeMethodDescriptor() + "((struct ___Object___*)(((void **)(((char *) &(global_defs_p->classobjs->___length___))+sizeof(int)))["
1591 + fc.getThis().getType().getClassDesc().getId() + "]));");
1596 output.println("{");
1597 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1599 LocalityBinding fclb=locality.getBinding(currlb, fc);
1600 output.print(" struct "+cn.getSafeSymbol()+fclb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
1602 output.print(" struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
1603 output.print(objectparams.numPointers());
1604 output.print(", "+localsprefixaddr);
1605 if (md.getThis()!=null) {
1607 output.print("(struct "+md.getThis().getType().getSafeSymbol() +" *)"+ generateTemp(fm,fc.getThis()));
1609 if (fc.getThis()!=null&&md.getThis()==null) {
1610 System.out.println("WARNING!!!!!!!!!!!!");
1611 System.out.println("Source code calls static method "+md+" on an object in "+fm.getMethod()+"!");
1615 for(int i=0; i<fc.numArgs(); i++) {
1616 Descriptor var=md.getParameter(i);
1617 TempDescriptor paramtemp=(TempDescriptor)temptovar.get(var);
1618 if (objectparams.isParamPtr(paramtemp)) {
1619 TempDescriptor targ=fc.getArg(i);
1621 TypeDescriptor td=md.getParamType(i);
1623 output.print("(struct "+(new TypeDescriptor(typeutil.getClass(TypeUtil.TagClass))).getSafeSymbol() +" *)"+generateTemp(fm, targ));
1625 output.print("(struct "+md.getParamType(i).getSafeSymbol() +" *)"+generateTemp(fm, targ));
1628 output.println("};");
1633 if (fc.getReturnTemp()!=null)
1634 output.print(generateTemp(fm,fc.getReturnTemp())+"=");
1636 /* Do we need to do virtual dispatch? */
1637 if (md.isStatic()||md.getReturnType()==null||singleCall(fc.getThis().getType().getClassDesc(),md)) {
1640 LocalityBinding fclb=locality.getBinding(currlb, fc);
1641 output.print(cn.getSafeSymbol()+fclb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
1643 output.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
1648 if (state.MGC && md.getReturnType().isClass() && md.getReturnType().getClassDesc().isEnum()) {
1649 output.print("int ");
1650 } else if (md.getReturnType().isClass()||md.getReturnType().isArray())
1651 output.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
1653 output.print(md.getReturnType().getSafeSymbol()+" ");
1654 output.print("(*)(");
1656 boolean printcomma=false;
1657 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1659 LocalityBinding fclb=locality.getBinding(currlb, fc);
1660 output.print("struct "+cn.getSafeSymbol()+fclb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * ");
1662 output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * ");
1666 for(int i=0; i<objectparams.numPrimitives(); i++) {
1667 TempDescriptor temp=objectparams.getPrimitive(i);
1671 if (state.MGC && temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
1672 output.print("int ");
1673 } else if (temp.getType().isClass()||temp.getType().isArray())
1674 output.print("struct " + temp.getType().getSafeSymbol()+" * ");
1676 output.print(temp.getType().getSafeSymbol());
1681 LocalityBinding fclb=locality.getBinding(currlb, fc);
1682 output.print("))virtualtable["+generateTemp(fm,fc.getThis())+"->type*"+maxcount+"+"+virtualcalls.getLocalityNumber(fclb)+"])");
1684 output.print("))virtualtable["+generateTemp(fm,fc.getThis())+"->type*"+maxcount+"+"+virtualcalls.getMethodNumber(md)+"])");
1688 boolean needcomma=false;
1689 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1690 output.print("&__parameterlist__");
1694 if (!GENERATEPRECISEGC && !this.state.MULTICOREGC) {
1695 if (fc.getThis()!=null) {
1696 TypeDescriptor ptd=null;
1697 if(md.getThis() != null) {
1698 ptd = md.getThis().getType();
1700 ptd = fc.getThis().getType();
1704 if(state.MGC && ptd.isClass() && ptd.getClassDesc().isEnum()) {
1706 } else if (ptd.isClass()&&!ptd.isArray())
1707 output.print("(struct "+ptd.getSafeSymbol()+" *) ");
1708 output.print(generateTemp(fm,fc.getThis()));
1713 for(int i=0; i<fc.numArgs(); i++) {
1714 Descriptor var=md.getParameter(i);
1715 TempDescriptor paramtemp=(TempDescriptor)temptovar.get(var);
1716 if (objectparams.isParamPrim(paramtemp)) {
1717 TempDescriptor targ=fc.getArg(i);
1721 TypeDescriptor ptd=md.getParamType(i);
1722 if (state.MGC && ptd.isClass() && ptd.getClassDesc().isEnum()) {
1724 } else if (ptd.isClass()&&!ptd.isArray())
1725 output.print("(struct "+ptd.getSafeSymbol()+" *) ");
1726 output.print(generateTemp(fm, targ));
1730 output.println(");");
1731 output.println(" }");
1735 protected void generateFlatFieldNode(FlatMethod fm, FlatFieldNode ffn, PrintWriter output) {
1736 if (state.SINGLETM) {
1737 //single machine transactional memory case
1738 String field=ffn.getField().getSafeSymbol();
1739 String src=generateTemp(fm, ffn.getSrc());
1740 String dst=generateTemp(fm, ffn.getDst());
1742 output.println(dst+"="+ src +"->"+field+ ";");
1743 if (ffn.getField().getType().isPtr()&&locality.getAtomic(currlb).get(ffn).intValue()>0&&
1744 locality.getNodePreTempInfo(currlb, ffn).get(ffn.getSrc())!=LocalityAnalysis.SCRATCH) {
1745 if ((dc==null)||(!state.READSET&&dc.getNeedTrans(currlb, ffn))||
1746 (state.READSET&&dc.getNeedWriteTrans(currlb, ffn))) {
1747 output.println("TRANSREAD("+dst+", "+dst+", (void *) (" + localsprefixaddr + "));");
1748 } else if (state.READSET&&dc.getNeedTrans(currlb, ffn)) {
1749 if (state.HYBRID&&delaycomp.getConv(currlb).contains(ffn)) {
1750 output.println("TRANSREADRDFISSION("+dst+", "+dst+");");
1752 output.println("TRANSREADRD("+dst+", "+dst+");");
1755 } else if (state.DSM) {
1756 Integer status=locality.getNodePreTempInfo(currlb,ffn).get(ffn.getSrc());
1757 if (status==LocalityAnalysis.GLOBAL) {
1758 String field=ffn.getField().getSafeSymbol();
1759 String src=generateTemp(fm, ffn.getSrc());
1760 String dst=generateTemp(fm, ffn.getDst());
1762 if (ffn.getField().getType().isPtr()) {
1763 output.println(dst+"="+ src +"->"+field+ ";");
1764 output.println("TRANSREAD("+dst+", (unsigned int) "+dst+");");
1766 output.println(dst+"="+ src+"->"+field+";");
1768 } else if (status==LocalityAnalysis.LOCAL) {
1769 if (ffn.getField().getType().isPtr()&&
1770 ffn.getField().isGlobal()) {
1771 String field=ffn.getField().getSafeSymbol();
1772 String src=generateTemp(fm, ffn.getSrc());
1773 String dst=generateTemp(fm, ffn.getDst());
1774 output.println(dst+"="+ src +"->"+field+ ";");
1775 if (locality.getAtomic(currlb).get(ffn).intValue()>0)
1776 output.println("TRANSREAD("+dst+", (unsigned int) "+dst+");");
1778 output.println(generateTemp(fm, ffn.getDst())+"="+ generateTemp(fm,ffn.getSrc())+"->"+ ffn.getField().getSafeSymbol()+";");
1779 } else if (status==LocalityAnalysis.EITHER) {
1780 //Code is reading from a null pointer
1781 output.println("if ("+generateTemp(fm, ffn.getSrc())+") {");
1782 output.println("#ifndef RAW");
1783 output.println("printf(\"BIG ERROR\\n\");exit(-1);}");
1784 output.println("#endif");
1785 //This should throw a suitable null pointer error
1786 output.println(generateTemp(fm, ffn.getDst())+"="+ generateTemp(fm,ffn.getSrc())+"->"+ ffn.getField().getSafeSymbol()+";");
1788 throw new Error("Read from non-global/non-local in:"+currlb.getExplanation());
1792 protected void generateFlatSetFieldNode(FlatMethod fm, FlatSetFieldNode fsfn, PrintWriter output) {
1793 if (fsfn.getField().getSymbol().equals("length")&&fsfn.getDst().getType().isArray())
1794 throw new Error("Can't set array length");
1795 if (state.SINGLETM && locality.getAtomic(currlb).get(fsfn).intValue()>0) {
1796 //Single Machine Transaction Case
1797 boolean srcptr=fsfn.getSrc().getType().isPtr();
1798 String src=generateTemp(fm,fsfn.getSrc());
1799 String dst=generateTemp(fm,fsfn.getDst());
1800 output.println("//"+srcptr+" "+fsfn.getSrc().getType().isNull());
1801 if (srcptr&&!fsfn.getSrc().getType().isNull()) {
1802 output.println("{");
1803 if ((dc==null)||dc.getNeedSrcTrans(currlb, fsfn)&&
1804 locality.getNodePreTempInfo(currlb, fsfn).get(fsfn.getSrc())!=LocalityAnalysis.SCRATCH) {
1805 output.println("INTPTR srcoid=("+src+"!=NULL?((INTPTR)"+src+"->"+oidstr+"):0);");
1807 output.println("INTPTR srcoid=(INTPTR)"+src+";");
1810 if (wb.needBarrier(fsfn)&&
1811 locality.getNodePreTempInfo(currlb, fsfn).get(fsfn.getDst())!=LocalityAnalysis.SCRATCH) {
1812 if (state.EVENTMONITOR) {
1813 output.println("if ("+dst+"->___objstatus___&DIRTY) EVLOGEVENTOBJ(EV_WRITE,"+dst+"->objuid)");
1815 output.println("*((unsigned int *)&("+dst+"->___objstatus___))|=DIRTY;");
1817 if (srcptr&!fsfn.getSrc().getType().isNull()) {
1818 output.println("*((unsigned INTPTR *)&("+dst+"->"+
1819 fsfn.getField().getSafeSymbol()+"))=srcoid;");
1820 output.println("}");
1822 output.println(dst+"->"+
1823 fsfn.getField().getSafeSymbol()+"="+ src+";");
1825 } else if (state.DSM && locality.getAtomic(currlb).get(fsfn).intValue()>0) {
1826 Integer statussrc=locality.getNodePreTempInfo(currlb,fsfn).get(fsfn.getSrc());
1827 Integer statusdst=locality.getNodeTempInfo(currlb).get(fsfn).get(fsfn.getDst());
1828 boolean srcglobal=statussrc==LocalityAnalysis.GLOBAL;
1830 String src=generateTemp(fm,fsfn.getSrc());
1831 String dst=generateTemp(fm,fsfn.getDst());
1833 output.println("{");
1834 output.println("INTPTR srcoid=("+src+"!=NULL?((INTPTR)"+src+"->"+oidstr+"):0);");
1836 if (statusdst.equals(LocalityAnalysis.GLOBAL)) {
1839 if (wb.needBarrier(fsfn))
1840 output.println("*((unsigned int *)&("+dst+"->___localcopy___))|=DIRTY;");
1842 output.println("*((unsigned INTPTR *)&("+glbdst+"->"+
1843 fsfn.getField().getSafeSymbol()+"))=srcoid;");
1845 output.println(glbdst+"->"+
1846 fsfn.getField().getSafeSymbol()+"="+ src+";");
1847 } else if (statusdst.equals(LocalityAnalysis.LOCAL)) {
1848 /** Check if we need to copy */
1849 output.println("if(!"+dst+"->"+localcopystr+") {");
1850 /* Link object into list */
1851 String revertptr=generateTemp(fm, reverttable.get(currlb));
1852 output.println(revertptr+"=revertlist;");
1853 if (GENERATEPRECISEGC || this.state.MULTICOREGC)
1854 output.println("COPY_OBJ((struct garbagelist *)"+localsprefixaddr+",(struct ___Object___ *)"+dst+");");
1856 output.println("COPY_OBJ("+dst+");");
1857 output.println(dst+"->"+nextobjstr+"="+revertptr+";");
1858 output.println("revertlist=(struct ___Object___ *)"+dst+";");
1859 output.println("}");
1861 output.println(dst+"->"+
1862 fsfn.getField().getSafeSymbol()+"=(void *) srcoid;");
1864 output.println(dst+"->"+
1865 fsfn.getField().getSafeSymbol()+"="+ src+";");
1866 } else if (statusdst.equals(LocalityAnalysis.EITHER)) {
1867 //writing to a null...bad
1868 output.println("if ("+dst+") {");
1869 output.println("printf(\"BIG ERROR 2\\n\");exit(-1);}");
1871 output.println(dst+"->"+
1872 fsfn.getField().getSafeSymbol()+"=(void *) srcoid;");
1874 output.println(dst+"->"+
1875 fsfn.getField().getSafeSymbol()+"="+ src+";");
1878 output.println("}");
1883 protected void generateFlatElementNode(FlatMethod fm, FlatElementNode fen, PrintWriter output) {
1884 TypeDescriptor elementtype=fen.getSrc().getType().dereference();
1887 if (state.MGC && elementtype.isClass() && elementtype.getClassDesc().isEnum()) {
1889 } else if (elementtype.isArray()||elementtype.isClass())
1892 type=elementtype.getSafeSymbol()+" ";
1894 if (this.state.ARRAYBOUNDARYCHECK && fen.needsBoundsCheck()) {
1895 output.println("if (unlikely(((unsigned int)"+generateTemp(fm, fen.getIndex())+") >= "+generateTemp(fm,fen.getSrc()) + "->___length___))");
1896 output.println("failedboundschk();");
1898 if (state.SINGLETM) {
1899 //Single machine transaction case
1900 String dst=generateTemp(fm, fen.getDst());
1901 if ((!state.STMARRAY)||(!wb.needBarrier(fen))||locality.getNodePreTempInfo(currlb, fen).get(fen.getSrc())==LocalityAnalysis.SCRATCH||locality.getAtomic(currlb).get(fen).intValue()==0||(state.READSET&&!dc.getNeedGet(currlb, fen))) {
1902 output.println(dst +"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc())+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex())+"];");
1904 output.println("STMGETARRAY("+dst+", "+ generateTemp(fm,fen.getSrc())+", "+generateTemp(fm, fen.getIndex())+", "+type+");");
1907 if (elementtype.isPtr()&&locality.getAtomic(currlb).get(fen).intValue()>0&&
1908 locality.getNodePreTempInfo(currlb, fen).get(fen.getSrc())!=LocalityAnalysis.SCRATCH) {
1909 if ((dc==null)||!state.READSET&&dc.getNeedTrans(currlb, fen)||state.READSET&&dc.getNeedWriteTrans(currlb, fen)) {
1910 output.println("TRANSREAD("+dst+", "+dst+", (void *)(" + localsprefixaddr+"));");
1911 } else if (state.READSET&&dc.getNeedTrans(currlb, fen)) {
1912 if (state.HYBRID&&delaycomp.getConv(currlb).contains(fen)) {
1913 output.println("TRANSREADRDFISSION("+dst+", "+dst+");");
1915 output.println("TRANSREADRD("+dst+", "+dst+");");
1918 } else if (state.DSM) {
1919 Integer status=locality.getNodePreTempInfo(currlb,fen).get(fen.getSrc());
1920 if (status==LocalityAnalysis.GLOBAL) {
1921 String dst=generateTemp(fm, fen.getDst());
1922 if (elementtype.isPtr()) {
1923 output.println(dst +"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc())+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex())+"];");
1924 output.println("TRANSREAD("+dst+", "+dst+");");
1926 output.println(dst +"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc())+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex())+"];");
1928 } else if (status==LocalityAnalysis.LOCAL) {
1929 output.println(generateTemp(fm, fen.getDst())+"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc())+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex())+"];");
1930 } else if (status==LocalityAnalysis.EITHER) {
1931 //Code is reading from a null pointer
1932 output.println("if ("+generateTemp(fm, fen.getSrc())+") {");
1933 output.println("#ifndef RAW");
1934 output.println("printf(\"BIG ERROR\\n\");exit(-1);}");
1935 output.println("#endif");
1936 //This should throw a suitable null pointer error
1937 output.println(generateTemp(fm, fen.getDst())+"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc())+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex())+"];");
1939 throw new Error("Read from non-global/non-local in:"+currlb.getExplanation());
1943 protected void generateFlatSetElementNode(FlatMethod fm, FlatSetElementNode fsen, PrintWriter output) {
1944 //TODO: need dynamic check to make sure this assignment is actually legal
1945 //Because Object[] could actually be something more specific...ie. Integer[]
1947 TypeDescriptor elementtype=fsen.getDst().getType().dereference();
1950 if (state.MGC && elementtype.isClass() && elementtype.getClassDesc().isEnum()) {
1952 } else if (elementtype.isArray()||elementtype.isClass() || (state.MGC && elementtype.isNull()))
1955 type=elementtype.getSafeSymbol()+" ";
1957 if (this.state.ARRAYBOUNDARYCHECK && fsen.needsBoundsCheck()) {
1958 output.println("if (unlikely(((unsigned int)"+generateTemp(fm, fsen.getIndex())+") >= "+generateTemp(fm,fsen.getDst()) + "->___length___))");
1959 output.println("failedboundschk();");
1962 if (state.SINGLETM && locality.getAtomic(currlb).get(fsen).intValue()>0) {
1963 //Transaction set element case
1964 if (wb.needBarrier(fsen)&&
1965 locality.getNodePreTempInfo(currlb, fsen).get(fsen.getDst())!=LocalityAnalysis.SCRATCH) {
1966 output.println("*((unsigned int *)&("+generateTemp(fm,fsen.getDst())+"->___objstatus___))|=DIRTY;");
1968 if (fsen.getSrc().getType().isPtr()&&!fsen.getSrc().getType().isNull()) {
1969 output.println("{");
1970 String src=generateTemp(fm, fsen.getSrc());
1971 if ((dc==null)||dc.getNeedSrcTrans(currlb, fsen)&&
1972 locality.getNodePreTempInfo(currlb, fsen).get(fsen.getSrc())!=LocalityAnalysis.SCRATCH) {
1973 output.println("INTPTR srcoid=("+src+"!=NULL?((INTPTR)"+src+"->"+oidstr+"):0);");
1975 output.println("INTPTR srcoid=(INTPTR)"+src+";");
1977 if (state.STMARRAY&&locality.getNodePreTempInfo(currlb, fsen).get(fsen.getDst())!=LocalityAnalysis.SCRATCH&&wb.needBarrier(fsen)&&locality.getAtomic(currlb).get(fsen).intValue()>0) {
1978 output.println("STMSETARRAY("+generateTemp(fm, fsen.getDst())+", "+generateTemp(fm, fsen.getIndex())+", srcoid, INTPTR);");
1980 output.println("((INTPTR*)(((char *) &("+ generateTemp(fm,fsen.getDst())+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex())+"]=srcoid;");
1982 output.println("}");
1984 if (state.STMARRAY&&locality.getNodePreTempInfo(currlb, fsen).get(fsen.getDst())!=LocalityAnalysis.SCRATCH&&wb.needBarrier(fsen)&&locality.getAtomic(currlb).get(fsen).intValue()>0) {
1985 output.println("STMSETARRAY("+generateTemp(fm, fsen.getDst())+", "+generateTemp(fm, fsen.getIndex())+", "+ generateTemp(fm, fsen.getSrc()) +", "+type+");");
1987 output.println("(("+type +"*)(((char *) &("+ generateTemp(fm,fsen.getDst())+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex())+"]="+generateTemp(fm,fsen.getSrc())+";");
1990 } else if (state.DSM && locality.getAtomic(currlb).get(fsen).intValue()>0) {
1991 Integer statussrc=locality.getNodePreTempInfo(currlb,fsen).get(fsen.getSrc());
1992 Integer statusdst=locality.getNodePreTempInfo(currlb,fsen).get(fsen.getDst());
1993 boolean srcglobal=statussrc==LocalityAnalysis.GLOBAL;
1994 boolean dstglobal=statusdst==LocalityAnalysis.GLOBAL;
1995 boolean dstlocal=(statusdst==LocalityAnalysis.LOCAL)||(statusdst==LocalityAnalysis.EITHER);
1998 if (wb.needBarrier(fsen))
1999 output.println("*((unsigned int *)&("+generateTemp(fm,fsen.getDst())+"->___localcopy___))|=DIRTY;");
2000 } else if (dstlocal) {
2001 /** Check if we need to copy */
2002 String dst=generateTemp(fm, fsen.getDst());
2003 output.println("if(!"+dst+"->"+localcopystr+") {");
2004 /* Link object into list */
2005 String revertptr=generateTemp(fm, reverttable.get(currlb));
2006 output.println(revertptr+"=revertlist;");
2007 if ((GENERATEPRECISEGC) || this.state.MULTICOREGC)
2008 output.println("COPY_OBJ((struct garbagelist *)"+localsprefixaddr+",(struct ___Object___ *)"+dst+");");
2010 output.println("COPY_OBJ("+dst+");");
2011 output.println(dst+"->"+nextobjstr+"="+revertptr+";");
2012 output.println("revertlist=(struct ___Object___ *)"+dst+";");
2013 output.println("}");
2015 System.out.println("Node: "+fsen);
2016 System.out.println(currlb);
2017 System.out.println("statusdst="+statusdst);
2018 System.out.println(fm.printMethod());
2019 throw new Error("Unknown array type");
2022 output.println("{");
2023 String src=generateTemp(fm, fsen.getSrc());
2024 output.println("INTPTR srcoid=("+src+"!=NULL?((INTPTR)"+src+"->"+oidstr+"):0);");
2025 output.println("((INTPTR*)(((char *) &("+ generateTemp(fm,fsen.getDst())+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex())+"]=srcoid;");
2026 output.println("}");
2028 output.println("(("+type +"*)(((char *) &("+ generateTemp(fm,fsen.getDst())+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex())+"]="+generateTemp(fm,fsen.getSrc())+";");
2031 if (state.FASTCHECK) {
2032 String dst=generateTemp(fm, fsen.getDst());
2033 output.println("if(!"+dst+"->"+localcopystr+") {");
2034 /* Link object into list */
2035 if (GENERATEPRECISEGC || this.state.MULTICOREGC)
2036 output.println("COPY_OBJ((struct garbagelist *)"+localsprefixaddr+",(struct ___Object___ *)"+dst+");");
2038 output.println("COPY_OBJ("+dst+");");
2039 output.println(dst+"->"+nextobjstr+"="+fcrevert+";");
2040 output.println(fcrevert+"=(struct ___Object___ *)"+dst+";");
2041 output.println("}");
2043 output.println("(("+type +"*)(((char *) &("+ generateTemp(fm,fsen.getDst())+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex())+"]="+generateTemp(fm,fsen.getSrc())+";");
2048 protected void generateFlatNew(FlatMethod fm, FlatNew fn, PrintWriter output) {
2049 if (state.DSM && locality.getAtomic(currlb).get(fn).intValue()>0&&!fn.isGlobal()) {
2050 //Stash pointer in case of GC
2051 String revertptr=generateTemp(fm, reverttable.get(currlb));
2052 output.println(revertptr+"=revertlist;");
2054 if (state.SINGLETM) {
2055 if (fn.getType().isArray()) {
2056 int arrayid=state.getArrayNumber(fn.getType())+state.numClasses();
2057 if (locality.getAtomic(currlb).get(fn).intValue()>0) {
2058 //inside transaction
2059 output.println(generateTemp(fm,fn.getDst())+"=allocate_newarraytrans("+localsprefixaddr+", "+arrayid+", "+generateTemp(fm, fn.getSize())+");");
2061 //outside transaction
2062 output.println(generateTemp(fm,fn.getDst())+"=allocate_newarray("+localsprefixaddr+", "+arrayid+", "+generateTemp(fm, fn.getSize())+");");
2065 if (locality.getAtomic(currlb).get(fn).intValue()>0) {
2066 //inside transaction
2067 output.println(generateTemp(fm,fn.getDst())+"=allocate_newtrans("+localsprefixaddr+", "+fn.getType().getClassDesc().getId()+");");
2069 //outside transaction
2070 output.println(generateTemp(fm,fn.getDst())+"=allocate_new("+localsprefixaddr+", "+fn.getType().getClassDesc().getId()+");");
2073 } else if (fn.getType().isArray()) {
2074 int arrayid=state.getArrayNumber(fn.getType())+state.numClasses();
2075 if (fn.isGlobal()) {
2076 output.println(generateTemp(fm,fn.getDst())+"=allocate_newarrayglobal("+arrayid+", "+generateTemp(fm, fn.getSize())+");");
2077 } else if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2078 output.println(generateTemp(fm,fn.getDst())+"=allocate_newarray("+localsprefixaddr+", "+arrayid+", "+generateTemp(fm, fn.getSize())+");");
2080 output.println(generateTemp(fm,fn.getDst())+"=allocate_newarray("+arrayid+", "+generateTemp(fm, fn.getSize())+");");
2083 if (fn.isGlobal()) {
2084 output.println(generateTemp(fm,fn.getDst())+"=allocate_newglobal("+fn.getType().getClassDesc().getId()+");");
2085 } else if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2086 output.println(generateTemp(fm,fn.getDst())+"=allocate_new("+localsprefixaddr+", "+fn.getType().getClassDesc().getId()+");");
2088 output.println(generateTemp(fm,fn.getDst())+"=allocate_new("+fn.getType().getClassDesc().getId()+");");
2091 if (state.DSM && locality.getAtomic(currlb).get(fn).intValue()>0&&!fn.isGlobal()) {
2092 String revertptr=generateTemp(fm, reverttable.get(currlb));
2093 String dst=generateTemp(fm,fn.getDst());
2094 output.println(dst+"->___localcopy___=(struct ___Object___*)1;");
2095 output.println(dst+"->"+nextobjstr+"="+revertptr+";");
2096 output.println("revertlist=(struct ___Object___ *)"+dst+";");
2098 if (state.FASTCHECK) {
2099 String dst=generateTemp(fm,fn.getDst());
2100 output.println(dst+"->___localcopy___=(struct ___Object___*)1;");
2101 output.println(dst+"->"+nextobjstr+"="+fcrevert+";");
2102 output.println(fcrevert+"=(struct ___Object___ *)"+dst+";");
2106 protected void generateFlatOpNode(FlatMethod fm, FlatOpNode fon, PrintWriter output) {
2107 if (fon.getRight()!=null) {
2108 if (fon.getOp().getOp()==Operation.URIGHTSHIFT) {
2109 if (fon.getLeft().getType().isLong())
2110 output.println(generateTemp(fm, fon.getDest())+" = ((unsigned long long)"+generateTemp(fm, fon.getLeft())+")>>"+generateTemp(fm,fon.getRight())+";");
2112 output.println(generateTemp(fm, fon.getDest())+" = ((unsigned int)"+generateTemp(fm, fon.getLeft())+")>>"+generateTemp(fm,fon.getRight())+";");
2114 } else if (dc!=null) {
2115 output.print(generateTemp(fm, fon.getDest())+" = (");
2116 if (fon.getLeft().getType().isPtr()&&(fon.getOp().getOp()==Operation.EQUAL||fon.getOp().getOp()==Operation.NOTEQUAL))
2117 output.print("(void *)");
2118 if (dc.getNeedLeftSrcTrans(currlb, fon))
2119 output.print("("+generateTemp(fm, fon.getLeft())+"!=NULL?"+generateTemp(fm, fon.getLeft())+"->"+oidstr+":NULL)");
2121 output.print(generateTemp(fm, fon.getLeft()));
2122 output.print(")"+fon.getOp().toString()+"(");
2123 if (fon.getRight().getType().isPtr()&&(fon.getOp().getOp()==Operation.EQUAL||fon.getOp().getOp()==Operation.NOTEQUAL))
2124 output.print("(void *)");
2125 if (dc.getNeedRightSrcTrans(currlb, fon))
2126 output.println("("+generateTemp(fm, fon.getRight())+"!=NULL?"+generateTemp(fm, fon.getRight())+"->"+oidstr+":NULL));");
2128 output.println(generateTemp(fm,fon.getRight())+");");
2130 output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+fon.getOp().toString()+generateTemp(fm,fon.getRight())+";");
2131 } else if (fon.getOp().getOp()==Operation.ASSIGN)
2132 output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+";");
2133 else if (fon.getOp().getOp()==Operation.UNARYPLUS)
2134 output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+";");
2135 else if (fon.getOp().getOp()==Operation.UNARYMINUS)
2136 output.println(generateTemp(fm, fon.getDest())+" = -"+generateTemp(fm, fon.getLeft())+";");
2137 else if (fon.getOp().getOp()==Operation.LOGIC_NOT)
2138 output.println(generateTemp(fm, fon.getDest())+" = !"+generateTemp(fm, fon.getLeft())+";");
2139 else if (fon.getOp().getOp()==Operation.COMP)
2140 output.println(generateTemp(fm, fon.getDest())+" = ~"+generateTemp(fm, fon.getLeft())+";");
2141 else if (fon.getOp().getOp()==Operation.ISAVAILABLE) {
2142 output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+"->fses==NULL;");
2144 output.println(generateTemp(fm, fon.getDest())+fon.getOp().toString()+generateTemp(fm, fon.getLeft())+";");
2147 protected void generateFlatLiteralNode(FlatMethod fm, FlatLiteralNode fln, PrintWriter output) {
2148 if (fln.getValue()==null)
2149 output.println(generateTemp(fm, fln.getDst())+"=0;");
2150 else if (fln.getType().getSymbol().equals(TypeUtil.StringClass)) {
2151 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2152 if (state.DSM && locality.getAtomic(currlb).get(fln).intValue()>0) {
2153 //Stash pointer in case of GC
2154 String revertptr=generateTemp(fm, reverttable.get(currlb));
2155 output.println(revertptr+"=revertlist;");
2157 output.println(generateTemp(fm, fln.getDst())+"=NewString("+localsprefixaddr+", \""+FlatLiteralNode.escapeString((String)fln.getValue())+"\","+((String)fln.getValue()).length()+");");
2158 if (state.DSM && locality.getAtomic(currlb).get(fln).intValue()>0) {
2159 //Stash pointer in case of GC
2160 String revertptr=generateTemp(fm, reverttable.get(currlb));
2161 output.println("revertlist="+revertptr+";");
2164 output.println(generateTemp(fm, fln.getDst())+"=NewString(\""+FlatLiteralNode.escapeString((String)fln.getValue())+"\","+((String)fln.getValue()).length()+");");
2166 } else if (fln.getType().isBoolean()) {
2167 if (((Boolean)fln.getValue()).booleanValue())
2168 output.println(generateTemp(fm, fln.getDst())+"=1;");
2170 output.println(generateTemp(fm, fln.getDst())+"=0;");
2171 } else if (fln.getType().isChar()) {
2172 String st=FlatLiteralNode.escapeString(fln.getValue().toString());
2173 output.println(generateTemp(fm, fln.getDst())+"='"+st+"';");
2174 } else if (fln.getType().isLong()) {
2175 output.println(generateTemp(fm, fln.getDst())+"="+fln.getValue()+"LL;");
2177 output.println(generateTemp(fm, fln.getDst())+"="+fln.getValue()+";");
2180 protected void generateStoreFlatCondBranch(FlatMethod fm, LocalityBinding lb, FlatCondBranch fcb, String label, PrintWriter output) {
2183 //only record if this group has more than one exit
2184 if (branchanalysis.numJumps(fcb)>1) {
2185 left=branchanalysis.jumpValue(fcb, 0);
2186 right=branchanalysis.jumpValue(fcb, 1);
2188 output.println("if (!"+generateTemp(fm, fcb.getTest())+") {");
2190 output.println("STOREBRANCH("+right+");");
2191 output.println("goto "+label+";");
2192 output.println("}");
2194 output.println("STOREBRANCH("+left+");");
2197 /** This method generates header information for the method or
2198 * task referenced by the Descriptor des. */
2199 protected void generateHeader(FlatMethod fm, LocalityBinding lb, Descriptor des, PrintWriter output) {
2201 ParamsObject objectparams=(ParamsObject)paramstable.get(lb!=null?lb:des);
2202 MethodDescriptor md=null;
2203 TaskDescriptor task=null;
2204 if (des instanceof MethodDescriptor)
2205 md=(MethodDescriptor) des;
2207 task=(TaskDescriptor) des;
2209 ClassDescriptor cn=md!=null?md.getClassDesc():null;
2211 if (md!=null&&md.getReturnType()!=null) {
2212 if (state.MGC && md.getReturnType().isClass() && md.getReturnType().getClassDesc().isEnum()) {
2213 output.print("int ");
2214 } else if (md.getReturnType().isClass()||md.getReturnType().isArray())
2215 output.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
2217 output.print(md.getReturnType().getSafeSymbol()+" ");
2219 //catch the constructor case
2220 output.print("void ");
2222 output.print(cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(");
2224 output.print(task.getSafeSymbol()+"(");
2226 boolean printcomma=false;
2227 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2229 output.print("struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
2231 output.print("struct "+task.getSafeSymbol()+"_params * "+paramsprefix);
2237 for(int i=0; i<objectparams.numPrimitives(); i++) {
2238 TempDescriptor temp=objectparams.getPrimitive(i);
2242 if(state.MGC && temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
2243 output.print("int " + temp.getSafeSymbol());
2244 } else if (temp.getType().isClass()||temp.getType().isArray())
2245 output.print("struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol());
2247 output.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
2249 output.println(") {");
2250 } else if (!GENERATEPRECISEGC && !this.state.MULTICOREGC) {
2251 /* Imprecise Task */
2252 output.println("void * parameterarray[]) {");
2253 /* Unpack variables */
2254 for(int i=0; i<objectparams.numPrimitives(); i++) {
2255 TempDescriptor temp=objectparams.getPrimitive(i);
2256 if(state.MGC && temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
2257 output.print("int " + temp.getSafeSymbol() + "=parameterarray["+i+"];");
2259 output.println("struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+"=parameterarray["+i+"];");
2262 for(int i=0; i<fm.numTags(); i++) {
2263 TempDescriptor temp=fm.getTag(i);
2264 int offset=i+objectparams.numPrimitives();
2265 output.println("struct ___TagDescriptor___ * "+temp.getSafeSymbol()+"=parameterarray["+offset+"];");
2268 if ((objectparams.numPrimitives()+fm.numTags())>maxtaskparams)
2269 maxtaskparams=objectparams.numPrimitives()+fm.numTags();
2270 } else output.println(") {");