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 BuildCode {
36 Hashtable paramstable;
41 String localsprefix="___locals___";
42 String localsprefixaddr="&"+localsprefix;
43 String localsprefixderef=localsprefix+".";
44 String fcrevert="___fcrevert___";
45 String paramsprefix="___params___";
46 String oidstr="___nextobject___";
47 String nextobjstr="___nextobject___";
48 String localcopystr="___localcopy___";
49 public static boolean GENERATEPRECISEGC=false;
50 public static String PREFIX="";
51 public static String arraytype="ArrayObject";
52 public static int flagcount = 0;
55 protected int maxtaskparams=0;
56 private int maxcount=0;
57 ClassDescriptor[] cdarray;
58 TypeDescriptor[] arraytable;
59 LocalityAnalysis locality;
60 Hashtable<LocalityBinding, TempDescriptor> reverttable;
61 Hashtable<LocalityBinding, Hashtable<TempDescriptor, TempDescriptor>> backuptable;
66 DiscoverConflicts recorddc;
69 Hashtable<String, ClassDescriptor> printedfieldstbl;
70 Hashtable<ClassDescriptor, Hashtable<String, ClassDescriptor>> cd2fieldstbl;
71 Hashtable<ClassDescriptor, Vector<FieldDescriptor>> cd2shadowfields;
74 public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, SafetyAnalysis sa, PrefetchAnalysis pa) {
75 this(st, temptovar, typeutil, null, sa, pa);
78 public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, LocalityAnalysis locality, PrefetchAnalysis pa) {
79 this(st, temptovar, typeutil, locality, null, pa);
82 public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, LocalityAnalysis locality, SafetyAnalysis sa, PrefetchAnalysis pa ) {
86 callgraph=new CallGraph(state);
88 oidstr="___objlocation___";
89 this.temptovar=temptovar;
90 paramstable=new Hashtable();
91 tempstable=new Hashtable();
92 fieldorder=new Hashtable();
93 flagorder=new Hashtable();
94 this.typeutil=typeutil;
95 virtualcalls=new Virtual(state,locality);
97 this.locality=locality;
98 this.reverttable=new Hashtable<LocalityBinding, TempDescriptor>();
99 this.backuptable=new Hashtable<LocalityBinding, Hashtable<TempDescriptor, TempDescriptor>>();
100 this.wb=new WriteBarrier(locality, st);
102 if (state.SINGLETM&&state.DCOPTS) {
103 TypeAnalysis typeanalysis=new TypeAnalysis(locality, st, typeutil,callgraph);
104 GlobalFieldType gft=new GlobalFieldType(callgraph, st, typeutil.getMain());
105 this.dc=new DiscoverConflicts(locality, st, typeanalysis, gft);
108 if (state.DELAYCOMP) {
109 //TypeAnalysis typeanalysis=new TypeAnalysis(locality, st, typeutil,callgraph);
110 TypeAnalysis typeanalysis=new TypeAnalysis(locality, st, typeutil,callgraph);
111 GlobalFieldType gft=new GlobalFieldType(callgraph, st, typeutil.getMain());
112 delaycomp=new DCWrapper(locality, st, typeanalysis, gft);
113 dc=delaycomp.getConflicts();
114 recorddc=new DiscoverConflicts(locality, st, typeanalysis, delaycomp.getCannotDelayMap(), true, true, null);
115 recorddc.doAnalysis();
117 printedfieldstbl = new Hashtable<String, ClassDescriptor>();
118 cd2fieldstbl = new Hashtable<ClassDescriptor, Hashtable<String, ClassDescriptor>>();
119 cd2shadowfields = new Hashtable<ClassDescriptor, Vector<FieldDescriptor>>();
122 /** The buildCode method outputs C code for all the methods. The Flat
123 * versions of the methods must already be generated and stored in
124 * the State object. */
125 PrintWriter outsandbox=null;
127 public void buildCode() {
128 /* Create output streams to write to */
129 PrintWriter outclassdefs=null;
130 PrintWriter outstructs=null;
131 PrintWriter outrepairstructs=null;
132 PrintWriter outmethodheader=null;
133 PrintWriter outmethod=null;
134 PrintWriter outvirtual=null;
135 PrintWriter outtask=null;
136 PrintWriter outtaskdefs=null;
137 PrintWriter outoptionalarrays=null;
138 PrintWriter optionalheaders=null;
139 PrintWriter outglobaldefs=null;
143 outsandbox=new CodePrinter(new FileOutputStream(PREFIX+"sandboxdefs.c"), true);
145 outstructs=new CodePrinter(new FileOutputStream(PREFIX+"structdefs.h"), true);
146 outmethodheader=new CodePrinter(new FileOutputStream(PREFIX+"methodheaders.h"), true);
147 outclassdefs=new CodePrinter(new FileOutputStream(PREFIX+"classdefs.h"), true);
149 // TODO add version for normal Java later
150 outglobaldefs=new CodePrinter(new FileOutputStream(PREFIX+"globaldefs.h"), true);
152 outmethod=new CodePrinter(new FileOutputStream(PREFIX+"methods.c"), true);
153 outvirtual=new CodePrinter(new FileOutputStream(PREFIX+"virtualtable.h"), true);
155 outtask=new CodePrinter(new FileOutputStream(PREFIX+"task.h"), true);
156 outtaskdefs=new CodePrinter(new FileOutputStream(PREFIX+"taskdefs.c"), true);
157 if (state.OPTIONAL) {
158 outoptionalarrays=new CodePrinter(new FileOutputStream(PREFIX+"optionalarrays.c"), true);
159 optionalheaders=new CodePrinter(new FileOutputStream(PREFIX+"optionalstruct.h"), true);
162 if (state.structfile!=null) {
163 outrepairstructs=new CodePrinter(new FileOutputStream(PREFIX+state.structfile+".struct"), true);
165 } catch (Exception e) {
170 /* Build the virtual dispatch tables */
171 buildVirtualTables(outvirtual);
173 /* Tag the methods that are invoked by static blocks */
174 tagMethodInvokedByStaticBlock();
176 /* Output includes */
177 outmethodheader.println("#ifndef METHODHEADERS_H");
178 outmethodheader.println("#define METHODHEADERS_H");
179 outmethodheader.println("#include \"structdefs.h\"");
181 outmethodheader.println("#include \"dstm.h\"");
183 outmethodheader.println("#include \"sandbox.h\"");
185 if (state.EVENTMONITOR) {
186 outmethodheader.println("#include \"monitor.h\"");
188 if (state.SINGLETM) {
189 outmethodheader.println("#include \"tm.h\"");
190 outmethodheader.println("#include \"delaycomp.h\"");
191 outmethodheader.println("#include \"inlinestm.h\"");
193 if (state.ABORTREADERS) {
194 outmethodheader.println("#include \"abortreaders.h\"");
195 outmethodheader.println("#include <setjmp.h>");
199 additionalIncludesMethodsHeader( outmethodheader );
202 /* Output Structures */
203 outputStructs(outstructs);
205 // Output the C class declarations
206 // These could mutually reference each other
209 // TODO add version for normal Java later
210 outglobaldefs.println("#ifndef __GLOBALDEF_H_");
211 outglobaldefs.println("#define __GLOBALDEF_H_");
212 outglobaldefs.println("");
213 outglobaldefs.println("struct global_defs_t {");
216 outclassdefs.println("#ifndef __CLASSDEF_H_");
217 outclassdefs.println("#define __CLASSDEF_H_");
218 outputClassDeclarations(outclassdefs, outglobaldefs);
220 // Output function prototypes and structures for parameters
221 Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
222 while(it.hasNext()) {
223 ClassDescriptor cn=(ClassDescriptor)it.next();
224 generateCallStructs(cn, outclassdefs, outstructs, outmethodheader, outglobaldefs);
226 outclassdefs.println("#endif");
227 outclassdefs.close();
229 // TODO add version for normal Java later
230 outglobaldefs.println("};");
231 outglobaldefs.println("");
232 outglobaldefs.println("extern struct global_defs_t * global_defs_p;");
233 outglobaldefs.println("#endif");
234 outglobaldefs.flush();
235 outglobaldefs.close();
239 /* Map flags to integers */
240 /* The runtime keeps track of flags using these integers */
241 it=state.getClassSymbolTable().getDescriptorsIterator();
242 while(it.hasNext()) {
243 ClassDescriptor cn=(ClassDescriptor)it.next();
247 generateTaskStructs(outstructs, outmethodheader);
249 /* Outputs generic task structures if this is a task
251 outputTaskTypes(outtask);
255 // an opportunity for subclasses to do extra
257 preCodeGenInitialization();
260 /* Build the actual methods */
261 outputMethods(outmethod);
264 // opportunity for subclasses to gen extra code
265 additionalCodeGen( outmethodheader,
271 /* Output code for tasks */
272 outputTaskCode(outtaskdefs, outmethod);
274 /* Record maximum number of task parameters */
275 outstructs.println("#define MAXTASKPARAMS "+maxtaskparams);
276 } else if (state.main!=null) {
277 /* Generate main method */
278 outputMainMethod(outmethod);
281 /* Generate information for task with optional parameters */
282 if (state.TASK&&state.OPTIONAL) {
283 generateOptionalArrays(outoptionalarrays, optionalheaders, state.getAnalysisResult(), state.getOptionalTaskDescriptors());
284 outoptionalarrays.close();
287 /* Output structure definitions for repair tool */
288 if (state.structfile!=null) {
289 buildRepairStructs(outrepairstructs);
290 outrepairstructs.close();
294 outmethodheader.println("#endif");
295 outmethodheader.close();
297 outstructs.println("#endif");
302 postCodeGenCleanUp();
307 /* This method goes though the call graph and tag those methods that are
308 * invoked inside static blocks
310 protected void tagMethodInvokedByStaticBlock() {
312 Iterator it_sclasses = this.state.getSClassSymbolTable().getDescriptorsIterator();
313 MethodDescriptor current_md=null;
314 HashSet tovisit=new HashSet();
315 HashSet visited=new HashSet();
317 while(it_sclasses.hasNext()) {
318 ClassDescriptor cd = (ClassDescriptor)it_sclasses.next();
319 MethodDescriptor md = (MethodDescriptor)cd.getMethodTable().get("staticblocks");
325 while(!tovisit.isEmpty()) {
326 current_md=(MethodDescriptor)tovisit.iterator().next();
327 tovisit.remove(current_md);
328 visited.add(current_md);
329 Iterator it_callee = this.callgraph.getCalleeSet(current_md).iterator();
330 while(it_callee.hasNext()) {
331 Descriptor d = (Descriptor)it_callee.next();
332 if(d instanceof MethodDescriptor) {
333 if(!visited.contains(d)) {
334 ((MethodDescriptor)d).setIsInvokedByStatic(true);
340 } // TODO for normal Java version
343 /* This code generates code for each static block and static field
345 protected void outputStaticBlocks(PrintWriter outmethod) {
346 // execute all the static blocks and all the static field initializations
350 /* This code generates code to create a Class object for each class for
353 protected void outputClassObjects(PrintWriter outmethod) {
354 // for each class, initialize its Class object
358 /* This code just generates the main C method for java programs.
359 * The main C method packs up the arguments into a string array
360 * and passes it to the java main method. */
362 protected void outputMainMethod(PrintWriter outmethod) {
363 outmethod.println("int main(int argc, const char *argv[]) {");
364 outmethod.println(" int i;");
366 outputStaticBlocks(outmethod);
367 outputClassObjects(outmethod);
370 additionalCodeAtTopOfMain( outmethod );
374 if (state.DSMRECOVERYSTATS) {
375 outmethod.println("#ifdef RECOVERYSTATS \n");
376 outmethod.println("handle();\n");
377 outmethod.println("#endif\n");
379 outmethod.println("#if defined(TRANSSTATS) || defined(RECOVERYSTATS) \n");
380 outmethod.println("handle();\n");
381 outmethod.println("#endif\n");
385 if (state.THREAD||state.DSM||state.SINGLETM) {
386 outmethod.println("initializethreads();");
389 outmethod.println("if (dstmStartup(argv[1])) {");
390 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
391 outmethod.println(" struct ArrayObject * stringarray=allocate_newarray(NULL, STRINGARRAYTYPE, argc-2);");
393 outmethod.println(" struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc-2);");
396 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
397 outmethod.println(" struct ArrayObject * stringarray=allocate_newarray(NULL, STRINGARRAYTYPE, argc-1);");
399 outmethod.println(" struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc-1);");
403 outmethod.println(" for(i=2;i<argc;i++) {");
405 outmethod.println(" for(i=1;i<argc;i++) {");
406 outmethod.println(" int length=strlen(argv[i]);");
407 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
408 outmethod.println(" struct ___String___ *newstring=NewString(NULL, argv[i], length);");
410 outmethod.println(" struct ___String___ *newstring=NewString(argv[i], length);");
413 outmethod.println(" ((void **)(((char *)& stringarray->___length___)+sizeof(int)))[i-2]=newstring;");
415 outmethod.println(" ((void **)(((char *)& stringarray->___length___)+sizeof(int)))[i-1]=newstring;");
416 outmethod.println(" }");
418 MethodDescriptor md=typeutil.getMain();
419 ClassDescriptor cd=typeutil.getMainClass();
421 outmethod.println(" {");
422 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
423 if (state.DSM||state.SINGLETM) {
424 outmethod.print(" struct "+cd.getSafeSymbol()+locality.getMain().getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
426 outmethod.print(" struct "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
427 outmethod.println("1, NULL,"+"stringarray};");
428 if (state.DSM||state.SINGLETM)
429 outmethod.println(" "+cd.getSafeSymbol()+locality.getMain().getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(& __parameterlist__);");
431 outmethod.println(" "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(& __parameterlist__);");
433 if (state.DSM||state.SINGLETM)
434 outmethod.println(" "+cd.getSafeSymbol()+locality.getMain().getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(stringarray);");
436 outmethod.println(" "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(stringarray);");
438 outmethod.println(" }");
441 outmethod.println("}");
444 if (state.THREAD||state.DSM||state.SINGLETM) {
445 outmethod.println("pthread_mutex_lock(&gclistlock);");
446 outmethod.println("threadcount--;");
447 outmethod.println("pthread_cond_signal(&gccond);");
448 outmethod.println("pthread_mutex_unlock(&gclistlock);");
451 if (state.DSM||state.SINGLETM) {
452 //outmethod.println("#if defined(TRANSSTATS) || defined(RECOVERYSTATS) \n");
453 outmethod.println("#if defined(TRANSSTATS) \n");
454 outmethod.println("printf(\"****** Transaction Stats ******\\n\");");
455 outmethod.println("printf(\"numTransCommit= %d\\n\", numTransCommit);");
456 outmethod.println("printf(\"numTransAbort= %d\\n\", numTransAbort);");
457 outmethod.println("printf(\"nSoftAbort= %d\\n\", nSoftAbort);");
459 outmethod.println("printf(\"nchashSearch= %d\\n\", nchashSearch);");
460 outmethod.println("printf(\"nmhashSearch= %d\\n\", nmhashSearch);");
461 outmethod.println("printf(\"nprehashSearch= %d\\n\", nprehashSearch);");
462 outmethod.println("printf(\"ndirtyCacheObj= %d\\n\", ndirtyCacheObj);");
463 outmethod.println("printf(\"nRemoteReadSend= %d\\n\", nRemoteSend);");
464 outmethod.println("printf(\"bytesSent= %d\\n\", bytesSent);");
465 outmethod.println("printf(\"bytesRecv= %d\\n\", bytesRecv);");
466 outmethod.println("printf(\"totalObjSize= %d\\n\", totalObjSize);");
467 outmethod.println("printf(\"sendRemoteReq= %d\\n\", sendRemoteReq);");
468 outmethod.println("printf(\"getResponse= %d\\n\", getResponse);");
469 } else if (state.SINGLETM) {
470 outmethod.println("printf(\"nSoftAbortAbort= %d\\n\", nSoftAbortAbort);");
471 outmethod.println("printf(\"nSoftAbortCommit= %d\\n\", nSoftAbortCommit);");
472 outmethod.println("#ifdef STMSTATS\n");
473 outmethod.println("for(i=0; i<TOTALNUMCLASSANDARRAY; i++) {\n");
474 outmethod.println(" printf(\"typesCausingAbort[%2d] numaccess= %5d numabort= %3d\\n\", i, typesCausingAbort[i].numaccess, typesCausingAbort[i].numabort);\n");
475 outmethod.println("}\n");
476 outmethod.println("#endif\n");
477 outmethod.println("fflush(stdout);");
479 outmethod.println("#endif\n");
482 if (state.EVENTMONITOR) {
483 outmethod.println("dumpdata();");
486 if (state.THREAD||state.SINGLETM)
487 outmethod.println("pthread_exit(NULL);");
490 additionalCodeAtBottomOfMain( outmethod );
493 outmethod.println("}");
496 /* This method outputs code for each task. */
498 private void outputTaskCode(PrintWriter outtaskdefs, PrintWriter outmethod) {
499 /* Compile task based program */
500 outtaskdefs.println("#include \"task.h\"");
501 outtaskdefs.println("#include \"methodheaders.h\"");
502 Iterator taskit=state.getTaskSymbolTable().getDescriptorsIterator();
503 while(taskit.hasNext()) {
504 TaskDescriptor td=(TaskDescriptor)taskit.next();
505 FlatMethod fm=state.getMethodFlat(td);
506 generateFlatMethod(fm, null, outmethod);
507 generateTaskDescriptor(outtaskdefs, fm, td);
510 //Output task descriptors
511 taskit=state.getTaskSymbolTable().getDescriptorsIterator();
512 outtaskdefs.println("struct taskdescriptor * taskarray[]= {");
514 while(taskit.hasNext()) {
515 TaskDescriptor td=(TaskDescriptor)taskit.next();
519 outtaskdefs.println(",");
520 outtaskdefs.print("&task_"+td.getSafeSymbol());
522 outtaskdefs.println("};");
524 outtaskdefs.println("int numtasks="+state.getTaskSymbolTable().getValueSet().size()+";");
528 /* This method outputs most of the methods.c file. This includes
529 * some standard includes and then an array with the sizes of
530 * objets and array that stores supertype and then the code for
531 * the Java methods.. */
532 protected void outputMethods(PrintWriter outmethod) {
533 outmethod.println("#include \"methodheaders.h\"");
534 outmethod.println("#include \"virtualtable.h\"");
535 outmethod.println("#include \"runtime.h\"");
537 // always include: compiler directives will leave out
538 // instrumentation when option is not set
539 outmethod.println("#include \"coreprof/coreprof.h\"");
542 outmethod.println("#include \"sandboxdefs.c\"");
545 outmethod.println("#include \"addPrefetchEnhance.h\"");
546 outmethod.println("#include \"localobjects.h\"");
548 if (state.FASTCHECK) {
549 outmethod.println("#include \"localobjects.h\"");
551 if(state.MULTICORE) {
553 outmethod.println("#include \"task.h\"");
555 outmethod.println("#include \"multicoreruntime.h\"");
556 outmethod.println("#include \"runtime_arch.h\"");
558 if (state.THREAD||state.DSM||state.SINGLETM) {
559 outmethod.println("#include <thread.h>");
562 outmethod.println("#include \"thread.h\"");
564 if (state.main!=null) {
565 outmethod.println("#include <string.h>");
567 if (state.CONSCHECK) {
568 outmethod.println("#include \"checkers.h\"");
572 additionalIncludesMethodsImplementation( outmethod );
576 // TODO add version for normal Java later
577 outmethod.println("struct global_defs_t * global_defs_p;");
579 //Store the sizes of classes & array elements
580 generateSizeArray(outmethod);
582 //Store table of supertypes
583 generateSuperTypeTable(outmethod);
585 // Store table of classnames
587 // TODO add code for normal Java later
588 generateClassNameTable(outmethod);
591 //Store the layout of classes
592 generateLayoutStructs(outmethod);
595 additionalCodeAtTopMethodsImplementation( outmethod );
598 /* Generate code for methods */
599 if (state.DSM||state.SINGLETM) {
600 for(Iterator<LocalityBinding> lbit=locality.getLocalityBindings().iterator(); lbit.hasNext();) {
601 LocalityBinding lb=lbit.next();
602 MethodDescriptor md=lb.getMethod();
603 FlatMethod fm=state.getMethodFlat(md);
605 if (!md.getModifiers().isNative()) {
606 generateFlatMethod(fm, lb, outmethod);
610 Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();
611 while(classit.hasNext()) {
612 ClassDescriptor cn=(ClassDescriptor)classit.next();
613 Iterator methodit=cn.getMethods();
614 while(methodit.hasNext()) {
615 /* Classify parameters */
616 MethodDescriptor md=(MethodDescriptor)methodit.next();
617 FlatMethod fm=state.getMethodFlat(md);
618 if (!md.getModifiers().isNative()) {
619 generateFlatMethod(fm, null, outmethod);
626 protected void outputStructs(PrintWriter outstructs) {
627 outstructs.println("#ifndef STRUCTDEFS_H");
628 outstructs.println("#define STRUCTDEFS_H");
629 outstructs.println("#include \"classdefs.h\"");
630 outstructs.println("#ifndef INTPTR");
631 outstructs.println("#ifdef BIT64");
632 outstructs.println("#define INTPTR long");
633 outstructs.println("#else");
634 outstructs.println("#define INTPTR int");
635 outstructs.println("#endif");
636 outstructs.println("#endif");
639 additionalIncludesStructsHeader( outstructs );
642 /* Output #defines that the runtime uses to determine type
643 * numbers for various objects it needs */
644 outstructs.println("#define MAXCOUNT "+maxcount);
645 if (state.DSM||state.SINGLETM) {
646 LocalityBinding lbrun=new LocalityBinding(typeutil.getRun(), false);
648 lbrun.setGlobalThis(LocalityAnalysis.GLOBAL);
650 else if (state.SINGLETM) {
651 lbrun.setGlobalThis(LocalityAnalysis.NORMAL);
653 outstructs.println("#define RUNMETHOD "+virtualcalls.getLocalityNumber(lbrun));
657 LocalityBinding lbexecute = new LocalityBinding(typeutil.getExecute(), false);
659 lbexecute.setGlobalThis(LocalityAnalysis.GLOBAL);
660 else if( state.SINGLETM)
661 lbexecute.setGlobalThis(LocalityAnalysis.NORMAL);
662 outstructs.println("#define EXECUTEMETHOD " + virtualcalls.getLocalityNumber(lbexecute));
665 outstructs.println("#define STRINGARRAYTYPE "+
666 (state.getArrayNumber(
667 (new TypeDescriptor(typeutil.getClass(TypeUtil.StringClass))).makeArray(state, true))+state.numClasses()));
669 outstructs.println("#define OBJECTARRAYTYPE "+
670 (state.getArrayNumber(
671 (new TypeDescriptor(typeutil.getClass(TypeUtil.ObjectClass))).makeArray(state, true))+state.numClasses()));
674 outstructs.println("#define STRINGTYPE "+typeutil.getClass(TypeUtil.StringClass).getId());
675 outstructs.println("#define CHARARRAYTYPE "+
676 (state.getArrayNumber((new TypeDescriptor(TypeDescriptor.CHAR)).makeArray(state, true))+state.numClasses()));
678 outstructs.println("#define BYTEARRAYTYPE "+
679 (state.getArrayNumber((new TypeDescriptor(TypeDescriptor.BYTE)).makeArray(state, true))+state.numClasses()));
681 outstructs.println("#define BYTEARRAYARRAYTYPE "+
682 (state.getArrayNumber((new TypeDescriptor(TypeDescriptor.BYTE)).makeArray(state, true).makeArray(state, true))+state.numClasses()));
684 outstructs.println("#define NUMCLASSES "+state.numClasses());
685 int totalClassSize = state.numClasses() + state.numArrays();
686 outstructs.println("#define TOTALNUMCLASSANDARRAY "+ totalClassSize);
688 outstructs.println("#define STARTUPTYPE "+typeutil.getClass(TypeUtil.StartupClass).getId());
689 outstructs.println("#define TAGTYPE "+typeutil.getClass(TypeUtil.TagClass).getId());
690 outstructs.println("#define TAGARRAYTYPE "+
691 (state.getArrayNumber(new TypeDescriptor(typeutil.getClass(TypeUtil.TagClass)).makeArray(state, true))+state.numClasses()));
695 protected void outputClassDeclarations(PrintWriter outclassdefs, PrintWriter outglobaldefs) {
696 if (state.THREAD||state.DSM||state.SINGLETM)
697 outclassdefs.println("#include <pthread.h>");
698 outclassdefs.println("#ifndef INTPTR");
699 outclassdefs.println("#ifdef BIT64");
700 outclassdefs.println("#define INTPTR long");
701 outclassdefs.println("#else");
702 outclassdefs.println("#define INTPTR int");
703 outclassdefs.println("#endif");
704 outclassdefs.println("#endif");
706 outclassdefs.println("#include \"optionalstruct.h\"");
707 outclassdefs.println("struct "+arraytype+";");
708 /* Start by declaring all structs */
709 Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
710 while(it.hasNext()) {
711 ClassDescriptor cn=(ClassDescriptor)it.next();
712 outclassdefs.println("struct "+cn.getSafeSymbol()+";");
715 // TODO add version for normal Java later
716 if((cn.getNumStaticFields() != 0) || (cn.getNumStaticBlocks() != 0)) {
717 // this class has static fields/blocks, need to add a global flag to
718 // indicate if its static fields have been initialized and/or if its
719 // static blocks have been executed
720 outglobaldefs.println(" int "+cn.getSafeSymbol()+"static_block_exe_flag;");
723 // for each class, create a global object
724 outglobaldefs.println(" struct ___Object___ "+cn.getSafeSymbol()+"classobj;");
727 outclassdefs.println("");
728 //Print out definition for array type
729 outclassdefs.println("struct "+arraytype+" {");
730 outclassdefs.println(" int type;");
733 additionalClassObjectFields( outclassdefs );
736 if (state.EVENTMONITOR) {
737 outclassdefs.println(" int objuid;");
740 outclassdefs.println(" pthread_t tid;");
741 outclassdefs.println(" void * lockentry;");
742 outclassdefs.println(" int lockcount;");
745 outclassdefs.println(" int mutex;");
746 outclassdefs.println(" int objlock;");
747 if(state.MULTICOREGC) {
748 outclassdefs.println(" int marked;");
752 outclassdefs.println(" int flag;");
753 if(!state.MULTICORE) {
754 outclassdefs.println(" void * flagptr;");
756 outclassdefs.println(" int version;");
757 outclassdefs.println(" int * lock;"); // lock entry for this obj
758 outclassdefs.println(" int mutex;");
759 outclassdefs.println(" int lockcount;");
760 if(state.MULTICOREGC) {
761 outclassdefs.println(" int marked;");
765 outclassdefs.println(" int numfses;");
766 outclassdefs.println(" int * fses;");
770 printClassStruct(typeutil.getClass(TypeUtil.ObjectClass), outclassdefs, outglobaldefs);
771 printedfieldstbl.clear();
773 if (state.STMARRAY) {
774 outclassdefs.println(" int lowindex;");
775 outclassdefs.println(" int highindex;");
778 outclassdefs.println(" int paddingforarray;");
779 if (state.DUALVIEW) {
780 outclassdefs.println(" int arrayversion;");
783 outclassdefs.println(" int ___length___;");
784 outclassdefs.println("};\n");
787 // TODO add version for normal Java later
788 outclassdefs.println("");
789 //Print out definition for Class type
790 outclassdefs.println("struct Class {");
791 outclassdefs.println(" int type;");
794 additionalClassObjectFields( outclassdefs );
797 if (state.EVENTMONITOR) {
798 outclassdefs.println(" int objuid;");
801 outclassdefs.println(" pthread_t tid;");
802 outclassdefs.println(" void * lockentry;");
803 outclassdefs.println(" int lockcount;");
806 outclassdefs.println(" int mutex;");
807 outclassdefs.println(" int objlock;");
808 if(state.MULTICOREGC) {
809 outclassdefs.println(" int marked;");
813 outclassdefs.println(" int flag;");
814 if(!state.MULTICORE) {
815 outclassdefs.println(" void * flagptr;");
817 outclassdefs.println(" int version;");
818 outclassdefs.println(" int * lock;"); // lock entry for this obj
819 outclassdefs.println(" int mutex;");
820 outclassdefs.println(" int lockcount;");
821 if(state.MULTICOREGC) {
822 outclassdefs.println(" int marked;");
826 outclassdefs.println(" int numfses;");
827 outclassdefs.println(" int * fses;");
830 printClassStruct(typeutil.getClass(TypeUtil.ObjectClass), outclassdefs, outglobaldefs);
831 printedfieldstbl.clear();
832 outclassdefs.println("};\n");
835 outclassdefs.println("");
836 outclassdefs.println("extern int classsize[];");
837 outclassdefs.println("extern int hasflags[];");
838 outclassdefs.println("extern unsigned INTPTR * pointerarray[];");
839 outclassdefs.println("extern int supertypes[];");
841 // TODO add version for normal Java later
842 outclassdefs.println("extern char * classname[];");
844 outclassdefs.println("");
847 /** Prints out definitions for generic task structures */
849 private void outputTaskTypes(PrintWriter outtask) {
850 outtask.println("#ifndef _TASK_H");
851 outtask.println("#define _TASK_H");
852 outtask.println("struct parameterdescriptor {");
853 outtask.println("int type;");
854 outtask.println("int numberterms;");
855 outtask.println("int *intarray;");
856 outtask.println("void * queue;");
857 outtask.println("int numbertags;");
858 outtask.println("int *tagarray;");
859 outtask.println("};");
861 outtask.println("struct taskdescriptor {");
862 outtask.println("void * taskptr;");
863 outtask.println("int numParameters;");
864 outtask.println(" int numTotal;");
865 outtask.println("struct parameterdescriptor **descriptorarray;");
866 outtask.println("char * name;");
867 outtask.println("};");
868 outtask.println("extern struct taskdescriptor * taskarray[];");
869 outtask.println("extern numtasks;");
870 outtask.println("#endif");
874 private void buildRepairStructs(PrintWriter outrepairstructs) {
875 Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();
876 while(classit.hasNext()) {
877 ClassDescriptor cn=(ClassDescriptor)classit.next();
878 outrepairstructs.println("structure "+cn.getSymbol()+" {");
879 outrepairstructs.println(" int __type__;");
881 outrepairstructs.println(" int __flag__;");
882 if(!state.MULTICORE) {
883 outrepairstructs.println(" int __flagptr__;");
886 printRepairStruct(cn, outrepairstructs);
887 outrepairstructs.println("}\n");
890 for(int i=0; i<state.numArrays(); i++) {
891 TypeDescriptor tdarray=arraytable[i];
892 TypeDescriptor tdelement=tdarray.dereference();
893 outrepairstructs.println("structure "+arraytype+"_"+state.getArrayNumber(tdarray)+" {");
894 outrepairstructs.println(" int __type__;");
895 printRepairStruct(typeutil.getClass(TypeUtil.ObjectClass), outrepairstructs);
896 outrepairstructs.println(" int length;");
898 // Need to add support to repair tool for this
899 if (tdelement.isClass()||tdelement.isArray())
900 outrepairstructs.println(" "+tdelement.getRepairSymbol()+" * elem[this.length];");
902 outrepairstructs.println(" "+tdelement.getRepairSymbol()+" elem[this.length];");
904 outrepairstructs.println("}\n");
908 private void printRepairStruct(ClassDescriptor cn, PrintWriter output) {
909 ClassDescriptor sp=cn.getSuperDesc();
911 printRepairStruct(sp, output);
913 Vector fields=(Vector)fieldorder.get(cn);
915 for(int i=0; i<fields.size(); i++) {
916 FieldDescriptor fd=(FieldDescriptor)fields.get(i);
917 if (fd.getType().isArray()) {
918 output.println(" "+arraytype+"_"+ state.getArrayNumber(fd.getType()) +" * "+fd.getSymbol()+";");
919 } else if (fd.getType().isClass())
920 output.println(" "+fd.getType().getRepairSymbol()+" * "+fd.getSymbol()+";");
921 else if (fd.getType().isFloat())
922 output.println(" int "+fd.getSymbol()+"; /* really float */");
924 output.println(" "+fd.getType().getRepairSymbol()+" "+fd.getSymbol()+";");
928 /** This method outputs TaskDescriptor information */
929 private void generateTaskDescriptor(PrintWriter output, FlatMethod fm, TaskDescriptor task) {
930 for (int i=0; i<task.numParameters(); i++) {
931 VarDescriptor param_var=task.getParameter(i);
932 TypeDescriptor param_type=task.getParamType(i);
933 FlagExpressionNode param_flag=task.getFlag(param_var);
934 TagExpressionList param_tag=task.getTag(param_var);
937 if (param_flag==null) {
938 output.println("int parameterdnf_"+i+"_"+task.getSafeSymbol()+"[]={");
939 output.println("0x0, 0x0 };");
942 DNFFlag dflag=param_flag.getDNF();
943 dnfterms=dflag.size();
945 Hashtable flags=(Hashtable)flagorder.get(param_type.getClassDesc());
946 output.println("int parameterdnf_"+i+"_"+task.getSafeSymbol()+"[]={");
947 for(int j=0; j<dflag.size(); j++) {
950 Vector term=dflag.get(j);
953 for(int k=0; k<term.size(); k++) {
954 DNFFlagAtom dfa=(DNFFlagAtom)term.get(k);
955 FlagDescriptor fd=dfa.getFlag();
956 boolean negated=dfa.getNegated();
957 int flagid=1<<((Integer)flags.get(fd)).intValue();
962 output.print("0x"+Integer.toHexString(andmask)+", 0x"+Integer.toHexString(checkmask));
964 output.println("};");
967 output.println("int parametertag_"+i+"_"+task.getSafeSymbol()+"[]={");
968 //BUG...added next line to fix, test with any task program
970 for(int j=0; j<param_tag.numTags(); j++) {
973 /* for each tag we need */
974 /* which slot it is */
975 /* what type it is */
976 TagVarDescriptor tvd=(TagVarDescriptor)task.getParameterTable().get(param_tag.getName(j));
977 TempDescriptor tmp=param_tag.getTemp(j);
978 int slot=fm.getTagInt(tmp);
979 output.println(slot+", "+state.getTagId(tvd.getTag()));
981 output.println("};");
983 output.println("struct parameterdescriptor parameter_"+i+"_"+task.getSafeSymbol()+"={");
984 output.println("/* type */"+param_type.getClassDesc().getId()+",");
985 output.println("/* number of DNF terms */"+dnfterms+",");
986 output.println("parameterdnf_"+i+"_"+task.getSafeSymbol()+",");
987 output.println("0,");
988 //BUG, added next line to fix and else statement...test
989 //with any task program
991 output.println("/* number of tags */"+param_tag.numTags()+",");
993 output.println("/* number of tags */ 0,");
994 output.println("parametertag_"+i+"_"+task.getSafeSymbol());
995 output.println("};");
999 output.println("struct parameterdescriptor * parameterdescriptors_"+task.getSafeSymbol()+"[] = {");
1000 for (int i=0; i<task.numParameters(); i++) {
1002 output.println(",");
1003 output.print("¶meter_"+i+"_"+task.getSafeSymbol());
1005 output.println("};");
1007 output.println("struct taskdescriptor task_"+task.getSafeSymbol()+"={");
1008 output.println("&"+task.getSafeSymbol()+",");
1009 output.println("/* number of parameters */" +task.numParameters() + ",");
1010 int numtotal=task.numParameters()+fm.numTags();
1011 output.println("/* number total parameters */" +numtotal + ",");
1012 output.println("parameterdescriptors_"+task.getSafeSymbol()+",");
1013 output.println("\""+task.getSymbol()+"\"");
1014 output.println("};");
1018 /** The buildVirtualTables method outputs the virtual dispatch
1019 * tables for methods. */
1021 protected void buildVirtualTables(PrintWriter outvirtual) {
1022 Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();
1023 while(classit.hasNext()) {
1024 ClassDescriptor cd=(ClassDescriptor)classit.next();
1025 if (virtualcalls.getMethodCount(cd)>maxcount)
1026 maxcount=virtualcalls.getMethodCount(cd);
1028 MethodDescriptor[][] virtualtable=null;
1029 LocalityBinding[][] lbvirtualtable=null;
1030 if (state.DSM||state.SINGLETM)
1031 lbvirtualtable=new LocalityBinding[state.numClasses()+state.numArrays()][maxcount];
1033 virtualtable=new MethodDescriptor[state.numClasses()+state.numArrays()][maxcount];
1035 /* Fill in virtual table */
1036 classit=state.getClassSymbolTable().getDescriptorsIterator();
1037 while(classit.hasNext()) {
1038 ClassDescriptor cd=(ClassDescriptor)classit.next();
1039 if(cd.isInterface()) {
1042 if (state.DSM||state.SINGLETM)
1043 fillinRow(cd, lbvirtualtable, cd.getId());
1045 fillinRow(cd, virtualtable, cd.getId());
1048 ClassDescriptor objectcd=typeutil.getClass(TypeUtil.ObjectClass);
1049 Iterator arrayit=state.getArrayIterator();
1050 while(arrayit.hasNext()) {
1051 TypeDescriptor td=(TypeDescriptor)arrayit.next();
1052 int id=state.getArrayNumber(td);
1053 if (state.DSM||state.SINGLETM)
1054 fillinRow(objectcd, lbvirtualtable, id+state.numClasses());
1056 fillinRow(objectcd, virtualtable, id+state.numClasses());
1059 outvirtual.print("void * virtualtable[]={");
1060 boolean needcomma=false;
1061 for(int i=0; i<state.numClasses()+state.numArrays(); i++) {
1062 for(int j=0; j<maxcount; j++) {
1064 outvirtual.print(", ");
1065 if ((state.DSM||state.SINGLETM)&&lbvirtualtable[i][j]!=null) {
1066 LocalityBinding lb=lbvirtualtable[i][j];
1067 MethodDescriptor md=lb.getMethod();
1068 outvirtual.print("& "+md.getClassDesc().getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
1069 } else if (!(state.DSM||state.SINGLETM)&&virtualtable[i][j]!=null) {
1070 MethodDescriptor md=virtualtable[i][j];
1071 outvirtual.print("& "+md.getClassDesc().getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
1073 outvirtual.print("0");
1077 outvirtual.println("");
1079 outvirtual.println("};");
1083 private void fillinRow(ClassDescriptor cd, MethodDescriptor[][] virtualtable, int rownum) {
1084 /* Get inherited methods */
1085 if (cd.getSuperDesc()!=null)
1086 fillinRow(cd.getSuperDesc(), virtualtable, rownum);
1088 // TODO add version for normal Java later
1089 Iterator it_sifs = cd.getSuperInterfaces();
1090 while(it_sifs.hasNext()) {
1091 ClassDescriptor superif = (ClassDescriptor)it_sifs.next();
1092 fillinRow(superif, virtualtable, rownum);
1095 /* Override them with our methods */
1096 for(Iterator it=cd.getMethods(); it.hasNext();) {
1097 MethodDescriptor md=(MethodDescriptor)it.next();
1098 if (md.isStatic()||md.getReturnType()==null)
1100 int methodnum=virtualcalls.getMethodNumber(md);
1101 virtualtable[rownum][methodnum]=md;
1105 private void fillinRow(ClassDescriptor cd, LocalityBinding[][] virtualtable, int rownum) {
1106 /* Get inherited methods */
1107 if (cd.getSuperDesc()!=null)
1108 fillinRow(cd.getSuperDesc(), virtualtable, rownum);
1109 /* Override them with our methods */
1110 if (locality.getClassBindings(cd)!=null)
1111 for(Iterator<LocalityBinding> lbit=locality.getClassBindings(cd).iterator(); lbit.hasNext();) {
1112 LocalityBinding lb=lbit.next();
1113 MethodDescriptor md=lb.getMethod();
1114 //Is the method static or a constructor
1115 if (md.isStatic()||md.getReturnType()==null)
1117 int methodnum=virtualcalls.getLocalityNumber(lb);
1118 virtualtable[rownum][methodnum]=lb;
1122 /** Generate array that contains the sizes of class objects. The
1123 * object allocation functions in the runtime use this
1126 private void generateSizeArray(PrintWriter outclassdefs) {
1127 outclassdefs.print("extern struct prefetchCountStats * evalPrefetch;\n");
1128 outclassdefs.print("#ifdef TRANSSTATS \n");
1129 outclassdefs.print("extern int numTransAbort;\n");
1130 outclassdefs.print("extern int numTransCommit;\n");
1131 outclassdefs.print("extern int nSoftAbort;\n");
1133 outclassdefs.print("extern int nchashSearch;\n");
1134 outclassdefs.print("extern int nmhashSearch;\n");
1135 outclassdefs.print("extern int nprehashSearch;\n");
1136 outclassdefs.print("extern int ndirtyCacheObj;\n");
1137 outclassdefs.print("extern int nRemoteSend;\n");
1138 outclassdefs.print("extern int sendRemoteReq;\n");
1139 outclassdefs.print("extern int getResponse;\n");
1140 outclassdefs.print("extern int bytesSent;\n");
1141 outclassdefs.print("extern int bytesRecv;\n");
1142 outclassdefs.print("extern int totalObjSize;\n");
1143 outclassdefs.print("extern void handle();\n");
1144 } else if (state.SINGLETM) {
1145 outclassdefs.println("extern int nSoftAbortAbort;");
1146 outclassdefs.println("extern int nSoftAbortCommit;");
1147 outclassdefs.println("#ifdef STMSTATS\n");
1148 outclassdefs.println("extern objtypestat_t typesCausingAbort[];");
1149 outclassdefs.println("#endif\n");
1151 outclassdefs.print("#endif\n");
1153 outclassdefs.print("int numprefetchsites = " + pa.prefetchsiteid + ";\n");
1156 Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
1157 cdarray=new ClassDescriptor[state.numClasses()];
1159 while(it.hasNext()) {
1160 ClassDescriptor cd=(ClassDescriptor)it.next();
1161 if(!cd.isInterface()) {
1162 cdarray[cd.getId()]=cd;
1166 arraytable=new TypeDescriptor[state.numArrays()];
1168 Iterator arrayit=state.getArrayIterator();
1169 while(arrayit.hasNext()) {
1170 TypeDescriptor td=(TypeDescriptor)arrayit.next();
1171 int id=state.getArrayNumber(td);
1177 /* Print out types */
1178 outclassdefs.println("/* ");
1179 for(int i=0; i<state.numClasses(); i++) {
1180 ClassDescriptor cd=cdarray[i];
1182 outclassdefs.println("NULL " + i);
1184 outclassdefs.println(cd +" "+i);
1188 for(int i=0; i<state.numArrays(); i++) {
1189 TypeDescriptor arraytd=arraytable[i];
1190 outclassdefs.println(arraytd.toPrettyString() +" "+(i+state.numClasses()));
1193 outclassdefs.println("*/");
1196 outclassdefs.print("int classsize[]={");
1198 boolean needcomma=false;
1199 for(int i=0; i<state.numClasses(); i++) {
1201 outclassdefs.print(", ");
1203 outclassdefs.print("sizeof(struct "+cdarray[i].getSafeSymbol()+")");
1205 outclassdefs.print("0");
1211 for(int i=0; i<state.numArrays(); i++) {
1213 outclassdefs.print(", ");
1214 TypeDescriptor tdelement=arraytable[i].dereference();
1215 if (tdelement.isArray()||tdelement.isClass())
1216 outclassdefs.print("sizeof(void *)");
1218 outclassdefs.print("sizeof("+tdelement.getSafeSymbol()+")");
1222 outclassdefs.println("};");
1224 ClassDescriptor objectclass=typeutil.getClass(TypeUtil.ObjectClass);
1226 outclassdefs.print("int typearray[]={");
1227 for(int i=0; i<state.numClasses(); i++) {
1228 ClassDescriptor cd=cdarray[i];
1229 ClassDescriptor supercd=i>0?cd.getSuperDesc():null;
1231 outclassdefs.print(", ");
1233 outclassdefs.print("-1");
1235 outclassdefs.print(supercd.getId());
1239 for(int i=0; i<state.numArrays(); i++) {
1240 TypeDescriptor arraytd=arraytable[i];
1241 ClassDescriptor arraycd=arraytd.getClassDesc();
1242 if (arraycd==null) {
1244 outclassdefs.print(", ");
1245 outclassdefs.print(objectclass.getId());
1249 ClassDescriptor cd=arraycd.getSuperDesc();
1252 TypeDescriptor supertd=new TypeDescriptor(cd);
1253 supertd.setArrayCount(arraytd.getArrayCount());
1254 type=state.getArrayNumber(supertd);
1256 type+=state.numClasses();
1259 cd=cd.getSuperDesc();
1262 outclassdefs.print(", ");
1263 outclassdefs.print(type);
1267 outclassdefs.println("};");
1272 outclassdefs.print("int typearray2[]={");
1273 for(int i=0; i<state.numArrays(); i++) {
1274 TypeDescriptor arraytd=arraytable[i];
1275 ClassDescriptor arraycd=arraytd.getClassDesc();
1276 if (arraycd==null) {
1278 outclassdefs.print(", ");
1279 outclassdefs.print("-1");
1283 ClassDescriptor cd=arraycd.getSuperDesc();
1284 int level=arraytd.getArrayCount()-1;
1286 for(; level>0; level--) {
1287 TypeDescriptor supertd=new TypeDescriptor(objectclass);
1288 supertd.setArrayCount(level);
1289 type=state.getArrayNumber(supertd);
1291 type+=state.numClasses();
1296 outclassdefs.print(", ");
1297 outclassdefs.print(type);
1301 outclassdefs.println("};");
1304 /** Constructs params and temp objects for each method or task.
1305 * These objects tell the compiler which temps need to be
1308 protected void generateTempStructs(FlatMethod fm, LocalityBinding lb) {
1309 MethodDescriptor md=fm.getMethod();
1310 TaskDescriptor task=fm.getTask();
1311 Set<TempDescriptor> saveset=lb!=null ? locality.getTempSet(lb) : null;
1312 ParamsObject objectparams=md!=null ? new ParamsObject(md,tag++) : new ParamsObject(task, tag++);
1314 paramstable.put(lb, objectparams);
1315 backuptable.put(lb, new Hashtable<TempDescriptor, TempDescriptor>());
1316 } else if (md!=null)
1317 paramstable.put(md, objectparams);
1319 paramstable.put(task, objectparams);
1321 for(int i=0; i<fm.numParameters(); i++) {
1322 TempDescriptor temp=fm.getParameter(i);
1323 TypeDescriptor type=temp.getType();
1324 if (type.isPtr()&&((GENERATEPRECISEGC) || (this.state.MULTICOREGC)))
1325 objectparams.addPtr(temp);
1327 objectparams.addPrim(temp);
1328 if(lb!=null&&saveset.contains(temp)) {
1329 backuptable.get(lb).put(temp, temp.createNew());
1333 for(int i=0; i<fm.numTags(); i++) {
1334 TempDescriptor temp=fm.getTag(i);
1335 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC))
1336 objectparams.addPtr(temp);
1338 objectparams.addPrim(temp);
1341 TempObject objecttemps=md!=null ? new TempObject(objectparams,md,tag++) : new TempObject(objectparams, task, tag++);
1343 tempstable.put(lb, objecttemps);
1345 tempstable.put(md, objecttemps);
1347 tempstable.put(task, objecttemps);
1349 for(Iterator nodeit=fm.getNodeSet().iterator(); nodeit.hasNext();) {
1350 FlatNode fn=(FlatNode)nodeit.next();
1351 TempDescriptor[] writes=fn.writesTemps();
1352 for(int i=0; i<writes.length; i++) {
1353 TempDescriptor temp=writes[i];
1354 TypeDescriptor type=temp.getType();
1355 if (type.isPtr()&&((GENERATEPRECISEGC) || (this.state.MULTICOREGC)))
1356 objecttemps.addPtr(temp);
1358 objecttemps.addPrim(temp);
1359 if(lb!=null&&saveset.contains(temp)&&
1360 !backuptable.get(lb).containsKey(temp))
1361 backuptable.get(lb).put(temp, temp.createNew());
1365 /* Create backup temps */
1367 for(Iterator<TempDescriptor> tmpit=backuptable.get(lb).values().iterator(); tmpit.hasNext();) {
1368 TempDescriptor tmp=tmpit.next();
1369 TypeDescriptor type=tmp.getType();
1370 if (type.isPtr()&&((GENERATEPRECISEGC) || (this.state.MULTICOREGC)))
1371 objecttemps.addPtr(tmp);
1373 objecttemps.addPrim(tmp);
1375 /* Create temp to hold revert table */
1376 if (state.DSM&&(lb.getHasAtomic()||lb.isAtomic())) {
1377 TempDescriptor reverttmp=new TempDescriptor("revertlist", typeutil.getClass(TypeUtil.ObjectClass));
1378 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC))
1379 objecttemps.addPtr(reverttmp);
1381 objecttemps.addPrim(reverttmp);
1382 reverttable.put(lb, reverttmp);
1387 /** This method outputs the following information about classes
1389 * (1) For classes, what are the locations of pointers.
1390 * (2) For arrays, does the array contain pointers or primitives.
1391 * (3) For classes, does the class contain flags.
1394 private void generateLayoutStructs(PrintWriter output) {
1395 Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
1396 while(it.hasNext()) {
1397 ClassDescriptor cn=(ClassDescriptor)it.next();
1398 output.println("unsigned INTPTR "+cn.getSafeSymbol()+"_pointers[]={");
1399 Iterator allit=cn.getFieldTable().getAllDescriptorsIterator();
1401 while(allit.hasNext()) {
1402 FieldDescriptor fd=(FieldDescriptor)allit.next();
1403 TypeDescriptor type=fd.getType();
1404 if (state.DSM&&fd.isGlobal()) //Don't GC the global objects for now
1409 output.print(count);
1410 allit=cn.getFieldTable().getAllDescriptorsIterator();
1411 while(allit.hasNext()) {
1412 FieldDescriptor fd=(FieldDescriptor)allit.next();
1413 TypeDescriptor type=fd.getType();
1414 if (state.DSM&&fd.isGlobal()) //Don't GC the global objects for now
1417 output.println(",");
1418 output.print("((unsigned INTPTR)&(((struct "+cn.getSafeSymbol() +" *)0)->"+fd.getSafeSymbol()+"))");
1421 output.println("};");
1423 output.println("unsigned INTPTR * pointerarray[]={");
1424 boolean needcomma=false;
1425 for(int i=0; i<state.numClasses(); i++) {
1426 ClassDescriptor cn=cdarray[i];
1428 output.println(",");
1431 output.print(cn.getSafeSymbol()+"_pointers");
1433 output.print("NULL");
1437 for(int i=0; i<state.numArrays(); i++) {
1439 output.println(", ");
1440 TypeDescriptor tdelement=arraytable[i].dereference();
1441 if (tdelement.isArray()||tdelement.isClass())
1442 output.print("((unsigned INTPTR *)1)");
1448 output.println("};");
1450 output.println("int hasflags[]={");
1451 for(int i=0; i<state.numClasses(); i++) {
1452 ClassDescriptor cn=cdarray[i];
1454 output.println(", ");
1456 if ((cn != null) && (cn.hasFlags()))
1461 output.println("};");
1464 /** Print out table to give us supertypes */
1465 private void generateSuperTypeTable(PrintWriter output) {
1466 output.println("int supertypes[]={");
1467 boolean needcomma=false;
1468 for(int i=0; i<state.numClasses(); i++) {
1469 ClassDescriptor cn=cdarray[i];
1471 output.println(",");
1473 if ((cn != null) && (cn.getSuperDesc()!=null)) {
1474 ClassDescriptor cdsuper=cn.getSuperDesc();
1475 output.print(cdsuper.getId());
1479 output.println("};");
1482 /** Print out table to give us classnames */
1483 /*private void generateClassNameTable(PrintWriter output) {
1484 output.println("char * classname[]={");
1485 boolean needcomma=false;
1486 for(int i=0; i<state.numClasses(); i++) {
1487 ClassDescriptor cn=cdarray[i];
1489 output.println(",");
1491 if ((cn != null) && (cn.getSuperDesc()!=null)) {
1492 output.print("\"" + cn.getSymbol() + "\"");
1494 output.print("\"\"");
1496 output.println("};");
1499 /** Force consistent field ordering between inherited classes. */
1501 private void printClassStruct(ClassDescriptor cn, PrintWriter classdefout, PrintWriter globaldefout) {
1503 ClassDescriptor sp=cn.getSuperDesc();
1505 printClassStruct(sp, classdefout, /*globaldefout*/null);
1507 // TODO: what about here are multiple inherited fields with the same name?
1508 SymbolTable sitbl = cn.getSuperInterfaceTable();
1509 Iterator it_sifs = sitbl.getDescriptorsIterator();
1511 while(it_sifs.hasNext()) {
1512 ClassDescriptor si = (ClassDescriptor)it_sifs.next();
1513 printClassStruct(si, classdefout, /*globaldefout*/null);
1517 Vector shadow_fields = null;
1519 if (!fieldorder.containsKey(cn)) {
1520 Vector fields=new Vector();
1521 fieldorder.put(cn,fields);
1522 shadow_fields = new Vector();
1523 cd2shadowfields.put(cn, shadow_fields);
1525 Vector fieldvec=cn.getFieldVec();
1526 for(int i=0;i<fieldvec.size();i++) {
1527 FieldDescriptor fd=(FieldDescriptor)fieldvec.get(i);
1529 if((sp != null) && sp.getFieldTable().contains(fd.getSymbol())) {
1530 shadow_fields.add(fd);
1532 it_sifs = sitbl.getDescriptorsIterator();
1533 boolean hasprinted = false;
1534 while(it_sifs.hasNext()) {
1535 ClassDescriptor si = (ClassDescriptor)it_sifs.next();
1536 if(si.getFieldTable().contains(fd.getSymbol())) {
1542 // this field has been defined in the super class
1543 shadow_fields.add(fd);
1549 if ((sp==null) || (!sp.getFieldTable().contains(fd.getSymbol())))
1554 Vector fields=(Vector)fieldorder.get(cn);
1555 shadow_fields=cd2shadowfields.get(cn);
1557 for(int i=0; i<fields.size(); i++) {
1558 FieldDescriptor fd=(FieldDescriptor)fields.get(i);
1559 if(printedfieldstbl.containsKey(fd.getSymbol())) {
1560 printedfieldstbl.put(fd.getSymbol(), cn);
1563 printedfieldstbl.put(fd.getSymbol(), cn);
1565 if (state.MGC && fd.getType().isClass()
1566 && fd.getType().getClassDesc().isEnum()) {
1567 classdefout.println(" int " + fd.getSafeSymbol() + ";");
1568 } else if (fd.getType().isClass()||fd.getType().isArray()) {
1569 if ((state.MGC) && (fd.isStatic())) {
1570 // TODO add version for normal Java later
1572 if(globaldefout != null) {
1573 if(fd.isVolatile()) {
1574 globaldefout.println(" volatile struct "+fd.getType().getSafeSymbol()+ " * "+cn.getSafeSymbol()+fd.getSafeSymbol()+";");
1576 globaldefout.println(" struct "+fd.getType().getSafeSymbol()+ " * "+cn.getSafeSymbol()+fd.getSafeSymbol()+";");
1579 classdefout.println(" struct "+fd.getType().getSafeSymbol()+" ** "+fd.getSafeSymbol()+";");
1580 } else if ((state.MGC) && (fd.isVolatile())) {
1581 // TODO add version for normal Java later
1583 if(globaldefout != null) {
1584 globaldefout.println(" volatile struct "+fd.getType().getSafeSymbol()+ " * "+cn.getSafeSymbol()+fd.getSafeSymbol()+";");
1586 classdefout.println(" struct"+fd.getType().getSafeSymbol()+" ** "+fd.getSafeSymbol()+";");
1588 classdefout.println(" struct "+fd.getType().getSafeSymbol()+" * "+fd.getSafeSymbol()+";");
1590 } else if ((state.MGC) && (fd.isStatic())) {
1591 // TODO add version for normal Java later
1593 if(globaldefout != null) {
1594 if(fd.isVolatile()) {
1595 globaldefout.println(" volatile "+fd.getType().getSafeSymbol()+ " "+cn.getSafeSymbol()+fd.getSafeSymbol()+";");
1597 globaldefout.println(" "+fd.getType().getSafeSymbol()+ " "+cn.getSafeSymbol()+fd.getSafeSymbol()+";");
1600 classdefout.println(" "+fd.getType().getSafeSymbol()+" * "+fd.getSafeSymbol()+";");
1601 } else if ((state.MGC) && (fd.isVolatile())) {
1602 // TODO add version for normal Java later
1604 if(globaldefout != null) {
1605 globaldefout.println(" volatile "+fd.getType().getSafeSymbol()+ " "+cn.getSafeSymbol()+fd.getSafeSymbol()+";");
1607 classdefout.println(" "+fd.getType().getSafeSymbol()+" * "+fd.getSafeSymbol()+";");
1609 classdefout.println(" "+fd.getType().getSafeSymbol()+" "+fd.getSafeSymbol()+";");
1612 // check the shadow fields, for those static shadow fields, need to add a
1613 // corresponding field in the global_defs_p structure
1614 for(int i=0; i<shadow_fields.size(); i++) {
1615 FieldDescriptor fd=(FieldDescriptor)shadow_fields.get(i);
1616 if ((state.MGC) && (fd.isStatic()) && (globaldefout != null)) {
1617 if (fd.getType().isClass()||fd.getType().isArray()) {
1618 // TODO add version for normal Java later
1620 if(fd.isVolatile()) {
1621 globaldefout.println(" volatile struct "+fd.getType().getSafeSymbol()+ " * "+cn.getSafeSymbol()+fd.getSafeSymbol()+";");
1623 globaldefout.println(" struct "+fd.getType().getSafeSymbol()+ " * "+cn.getSafeSymbol()+fd.getSafeSymbol()+";");
1626 // TODO add version for normal Java later
1628 if(fd.isVolatile()) {
1629 globaldefout.println(" volatile "+fd.getType().getSafeSymbol()+ " "+cn.getSafeSymbol()+fd.getSafeSymbol()+";");
1631 globaldefout.println(" "+fd.getType().getSafeSymbol()+ " "+cn.getSafeSymbol()+fd.getSafeSymbol()+";");
1634 } else if ((state.MGC) && (fd.isVolatile()) && (globaldefout != null)) {
1635 // TODO add version for normal Java later
1637 if (fd.getType().isClass()||fd.getType().isArray()) {
1638 // TODO add version for normal Java later
1640 globaldefout.println(" volatile struct "+fd.getType().getSafeSymbol()+ " * "+cn.getSafeSymbol()+fd.getSafeSymbol()+";");
1642 // TODO add version for normal Java later
1644 globaldefout.println(" volatile "+fd.getType().getSafeSymbol()+ " "+cn.getSafeSymbol()+fd.getSafeSymbol()+";");
1651 /* Map flags to integers consistently between inherited
1654 protected void mapFlags(ClassDescriptor cn) {
1655 ClassDescriptor sp=cn.getSuperDesc();
1659 if (!flagorder.containsKey(cn)) {
1660 Hashtable flags=new Hashtable();
1661 flagorder.put(cn,flags);
1663 Hashtable superflags=(Hashtable)flagorder.get(sp);
1664 Iterator superflagit=superflags.keySet().iterator();
1665 while(superflagit.hasNext()) {
1666 FlagDescriptor fd=(FlagDescriptor)superflagit.next();
1667 Integer number=(Integer)superflags.get(fd);
1668 flags.put(fd, number);
1669 if ((number.intValue()+1)>max)
1670 max=number.intValue()+1;
1674 Iterator flagit=cn.getFlags();
1675 while(flagit.hasNext()) {
1676 FlagDescriptor fd=(FlagDescriptor)flagit.next();
1677 if (sp==null||!sp.getFlagTable().contains(fd.getSymbol()))
1678 flags.put(fd, new Integer(max++));
1684 /** This function outputs (1) structures that parameters are
1685 * passed in (when PRECISE GC is enabled) and (2) function
1686 * prototypes for the methods */
1688 protected void generateCallStructs(ClassDescriptor cn, PrintWriter classdefout, PrintWriter output, PrintWriter headersout, PrintWriter globaldefout) {
1689 /* Output class structure */
1690 classdefout.println("struct "+cn.getSafeSymbol()+" {");
1691 classdefout.println(" int type;");
1694 additionalClassObjectFields( classdefout );
1697 if (state.EVENTMONITOR) {
1698 classdefout.println(" int objuid;");
1701 classdefout.println(" pthread_t tid;");
1702 classdefout.println(" void * lockentry;");
1703 classdefout.println(" int lockcount;");
1706 classdefout.println(" int mutex;");
1707 classdefout.println(" int objlock;");
1708 if(state.MULTICOREGC) {
1709 classdefout.println(" int marked;");
1713 classdefout.println(" int flag;");
1714 if((!state.MULTICORE) || (cn.getSymbol().equals("TagDescriptor"))) {
1715 classdefout.println(" void * flagptr;");
1716 } else if (state.MULTICORE) {
1717 classdefout.println(" int version;");
1718 classdefout.println(" int * lock;"); // lock entry for this obj
1719 classdefout.println(" int mutex;");
1720 classdefout.println(" int lockcount;");
1721 if(state.MULTICOREGC) {
1722 classdefout.println(" int marked;");
1725 if (state.OPTIONAL) {
1726 classdefout.println(" int numfses;");
1727 classdefout.println(" int * fses;");
1730 printClassStruct(cn, classdefout, globaldefout);
1731 cd2fieldstbl.put(cn, printedfieldstbl);
1732 printedfieldstbl = new Hashtable<String, ClassDescriptor>();
1733 classdefout.println("};\n");
1735 if (state.DSM||state.SINGLETM) {
1736 /* Cycle through LocalityBindings */
1737 HashSet<MethodDescriptor> nativemethods=new HashSet<MethodDescriptor>();
1738 Set<LocalityBinding> lbset=locality.getClassBindings(cn);
1740 for(Iterator<LocalityBinding> lbit=lbset.iterator(); lbit.hasNext();) {
1741 LocalityBinding lb=lbit.next();
1742 MethodDescriptor md=lb.getMethod();
1743 if (md.getModifiers().isNative()) {
1744 //make sure we only print a native method once
1745 if (nativemethods.contains(md)) {
1746 FlatMethod fm=state.getMethodFlat(md);
1747 generateTempStructs(fm, lb);
1750 nativemethods.add(md);
1752 generateMethod(cn, md, lb, headersout, output);
1755 for(Iterator methodit=cn.getMethods(); methodit.hasNext();) {
1756 MethodDescriptor md=(MethodDescriptor)methodit.next();
1757 if (md.getModifiers().isNative()&&!nativemethods.contains(md)) {
1758 //Need to build param structure for library code
1759 FlatMethod fm=state.getMethodFlat(md);
1760 generateTempStructs(fm, null);
1761 generateMethodParam(cn, md, null, output);
1766 for(Iterator methodit=cn.getMethods(); methodit.hasNext();) {
1767 MethodDescriptor md=(MethodDescriptor)methodit.next();
1768 generateMethod(cn, md, null, headersout, output);
1772 private void generateMethodParam(ClassDescriptor cn, MethodDescriptor md, LocalityBinding lb, PrintWriter output) {
1773 /* Output parameter structure */
1774 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1775 ParamsObject objectparams=(ParamsObject) paramstable.get(lb!=null ? lb : md);
1776 if ((state.DSM||state.SINGLETM)&&lb!=null)
1777 output.println("struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params {");
1779 output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params {");
1780 output.println(" int size;");
1781 output.println(" void * next;");
1782 for(int i=0; i<objectparams.numPointers(); i++) {
1783 TempDescriptor temp=objectparams.getPointer(i);
1784 if(state.MGC && temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
1785 output.println(" int " + temp.getSafeSymbol() + ";");
1787 output.println(" struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
1790 output.println("};\n");
1794 private void generateMethod(ClassDescriptor cn, MethodDescriptor md, LocalityBinding lb, PrintWriter headersout, PrintWriter output) {
1795 FlatMethod fm=state.getMethodFlat(md);
1796 generateTempStructs(fm, lb);
1798 ParamsObject objectparams=(ParamsObject) paramstable.get(lb!=null ? lb : md);
1799 TempObject objecttemps=(TempObject) tempstable.get(lb!=null ? lb : md);
1801 generateMethodParam(cn, md, lb, output);
1803 /* Output temp structure */
1804 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1805 if (state.DSM||state.SINGLETM)
1806 output.println("struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals {");
1808 output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals {");
1809 output.println(" int size;");
1810 output.println(" void * next;");
1811 for(int i=0; i<objecttemps.numPointers(); i++) {
1812 TempDescriptor temp=objecttemps.getPointer(i);
1813 if (temp.getType().isNull())
1814 output.println(" void * "+temp.getSafeSymbol()+";");
1816 output.println(" struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
1818 output.println("};\n");
1821 /********* Output method declaration ***********/
1822 if (state.DSM||state.SINGLETM) {
1823 headersout.println("#define D"+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+" 1");
1825 headersout.println("#define D"+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+" 1");
1827 /* First the return type */
1828 if (md.getReturnType()!=null) {
1829 if(state.MGC && md.getReturnType().isClass() && md.getReturnType().getClassDesc().isEnum()) {
1830 headersout.println(" int ");
1831 } else if (md.getReturnType().isClass()||md.getReturnType().isArray())
1832 headersout.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
1834 headersout.print(md.getReturnType().getSafeSymbol()+" ");
1836 //catch the constructor case
1837 headersout.print("void ");
1839 /* Next the method name */
1840 if (state.DSM||state.SINGLETM) {
1841 headersout.print(cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(");
1843 headersout.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(");
1845 boolean printcomma=false;
1846 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1847 if (state.DSM||state.SINGLETM) {
1848 headersout.print("struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
1850 headersout.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
1854 /* Output parameter list*/
1855 for(int i=0; i<objectparams.numPrimitives(); i++) {
1856 TempDescriptor temp=objectparams.getPrimitive(i);
1858 headersout.print(", ");
1860 if(state.MGC && temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
1861 headersout.print("int " + temp.getSafeSymbol());
1862 } else if (temp.getType().isClass()||temp.getType().isArray())
1863 headersout.print("struct " + temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol());
1865 headersout.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
1867 headersout.println(");\n");
1871 /** This function outputs (1) structures that parameters are
1872 * passed in (when PRECISE GC is enabled) and (2) function
1873 * prototypes for the tasks */
1875 private void generateTaskStructs(PrintWriter output, PrintWriter headersout) {
1876 /* Cycle through tasks */
1877 Iterator taskit=state.getTaskSymbolTable().getDescriptorsIterator();
1879 while(taskit.hasNext()) {
1880 /* Classify parameters */
1881 TaskDescriptor task=(TaskDescriptor)taskit.next();
1882 FlatMethod fm=state.getMethodFlat(task);
1883 generateTempStructs(fm, null);
1885 ParamsObject objectparams=(ParamsObject) paramstable.get(task);
1886 TempObject objecttemps=(TempObject) tempstable.get(task);
1888 /* Output parameter structure */
1889 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1890 output.println("struct "+task.getSafeSymbol()+"_params {");
1891 output.println(" int size;");
1892 output.println(" void * next;");
1893 for(int i=0; i<objectparams.numPointers(); i++) {
1894 TempDescriptor temp=objectparams.getPointer(i);
1895 output.println(" struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
1898 output.println("};\n");
1899 if ((objectparams.numPointers()+fm.numTags())>maxtaskparams) {
1900 maxtaskparams=objectparams.numPointers()+fm.numTags();
1904 /* Output temp structure */
1905 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1906 output.println("struct "+task.getSafeSymbol()+"_locals {");
1907 output.println(" int size;");
1908 output.println(" void * next;");
1909 for(int i=0; i<objecttemps.numPointers(); i++) {
1910 TempDescriptor temp=objecttemps.getPointer(i);
1911 if (temp.getType().isNull())
1912 output.println(" void * "+temp.getSafeSymbol()+";");
1913 else if(temp.getType().isTag())
1914 output.println(" struct "+
1915 (new TypeDescriptor(typeutil.getClass(TypeUtil.TagClass))).getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
1917 output.println(" struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
1919 output.println("};\n");
1922 /* Output task declaration */
1923 headersout.print("void " + task.getSafeSymbol()+"(");
1925 boolean printcomma=false;
1926 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1927 headersout.print("struct "+task.getSafeSymbol()+"_params * "+paramsprefix);
1929 headersout.print("void * parameterarray[]");
1930 headersout.println(");\n");
1934 /***** Generate code for FlatMethod fm. *****/
1936 Hashtable<FlatAtomicEnterNode, AtomicRecord> atomicmethodmap;
1937 static int atomicmethodcount=0;
1940 BranchAnalysis branchanalysis;
1941 private void generateFlatMethod(FlatMethod fm, LocalityBinding lb, PrintWriter output) {
1942 if (State.PRINTFLAT)
1943 System.out.println(fm.printMethod());
1944 MethodDescriptor md=fm.getMethod();
1945 TaskDescriptor task=fm.getTask();
1946 ClassDescriptor cn=md!=null ? md.getClassDesc() : null;
1947 ParamsObject objectparams=(ParamsObject)paramstable.get(lb!=null ? lb : md!=null ? md : task);
1949 HashSet<AtomicRecord> arset=null;
1950 branchanalysis=null;
1952 if (state.DELAYCOMP&&!lb.isAtomic()&&lb.getHasAtomic()) {
1954 if (atomicmethodmap==null)
1955 atomicmethodmap=new Hashtable<FlatAtomicEnterNode, AtomicRecord>();
1957 //fix these so we get right strings for local variables
1958 localsprefixaddr=localsprefix;
1959 localsprefixderef=localsprefix+"->";
1960 arset=new HashSet<AtomicRecord>();
1962 //build branchanalysis
1963 branchanalysis=new BranchAnalysis(locality, lb, delaycomp.getNotReady(lb), delaycomp.livecode(lb), state);
1965 //Generate commit methods here
1966 for(Iterator<FlatNode> fnit=fm.getNodeSet().iterator();fnit.hasNext();) {
1967 FlatNode fn=fnit.next();
1968 if (fn.kind()==FKind.FlatAtomicEnterNode&&
1969 locality.getAtomic(lb).get(fn.getPrev(0)).intValue()==0&&
1970 delaycomp.needsFission(lb, (FlatAtomicEnterNode) fn)) {
1971 //We have an atomic enter
1972 FlatAtomicEnterNode faen=(FlatAtomicEnterNode) fn;
1973 Set<FlatNode> exitset=faen.getExits();
1975 String methodname=md.getSymbol()+(atomicmethodcount++);
1976 AtomicRecord ar=new AtomicRecord();
1980 atomicmethodmap.put(faen, ar);
1982 //build data structure declaration
1983 output.println("struct atomicprimitives_"+methodname+" {");
1985 Set<FlatNode> recordset=delaycomp.livecode(lb);
1986 Set<TempDescriptor> liveinto=delaycomp.liveinto(lb, faen, recordset);
1987 Set<TempDescriptor> liveout=delaycomp.liveout(lb, faen);
1988 Set<TempDescriptor> liveoutvirtualread=delaycomp.liveoutvirtualread(lb, faen);
1990 ar.reallivein=new HashSet(liveinto);
1992 ar.liveoutvirtualread=liveoutvirtualread;
1995 for(Iterator<TempDescriptor> it=liveinto.iterator(); it.hasNext();) {
1996 TempDescriptor tmp=it.next();
1997 //remove the pointers
1998 if (tmp.getType().isPtr()) {
2001 //let's print it here
2002 output.println(tmp.getType().getSafeSymbol()+" "+tmp.getSafeSymbol()+";");
2005 for(Iterator<TempDescriptor> it=liveout.iterator(); it.hasNext();) {
2006 TempDescriptor tmp=it.next();
2007 //remove the pointers
2008 if (tmp.getType().isPtr()) {
2010 } else if (!liveinto.contains(tmp)) {
2011 //let's print it here
2012 output.println(tmp.getType().getSafeSymbol()+" "+tmp.getSafeSymbol()+";");
2015 output.println("};");
2017 //print out method name
2018 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) {");
2019 //build code for commit method
2021 //first define local primitives
2022 Set<TempDescriptor> alltemps=delaycomp.alltemps(lb, faen, recordset);
2023 for(Iterator<TempDescriptor> tmpit=alltemps.iterator();tmpit.hasNext();) {
2024 TempDescriptor tmp=tmpit.next();
2025 if (!tmp.getType().isPtr()) {
2026 if (liveinto.contains(tmp)||liveoutvirtualread.contains(tmp)) {
2027 //read from live into set
2028 output.println(tmp.getType().getSafeSymbol()+" "+tmp.getSafeSymbol()+"=primitives->"+tmp.getSafeSymbol()+";");
2031 output.println(tmp.getType().getSafeSymbol()+" "+tmp.getSafeSymbol()+";");
2035 //turn off write barrier generation
2037 state.SINGLETM=false;
2038 generateCode(faen, fm, lb, exitset, output, false);
2039 state.SINGLETM=true;
2040 //turn on write barrier generation
2042 output.println("}\n\n");
2046 //redefine these back to normal
2048 localsprefixaddr="&"+localsprefix;
2049 localsprefixderef=localsprefix+".";
2051 generateHeader(fm, lb, md!=null ? md : task,output);
2052 TempObject objecttemp=(TempObject) tempstable.get(lb!=null ? lb : md!=null ? md : task);
2054 if (state.DELAYCOMP&&!lb.isAtomic()&&lb.getHasAtomic()) {
2055 for(Iterator<AtomicRecord> arit=arset.iterator();arit.hasNext();) {
2056 AtomicRecord ar=arit.next();
2057 output.println("struct atomicprimitives_"+ar.name+" primitives_"+ar.name+";");
2061 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2062 if (md!=null&&(state.DSM||state.SINGLETM))
2063 output.print(" struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals "+localsprefix+"={");
2064 else if (md!=null&&!(state.DSM||state.SINGLETM))
2065 output.print(" struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals "+localsprefix+"={");
2067 output.print(" struct "+task.getSafeSymbol()+"_locals "+localsprefix+"={");
2068 output.print(objecttemp.numPointers()+",");
2069 output.print(paramsprefix);
2070 for(int j=0; j<objecttemp.numPointers(); j++)
2071 output.print(", NULL");
2072 output.println("};");
2075 for(int i=0; i<objecttemp.numPrimitives(); i++) {
2076 TempDescriptor td=objecttemp.getPrimitive(i);
2077 TypeDescriptor type=td.getType();
2079 output.println(" void * "+td.getSafeSymbol()+";");
2080 else if (state.MGC && type.isClass() && type.getClassDesc().isEnum()) {
2081 output.println(" int " + td.getSafeSymbol() + ";");
2082 } else if (type.isClass()||type.isArray())
2083 output.println(" struct "+type.getSafeSymbol()+" * "+td.getSafeSymbol()+";");
2085 output.println(" "+type.getSafeSymbol()+" "+td.getSafeSymbol()+";");
2090 additionalCodeAtTopFlatMethodBody( output, fm );
2094 /* Check to see if we need to do a GC if this is a
2095 * multi-threaded program...*/
2097 if (((state.OOOJAVA||state.THREAD||state.DSM||state.SINGLETM)&&GENERATEPRECISEGC)
2098 || this.state.MULTICOREGC) {
2099 //Don't bother if we aren't in recursive methods...The loops case will catch it
2100 if (callgraph.getAllMethods(md).contains(md)) {
2101 if (state.DSM&&lb.isAtomic())
2102 output.println("if (needtocollect) checkcollect2("+localsprefixaddr+");");
2103 else if (this.state.MULTICOREGC) {
2104 output.println("if(gcflag) gc("+localsprefixaddr+");");
2106 output.println("if (unlikely(needtocollect)) checkcollect("+localsprefixaddr+");");
2112 // TODO add version for normal Java later
2113 if(fm.getMethod().isStaticBlock()) {
2114 // a static block, check if it has been executed
2115 output.println(" if(global_defs_p->" + cn.getSafeSymbol()+"static_block_exe_flag != 0) {");
2116 output.println(" return;");
2117 output.println(" }");
2120 if((!fm.getMethod().isStaticBlock()) && (fm.getMethod().getReturnType() == null) && (cn != null)){
2121 // is a constructor, check and output initialization of the static fields
2122 // here does not initialize the static fields of the class, instead it
2123 // redirect the corresponding fields in the object to the global_defs_p
2124 Vector fields=cn.getFieldVec();
2126 for(int i=0; i<fields.size(); i++) {
2127 FieldDescriptor fd=(FieldDescriptor)fields.get(i);
2130 // decide the exact class/interface that defines the field
2131 ClassDescriptor fdcn =
2132 cd2fieldstbl.get(cn).get(fd.getSymbol());
2135 output.println(generateTemp(fm,fm.getParameter(0),lb)+"->"+fd.getSafeSymbol()+"=&(global_defs_p->"+fdcn.getSafeSymbol()+fd.getSafeSymbol()+");");
2141 generateCode(fm.getNext(0), fm, lb, null, output, true);
2143 output.println("}\n\n");
2148 protected void generateCode(FlatNode first,
2151 Set<FlatNode> stopset,
2153 boolean firstpass) {
2155 /* Assign labels to FlatNode's if necessary.*/
2157 Hashtable<FlatNode, Integer> nodetolabel;
2159 if (state.DELAYCOMP&&!firstpass)
2160 nodetolabel=dcassignLabels(first, stopset);
2162 nodetolabel=assignLabels(first, stopset);
2164 Set<FlatNode> storeset=null;
2165 HashSet<FlatNode> genset=null;
2166 HashSet<FlatNode> refset=null;
2167 Set<FlatNode> unionset=null;
2169 if (state.DELAYCOMP&&!lb.isAtomic()&&lb.getHasAtomic()) {
2170 storeset=delaycomp.livecode(lb);
2171 genset=new HashSet<FlatNode>();
2172 if (state.STMARRAY&&!state.DUALVIEW) {
2173 refset=new HashSet<FlatNode>();
2174 refset.addAll(delaycomp.getDeref(lb));
2175 refset.removeAll(delaycomp.getCannotDelay(lb));
2176 refset.removeAll(delaycomp.getOther(lb));
2179 genset.addAll(delaycomp.getCannotDelay(lb));
2180 genset.addAll(delaycomp.getOther(lb));
2182 genset.addAll(delaycomp.getNotReady(lb));
2183 if (state.STMARRAY&&!state.DUALVIEW) {
2184 genset.removeAll(refset);
2187 unionset=new HashSet<FlatNode>();
2188 unionset.addAll(storeset);
2189 unionset.addAll(genset);
2190 if (state.STMARRAY&&!state.DUALVIEW)
2191 unionset.addAll(refset);
2194 /* Do the actual code generation */
2195 FlatNode current_node=null;
2196 HashSet tovisit=new HashSet();
2197 HashSet visited=new HashSet();
2199 tovisit.add(first.getNext(0));
2202 while(current_node!=null||!tovisit.isEmpty()) {
2203 if (current_node==null) {
2204 current_node=(FlatNode)tovisit.iterator().next();
2205 tovisit.remove(current_node);
2206 } else if (tovisit.contains(current_node)) {
2207 tovisit.remove(current_node);
2209 visited.add(current_node);
2210 if (nodetolabel.containsKey(current_node)) {
2211 output.println("L"+nodetolabel.get(current_node)+":");
2213 if (state.INSTRUCTIONFAILURE) {
2214 if (state.THREAD||state.DSM||state.SINGLETM) {
2215 output.println("if ((++instructioncount)>failurecount) {instructioncount=0;injectinstructionfailure();}");
2217 output.println("if ((--instructioncount)==0) injectinstructionfailure();");
2219 if (current_node.numNext()==0||stopset!=null&&stopset.contains(current_node)) {
2221 if (!state.DELAYCOMP||firstpass) {
2222 generateFlatNode(fm, lb, current_node, output);
2224 //store primitive variables in out set
2225 AtomicRecord ar=atomicmethodmap.get((FlatAtomicEnterNode)first);
2226 Set<TempDescriptor> liveout=ar.liveout;
2227 for(Iterator<TempDescriptor> tmpit=liveout.iterator();tmpit.hasNext();) {
2228 TempDescriptor tmp=tmpit.next();
2229 output.println("primitives->"+tmp.getSafeSymbol()+"="+tmp.getSafeSymbol()+";");
2232 if (state.OOOJAVA && stopset!=null) {
2233 assert first.getPrev( 0 ) instanceof FlatSESEEnterNode;
2234 assert current_node instanceof FlatSESEExitNode;
2235 FlatSESEEnterNode fsen = (FlatSESEEnterNode) first.getPrev( 0 );
2236 FlatSESEExitNode fsxn = (FlatSESEExitNode) current_node;
2237 assert fsen.getFlatExit().equals( fsxn );
2238 assert fsxn.getFlatEnter().equals( fsen );
2240 if (current_node.kind()!=FKind.FlatReturnNode) {
2242 // TODO add version for normal Java later
2243 if((fm.getMethod() != null) && (fm.getMethod().isStaticBlock())) {
2244 // a static block, check if it has been executed
2245 output.println(" global_defs_p->" + fm.getMethod().getClassDesc().getSafeSymbol()+"static_block_exe_flag = 1;");
2249 output.println(" return;");
2252 } else if(current_node.numNext()==1) {
2254 if (state.OOOJAVA &&
2255 current_node.kind()==FKind.FlatSESEEnterNode
2257 FlatSESEEnterNode fsen = (FlatSESEEnterNode)current_node;
2258 generateFlatNode(fm, lb, current_node, output);
2259 nextnode=fsen.getFlatExit().getNext(0);
2260 } else if (state.DELAYCOMP) {
2261 boolean specialprimitive=false;
2262 //skip literals...no need to add extra overhead
2263 if (storeset!=null&&storeset.contains(current_node)&¤t_node.kind()==FKind.FlatLiteralNode) {
2264 TypeDescriptor typedesc=((FlatLiteralNode)current_node).getType();
2265 if (!typedesc.isClass()&&!typedesc.isArray()) {
2266 specialprimitive=true;
2270 if (genset==null||genset.contains(current_node)||specialprimitive)
2271 generateFlatNode(fm, lb, current_node, output);
2272 if (state.STMARRAY&&!state.DUALVIEW&&refset!=null&&refset.contains(current_node)) {
2273 //need to acquire lock
2274 handleArrayDeref(fm, lb, current_node, output, firstpass);
2276 if (storeset!=null&&storeset.contains(current_node)&&!specialprimitive) {
2277 TempDescriptor wrtmp=current_node.writesTemps()[0];
2279 //need to store value written by previous node
2280 if (wrtmp.getType().isPtr()) {
2281 //only lock the objects that may actually need locking
2282 if (recorddc.getNeedTrans(lb, current_node)&&
2283 (!state.STMARRAY||state.DUALVIEW||!wrtmp.getType().isArray()||
2284 wrtmp.getType().getSymbol().equals(TypeUtil.ObjectClass))) {
2285 output.println("STOREPTR("+generateTemp(fm, wrtmp,lb)+");/* "+current_node.nodeid+" */");
2287 output.println("STOREPTRNOLOCK("+generateTemp(fm, wrtmp,lb)+");/* "+current_node.nodeid+" */");
2290 output.println("STORE"+wrtmp.getType().getSafeDescriptor()+"("+generateTemp(fm, wrtmp, lb)+");/* "+current_node.nodeid+" */");
2293 //need to read value read by previous node
2294 if (wrtmp.getType().isPtr()) {
2295 output.println("RESTOREPTR("+generateTemp(fm, wrtmp,lb)+");/* "+current_node.nodeid+" */");
2297 output.println("RESTORE"+wrtmp.getType().getSafeDescriptor()+"("+generateTemp(fm, wrtmp, lb)+"); /* "+current_node.nodeid+" */");
2301 nextnode=current_node.getNext(0);
2304 generateFlatNode(fm, lb, current_node, output);
2305 nextnode=current_node.getNext(0);
2307 if (visited.contains(nextnode)) {
2308 output.println("goto L"+nodetolabel.get(nextnode)+";");
2311 current_node=nextnode;
2312 } else if (current_node.numNext()==2) {
2314 if (state.DELAYCOMP) {
2315 boolean computeside=false;
2317 //need to record which way it should go
2318 if (genset==null||genset.contains(current_node)) {
2319 if (storeset!=null&&storeset.contains(current_node)) {
2320 //need to store which way branch goes
2321 generateStoreFlatCondBranch(fm, lb, (FlatCondBranch)current_node, "L"+nodetolabel.get(current_node.getNext(1)), output);
2323 generateFlatCondBranch(fm, lb, (FlatCondBranch)current_node, "L"+nodetolabel.get(current_node.getNext(1)), output);
2325 //which side to execute
2329 if (genset.contains(current_node)) {
2330 generateFlatCondBranch(fm, lb, (FlatCondBranch)current_node, "L"+nodetolabel.get(current_node.getNext(1)), output);
2331 } else if (storeset.contains(current_node)) {
2333 branchanalysis.generateGroupCode(current_node, output, nodetolabel);
2335 //which side to execute
2340 Set<FlatNode> leftset=DelayComputation.getNext(current_node, 0, unionset, lb,locality, true);
2342 if (leftset.size()==0)
2344 if (visited.contains(current_node.getNext(branch))) {
2345 //already visited -- build jump
2346 output.println("goto L"+nodetolabel.get(current_node.getNext(branch))+";");
2349 current_node=current_node.getNext(branch);
2352 if (!visited.contains(current_node.getNext(1)))
2353 tovisit.add(current_node.getNext(1));
2354 if (visited.contains(current_node.getNext(0))) {
2355 output.println("goto L"+nodetolabel.get(current_node.getNext(0))+";");
2358 current_node=current_node.getNext(0);
2362 generateFlatCondBranch(fm, lb, (FlatCondBranch)current_node, "L"+nodetolabel.get(current_node.getNext(1)), output);
2363 if (!visited.contains(current_node.getNext(1)))
2364 tovisit.add(current_node.getNext(1));
2365 if (visited.contains(current_node.getNext(0))) {
2366 output.println("goto L"+nodetolabel.get(current_node.getNext(0))+";");
2369 current_node=current_node.getNext(0);
2371 } else throw new Error();
2375 protected void handleArrayDeref(FlatMethod fm, LocalityBinding lb, FlatNode fn, PrintWriter output, boolean firstpass) {
2376 if (fn.kind()==FKind.FlatSetElementNode) {
2377 FlatSetElementNode fsen=(FlatSetElementNode) fn;
2378 String dst=generateTemp(fm, fsen.getDst(), lb);
2379 String src=generateTemp(fm, fsen.getSrc(), lb);
2380 String index=generateTemp(fm, fsen.getIndex(), lb);
2381 TypeDescriptor elementtype=fsen.getDst().getType().dereference();
2383 if (elementtype.isArray()||elementtype.isClass())
2386 type=elementtype.getSafeSymbol()+" ";
2388 output.println("STOREARRAY("+dst+","+index+","+type+")");
2390 output.println("{");
2391 output.println(" struct ArrayObject *array;");
2392 output.println(" int index;");
2393 output.println(" RESTOREARRAY(array,index);");
2394 output.println(" (("+type+"*)(((char *)&array->___length___)+sizeof(int)))[index]="+src+";");
2395 output.println("}");
2397 } else if (fn.kind()==FKind.FlatElementNode) {
2398 FlatElementNode fen=(FlatElementNode) fn;
2399 String src=generateTemp(fm, fen.getSrc(), lb);
2400 String index=generateTemp(fm, fen.getIndex(), lb);
2401 TypeDescriptor elementtype=fen.getSrc().getType().dereference();
2402 String dst=generateTemp(fm, fen.getDst(), lb);
2404 if (elementtype.isArray()||elementtype.isClass())
2407 type=elementtype.getSafeSymbol()+" ";
2409 output.println("STOREARRAY("+src+","+index+","+type+")");
2411 output.println("{");
2412 output.println(" struct ArrayObject *array;");
2413 output.println(" int index;");
2414 output.println(" RESTOREARRAY(array,index);");
2415 output.println(" "+dst+"=(("+type+"*)(((char *)&array->___length___)+sizeof(int)))[index];");
2416 output.println("}");
2420 /** Special label assignment for delaycomputation */
2421 protected Hashtable<FlatNode, Integer> dcassignLabels(FlatNode first, Set<FlatNode> lastset) {
2422 HashSet tovisit=new HashSet();
2423 HashSet visited=new HashSet();
2425 Hashtable<FlatNode, Integer> nodetolabel=new Hashtable<FlatNode, Integer>();
2427 //Label targets of branches
2428 Set<FlatNode> targets=branchanalysis.getTargets();
2429 for(Iterator<FlatNode> it=targets.iterator();it.hasNext();) {
2430 nodetolabel.put(it.next(), new Integer(labelindex++));
2435 /*Assign labels first. A node needs a label if the previous
2436 * node has two exits or this node is a join point. */
2438 while(!tovisit.isEmpty()) {
2439 FlatNode fn=(FlatNode)tovisit.iterator().next();
2444 if(lastset!=null&&lastset.contains(fn)) {
2445 // if last is not null and matches, don't go
2446 // any further for assigning labels
2450 for(int i=0; i<fn.numNext(); i++) {
2451 FlatNode nn=fn.getNext(i);
2454 //1) Edge >1 of node
2455 nodetolabel.put(nn,new Integer(labelindex++));
2457 if (!visited.contains(nn)&&!tovisit.contains(nn)) {
2461 nodetolabel.put(nn,new Integer(labelindex++));
2469 protected Hashtable<FlatNode, Integer> assignLabels(FlatNode first) {
2470 return assignLabels(first, null);
2473 protected Hashtable<FlatNode, Integer> assignLabels(FlatNode first, Set<FlatNode> lastset) {
2474 HashSet tovisit=new HashSet();
2475 HashSet visited=new HashSet();
2477 Hashtable<FlatNode, Integer> nodetolabel=new Hashtable<FlatNode, Integer>();
2480 /*Assign labels first. A node needs a label if the previous
2481 * node has two exits or this node is a join point. */
2483 while(!tovisit.isEmpty()) {
2484 FlatNode fn=(FlatNode)tovisit.iterator().next();
2489 if(lastset!=null&&lastset.contains(fn)) {
2490 // if last is not null and matches, don't go
2491 // any further for assigning labels
2495 for(int i=0; i<fn.numNext(); i++) {
2496 FlatNode nn=fn.getNext(i);
2499 //1) Edge >1 of node
2500 nodetolabel.put(nn,new Integer(labelindex++));
2502 if (!visited.contains(nn)&&!tovisit.contains(nn)) {
2506 nodetolabel.put(nn,new Integer(labelindex++));
2514 /** Generate text string that corresponds to the TempDescriptor td. */
2515 protected String generateTemp(FlatMethod fm, TempDescriptor td, LocalityBinding lb) {
2516 MethodDescriptor md=fm.getMethod();
2517 TaskDescriptor task=fm.getTask();
2518 TempObject objecttemps=(TempObject) tempstable.get(lb!=null ? lb : md!=null ? md : task);
2520 if (objecttemps.isLocalPrim(td)||objecttemps.isParamPrim(td)) {
2521 return td.getSafeSymbol();
2524 if (objecttemps.isLocalPtr(td)) {
2525 return localsprefixderef+td.getSafeSymbol();
2528 if (objecttemps.isParamPtr(td)) {
2529 return paramsprefix+"->"+td.getSafeSymbol();
2537 protected void generateFlatNode(FlatMethod fm, LocalityBinding lb, FlatNode fn, PrintWriter output) {
2540 additionalCodePreNode( fm, lb, fn, output );
2544 case FKind.FlatAtomicEnterNode:
2545 generateFlatAtomicEnterNode(fm, lb, (FlatAtomicEnterNode) fn, output);
2548 case FKind.FlatAtomicExitNode:
2549 generateFlatAtomicExitNode(fm, lb, (FlatAtomicExitNode) fn, output);
2552 case FKind.FlatInstanceOfNode:
2553 generateFlatInstanceOfNode(fm, lb, (FlatInstanceOfNode)fn, output);
2556 case FKind.FlatSESEEnterNode:
2557 generateFlatSESEEnterNode(fm, lb, (FlatSESEEnterNode)fn, output);
2560 case FKind.FlatSESEExitNode:
2561 generateFlatSESEExitNode(fm, lb, (FlatSESEExitNode)fn, output);
2564 case FKind.FlatWriteDynamicVarNode:
2565 generateFlatWriteDynamicVarNode(fm, lb, (FlatWriteDynamicVarNode)fn, output);
2568 case FKind.FlatGlobalConvNode:
2569 generateFlatGlobalConvNode(fm, lb, (FlatGlobalConvNode) fn, output);
2572 case FKind.FlatTagDeclaration:
2573 generateFlatTagDeclaration(fm, lb, (FlatTagDeclaration) fn,output);
2576 case FKind.FlatCall:
2577 generateFlatCall(fm, lb, (FlatCall) fn,output);
2580 case FKind.FlatFieldNode:
2581 generateFlatFieldNode(fm, lb, (FlatFieldNode) fn,output);
2584 case FKind.FlatElementNode:
2585 generateFlatElementNode(fm, lb, (FlatElementNode) fn,output);
2588 case FKind.FlatSetElementNode:
2589 generateFlatSetElementNode(fm, lb, (FlatSetElementNode) fn,output);
2592 case FKind.FlatSetFieldNode:
2593 generateFlatSetFieldNode(fm, lb, (FlatSetFieldNode) fn,output);
2597 generateFlatNew(fm, lb, (FlatNew) fn,output);
2600 case FKind.FlatOpNode:
2601 generateFlatOpNode(fm, lb, (FlatOpNode) fn,output);
2604 case FKind.FlatCastNode:
2605 generateFlatCastNode(fm, lb, (FlatCastNode) fn,output);
2608 case FKind.FlatLiteralNode:
2609 generateFlatLiteralNode(fm, lb, (FlatLiteralNode) fn,output);
2612 case FKind.FlatReturnNode:
2613 generateFlatReturnNode(fm, lb, (FlatReturnNode) fn,output);
2617 output.println("/* nop */");
2620 case FKind.FlatGenReachNode:
2621 // this node is just for generating a reach graph
2622 // in disjointness analysis at a particular program point
2625 case FKind.FlatExit:
2626 output.println("/* exit */");
2629 case FKind.FlatBackEdge:
2630 if (state.SINGLETM&&state.SANDBOX&&(locality.getAtomic(lb).get(fn).intValue()>0)) {
2631 output.println("if (unlikely((--transaction_check_counter)<=0)) checkObjects();");
2633 if(state.DSM&&state.SANDBOX&&(locality.getAtomic(lb).get(fn).intValue()>0)) {
2634 output.println("if (unlikely((--transaction_check_counter)<=0)) checkObjects();");
2636 if (((state.OOOJAVA||state.THREAD||state.DSM||state.SINGLETM)&&GENERATEPRECISEGC)
2637 || (this.state.MULTICOREGC)) {
2638 if(state.DSM&&locality.getAtomic(lb).get(fn).intValue()>0) {
2639 output.println("if (needtocollect) checkcollect2("+localsprefixaddr+");");
2640 } else if(this.state.MULTICOREGC) {
2641 output.println("if (gcflag) gc("+localsprefixaddr+");");
2643 output.println("if (unlikely(needtocollect)) checkcollect("+localsprefixaddr+");");
2646 output.println("/* nop */");
2649 case FKind.FlatCheckNode:
2650 generateFlatCheckNode(fm, lb, (FlatCheckNode) fn, output);
2653 case FKind.FlatFlagActionNode:
2654 generateFlatFlagActionNode(fm, lb, (FlatFlagActionNode) fn, output);
2657 case FKind.FlatPrefetchNode:
2658 generateFlatPrefetchNode(fm,lb, (FlatPrefetchNode) fn, output);
2661 case FKind.FlatOffsetNode:
2662 generateFlatOffsetNode(fm, lb, (FlatOffsetNode)fn, output);
2670 additionalCodePostNode( fm, lb, fn, output );
2673 public void generateFlatOffsetNode(FlatMethod fm, LocalityBinding lb, FlatOffsetNode fofn, PrintWriter output) {
2674 output.println("/* FlatOffsetNode */");
2675 FieldDescriptor fd=fofn.getField();
2676 output.println(generateTemp(fm, fofn.getDst(),lb)+ " = (short)(int) (&((struct "+fofn.getClassType().getSafeSymbol() +" *)0)->"+ fd.getSafeSymbol()+");");
2677 output.println("/* offset */");
2680 public void generateFlatPrefetchNode(FlatMethod fm, LocalityBinding lb, FlatPrefetchNode fpn, PrintWriter output) {
2681 if (state.PREFETCH) {
2682 Vector oids = new Vector();
2683 Vector fieldoffset = new Vector();
2684 Vector endoffset = new Vector();
2685 int tuplecount = 0; //Keeps track of number of prefetch tuples that need to be generated
2686 for(Iterator it = fpn.hspp.iterator(); it.hasNext();) {
2687 PrefetchPair pp = (PrefetchPair) it.next();
2688 Integer statusbase = locality.getNodePreTempInfo(lb,fpn).get(pp.base);
2689 /* Find prefetches that can generate oid */
2690 if(statusbase == LocalityAnalysis.GLOBAL) {
2691 generateTransCode(fm, lb, pp, oids, fieldoffset, endoffset, tuplecount, locality.getAtomic(lb).get(fpn).intValue()>0, false);
2693 } else if (statusbase == LocalityAnalysis.LOCAL) {
2694 generateTransCode(fm,lb,pp,oids,fieldoffset,endoffset,tuplecount,false,true);
2701 System.out.println("Adding prefetch "+fpn+ " to method:" +fm);
2702 output.println("{");
2703 output.println("/* prefetch */");
2704 output.println("/* prefetchid_" + fpn.siteid + " */");
2705 output.println("void * prefptr;");
2706 output.println("int tmpindex;");
2708 output.println("if((evalPrefetch["+fpn.siteid+"].operMode) || (evalPrefetch["+fpn.siteid+"].retrycount <= 0)) {");
2709 /*Create C code for oid array */
2710 output.print(" unsigned int oidarray_[] = {");
2711 boolean needcomma=false;
2712 for (Iterator it = oids.iterator(); it.hasNext();) {
2715 output.print(it.next());
2718 output.println("};");
2720 /*Create C code for endoffset values */
2721 output.print(" unsigned short endoffsetarry_[] = {");
2723 for (Iterator it = endoffset.iterator(); it.hasNext();) {
2726 output.print(it.next());
2729 output.println("};");
2731 /*Create C code for Field Offset Values */
2732 output.print(" short fieldarry_[] = {");
2734 for (Iterator it = fieldoffset.iterator(); it.hasNext();) {
2737 output.print(it.next());
2740 output.println("};");
2741 /* make the prefetch call to Runtime */
2742 output.println(" if(!evalPrefetch["+fpn.siteid+"].operMode) {");
2743 output.println(" evalPrefetch["+fpn.siteid+"].retrycount = RETRYINTERVAL;");
2744 output.println(" }");
2745 output.println(" prefetch("+fpn.siteid+" ,"+tuplecount+", oidarray_, endoffsetarry_, fieldarry_);");
2746 output.println(" } else {");
2747 output.println(" evalPrefetch["+fpn.siteid+"].retrycount--;");
2748 output.println(" }");
2749 output.println("}");
2753 public void generateTransCode(FlatMethod fm, LocalityBinding lb,PrefetchPair pp, Vector oids, Vector fieldoffset, Vector endoffset, int tuplecount, boolean inside, boolean localbase) {
2754 short offsetcount = 0;
2758 } else if (localbase) {
2759 for(; breakindex<pp.desc.size(); breakindex++) {
2760 Descriptor desc=pp.getDescAt(breakindex);
2761 if (desc instanceof FieldDescriptor) {
2762 FieldDescriptor fd=(FieldDescriptor)desc;
2763 if (fd.isGlobal()) {
2771 if (breakindex>pp.desc.size()) //all local
2774 TypeDescriptor lasttype=pp.base.getType();
2775 String basestr=generateTemp(fm, pp.base, lb);
2777 boolean maybenull=fm.getMethod().isStatic()||
2778 !pp.base.equals(fm.getParameter(0));
2780 for(int i=0; i<breakindex; i++) {
2781 String indexcheck="";
2783 Descriptor desc=pp.getDescAt(i);
2784 if (desc instanceof FieldDescriptor) {
2785 FieldDescriptor fd=(FieldDescriptor)desc;
2787 if (!teststr.equals(""))
2789 teststr+="((prefptr="+basestr+")!=NULL)";
2790 basestr="((struct "+lasttype.getSafeSymbol()+" *)prefptr)->"+fd.getSafeSymbol();
2792 basestr=basestr+"->"+fd.getSafeSymbol();
2795 lasttype=fd.getType();
2797 IndexDescriptor id=(IndexDescriptor)desc;
2798 indexcheck="((tmpindex=";
2799 for(int j=0; j<id.tddesc.size(); j++) {
2800 indexcheck+=generateTemp(fm, id.getTempDescAt(j), lb)+"+";
2802 indexcheck+=id.offset+")>=0)&(tmpindex<((struct ArrayObject *)prefptr)->___length___)";
2804 if (!teststr.equals(""))
2806 teststr+="((prefptr="+basestr+")!= NULL) &&"+indexcheck;
2807 basestr="((void **)(((char *) &(((struct ArrayObject *)prefptr)->___length___))+sizeof(int)))[tmpindex]";
2809 lasttype=lasttype.dereference();
2814 if (teststr.equals("")) {
2815 oid="((unsigned int)"+basestr+")";
2817 oid="((unsigned int)(("+teststr+")?"+basestr+":NULL))";
2821 for(int i = breakindex; i < pp.desc.size(); i++) {
2822 String newfieldoffset;
2823 Object desc = pp.getDescAt(i);
2824 if(desc instanceof FieldDescriptor) {
2825 FieldDescriptor fd=(FieldDescriptor)desc;
2826 newfieldoffset = new String("(unsigned int)(&(((struct "+ lasttype.getSafeSymbol()+" *)0)->"+ fd.getSafeSymbol()+ "))");
2827 lasttype=fd.getType();
2829 newfieldoffset = "";
2830 IndexDescriptor id=(IndexDescriptor)desc;
2831 for(int j = 0; j < id.tddesc.size(); j++) {
2832 newfieldoffset += generateTemp(fm, id.getTempDescAt(j), lb) + "+";
2834 newfieldoffset += id.offset.toString();
2835 lasttype=lasttype.dereference();
2837 fieldoffset.add(newfieldoffset);
2840 int base=(tuplecount>0) ? ((Short)endoffset.get(tuplecount-1)).intValue() : 0;
2841 base+=pp.desc.size()-breakindex;
2842 endoffset.add(new Short((short)base));
2847 public void generateFlatGlobalConvNode(FlatMethod fm, LocalityBinding lb, FlatGlobalConvNode fgcn, PrintWriter output) {
2848 if (lb!=fgcn.getLocality())
2850 /* Have to generate flat globalconv */
2851 if (fgcn.getMakePtr()) {
2853 //DEBUG: output.println("TRANSREAD("+generateTemp(fm, fgcn.getSrc(),lb)+", (unsigned int) "+generateTemp(fm, fgcn.getSrc(),lb)+",\" "+fm+":"+fgcn+"\");");
2854 output.println("TRANSREAD("+generateTemp(fm, fgcn.getSrc(),lb)+", (unsigned int) "+generateTemp(fm, fgcn.getSrc(),lb)+");");
2856 if ((dc==null)||!state.READSET&&dc.getNeedTrans(lb, fgcn)||state.READSET&&dc.getNeedWriteTrans(lb, fgcn)) {
2857 //need to do translation
2858 output.println("TRANSREAD("+generateTemp(fm, fgcn.getSrc(),lb)+", "+generateTemp(fm, fgcn.getSrc(),lb)+", (void *)("+localsprefixaddr+"));");
2859 } else if (state.READSET&&dc.getNeedTrans(lb, fgcn)) {
2860 if (state.HYBRID&&delaycomp.getConv(lb).contains(fgcn)) {
2861 output.println("TRANSREADRDFISSION("+generateTemp(fm, fgcn.getSrc(),lb)+", "+generateTemp(fm, fgcn.getSrc(),lb)+");");
2863 output.println("TRANSREADRD("+generateTemp(fm, fgcn.getSrc(),lb)+", "+generateTemp(fm, fgcn.getSrc(),lb)+");");
2867 /* Need to convert to OID */
2868 if ((dc==null)||dc.getNeedSrcTrans(lb,fgcn)) {
2869 if (fgcn.doConvert()||(delaycomp!=null&&delaycomp.needsFission(lb, fgcn.getAtomicEnter())&&atomicmethodmap.get(fgcn.getAtomicEnter()).reallivein.contains(fgcn.getSrc()))) {
2870 output.println(generateTemp(fm, fgcn.getSrc(),lb)+"=(void *)COMPOID("+generateTemp(fm, fgcn.getSrc(),lb)+");");
2872 output.println(generateTemp(fm, fgcn.getSrc(),lb)+"=NULL;");
2878 public void generateFlatInstanceOfNode(FlatMethod fm, LocalityBinding lb, FlatInstanceOfNode fion, PrintWriter output) {
2880 if (fion.getType().isArray()) {
2881 type=state.getArrayNumber(fion.getType())+state.numClasses();
2883 type=fion.getType().getClassDesc().getId();
2886 if (fion.getType().getSymbol().equals(TypeUtil.ObjectClass))
2887 output.println(generateTemp(fm, fion.getDst(), lb)+"=1;");
2889 output.println(generateTemp(fm, fion.getDst(), lb)+"=instanceof("+generateTemp(fm,fion.getSrc(),lb)+","+type+");");
2892 int sandboxcounter=0;
2893 public void generateFlatAtomicEnterNode(FlatMethod fm, LocalityBinding lb, FlatAtomicEnterNode faen, PrintWriter output) {
2894 /* Check to see if we need to generate code for this atomic */
2895 if (locality==null) {
2896 if (GENERATEPRECISEGC) {
2897 output.println("if (pthread_mutex_trylock(&atomiclock)!=0) {");
2898 output.println("stopforgc((struct garbagelist *) &___locals___);");
2899 output.println("pthread_mutex_lock(&atomiclock);");
2900 output.println("restartaftergc();");
2901 output.println("}");
2903 output.println("pthread_mutex_lock(&atomiclock);");
2908 if (locality.getAtomic(lb).get(faen.getPrev(0)).intValue()>0)
2912 if (state.SANDBOX) {
2913 outsandbox.println("int atomiccounter"+sandboxcounter+"=LOW_CHECK_FREQUENCY;");
2914 output.println("counter_reset_pointer=&atomiccounter"+sandboxcounter+";");
2917 if (state.DELAYCOMP&&delaycomp.needsFission(lb, faen)) {
2918 AtomicRecord ar=atomicmethodmap.get(faen);
2920 for(Iterator<TempDescriptor> tmpit=ar.livein.iterator();tmpit.hasNext();) {
2921 TempDescriptor tmp=tmpit.next();
2922 output.println("primitives_"+ar.name+"."+tmp.getSafeSymbol()+"="+tmp.getSafeSymbol()+";");
2925 //copy outs that depend on path
2926 for(Iterator<TempDescriptor> tmpit=ar.liveoutvirtualread.iterator();tmpit.hasNext();) {
2927 TempDescriptor tmp=tmpit.next();
2928 if (!ar.livein.contains(tmp))
2929 output.println("primitives_"+ar.name+"."+tmp.getSafeSymbol()+"="+tmp.getSafeSymbol()+";");
2933 /* Backup the temps. */
2934 for(Iterator<TempDescriptor> tmpit=locality.getTemps(lb).get(faen).iterator(); tmpit.hasNext();) {
2935 TempDescriptor tmp=tmpit.next();
2936 output.println(generateTemp(fm, backuptable.get(lb).get(tmp),lb)+"="+generateTemp(fm,tmp,lb)+";");
2939 output.println("goto transstart"+faen.getIdentifier()+";");
2941 /******* Print code to retry aborted transaction *******/
2942 output.println("transretry"+faen.getIdentifier()+":");
2945 for(Iterator<TempDescriptor> tmpit=locality.getTemps(lb).get(faen).iterator(); tmpit.hasNext();) {
2946 TempDescriptor tmp=tmpit.next();
2947 output.println(generateTemp(fm, tmp,lb)+"="+generateTemp(fm,backuptable.get(lb).get(tmp),lb)+";");
2951 /********* Need to revert local object store ********/
2952 String revertptr=generateTemp(fm, reverttable.get(lb),lb);
2954 output.println("while ("+revertptr+") {");
2955 output.println("struct ___Object___ * tmpptr;");
2956 output.println("tmpptr="+revertptr+"->"+nextobjstr+";");
2957 output.println("REVERT_OBJ("+revertptr+");");
2958 output.println(revertptr+"=tmpptr;");
2959 output.println("}");
2961 /******* Tell the runtime to start the transaction *******/
2963 output.println("transstart"+faen.getIdentifier()+":");
2964 if (state.SANDBOX) {
2965 output.println("transaction_check_counter=*counter_reset_pointer;");
2968 output.println("transStart();");
2970 if (state.ABORTREADERS||state.SANDBOX) {
2972 output.println("abortenabled=1;");
2973 output.println("if (_setjmp(aborttrans)) {");
2974 output.println(" goto transretry"+faen.getIdentifier()+"; }");
2978 public void generateFlatAtomicExitNode(FlatMethod fm, LocalityBinding lb, FlatAtomicExitNode faen, PrintWriter output) {
2979 /* Check to see if we need to generate code for this atomic */
2980 if (locality==null) {
2981 output.println("pthread_mutex_unlock(&atomiclock);");
2984 if (locality.getAtomic(lb).get(faen).intValue()>0)
2986 //store the revert list before we lose the transaction object
2989 String revertptr=generateTemp(fm, reverttable.get(lb),lb);
2990 output.println(revertptr+"=revertlist;");
2991 output.println("if (transCommit()) {");
2992 output.println("if (unlikely(needtocollect)) checkcollect("+localsprefixaddr+");");
2993 output.println("goto transretry"+faen.getAtomicEnter().getIdentifier()+";");
2994 output.println("} else {");
2995 /* Need to commit local object store */
2996 output.println("while ("+revertptr+") {");
2997 output.println("struct ___Object___ * tmpptr;");
2998 output.println("tmpptr="+revertptr+"->"+nextobjstr+";");
2999 output.println("COMMIT_OBJ("+revertptr+");");
3000 output.println(revertptr+"=tmpptr;");
3001 output.println("}");
3002 output.println("}");
3006 if (!state.DELAYCOMP) {
3008 output.println("if (transCommit()) {");
3009 /* Transaction aborts if it returns true */
3010 output.println("if (unlikely(needtocollect)) checkcollect("+localsprefixaddr+");");
3011 output.println("goto transretry"+faen.getAtomicEnter().getIdentifier()+";");
3012 output.println("}");
3014 if (delaycomp.optimizeTrans(lb, faen.getAtomicEnter())&&(!state.STMARRAY||state.DUALVIEW)) {
3015 AtomicRecord ar=atomicmethodmap.get(faen.getAtomicEnter());
3016 output.println("LIGHTWEIGHTCOMMIT("+ar.name+", &primitives_"+ar.name+", &"+localsprefix+", "+paramsprefix+", transretry"+faen.getAtomicEnter().getIdentifier()+");");
3018 for(Iterator<TempDescriptor> tmpit=ar.liveout.iterator();tmpit.hasNext();) {
3019 TempDescriptor tmp=tmpit.next();
3020 output.println(tmp.getSafeSymbol()+"=primitives_"+ar.name+"."+tmp.getSafeSymbol()+";");
3022 } else if (delaycomp.needsFission(lb, faen.getAtomicEnter())) {
3023 AtomicRecord ar=atomicmethodmap.get(faen.getAtomicEnter());
3025 output.println("if (transCommit((void (*)(void *, void *, void *))&"+ar.name+", &primitives_"+ar.name+", &"+localsprefix+", "+paramsprefix+")) {");
3026 output.println("if (unlikely(needtocollect)) checkcollect("+localsprefixaddr+");");
3027 output.println("goto transretry"+faen.getAtomicEnter().getIdentifier()+";");
3028 output.println("}");
3030 output.println("else {");
3031 for(Iterator<TempDescriptor> tmpit=ar.liveout.iterator();tmpit.hasNext();) {
3032 TempDescriptor tmp=tmpit.next();
3033 output.println(tmp.getSafeSymbol()+"=primitives_"+ar.name+"."+tmp.getSafeSymbol()+";");
3035 output.println("}");
3037 output.println("if (transCommit(NULL, NULL, NULL, NULL)) {");
3038 output.println("if (unlikely(needtocollect)) checkcollect("+localsprefixaddr+");");
3039 output.println("goto transretry"+faen.getAtomicEnter().getIdentifier()+";");
3040 output.println("}");
3045 public void generateFlatSESEEnterNode( FlatMethod fm,
3047 FlatSESEEnterNode fsen,
3048 PrintWriter output) {
3049 // if OOOJAVA flag is off, okay that SESE nodes are in IR graph,
3050 // just skip over them and code generates exactly the same
3053 public void generateFlatSESEExitNode( FlatMethod fm,
3055 FlatSESEExitNode fsexn,
3056 PrintWriter output) {
3057 // if OOOJAVA flag is off, okay that SESE nodes are in IR graph,
3058 // just skip over them and code generates exactly the same
3061 public void generateFlatWriteDynamicVarNode( FlatMethod fm,
3063 FlatWriteDynamicVarNode fwdvn,
3066 if( !state.OOOJAVA ) {
3067 // should node should not be in an IR graph if the
3068 // OOOJAVA flag is not set
3069 throw new Error("Unexpected presence of FlatWriteDynamicVarNode");
3074 private void generateFlatCheckNode(FlatMethod fm, LocalityBinding lb, FlatCheckNode fcn, PrintWriter output) {
3075 if (state.CONSCHECK) {
3076 String specname=fcn.getSpec();
3077 String varname="repairstate___";
3078 output.println("{");
3079 output.println("struct "+specname+"_state * "+varname+"=allocate"+specname+"_state();");
3081 TempDescriptor[] temps=fcn.getTemps();
3082 String[] vars=fcn.getVars();
3083 for(int i=0; i<temps.length; i++) {
3084 output.println(varname+"->"+vars[i]+"=(unsigned int)"+generateTemp(fm, temps[i],lb)+";");
3087 output.println("if (doanalysis"+specname+"("+varname+")) {");
3088 output.println("free"+specname+"_state("+varname+");");
3089 output.println("} else {");
3090 output.println("/* Bad invariant */");
3091 output.println("free"+specname+"_state("+varname+");");
3092 output.println("abort_task();");
3093 output.println("}");
3094 output.println("}");
3098 private void generateFlatCall(FlatMethod fm, LocalityBinding lb, FlatCall fc, PrintWriter output) {
3100 MethodDescriptor md=fc.getMethod();
3101 ParamsObject objectparams=(ParamsObject)paramstable.get(lb!=null ? locality.getBinding(lb, fc) : md);
3102 ClassDescriptor cn=md.getClassDesc();
3104 // if the called method is a static block or a static method or a constructor
3105 // need to check if it can be invoked inside some static block
3107 // TODO add version for normal Java later
3108 if((md.isStatic() || md.isStaticBlock() || md.isConstructor()) &&
3109 ((fm.getMethod().isStaticBlock()) || (fm.getMethod().isInvokedByStatic()))) {
3110 if(!md.isInvokedByStatic()) {
3111 System.err.println("Error: a method that is invoked inside a static block is not tagged!");
3113 // is a static block or is invoked in some static block
3114 ClassDescriptor cd = fm.getMethod().getClassDesc();
3116 // the same class, do nothing
3117 // TODO may want to invoke static field initialization here
3119 if((cn.getNumStaticFields() != 0) || (cn.getNumStaticBlocks() != 0)) {
3120 // need to check if the class' static fields have been initialized and/or
3121 // its static blocks have been executed
3122 output.println("#ifdef MGC_STATIC_INIT_CHECK");
3123 output.println("if(global_defs_p->" + cn.getSafeSymbol()+"static_block_exe_flag == 0) {");
3124 if(cn.getNumStaticBlocks() != 0) {
3125 MethodDescriptor t_md = (MethodDescriptor)cn.getMethodTable().get("staticblocks");
3126 output.println(" "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"();");
3128 output.println(" global_defs_p->" + cn.getSafeSymbol()+"static_block_exe_flag = 1;");
3130 output.println("}");
3131 output.println("#endif // MGC_STATIC_INIT_CHECK");
3135 if((md.getSymbol().equals("MonitorEnter") || md.getSymbol().equals("MonitorExit")) && fc.getThis().getSymbol().equals("classobj")) {
3136 // call MonitorEnter/MonitorExit on a class obj
3137 output.println(" " + cn.getSafeSymbol()+md.getSafeSymbol()+"_"
3138 +md.getSafeMethodDescriptor() + "((struct ___Object___*)(&global_defs_p->"
3139 + fc.getThis().getType().getClassDesc().getSafeSymbol() +"classobj));");
3144 output.println("{");
3145 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
3147 LocalityBinding fclb=locality.getBinding(lb, fc);
3148 output.print(" struct "+cn.getSafeSymbol()+fclb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
3150 output.print(" struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
3151 output.print(objectparams.numPointers());
3152 output.print(", "+localsprefixaddr);
3153 if (md.getThis()!=null) {
3155 output.print("(struct "+md.getThis().getType().getSafeSymbol() +" *)"+ generateTemp(fm,fc.getThis(),lb));
3157 if (fc.getThis()!=null&&md.getThis()==null) {
3158 System.out.println("WARNING!!!!!!!!!!!!");
3159 System.out.println("Source code calls static method "+md+" on an object in "+fm.getMethod()+"!");
3163 for(int i=0; i<fc.numArgs(); i++) {
3164 Descriptor var=md.getParameter(i);
3165 TempDescriptor paramtemp=(TempDescriptor)temptovar.get(var);
3166 if (objectparams.isParamPtr(paramtemp)) {
3167 TempDescriptor targ=fc.getArg(i);
3169 TypeDescriptor td=md.getParamType(i);
3171 output.print("(struct "+(new TypeDescriptor(typeutil.getClass(TypeUtil.TagClass))).getSafeSymbol() +" *)"+generateTemp(fm, targ,lb));
3173 output.print("(struct "+md.getParamType(i).getSafeSymbol() +" *)"+generateTemp(fm, targ,lb));
3176 output.println("};");
3181 if (fc.getReturnTemp()!=null)
3182 output.print(generateTemp(fm,fc.getReturnTemp(),lb)+"=");
3184 /* Do we need to do virtual dispatch? */
3185 if (md.isStatic()||md.getReturnType()==null||singleCall(fc.getThis().getType().getClassDesc(),md)) {
3188 LocalityBinding fclb=locality.getBinding(lb, fc);
3189 output.print(cn.getSafeSymbol()+fclb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
3191 output.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
3196 if (state.MGC && md.getReturnType().isClass() && md.getReturnType().getClassDesc().isEnum()) {
3197 output.print("int ");
3198 } else if (md.getReturnType().isClass()||md.getReturnType().isArray())
3199 output.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
3201 output.print(md.getReturnType().getSafeSymbol()+" ");
3202 output.print("(*)(");
3204 boolean printcomma=false;
3205 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
3207 LocalityBinding fclb=locality.getBinding(lb, fc);
3208 output.print("struct "+cn.getSafeSymbol()+fclb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * ");
3210 output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * ");
3214 for(int i=0; i<objectparams.numPrimitives(); i++) {
3215 TempDescriptor temp=objectparams.getPrimitive(i);
3219 if (state.MGC && temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
3220 output.print("int ");
3221 } else if (temp.getType().isClass()||temp.getType().isArray())
3222 output.print("struct " + temp.getType().getSafeSymbol()+" * ");
3224 output.print(temp.getType().getSafeSymbol());
3229 LocalityBinding fclb=locality.getBinding(lb, fc);
3230 output.print("))virtualtable["+generateTemp(fm,fc.getThis(),lb)+"->type*"+maxcount+"+"+virtualcalls.getLocalityNumber(fclb)+"])");
3232 output.print("))virtualtable["+generateTemp(fm,fc.getThis(),lb)+"->type*"+maxcount+"+"+virtualcalls.getMethodNumber(md)+"])");
3236 boolean needcomma=false;
3237 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
3238 output.print("&__parameterlist__");
3242 if (!GENERATEPRECISEGC && !this.state.MULTICOREGC) {
3243 if (fc.getThis()!=null) {
3244 TypeDescriptor ptd=null;
3245 if(md.getThis() != null) {
3246 ptd = md.getThis().getType();
3248 ptd = fc.getThis().getType();
3252 if(state.MGC && ptd.isClass() && ptd.getClassDesc().isEnum()) {
3254 } else if (ptd.isClass()&&!ptd.isArray())
3255 output.print("(struct "+ptd.getSafeSymbol()+" *) ");
3256 output.print(generateTemp(fm,fc.getThis(),lb));
3261 for(int i=0; i<fc.numArgs(); i++) {
3262 Descriptor var=md.getParameter(i);
3263 TempDescriptor paramtemp=(TempDescriptor)temptovar.get(var);
3264 if (objectparams.isParamPrim(paramtemp)) {
3265 TempDescriptor targ=fc.getArg(i);
3269 TypeDescriptor ptd=md.getParamType(i);
3270 if (state.MGC && ptd.isClass() && ptd.getClassDesc().isEnum()) {
3272 } else if (ptd.isClass()&&!ptd.isArray())
3273 output.print("(struct "+ptd.getSafeSymbol()+" *) ");
3274 output.print(generateTemp(fm, targ,lb));
3278 output.println(");");
3279 output.println(" }");
3282 private boolean singleCall(ClassDescriptor thiscd, MethodDescriptor md) {
3283 Set subclasses=typeutil.getSubClasses(thiscd);
3284 if (subclasses==null)
3286 for(Iterator classit=subclasses.iterator(); classit.hasNext();) {
3287 ClassDescriptor cd=(ClassDescriptor)classit.next();
3288 Set possiblematches=cd.getMethodTable().getSetFromSameScope(md.getSymbol());
3289 for(Iterator matchit=possiblematches.iterator(); matchit.hasNext();) {
3290 MethodDescriptor matchmd=(MethodDescriptor)matchit.next();
3291 if (md.matches(matchmd))
3298 private void generateFlatFieldNode(FlatMethod fm, LocalityBinding lb, FlatFieldNode ffn, PrintWriter output) {
3299 if (state.SINGLETM) {
3300 //single machine transactional memory case
3301 String field=ffn.getField().getSafeSymbol();
3302 String src=generateTemp(fm, ffn.getSrc(),lb);
3303 String dst=generateTemp(fm, ffn.getDst(),lb);
3305 output.println(dst+"="+ src +"->"+field+ ";");
3306 if (ffn.getField().getType().isPtr()&&locality.getAtomic(lb).get(ffn).intValue()>0&&
3307 locality.getNodePreTempInfo(lb, ffn).get(ffn.getSrc())!=LocalityAnalysis.SCRATCH) {
3308 if ((dc==null)||(!state.READSET&&dc.getNeedTrans(lb, ffn))||
3309 (state.READSET&&dc.getNeedWriteTrans(lb, ffn))) {
3310 output.println("TRANSREAD("+dst+", "+dst+", (void *) (" + localsprefixaddr + "));");
3311 } else if (state.READSET&&dc.getNeedTrans(lb, ffn)) {
3312 if (state.HYBRID&&delaycomp.getConv(lb).contains(ffn)) {
3313 output.println("TRANSREADRDFISSION("+dst+", "+dst+");");
3315 output.println("TRANSREADRD("+dst+", "+dst+");");
3318 } else if (state.DSM) {
3319 Integer status=locality.getNodePreTempInfo(lb,ffn).get(ffn.getSrc());
3320 if (status==LocalityAnalysis.GLOBAL) {
3321 String field=ffn.getField().getSafeSymbol();
3322 String src=generateTemp(fm, ffn.getSrc(),lb);
3323 String dst=generateTemp(fm, ffn.getDst(),lb);
3325 if (ffn.getField().getType().isPtr()) {
3327 //TODO: Uncomment this when we have runtime support
3328 //if (ffn.getSrc()==ffn.getDst()) {
3329 //output.println("{");
3330 //output.println("void * temp="+src+";");
3331 //output.println("if (temp&0x1) {");
3332 //output.println("temp=(void *) transRead(trans, (unsigned int) temp);");
3333 //output.println(src+"->"+field+"="+temp+";");
3334 //output.println("}");
3335 //output.println(dst+"=temp;");
3336 //output.println("}");
3338 output.println(dst+"="+ src +"->"+field+ ";");
3339 //output.println("if ("+dst+"&0x1) {");
3340 //DEBUG: output.println("TRANSREAD("+dst+", (unsigned int) "+dst+",\""+fm+":"+ffn+"\");");
3341 output.println("TRANSREAD("+dst+", (unsigned int) "+dst+");");
3342 //output.println(src+"->"+field+"="+src+"->"+field+";");
3343 //output.println("}");
3346 output.println(dst+"="+ src+"->"+field+";");
3348 } else if (status==LocalityAnalysis.LOCAL) {
3349 if (ffn.getField().getType().isPtr()&&
3350 ffn.getField().isGlobal()) {
3351 String field=ffn.getField().getSafeSymbol();
3352 String src=generateTemp(fm, ffn.getSrc(),lb);
3353 String dst=generateTemp(fm, ffn.getDst(),lb);
3354 output.println(dst+"="+ src +"->"+field+ ";");
3355 if (locality.getAtomic(lb).get(ffn).intValue()>0)
3356 //DEBUG: output.println("TRANSREAD("+dst+", (unsigned int) "+dst+",\""+fm+":"+ffn+"\");");
3357 output.println("TRANSREAD("+dst+", (unsigned int) "+dst+");");
3359 output.println(generateTemp(fm, ffn.getDst(),lb)+"="+ generateTemp(fm,ffn.getSrc(),lb)+"->"+ ffn.getField().getSafeSymbol()+";");
3360 } else if (status==LocalityAnalysis.EITHER) {
3361 //Code is reading from a null pointer
3362 output.println("if ("+generateTemp(fm, ffn.getSrc(),lb)+") {");
3363 output.println("#ifndef RAW");
3364 output.println("printf(\"BIG ERROR\\n\");exit(-1);}");
3365 output.println("#endif");
3366 //This should throw a suitable null pointer error
3367 output.println(generateTemp(fm, ffn.getDst(),lb)+"="+ generateTemp(fm,ffn.getSrc(),lb)+"->"+ ffn.getField().getSafeSymbol()+";");
3369 throw new Error("Read from non-global/non-local in:"+lb.getExplanation());
3371 // DEBUG if(!ffn.getDst().getType().isPrimitive()){
3372 // DEBUG output.println("within((void*)"+generateTemp(fm,ffn.getSrc(),lb)+"->"+ ffn.getField().getSafeSymbol()+");");
3375 // TODO add version for normal Java later
3376 if(ffn.getField().isStatic()) {
3378 if((fm.getMethod().isStaticBlock()) || (fm.getMethod().isInvokedByStatic())) {
3379 // is a static block or is invoked in some static block
3380 ClassDescriptor cd = fm.getMethod().getClassDesc();
3381 ClassDescriptor cn = ffn.getSrc().getType().getClassDesc();
3383 // the same class, do nothing
3384 // TODO may want to invoke static field initialization here
3386 if((cn.getNumStaticFields() != 0) || (cn.getNumStaticBlocks() != 0)) {
3387 // need to check if the class' static fields have been initialized and/or
3388 // its static blocks have been executed
3389 output.println("#ifdef MGC_STATIC_INIT_CHECK");
3390 output.println("if(global_defs_p->" + cn.getSafeSymbol()+"static_block_exe_flag == 0) {");
3391 if(cn.getNumStaticBlocks() != 0) {
3392 MethodDescriptor t_md = (MethodDescriptor)cn.getMethodTable().get("staticblocks");
3393 output.println(" "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"();");
3395 output.println(" global_defs_p->" + cn.getSafeSymbol()+"static_block_exe_flag = 1;");
3397 output.println("}");
3398 output.println("#endif // MGC_STATIC_INIT_CHECK");
3402 // redirect to the global_defs_p structure
3403 if((ffn.getField().isStatic()) || (ffn.getSrc().getType().isClassNameRef())) {
3404 // decide the exact class/interface that defines the field
3405 ClassDescriptor fdcn =
3406 cd2fieldstbl.get(ffn.getSrc().getType().getClassDesc()).get(ffn.getField().getSymbol());
3408 // reference to the static field with Class name
3409 output.println(generateTemp(fm, ffn.getDst(),lb)+"=global_defs_p->"+ fdcn.getSafeSymbol()+ffn.getField().getSafeSymbol()+";");
3411 output.println(generateTemp(fm, ffn.getDst(),lb)+"=*"+ generateTemp(fm,ffn.getSrc(),lb)+"->"+ ffn.getField().getSafeSymbol()+";");
3413 } else if (ffn.getField().isEnum()) {
3414 // an Enum value, directly replace the field access as int
3415 output.println(generateTemp(fm, ffn.getDst(), lb) + "=" + ffn.getField().enumValue() + ";");
3417 output.println(generateTemp(fm, ffn.getDst(),lb)+"="+ generateTemp(fm,ffn.getSrc(),lb)+"->"+ ffn.getField().getSafeSymbol()+";");
3420 output.println(generateTemp(fm, ffn.getDst(),lb)+"="+ generateTemp(fm,ffn.getSrc(),lb)+"->"+ ffn.getField().getSafeSymbol()+";");
3426 private void generateFlatSetFieldNode(FlatMethod fm, LocalityBinding lb, FlatSetFieldNode fsfn, PrintWriter output) {
3427 if (fsfn.getField().getSymbol().equals("length")&&fsfn.getDst().getType().isArray())
3428 throw new Error("Can't set array length");
3429 if (state.SINGLETM && locality.getAtomic(lb).get(fsfn).intValue()>0) {
3430 //Single Machine Transaction Case
3431 boolean srcptr=fsfn.getSrc().getType().isPtr();
3432 String src=generateTemp(fm,fsfn.getSrc(),lb);
3433 String dst=generateTemp(fm,fsfn.getDst(),lb);
3434 output.println("//"+srcptr+" "+fsfn.getSrc().getType().isNull());
3435 if (srcptr&&!fsfn.getSrc().getType().isNull()) {
3436 output.println("{");
3437 if ((dc==null)||dc.getNeedSrcTrans(lb, fsfn)&&
3438 locality.getNodePreTempInfo(lb, fsfn).get(fsfn.getSrc())!=LocalityAnalysis.SCRATCH) {
3439 output.println("INTPTR srcoid=("+src+"!=NULL?((INTPTR)"+src+"->"+oidstr+"):0);");
3441 output.println("INTPTR srcoid=(INTPTR)"+src+";");
3444 if (wb.needBarrier(fsfn)&&
3445 locality.getNodePreTempInfo(lb, fsfn).get(fsfn.getDst())!=LocalityAnalysis.SCRATCH) {
3446 if (state.EVENTMONITOR) {
3447 output.println("if ("+dst+"->___objstatus___&DIRTY) EVLOGEVENTOBJ(EV_WRITE,"+dst+"->objuid)");
3449 output.println("*((unsigned int *)&("+dst+"->___objstatus___))|=DIRTY;");
3451 if (srcptr&!fsfn.getSrc().getType().isNull()) {
3452 output.println("*((unsigned INTPTR *)&("+dst+"->"+ fsfn.getField().getSafeSymbol()+"))=srcoid;");
3453 output.println("}");
3455 output.println(dst+"->"+ fsfn.getField().getSafeSymbol()+"="+ src+";");
3457 } else if (state.DSM && locality.getAtomic(lb).get(fsfn).intValue()>0) {
3458 Integer statussrc=locality.getNodePreTempInfo(lb,fsfn).get(fsfn.getSrc());
3459 Integer statusdst=locality.getNodeTempInfo(lb).get(fsfn).get(fsfn.getDst());
3460 boolean srcglobal=statussrc==LocalityAnalysis.GLOBAL;
3462 String src=generateTemp(fm,fsfn.getSrc(),lb);
3463 String dst=generateTemp(fm,fsfn.getDst(),lb);
3465 output.println("{");
3466 output.println("INTPTR srcoid=("+src+"!=NULL?((INTPTR)"+src+"->"+oidstr+"):0);");
3468 if (statusdst.equals(LocalityAnalysis.GLOBAL)) {
3471 if (wb.needBarrier(fsfn))
3472 output.println("*((unsigned int *)&("+dst+"->___localcopy___))|=DIRTY;");
3474 output.println("*((unsigned INTPTR *)&("+glbdst+"->"+ fsfn.getField().getSafeSymbol()+"))=srcoid;");
3476 output.println(glbdst+"->"+ fsfn.getField().getSafeSymbol()+"="+ src+";");
3477 } else if (statusdst.equals(LocalityAnalysis.LOCAL)) {
3478 /** Check if we need to copy */
3479 output.println("if(!"+dst+"->"+localcopystr+") {");
3480 /* Link object into list */
3481 String revertptr=generateTemp(fm, reverttable.get(lb),lb);
3482 output.println(revertptr+"=revertlist;");
3483 if (GENERATEPRECISEGC || this.state.MULTICOREGC)
3484 output.println("COPY_OBJ((struct garbagelist *)"+localsprefixaddr+",(struct ___Object___ *)"+dst+");");
3486 output.println("COPY_OBJ("+dst+");");
3487 output.println(dst+"->"+nextobjstr+"="+revertptr+";");
3488 output.println("revertlist=(struct ___Object___ *)"+dst+";");
3489 output.println("}");
3491 output.println(dst+"->"+ fsfn.getField().getSafeSymbol()+"=(void *) srcoid;");
3493 output.println(dst+"->"+ fsfn.getField().getSafeSymbol()+"="+ src+";");
3494 } else if (statusdst.equals(LocalityAnalysis.EITHER)) {
3495 //writing to a null...bad
3496 output.println("if ("+dst+") {");
3497 output.println("printf(\"BIG ERROR 2\\n\");exit(-1);}");
3499 output.println(dst+"->"+ fsfn.getField().getSafeSymbol()+"=(void *) srcoid;");
3501 output.println(dst+"->"+ fsfn.getField().getSafeSymbol()+"="+ src+";");
3504 output.println("}");
3507 if (state.FASTCHECK) {
3508 String dst=generateTemp(fm, fsfn.getDst(),lb);
3509 output.println("if(!"+dst+"->"+localcopystr+") {");
3510 /* Link object into list */
3511 if (GENERATEPRECISEGC || this.state.MULTICOREGC)
3512 output.println("COPY_OBJ((struct garbagelist *)"+localsprefixaddr+",(struct ___Object___ *)"+dst+");");
3514 output.println("COPY_OBJ("+dst+");");
3515 output.println(dst+"->"+nextobjstr+"="+fcrevert+";");
3516 output.println(fcrevert+"=(struct ___Object___ *)"+dst+";");
3517 output.println("}");
3520 // DEBUG if(!fsfn.getField().getType().isPrimitive()){
3521 // DEBUG output.println("within((void*)"+generateTemp(fm,fsfn.getSrc(),lb)+");");
3524 // TODO add version for normal Java later
3525 if(fsfn.getField().isStatic()) {
3527 if((fm.getMethod().isStaticBlock()) || (fm.getMethod().isInvokedByStatic())) {
3528 // is a static block or is invoked in some static block
3529 ClassDescriptor cd = fm.getMethod().getClassDesc();
3530 ClassDescriptor cn = fsfn.getDst().getType().getClassDesc();
3532 // the same class, do nothing
3533 // TODO may want to invoke static field initialization here
3535 if((cn.getNumStaticFields() != 0) || (cn.getNumStaticBlocks() != 0)) {
3536 // need to check if the class' static fields have been initialized and/or
3537 // its static blocks have been executed
3538 output.println("#ifdef MGC_STATIC_INIT_CHECK");
3539 output.println("if(global_defs_p->" + cn.getSafeSymbol()+"static_block_exe_flag == 0) {");
3540 if(cn.getNumStaticFields() != 0) {
3541 // TODO add static field initialization here
3543 if(cn.getNumStaticBlocks() != 0) {
3544 MethodDescriptor t_md = (MethodDescriptor)cn.getMethodTable().get("staticblocks");
3545 output.println(" "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"();");
3547 output.println(" global_defs_p->" + cn.getSafeSymbol()+"static_block_exe_flag = 1;");
3549 output.println("}");
3550 output.println("#endif // MGC_STATIC_INIT_CHECK");
3554 // redirect to the global_defs_p structure
3555 if(fsfn.getDst().getType().isClassNameRef()) {
3556 // reference to the static field with Class name
3557 // decide the exact class/interface that defines the field
3558 ClassDescriptor fdcn =
3559 cd2fieldstbl.get(fsfn.getDst().getType().getClassDesc()).get(fsfn.getField().getSymbol());
3561 output.println("global_defs_p->" + fdcn.getSafeSymbol() + fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc(),lb)+";");
3563 output.println("*"+generateTemp(fm, fsfn.getDst(),lb)+"->"+ fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc(),lb)+";");
3566 output.println(generateTemp(fm, fsfn.getDst(),lb)+"->"+ fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc(),lb)+";");
3569 output.println(generateTemp(fm, fsfn.getDst(),lb)+"->"+ fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc(),lb)+";");
3574 private void generateFlatElementNode(FlatMethod fm, LocalityBinding lb, FlatElementNode fen, PrintWriter output) {
3575 TypeDescriptor elementtype=fen.getSrc().getType().dereference();
3578 if (state.MGC && elementtype.isClass() && elementtype.getClassDesc().isEnum()) {
3580 } else if (elementtype.isArray()||elementtype.isClass())
3583 type=elementtype.getSafeSymbol()+" ";
3585 if (this.state.ARRAYBOUNDARYCHECK && fen.needsBoundsCheck()) {
3586 output.println("if (unlikely(((unsigned int)"+generateTemp(fm, fen.getIndex(),lb)+") >= "+generateTemp(fm,fen.getSrc(),lb) + "->___length___))");
3587 output.println("failedboundschk();");
3589 if (state.SINGLETM) {
3590 //Single machine transaction case
3591 String dst=generateTemp(fm, fen.getDst(),lb);
3592 if ((!state.STMARRAY)||(!wb.needBarrier(fen))||locality.getNodePreTempInfo(lb, fen).get(fen.getSrc())==LocalityAnalysis.SCRATCH||locality.getAtomic(lb).get(fen).intValue()==0||(state.READSET&&!dc.getNeedGet(lb, fen))) {
3593 output.println(dst +"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex(),lb)+"];");
3595 output.println("STMGETARRAY("+dst+", "+ generateTemp(fm,fen.getSrc(),lb)+", "+generateTemp(fm, fen.getIndex(),lb)+", "+type+");");
3598 if (elementtype.isPtr()&&locality.getAtomic(lb).get(fen).intValue()>0&&
3599 locality.getNodePreTempInfo(lb, fen).get(fen.getSrc())!=LocalityAnalysis.SCRATCH) {
3600 if ((dc==null)||!state.READSET&&dc.getNeedTrans(lb, fen)||state.READSET&&dc.getNeedWriteTrans(lb, fen)) {
3601 output.println("TRANSREAD("+dst+", "+dst+", (void *)(" + localsprefixaddr+"));");
3602 } else if (state.READSET&&dc.getNeedTrans(lb, fen)) {
3603 if (state.HYBRID&&delaycomp.getConv(lb).contains(fen)) {
3604 output.println("TRANSREADRDFISSION("+dst+", "+dst+");");
3606 output.println("TRANSREADRD("+dst+", "+dst+");");
3609 } else if (state.DSM) {
3610 Integer status=locality.getNodePreTempInfo(lb,fen).get(fen.getSrc());
3611 if (status==LocalityAnalysis.GLOBAL) {
3612 String dst=generateTemp(fm, fen.getDst(),lb);
3613 if (elementtype.isPtr()) {
3614 output.println(dst +"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex(),lb)+"];");
3615 //DEBUG: output.println("TRANSREAD("+dst+", "+dst+",\""+fm+":"+fen+"\");");
3616 output.println("TRANSREAD("+dst+", "+dst+");");
3618 output.println(dst +"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex(),lb)+"];");
3620 } else if (status==LocalityAnalysis.LOCAL) {
3621 output.println(generateTemp(fm, fen.getDst(),lb)+"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex(),lb)+"];");
3622 } else if (status==LocalityAnalysis.EITHER) {
3623 //Code is reading from a null pointer
3624 output.println("if ("+generateTemp(fm, fen.getSrc(),lb)+") {");
3625 output.println("#ifndef RAW");
3626 output.println("printf(\"BIG ERROR\\n\");exit(-1);}");
3627 output.println("#endif");
3628 //This should throw a suitable null pointer error
3629 output.println(generateTemp(fm, fen.getDst(),lb)+"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex(),lb)+"];");
3631 throw new Error("Read from non-global/non-local in:"+lb.getExplanation());
3633 // DEBUG output.println("within((void*)"+generateTemp(fm,fen.getSrc(),lb)+");");
3634 output.println(generateTemp(fm, fen.getDst(),lb)+"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex(),lb)+"];");
3638 private void generateFlatSetElementNode(FlatMethod fm, LocalityBinding lb, FlatSetElementNode fsen, PrintWriter output) {
3639 //TODO: need dynamic check to make sure this assignment is actually legal
3640 //Because Object[] could actually be something more specific...ie. Integer[]
3642 TypeDescriptor elementtype=fsen.getDst().getType().dereference();
3645 if (state.MGC && elementtype.isClass() && elementtype.getClassDesc().isEnum()) {
3647 } else if (elementtype.isArray()||elementtype.isClass() || (state.MGC && elementtype.isNull()))
3650 type=elementtype.getSafeSymbol()+" ";
3652 if (this.state.ARRAYBOUNDARYCHECK && fsen.needsBoundsCheck()) {
3653 output.println("if (unlikely(((unsigned int)"+generateTemp(fm, fsen.getIndex(),lb)+") >= "+generateTemp(fm,fsen.getDst(),lb) + "->___length___))");
3654 output.println("failedboundschk();");
3657 if (state.SINGLETM && locality.getAtomic(lb).get(fsen).intValue()>0) {
3658 //Transaction set element case
3659 if (wb.needBarrier(fsen)&&
3660 locality.getNodePreTempInfo(lb, fsen).get(fsen.getDst())!=LocalityAnalysis.SCRATCH) {
3661 output.println("*((unsigned int *)&("+generateTemp(fm,fsen.getDst(),lb)+"->___objstatus___))|=DIRTY;");
3663 if (fsen.getSrc().getType().isPtr()&&!fsen.getSrc().getType().isNull()) {
3664 output.println("{");
3665 String src=generateTemp(fm, fsen.getSrc(), lb);
3666 if ((dc==null)||dc.getNeedSrcTrans(lb, fsen)&&
3667 locality.getNodePreTempInfo(lb, fsen).get(fsen.getSrc())!=LocalityAnalysis.SCRATCH) {
3668 output.println("INTPTR srcoid=("+src+"!=NULL?((INTPTR)"+src+"->"+oidstr+"):0);");
3670 output.println("INTPTR srcoid=(INTPTR)"+src+";");
3672 if (state.STMARRAY&&locality.getNodePreTempInfo(lb, fsen).get(fsen.getDst())!=LocalityAnalysis.SCRATCH&&wb.needBarrier(fsen)&&locality.getAtomic(lb).get(fsen).intValue()>0) {
3673 output.println("STMSETARRAY("+generateTemp(fm, fsen.getDst(),lb)+", "+generateTemp(fm, fsen.getIndex(),lb)+", srcoid, INTPTR);");
3675 output.println("((INTPTR*)(((char *) &("+ generateTemp(fm,fsen.getDst(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex(),lb)+"]=srcoid;");
3677 output.println("}");
3679 if (state.STMARRAY&&locality.getNodePreTempInfo(lb, fsen).get(fsen.getDst())!=LocalityAnalysis.SCRATCH&&wb.needBarrier(fsen)&&locality.getAtomic(lb).get(fsen).intValue()>0) {
3680 output.println("STMSETARRAY("+generateTemp(fm, fsen.getDst(),lb)+", "+generateTemp(fm, fsen.getIndex(),lb)+", "+ generateTemp(fm, fsen.getSrc(), lb) +", "+type+");");
3682 output.println("(("+type +"*)(((char *) &("+ generateTemp(fm,fsen.getDst(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex(),lb)+"]="+generateTemp(fm,fsen.getSrc(),lb)+";");
3685 } else if (state.DSM && locality.getAtomic(lb).get(fsen).intValue()>0) {
3686 Integer statussrc=locality.getNodePreTempInfo(lb,fsen).get(fsen.getSrc());
3687 Integer statusdst=locality.getNodePreTempInfo(lb,fsen).get(fsen.getDst());
3688 boolean srcglobal=statussrc==LocalityAnalysis.GLOBAL;
3689 boolean dstglobal=statusdst==LocalityAnalysis.GLOBAL;
3690 boolean dstlocal=(statusdst==LocalityAnalysis.LOCAL)||(statusdst==LocalityAnalysis.EITHER);
3693 if (wb.needBarrier(fsen))
3694 output.println("*((unsigned int *)&("+generateTemp(fm,fsen.getDst(),lb)+"->___localcopy___))|=DIRTY;");
3695 } else if (dstlocal) {
3696 /** Check if we need to copy */
3697 String dst=generateTemp(fm, fsen.getDst(),lb);
3698 output.println("if(!"+dst+"->"+localcopystr+") {");
3699 /* Link object into list */
3700 String revertptr=generateTemp(fm, reverttable.get(lb),lb);
3701 output.println(revertptr+"=revertlist;");
3702 if ((GENERATEPRECISEGC) || this.state.MULTICOREGC)
3703 output.println("COPY_OBJ((struct garbagelist *)"+localsprefixaddr+",(struct ___Object___ *)"+dst+");");
3705 output.println("COPY_OBJ("+dst+");");
3706 output.println(dst+"->"+nextobjstr+"="+revertptr+";");
3707 output.println("revertlist=(struct ___Object___ *)"+dst+";");
3708 output.println("}");
3710 System.out.println("Node: "+fsen);
3711 System.out.println(lb);
3712 System.out.println("statusdst="+statusdst);
3713 System.out.println(fm.printMethod());
3714 throw new Error("Unknown array type");
3717 output.println("{");
3718 String src=generateTemp(fm, fsen.getSrc(), lb);
3719 output.println("INTPTR srcoid=("+src+"!=NULL?((INTPTR)"+src+"->"+oidstr+"):0);");
3720 output.println("((INTPTR*)(((char *) &("+ generateTemp(fm,fsen.getDst(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex(),lb)+"]=srcoid;");
3721 output.println("}");
3723 output.println("(("+type +"*)(((char *) &("+ generateTemp(fm,fsen.getDst(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex(),lb)+"]="+generateTemp(fm,fsen.getSrc(),lb)+";");
3726 if (state.FASTCHECK) {
3727 String dst=generateTemp(fm, fsen.getDst(),lb);
3728 output.println("if(!"+dst+"->"+localcopystr+") {");
3729 /* Link object into list */
3730 if (GENERATEPRECISEGC || this.state.MULTICOREGC)
3731 output.println("COPY_OBJ((struct garbagelist *)"+localsprefixaddr+",(struct ___Object___ *)"+dst+");");
3733 output.println("COPY_OBJ("+dst+");");
3734 output.println(dst+"->"+nextobjstr+"="+fcrevert+";");
3735 output.println(fcrevert+"=(struct ___Object___ *)"+dst+";");
3736 output.println("}");
3738 // DEBUG output.println("within((void*)"+generateTemp(fm,fsen.getDst(),lb)+");");
3739 output.println("(("+type +"*)(((char *) &("+ generateTemp(fm,fsen.getDst(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex(),lb)+"]="+generateTemp(fm,fsen.getSrc(),lb)+";");
3744 protected void generateFlatNew(FlatMethod fm, LocalityBinding lb, FlatNew fn, PrintWriter output) {
3745 if (state.DSM && locality.getAtomic(lb).get(fn).intValue()>0&&!fn.isGlobal()) {
3746 //Stash pointer in case of GC
3747 String revertptr=generateTemp(fm, reverttable.get(lb),lb);
3748 output.println(revertptr+"=revertlist;");
3750 if (state.SINGLETM) {
3751 if (fn.getType().isArray()) {
3752 int arrayid=state.getArrayNumber(fn.getType())+state.numClasses();
3753 if (locality.getAtomic(lb).get(fn).intValue()>0) {
3754 //inside transaction
3755 output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_newarraytrans("+localsprefixaddr+", "+arrayid+", "+generateTemp(fm, fn.getSize(),lb)+");");
3757 //outside transaction
3758 output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_newarray("+localsprefixaddr+", "+arrayid+", "+generateTemp(fm, fn.getSize(),lb)+");");
3761 if (locality.getAtomic(lb).get(fn).intValue()>0) {
3762 //inside transaction
3763 output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_newtrans("+localsprefixaddr+", "+fn.getType().getClassDesc().getId()+");");
3765 //outside transaction
3766 output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_new("+localsprefixaddr+", "+fn.getType().getClassDesc().getId()+");");
3769 } else if (fn.getType().isArray()) {
3770 int arrayid=state.getArrayNumber(fn.getType())+state.numClasses();
3771 if (fn.isGlobal()&&(state.DSM||state.SINGLETM)) {
3772 output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_newarrayglobal("+arrayid+", "+generateTemp(fm, fn.getSize(),lb)+");");
3773 } else if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
3774 output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_newarray("+localsprefixaddr+", "+arrayid+", "+generateTemp(fm, fn.getSize(),lb)+");");
3776 output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_newarray("+arrayid+", "+generateTemp(fm, fn.getSize(),lb)+");");
3779 if (fn.isGlobal()&&(state.DSM||state.SINGLETM)) {
3780 output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_newglobal("+fn.getType().getClassDesc().getId()+");");
3781 } else if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
3782 output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_new("+localsprefixaddr+", "+fn.getType().getClassDesc().getId()+");");
3784 output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_new("+fn.getType().getClassDesc().getId()+");");
3787 if (state.DSM && locality.getAtomic(lb).get(fn).intValue()>0&&!fn.isGlobal()) {
3788 String revertptr=generateTemp(fm, reverttable.get(lb),lb);
3789 String dst=generateTemp(fm,fn.getDst(),lb);
3790 output.println(dst+"->___localcopy___=(struct ___Object___*)1;");
3791 output.println(dst+"->"+nextobjstr+"="+revertptr+";");
3792 output.println("revertlist=(struct ___Object___ *)"+dst+";");
3794 if (state.FASTCHECK) {
3795 String dst=generateTemp(fm,fn.getDst(),lb);
3796 output.println(dst+"->___localcopy___=(struct ___Object___*)1;");
3797 output.println(dst+"->"+nextobjstr+"="+fcrevert+";");
3798 output.println(fcrevert+"=(struct ___Object___ *)"+dst+";");
3802 private void generateFlatTagDeclaration(FlatMethod fm, LocalityBinding lb, FlatTagDeclaration fn, PrintWriter output) {
3803 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
3804 output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_tag("+localsprefixaddr+", "+state.getTagId(fn.getType())+");");
3806 output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_tag("+state.getTagId(fn.getType())+");");
3810 private void generateFlatOpNode(FlatMethod fm, LocalityBinding lb, FlatOpNode fon, PrintWriter output) {
3811 if (fon.getRight()!=null) {
3812 if (fon.getOp().getOp()==Operation.URIGHTSHIFT) {
3813 if (fon.getLeft().getType().isLong())
3814 output.println(generateTemp(fm, fon.getDest(),lb)+" = ((unsigned long long)"+generateTemp(fm, fon.getLeft(),lb)+")>>"+generateTemp(fm,fon.getRight(),lb)+";");
3816 output.println(generateTemp(fm, fon.getDest(),lb)+" = ((unsigned int)"+generateTemp(fm, fon.getLeft(),lb)+")>>"+generateTemp(fm,fon.getRight(),lb)+";");
3818 } else if (dc!=null) {
3819 output.print(generateTemp(fm, fon.getDest(),lb)+" = (");
3820 if (fon.getLeft().getType().isPtr()&&(fon.getOp().getOp()==Operation.EQUAL||fon.getOp().getOp()==Operation.NOTEQUAL))
3821 output.print("(void *)");
3822 if (dc.getNeedLeftSrcTrans(lb, fon))
3823 output.print("("+generateTemp(fm, fon.getLeft(),lb)+"!=NULL?"+generateTemp(fm, fon.getLeft(),lb)+"->"+oidstr+":NULL)");
3825 output.print(generateTemp(fm, fon.getLeft(),lb));
3826 output.print(")"+fon.getOp().toString()+"(");
3827 if (fon.getRight().getType().isPtr()&&(fon.getOp().getOp()==Operation.EQUAL||fon.getOp().getOp()==Operation.NOTEQUAL))
3828 output.print("(void *)");
3829 if (dc.getNeedRightSrcTrans(lb, fon))
3830 output.println("("+generateTemp(fm, fon.getRight(),lb)+"!=NULL?"+generateTemp(fm, fon.getRight(),lb)+"->"+oidstr+":NULL));");
3832 output.println(generateTemp(fm,fon.getRight(),lb)+");");
3834 output.println(generateTemp(fm, fon.getDest(),lb)+" = "+generateTemp(fm, fon.getLeft(),lb)+fon.getOp().toString()+generateTemp(fm,fon.getRight(),lb)+";");
3835 } else if (fon.getOp().getOp()==Operation.ASSIGN)
3836 output.println(generateTemp(fm, fon.getDest(),lb)+" = "+generateTemp(fm, fon.getLeft(),lb)+";");
3837 else if (fon.getOp().getOp()==Operation.UNARYPLUS)
3838 output.println(generateTemp(fm, fon.getDest(),lb)+" = "+generateTemp(fm, fon.getLeft(),lb)+";");
3839 else if (fon.getOp().getOp()==Operation.UNARYMINUS)
3840 output.println(generateTemp(fm, fon.getDest(),lb)+" = -"+generateTemp(fm, fon.getLeft(),lb)+";");
3841 else if (fon.getOp().getOp()==Operation.LOGIC_NOT)
3842 output.println(generateTemp(fm, fon.getDest(),lb)+" = !"+generateTemp(fm, fon.getLeft(),lb)+";");
3843 else if (fon.getOp().getOp()==Operation.COMP)
3844 output.println(generateTemp(fm, fon.getDest(),lb)+" = ~"+generateTemp(fm, fon.getLeft(),lb)+";");
3845 else if (fon.getOp().getOp()==Operation.ISAVAILABLE) {
3846 output.println(generateTemp(fm, fon.getDest(),lb)+" = "+generateTemp(fm, fon.getLeft(),lb)+"->fses==NULL;");
3848 output.println(generateTemp(fm, fon.getDest(),lb)+fon.getOp().toString()+generateTemp(fm, fon.getLeft(),lb)+";");
3851 private void generateFlatCastNode(FlatMethod fm, LocalityBinding lb, FlatCastNode fcn, PrintWriter output) {
3852 /* TODO: Do type check here */
3853 if (fcn.getType().isArray()) {
3854 output.println(generateTemp(fm,fcn.getDst(),lb)+"=(struct ArrayObject *)"+generateTemp(fm,fcn.getSrc(),lb)+";");
3855 } else if (state.MGC && fcn.getType().isClass() && fcn.getType().getClassDesc().isEnum()) {
3856 output.println(generateTemp(fm,fcn.getDst(),lb)+"=(int)"+generateTemp(fm,fcn.getSrc(),lb)+";");
3857 } else if (fcn.getType().isClass())
3858 output.println(generateTemp(fm,fcn.getDst(),lb)+"=(struct "+fcn.getType().getSafeSymbol()+" *)"+generateTemp(fm,fcn.getSrc(),lb)+";");
3860 output.println(generateTemp(fm,fcn.getDst(),lb)+"=("+fcn.getType().getSafeSymbol()+")"+generateTemp(fm,fcn.getSrc(),lb)+";");
3863 private void generateFlatLiteralNode(FlatMethod fm, LocalityBinding lb, FlatLiteralNode fln, PrintWriter output) {
3864 if (fln.getValue()==null)
3865 output.println(generateTemp(fm, fln.getDst(),lb)+"=0;");
3866 else if (fln.getType().getSymbol().equals(TypeUtil.StringClass)) {
3867 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
3868 if (state.DSM && locality.getAtomic(lb).get(fln).intValue()>0) {
3869 //Stash pointer in case of GC
3870 String revertptr=generateTemp(fm, reverttable.get(lb),lb);
3871 output.println(revertptr+"=revertlist;");
3873 output.println(generateTemp(fm, fln.getDst(),lb)+"=NewString("+localsprefixaddr+", \""+FlatLiteralNode.escapeString((String)fln.getValue())+"\","+((String)fln.getValue()).length()+");");
3874 if (state.DSM && locality.getAtomic(lb).get(fln).intValue()>0) {
3875 //Stash pointer in case of GC
3876 String revertptr=generateTemp(fm, reverttable.get(lb),lb);
3877 output.println("revertlist="+revertptr+";");
3880 output.println(generateTemp(fm, fln.getDst(),lb)+"=NewString(\""+FlatLiteralNode.escapeString((String)fln.getValue())+"\","+((String)fln.getValue()).length()+");");
3882 } else if (fln.getType().isBoolean()) {
3883 if (((Boolean)fln.getValue()).booleanValue())
3884 output.println(generateTemp(fm, fln.getDst(),lb)+"=1;");
3886 output.println(generateTemp(fm, fln.getDst(),lb)+"=0;");
3887 } else if (fln.getType().isChar()) {
3888 String st=FlatLiteralNode.escapeString(fln.getValue().toString());
3889 output.println(generateTemp(fm, fln.getDst(),lb)+"='"+st+"';");
3890 } else if (fln.getType().isLong()) {
3891 output.println(generateTemp(fm, fln.getDst(),lb)+"="+fln.getValue()+"LL;");
3893 output.println(generateTemp(fm, fln.getDst(),lb)+"="+fln.getValue()+";");
3896 protected void generateFlatReturnNode(FlatMethod fm, LocalityBinding lb, FlatReturnNode frn, PrintWriter output) {
3898 // TODO add version for normal Java later
3899 if((fm.getMethod() != null) && (fm.getMethod().isStaticBlock())) {
3900 // a static block, check if it has been executed
3901 output.println(" global_defs_p->" + fm.getMethod().getClassDesc().getSafeSymbol()+"static_block_exe_flag = 1;");
3905 if (frn.getReturnTemp()!=null) {
3906 if (frn.getReturnTemp().getType().isPtr())
3907 output.println("return (struct "+fm.getMethod().getReturnType().getSafeSymbol()+"*)"+generateTemp(fm, frn.getReturnTemp(), lb)+";");
3909 output.println("return "+generateTemp(fm, frn.getReturnTemp(), lb)+";");
3911 output.println("return;");
3915 protected void generateStoreFlatCondBranch(FlatMethod fm, LocalityBinding lb, FlatCondBranch fcb, String label, PrintWriter output) {
3918 //only record if this group has more than one exit
3919 if (branchanalysis.numJumps(fcb)>1) {
3920 left=branchanalysis.jumpValue(fcb, 0);
3921 right=branchanalysis.jumpValue(fcb, 1);
3923 output.println("if (!"+generateTemp(fm, fcb.getTest(),lb)+") {");
3925 output.println("STOREBRANCH("+right+");");
3926 output.println("goto "+label+";");
3927 output.println("}");
3929 output.println("STOREBRANCH("+left+");");
3932 protected void generateFlatCondBranch(FlatMethod fm, LocalityBinding lb, FlatCondBranch fcb, String label, PrintWriter output) {
3933 output.println("if (!"+generateTemp(fm, fcb.getTest(),lb)+") goto "+label+";");
3936 /** This method generates header information for the method or
3937 * task referenced by the Descriptor des. */
3938 private void generateHeader(FlatMethod fm, LocalityBinding lb, Descriptor des, PrintWriter output) {
3939 generateHeader(fm, lb, des, output, false);
3942 private void generateHeader(FlatMethod fm, LocalityBinding lb, Descriptor des, PrintWriter output, boolean addSESErecord) {
3944 ParamsObject objectparams=(ParamsObject)paramstable.get(lb!=null ? lb : des);
3945 MethodDescriptor md=null;
3946 TaskDescriptor task=null;
3947 if (des instanceof MethodDescriptor)
3948 md=(MethodDescriptor) des;
3950 task=(TaskDescriptor) des;
3952 ClassDescriptor cn=md!=null ? md.getClassDesc() : null;
3954 if (md!=null&&md.getReturnType()!=null) {
3955 if (state.MGC && md.getReturnType().isClass() && md.getReturnType().getClassDesc().isEnum()) {
3956 output.print("int ");
3957 } else if (md.getReturnType().isClass()||md.getReturnType().isArray())
3958 output.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
3960 output.print(md.getReturnType().getSafeSymbol()+" ");
3962 //catch the constructor case
3963 output.print("void ");
3965 if (state.DSM||state.SINGLETM) {
3966 output.print(cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(");
3968 output.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(");
3970 output.print(task.getSafeSymbol()+"(");
3972 boolean printcomma=false;
3973 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
3975 if (state.DSM||state.SINGLETM) {
3976 output.print("struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
3978 output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
3980 output.print("struct "+task.getSafeSymbol()+"_params * "+paramsprefix);
3986 for(int i=0; i<objectparams.numPrimitives(); i++) {
3987 TempDescriptor temp=objectparams.getPrimitive(i);
3991 if(state.MGC && temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
3992 output.print("int " + temp.getSafeSymbol());
3993 } else if (temp.getType().isClass()||temp.getType().isArray())
3994 output.print("struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol());
3996 output.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
3998 output.println(") {");
3999 } else if (!GENERATEPRECISEGC && !this.state.MULTICOREGC) {
4000 /* Imprecise Task */
4001 output.println("void * parameterarray[]) {");
4002 /* Unpack variables */
4003 for(int i=0; i<objectparams.numPrimitives(); i++) {
4004 TempDescriptor temp=objectparams.getPrimitive(i);
4005 if(state.MGC && temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
4006 output.print("int " + temp.getSafeSymbol() + "=parameterarray["+i+"];");
4008 output.println("struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+"=parameterarray["+i+"];");
4011 for(int i=0; i<fm.numTags(); i++) {
4012 TempDescriptor temp=fm.getTag(i);
4013 int offset=i+objectparams.numPrimitives();
4014 output.println("struct ___TagDescriptor___ * "+temp.getSafeSymbol()+"=parameterarray["+offset+"];");
4017 if ((objectparams.numPrimitives()+fm.numTags())>maxtaskparams)
4018 maxtaskparams=objectparams.numPrimitives()+fm.numTags();
4019 } else output.println(") {");
4022 public void generateFlatFlagActionNode(FlatMethod fm, LocalityBinding lb, FlatFlagActionNode ffan, PrintWriter output) {
4023 output.println("/* FlatFlagActionNode */");
4026 /* Process tag changes */
4027 Relation tagsettable=new Relation();
4028 Relation tagcleartable=new Relation();
4030 Iterator tagsit=ffan.getTempTagPairs();
4031 while (tagsit.hasNext()) {
4032 TempTagPair ttp=(TempTagPair) tagsit.next();
4033 TempDescriptor objtmp=ttp.getTemp();
4034 TagDescriptor tag=ttp.getTag();
4035 TempDescriptor tagtmp=ttp.getTagTemp();
4036 boolean tagstatus=ffan.getTagChange(ttp);
4038 tagsettable.put(objtmp, tagtmp);
4040 tagcleartable.put(objtmp, tagtmp);
4045 Hashtable flagandtable=new Hashtable();
4046 Hashtable flagortable=new Hashtable();
4048 /* Process flag changes */
4049 Iterator flagsit=ffan.getTempFlagPairs();
4050 while(flagsit.hasNext()) {
4051 TempFlagPair tfp=(TempFlagPair)flagsit.next();
4052 TempDescriptor temp=tfp.getTemp();
4053 Hashtable flagtable=(Hashtable)flagorder.get(temp.getType().getClassDesc());
4054 FlagDescriptor flag=tfp.getFlag();
4056 //Newly allocate objects that don't set any flags case
4057 if (flagortable.containsKey(temp)) {
4061 flagortable.put(temp,new Integer(mask));
4063 int flagid=1<<((Integer)flagtable.get(flag)).intValue();
4064 boolean flagstatus=ffan.getFlagChange(tfp);
4067 if (flagortable.containsKey(temp)) {
4068 mask=((Integer)flagortable.get(temp)).intValue();
4071 flagortable.put(temp,new Integer(mask));
4073 int mask=0xFFFFFFFF;
4074 if (flagandtable.containsKey(temp)) {
4075 mask=((Integer)flagandtable.get(temp)).intValue();
4077 mask&=(0xFFFFFFFF^flagid);
4078 flagandtable.put(temp,new Integer(mask));
4084 HashSet flagtagset=new HashSet();
4085 flagtagset.addAll(flagortable.keySet());
4086 flagtagset.addAll(flagandtable.keySet());
4087 flagtagset.addAll(tagsettable.keySet());
4088 flagtagset.addAll(tagcleartable.keySet());
4090 Iterator ftit=flagtagset.iterator();
4091 while(ftit.hasNext()) {
4092 TempDescriptor temp=(TempDescriptor)ftit.next();
4095 Set tagtmps=tagcleartable.get(temp);
4096 if (tagtmps!=null) {
4097 Iterator tagit=tagtmps.iterator();
4098 while(tagit.hasNext()) {
4099 TempDescriptor tagtmp=(TempDescriptor)tagit.next();
4100 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC))
4101 output.println("tagclear("+localsprefixaddr+", (struct ___Object___ *)"+generateTemp(fm, temp,lb)+", "+generateTemp(fm,tagtmp,lb)+");");
4103 output.println("tagclear((struct ___Object___ *)"+generateTemp(fm, temp,lb)+", "+generateTemp(fm,tagtmp,lb)+");");
4107 tagtmps=tagsettable.get(temp);
4108 if (tagtmps!=null) {
4109 Iterator tagit=tagtmps.iterator();
4110 while(tagit.hasNext()) {
4111 TempDescriptor tagtmp=(TempDescriptor)tagit.next();
4112 if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC))
4113 output.println("tagset("+localsprefixaddr+", (struct ___Object___ *)"+generateTemp(fm, temp,lb)+", "+generateTemp(fm,tagtmp,lb)+");");
4115 output.println("tagset((struct ___Object___ *)"+generateTemp(fm, temp, lb)+", "+generateTemp(fm,tagtmp, lb)+");");
4120 int andmask=0xFFFFFFF;
4122 if (flagortable.containsKey(temp))
4123 ormask=((Integer)flagortable.get(temp)).intValue();
4124 if (flagandtable.containsKey(temp))
4125 andmask=((Integer)flagandtable.get(temp)).intValue();
4126 generateFlagOrAnd(ffan, fm, lb, temp, output, ormask, andmask);
4127 generateObjectDistribute(ffan, fm, lb, temp, output);
4131 protected void generateFlagOrAnd(FlatFlagActionNode ffan, FlatMethod fm, LocalityBinding lb, TempDescriptor temp,
4132 PrintWriter output, int ormask, int andmask) {
4133 if (ffan.getTaskType()==FlatFlagActionNode.NEWOBJECT) {
4134 output.println("flagorandinit("+generateTemp(fm, temp, lb)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
4136 output.println("flagorand("+generateTemp(fm, temp, lb)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
4140 protected void generateObjectDistribute(FlatFlagActionNode ffan, FlatMethod fm, LocalityBinding lb, TempDescriptor temp, PrintWriter output) {
4141 output.println("enqueueObject("+generateTemp(fm, temp, lb)+");");
4144 void generateOptionalHeader(PrintWriter headers) {
4147 headers.println("#include \"task.h\"\n\n");
4148 headers.println("#ifndef _OPTIONAL_STRUCT_");
4149 headers.println("#define _OPTIONAL_STRUCT_");
4151 //STRUCT PREDICATEMEMBER
4152 headers.println("struct predicatemember{");
4153 headers.println("int type;");
4154 headers.println("int numdnfterms;");
4155 headers.println("int * flags;");
4156 headers.println("int numtags;");
4157 headers.println("int * tags;\n};\n\n");
4159 //STRUCT OPTIONALTASKDESCRIPTOR
4160 headers.println("struct optionaltaskdescriptor{");
4161 headers.println("struct taskdescriptor * task;");
4162 headers.println("int index;");
4163 headers.println("int numenterflags;");
4164 headers.println("int * enterflags;");
4165 headers.println("int numpredicatemembers;");
4166 headers.println("struct predicatemember ** predicatememberarray;");
4167 headers.println("};\n\n");
4169 //STRUCT TASKFAILURE
4170 headers.println("struct taskfailure {");
4171 headers.println("struct taskdescriptor * task;");
4172 headers.println("int index;");
4173 headers.println("int numoptionaltaskdescriptors;");
4174 headers.println("struct optionaltaskdescriptor ** optionaltaskdescriptorarray;\n};\n\n");
4176 //STRUCT FSANALYSISWRAPPER
4177 headers.println("struct fsanalysiswrapper{");
4178 headers.println("int flags;");
4179 headers.println("int numtags;");
4180 headers.println("int * tags;");
4181 headers.println("int numtaskfailures;");
4182 headers.println("struct taskfailure ** taskfailurearray;");
4183 headers.println("int numoptionaltaskdescriptors;");
4184 headers.println("struct optionaltaskdescriptor ** optionaltaskdescriptorarray;\n};\n\n");
4186 //STRUCT CLASSANALYSISWRAPPER
4187 headers.println("struct classanalysiswrapper{");
4188 headers.println("int type;");
4189 headers.println("int numotd;");
4190 headers.println("struct optionaltaskdescriptor ** otdarray;");
4191 headers.println("int numfsanalysiswrappers;");
4192 headers.println("struct fsanalysiswrapper ** fsanalysiswrapperarray;\n};");
4194 headers.println("extern struct classanalysiswrapper * classanalysiswrapperarray[];");
4196 Iterator taskit=state.getTaskSymbolTable().getDescriptorsIterator();
4197 while(taskit.hasNext()) {
4198 TaskDescriptor td=(TaskDescriptor)taskit.next();
4199 headers.println("extern struct taskdescriptor task_"+td.getSafeSymbol()+";");
4204 //CHECK OVER THIS -- THERE COULD BE SOME ERRORS HERE
4205 int generateOptionalPredicate(Predicate predicate, OptionalTaskDescriptor otd, ClassDescriptor cdtemp, PrintWriter output) {
4206 int predicateindex = 0;
4207 //iterate through the classes concerned by the predicate
4208 Set c_vard = predicate.vardescriptors;
4209 Hashtable<TempDescriptor, Integer> slotnumber=new Hashtable<TempDescriptor, Integer>();
4212 for(Iterator vard_it = c_vard.iterator(); vard_it.hasNext();) {
4213 VarDescriptor vard = (VarDescriptor)vard_it.next();
4214 TypeDescriptor typed = vard.getType();
4216 //generate for flags
4217 HashSet fen_hashset = predicate.flags.get(vard.getSymbol());
4218 output.println("int predicateflags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
4220 if (fen_hashset!=null) {
4221 for (Iterator fen_it = fen_hashset.iterator(); fen_it.hasNext();) {
4222 FlagExpressionNode fen = (FlagExpressionNode)fen_it.next();
4224 DNFFlag dflag=fen.getDNF();
4225 numberterms+=dflag.size();
4227 Hashtable flags=(Hashtable)flagorder.get(typed.getClassDesc());
4229 for(int j=0; j<dflag.size(); j++) {
4231 output.println(",");
4232 Vector term=dflag.get(j);
4235 for(int k=0; k<term.size(); k++) {
4236 DNFFlagAtom dfa=(DNFFlagAtom)term.get(k);
4237 FlagDescriptor fd=dfa.getFlag();
4238 boolean negated=dfa.getNegated();
4239 int flagid=1<<((Integer)flags.get(fd)).intValue();
4244 output.print("/*andmask*/0x"+Integer.toHexString(andmask)+", /*checkmask*/0x"+Integer.toHexString(checkmask));
4249 output.println("};\n");
4252 TagExpressionList tagel = predicate.tags.get(vard.getSymbol());
4253 output.println("int predicatetags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
4256 for(int j=0; j<tagel.numTags(); j++) {
4258 output.println(",");
4259 TempDescriptor tmp=tagel.getTemp(j);
4260 if (!slotnumber.containsKey(tmp)) {
4261 Integer slotint=new Integer(current_slot++);
4262 slotnumber.put(tmp,slotint);
4264 int slot=slotnumber.get(tmp).intValue();
4265 output.println("/* slot */"+ slot+", /*tagid*/"+state.getTagId(tmp.getTag()));
4267 numtags = tagel.numTags();
4269 output.println("};");
4271 //store the result into a predicatemember struct
4272 output.println("struct predicatemember predicatemember_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"={");
4273 output.println("/*type*/"+typed.getClassDesc().getId()+",");
4274 output.println("/* number of dnf terms */"+numberterms+",");
4275 output.println("predicateflags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
4276 output.println("/* number of tag */"+numtags+",");
4277 output.println("predicatetags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
4278 output.println("};\n");
4283 //generate an array that stores the entire predicate
4284 output.println("struct predicatemember * predicatememberarray_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
4285 for( int j = 0; j<predicateindex; j++) {
4286 if( j != predicateindex-1) output.println("&predicatemember_"+j+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
4287 else output.println("&predicatemember_"+j+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
4289 output.println("};\n");
4290 return predicateindex;
4294 void generateOptionalArrays(PrintWriter output, PrintWriter headers, Hashtable<ClassDescriptor, Hashtable<FlagState, Set<OptionalTaskDescriptor>>> safeexecution, Hashtable optionaltaskdescriptors) {
4295 generateOptionalHeader(headers);
4297 output.println("#include \"optionalstruct.h\"\n\n");
4298 output.println("#include \"stdlib.h\"\n");
4300 HashSet processedcd = new HashSet();
4302 Enumeration e = safeexecution.keys();
4303 while (e.hasMoreElements()) {
4306 ClassDescriptor cdtemp=(ClassDescriptor)e.nextElement();
4307 Hashtable flaginfo=(Hashtable)flagorder.get(cdtemp); //will be used several times
4309 //Generate the struct of optionals
4310 Collection c_otd = ((Hashtable)optionaltaskdescriptors.get(cdtemp)).values();
4311 numotd = c_otd.size();
4312 if(maxotd<numotd) maxotd = numotd;
4313 if( !c_otd.isEmpty() ) {
4314 for(Iterator otd_it = c_otd.iterator(); otd_it.hasNext();) {
4315 OptionalTaskDescriptor otd = (OptionalTaskDescriptor)otd_it.next();
4317 //generate the int arrays for the predicate
4318 Predicate predicate = otd.predicate;
4319 int predicateindex = generateOptionalPredicate(predicate, otd, cdtemp, output);
4320 TreeSet<Integer> fsset=new TreeSet<Integer>();
4321 //iterate through possible FSes corresponding to
4322 //the state when entering
4324 for(Iterator fses = otd.enterflagstates.iterator(); fses.hasNext();) {
4325 FlagState fs = (FlagState)fses.next();
4327 for(Iterator flags = fs.getFlags(); flags.hasNext();) {
4328 FlagDescriptor flagd = (FlagDescriptor)flags.next();
4329 int id=1<<((Integer)flaginfo.get(flagd)).intValue();
4332 fsset.add(new Integer(flagid));
4333 //tag information not needed because tag
4334 //changes are not tolerated.
4337 output.println("int enterflag_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
4338 boolean needcomma=false;
4339 for(Iterator<Integer> it=fsset.iterator(); it.hasNext();) {
4342 output.println(it.next());
4345 output.println("};\n");
4348 //generate optionaltaskdescriptor that actually
4349 //includes exit fses, predicate and the task
4351 output.println("struct optionaltaskdescriptor optionaltaskdescriptor_"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"={");
4352 output.println("&task_"+otd.td.getSafeSymbol()+",");
4353 output.println("/*index*/"+otd.getIndex()+",");
4354 output.println("/*number of enter flags*/"+fsset.size()+",");
4355 output.println("enterflag_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
4356 output.println("/*number of members */"+predicateindex+",");
4357 output.println("predicatememberarray_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
4358 output.println("};\n");
4362 // if there are no optionals, there is no need to build the rest of the struct
4364 output.println("struct optionaltaskdescriptor * otdarray"+cdtemp.getSafeSymbol()+"[]={");
4365 c_otd = ((Hashtable)optionaltaskdescriptors.get(cdtemp)).values();
4366 if( !c_otd.isEmpty() ) {
4367 boolean needcomma=false;
4368 for(Iterator otd_it = c_otd.iterator(); otd_it.hasNext();) {
4369 OptionalTaskDescriptor otd = (OptionalTaskDescriptor)otd_it.next();
4371 output.println(",");
4373 output.println("&optionaltaskdescriptor_"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
4376 output.println("};\n");
4378 //get all the possible flagstates reachable by an object
4379 Hashtable hashtbtemp = safeexecution.get(cdtemp);
4381 TreeSet fsts=new TreeSet(new FlagComparator(flaginfo));
4382 fsts.addAll(hashtbtemp.keySet());
4383 for(Iterator fsit=fsts.iterator(); fsit.hasNext();) {
4384 FlagState fs = (FlagState)fsit.next();
4387 //get the set of OptionalTaskDescriptors corresponding
4388 HashSet<OptionalTaskDescriptor> availabletasks = (HashSet<OptionalTaskDescriptor>)hashtbtemp.get(fs);
4389 //iterate through the OptionalTaskDescriptors and
4390 //store the pointers to the optionals struct (see on
4391 //top) into an array
4393 output.println("struct optionaltaskdescriptor * optionaltaskdescriptorarray_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"[] = {");
4394 for(Iterator<OptionalTaskDescriptor> mos = ordertd(availabletasks).iterator(); mos.hasNext();) {
4395 OptionalTaskDescriptor mm = mos.next();
4397 output.println("&optionaltaskdescriptor_"+mm.getuid()+"_"+cdtemp.getSafeSymbol());
4399 output.println("&optionaltaskdescriptor_"+mm.getuid()+"_"+cdtemp.getSafeSymbol()+",");
4402 output.println("};\n");
4404 //process flag information (what the flag after failure is) so we know what optionaltaskdescriptors to choose.
4407 for(Iterator flags = fs.getFlags(); flags.hasNext();) {
4408 FlagDescriptor flagd = (FlagDescriptor)flags.next();
4409 int id=1<<((Integer)flaginfo.get(flagd)).intValue();
4413 //process tag information
4416 boolean first = true;
4417 Enumeration tag_enum = fs.getTags();
4418 output.println("int tags_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"[]={");
4419 while(tag_enum.hasMoreElements()) {
4421 TagDescriptor tagd = (TagDescriptor)tag_enum.nextElement();
4425 output.println(", ");
4426 output.println("/*tagid*/"+state.getTagId(tagd));
4428 output.println("};");
4430 Set<TaskIndex> tiset=sa.getTaskIndex(fs);
4431 for(Iterator<TaskIndex> itti=tiset.iterator(); itti.hasNext();) {
4432 TaskIndex ti=itti.next();
4436 Set<OptionalTaskDescriptor> otdset=sa.getOptions(fs, ti);
4438 output.print("struct optionaltaskdescriptor * optionaltaskfailure_FS"+fscounter+"_"+ti.getTask().getSafeSymbol()+"_"+ti.getIndex()+"_array[] = {");
4439 boolean needcomma=false;
4440 for(Iterator<OptionalTaskDescriptor> otdit=ordertd(otdset).iterator(); otdit.hasNext();) {
4441 OptionalTaskDescriptor otd=otdit.next();
4445 output.println("&optionaltaskdescriptor_"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
4447 output.println("};");
4449 output.print("struct taskfailure taskfailure_FS"+fscounter+"_"+ti.getTask().getSafeSymbol()+"_"+ti.getIndex()+" = {");
4450 output.print("&task_"+ti.getTask().getSafeSymbol()+", ");
4451 output.print(ti.getIndex()+", ");
4452 output.print(otdset.size()+", ");
4453 output.print("optionaltaskfailure_FS"+fscounter+"_"+ti.getTask().getSafeSymbol()+"_"+ti.getIndex()+"_array");
4454 output.println("};");
4457 tiset=sa.getTaskIndex(fs);
4458 boolean needcomma=false;
4460 output.println("struct taskfailure * taskfailurearray"+fscounter+"_"+cdtemp.getSafeSymbol()+"[]={");
4461 for(Iterator<TaskIndex> itti=tiset.iterator(); itti.hasNext();) {
4462 TaskIndex ti=itti.next();
4463 if (ti.isRuntime()) {
4470 output.print("&taskfailure_FS"+fscounter+"_"+ti.getTask().getSafeSymbol()+"_"+ti.getIndex());
4472 output.println("};\n");
4474 //Store the result in fsanalysiswrapper
4476 output.println("struct fsanalysiswrapper fsanalysiswrapper_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"={");
4477 output.println("/*flag*/"+flagid+",");
4478 output.println("/* number of tags*/"+tagcounter+",");
4479 output.println("tags_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+",");
4480 output.println("/* numtask failures */"+(tiset.size()-runtimeti)+",");
4481 output.println("taskfailurearray"+fscounter+"_"+cdtemp.getSafeSymbol()+",");
4482 output.println("/* number of optionaltaskdescriptors */"+availabletasks.size()+",");
4483 output.println("optionaltaskdescriptorarray_FS"+fscounter+"_"+cdtemp.getSafeSymbol());
4484 output.println("};\n");
4488 //Build the array of fsanalysiswrappers
4489 output.println("struct fsanalysiswrapper * fsanalysiswrapperarray_"+cdtemp.getSafeSymbol()+"[] = {");
4490 boolean needcomma=false;
4491 for(int i = 0; i<fscounter; i++) {
4492 if (needcomma) output.print(",");
4493 output.println("&fsanalysiswrapper_FS"+(i+1)+"_"+cdtemp.getSafeSymbol());
4496 output.println("};");
4498 //Build the classanalysiswrapper referring to the previous array
4499 output.println("struct classanalysiswrapper classanalysiswrapper_"+cdtemp.getSafeSymbol()+"={");
4500 output.println("/*type*/"+cdtemp.getId()+",");
4501 output.println("/*numotd*/"+numotd+",");
4502 output.println("otdarray"+cdtemp.getSafeSymbol()+",");
4503 output.println("/* number of fsanalysiswrappers */"+fscounter+",");
4504 output.println("fsanalysiswrapperarray_"+cdtemp.getSafeSymbol()+"};\n");
4505 processedcd.add(cdtemp);
4508 //build an array containing every classes for which code has been build
4509 output.println("struct classanalysiswrapper * classanalysiswrapperarray[]={");
4510 for(int i=0; i<state.numClasses(); i++) {
4511 ClassDescriptor cn=cdarray[i];
4514 if ((cn != null) && (processedcd.contains(cn)))
4515 output.print("&classanalysiswrapper_"+cn.getSafeSymbol());
4517 output.print("NULL");
4519 output.println("};");
4521 output.println("#define MAXOTD "+maxotd);
4522 headers.println("#endif");
4525 public List<OptionalTaskDescriptor> ordertd(Set<OptionalTaskDescriptor> otdset) {
4526 Relation r=new Relation();
4527 for(Iterator<OptionalTaskDescriptor>otdit=otdset.iterator(); otdit.hasNext();) {
4528 OptionalTaskDescriptor otd=otdit.next();
4529 TaskIndex ti=new TaskIndex(otd.td, otd.getIndex());
4533 LinkedList<OptionalTaskDescriptor> l=new LinkedList<OptionalTaskDescriptor>();
4534 for(Iterator it=r.keySet().iterator(); it.hasNext();) {
4535 Set s=r.get(it.next());
4536 for(Iterator it2=s.iterator(); it2.hasNext();) {
4537 OptionalTaskDescriptor otd=(OptionalTaskDescriptor)it2.next();
4545 protected void outputTransCode(PrintWriter output) {
4550 // override these methods in a subclass of BuildCode
4551 // to generate code for additional systems
4552 protected void additionalIncludesMethodsHeader( PrintWriter outmethodheader ) {}
4553 protected void preCodeGenInitialization() {}
4554 protected void postCodeGenCleanUp() {}
4555 protected void additionalCodeGen( PrintWriter outmethodheader,
4556 PrintWriter outstructs,
4557 PrintWriter outmethod ) {}
4558 protected void additionalCodeAtTopOfMain( PrintWriter outmethod ) {}
4559 protected void additionalCodeAtBottomOfMain( PrintWriter outmethod ) {}
4560 protected void additionalIncludesMethodsImplementation( PrintWriter outmethod ) {}
4561 protected void additionalIncludesStructsHeader( PrintWriter outstructs ) {}
4562 protected void additionalClassObjectFields( PrintWriter outclassdefs ) {}
4563 protected void additionalCodeAtTopMethodsImplementation( PrintWriter outmethod ) {}
4564 protected void additionalCodeAtTopFlatMethodBody( PrintWriter output, FlatMethod fm ) {}
4565 protected void additionalCodePreNode( FlatMethod fm, LocalityBinding lb, FlatNode fn, PrintWriter output ) {}
4566 protected void additionalCodePostNode( FlatMethod fm, LocalityBinding lb, FlatNode fn, PrintWriter output ) {}