Robust/src/IR/Flat/BuildCode.java

   1 package IR.Flat;
   2 import IR.Tree.Modifiers;
   3 import IR.Tree.FlagExpressionNode;
   4 import IR.Tree.DNFFlag;
   5 import IR.Tree.DNFFlagAtom;
   6 import IR.Tree.TagExpressionList;
   7 import IR.Tree.OffsetNode;
   8 import IR.*;
   9 import IR.Tree.JavaBuilder;
  10
  11 import java.util.*;
  12 import java.io.*;
  13
  14 import Util.Relation;
  15 import Analysis.TaskStateAnalysis.FlagState;
  16 import Analysis.TaskStateAnalysis.FlagComparator;
  17 import Analysis.TaskStateAnalysis.OptionalTaskDescriptor;
  18 import Analysis.TaskStateAnalysis.Predicate;
  19 import Analysis.TaskStateAnalysis.SafetyAnalysis;
  20 import Analysis.TaskStateAnalysis.TaskIndex;
  21 import Analysis.CallGraph.CallGraph;
  22 import Analysis.Loops.GlobalFieldType;
  23 import Util.CodePrinter;
  24
  25 public class BuildCode {
  26   State state;
  27   Hashtable temptovar;
  28   Hashtable paramstable;
  29   Hashtable tempstable;
  30   Hashtable fieldorder;
  31   Hashtable flagorder;
  32   int tag=0;
  33   String localsprefix="___locals___";
  34   String localsprefixaddr="&"+localsprefix;
  35   String localsprefixderef=localsprefix+".";
  36   String fcrevert="___fcrevert___";
  37   String paramsprefix="___params___";
  38   String nextobjstr="___nextobject___";
  39   String localcopystr="___localcopy___";
  40   public static boolean GENERATEPRECISEGC=false;
  41   public static String PREFIX="";
  42   public static String arraytype="ArrayObject";
  43   public static int flagcount = 0;
  44   Virtual virtualcalls;
  45   TypeUtil typeutil;
  46   protected int maxtaskparams=0;
  47   protected int maxcount=0;
  48   ClassDescriptor[] cdarray;
  49   ClassDescriptor[] ifarray;
  50   TypeDescriptor[] arraytable;
  51   SafetyAnalysis sa;
  52   CallGraph callgraph;
  53   Hashtable<String, ClassDescriptor> printedfieldstbl;
  54   int globaldefscount=0;
  55   boolean mgcstaticinit = false;
  56   JavaBuilder javabuilder;
  57
  58   int boundschknum = 0;
  59
  60   public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, CallGraph callgraph, JavaBuilder javabuilder) {
  61     this(st, temptovar, typeutil, null, callgraph, javabuilder);
  62   }
  63
  64   public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, CallGraph callgraph) {
  65     this(st, temptovar, typeutil, null, callgraph, null);
  66   }
  67
  68   public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, SafetyAnalysis sa, CallGraph callgraph) {
  69     this(st, temptovar, typeutil, sa, callgraph, null);
  70   }
  71
  72   public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, SafetyAnalysis sa, CallGraph callgraph, JavaBuilder javabuilder) {
  73     this.sa=sa;
  74     state=st;
  75     this.javabuilder=javabuilder;
  76     this.callgraph=callgraph;
  77     this.temptovar=temptovar;
  78     paramstable=new Hashtable();
  79     tempstable=new Hashtable();
  80     fieldorder=new Hashtable();
  81     flagorder=new Hashtable();
  82     this.typeutil=typeutil;
  83     State.logEvent("Virtual");
  84     virtualcalls=new Virtual(state, null, callgraph);
  85     printedfieldstbl = new Hashtable<String, ClassDescriptor>();
  86   }
  87
  88   /** The buildCode method outputs C code for all the methods.  The Flat
  89    * versions of the methods must already be generated and stored in
  90    * the State object. */
  91
  92   public void buildCode() {
  93     /* Create output streams to write to */
  94     PrintWriter outclassdefs=null;
  95     PrintWriter outstructs=null;
  96     PrintWriter outrepairstructs=null;
  97     PrintWriter outmethodheader=null;
  98     PrintWriter outmethod=null;
  99     PrintWriter outvirtual=null;
 100     PrintWriter outtask=null;
 101     PrintWriter outtaskdefs=null;
 102     PrintWriter outoptionalarrays=null;
 103     PrintWriter optionalheaders=null;
 104     PrintWriter outglobaldefs=null;
 105     PrintWriter outglobaldefsprim=null;
 106     State.logEvent("Beginning of buildCode");
 107
 108     try {
 109       buildCodeSetup(); //EXTENSION POINT
 110       outstructs=new CodePrinter(new FileOutputStream(PREFIX+"structdefs.h"), true);
 111       outmethodheader=new CodePrinter(new FileOutputStream(PREFIX+"methodheaders.h"), true);
 112       outclassdefs=new CodePrinter(new FileOutputStream(PREFIX+"classdefs.h"), true);
 113       outglobaldefs=new CodePrinter(new FileOutputStream(PREFIX+"globaldefs.h"), true);
 114       outglobaldefsprim=new CodePrinter(new FileOutputStream(PREFIX+"globaldefsprim.h"), true);
 115       outmethod=new CodePrinter(new FileOutputStream(PREFIX+"methods.c"), true);
 116       outvirtual=new CodePrinter(new FileOutputStream(PREFIX+"virtualtable.h"), true);
 117       if (state.TASK) {
 118         outtask=new CodePrinter(new FileOutputStream(PREFIX+"task.h"), true);
 119         outtaskdefs=new CodePrinter(new FileOutputStream(PREFIX+"taskdefs.c"), true);
 120         if (state.OPTIONAL) {
 121           outoptionalarrays=new CodePrinter(new FileOutputStream(PREFIX+"optionalarrays.c"), true);
 122           optionalheaders=new CodePrinter(new FileOutputStream(PREFIX+"optionalstruct.h"), true);
 123         }
 124       }
 125       if (state.structfile!=null) {
 126         outrepairstructs=new CodePrinter(new FileOutputStream(PREFIX+state.structfile+".struct"), true);
 127       }
 128     } catch (Exception e) {
 129       e.printStackTrace();
 130       System.exit(-1);
 131     }
 132
 133     /* Fix field safe symbols due to shadowing */
 134     FieldShadow.handleFieldShadow(state);
 135
 136     /* Build the virtual dispatch tables */
 137     buildVirtualTables(outvirtual);
 138
 139     /* Tag the methods that are invoked by static blocks */
 140     tagMethodInvokedByStaticBlock();
 141
 142     /* Output includes */
 143     outmethodheader.println("#ifndef METHODHEADERS_H");
 144     outmethodheader.println("#define METHODHEADERS_H");
 145     outmethodheader.println("#include \"structdefs.h\"");
 146
 147     if (state.EVENTMONITOR) {
 148       outmethodheader.println("#include \"monitor.h\"");
 149     }
 150
 151     additionalIncludesMethodsHeader(outmethodheader);
 152
 153     /* Output Structures */
 154     outputStructs(outstructs);
 155
 156     initOutputGlobals(outglobaldefs, outglobaldefsprim);
 157
 158     outclassdefs.println("#ifndef __CLASSDEF_H_");
 159     outclassdefs.println("#define __CLASSDEF_H_");
 160     outputClassDeclarations(outclassdefs, outglobaldefs, outglobaldefsprim);
 161
 162     // Output function prototypes and structures for parameters
 163     Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
 164     while(it.hasNext()) {
 165       ClassDescriptor cn=(ClassDescriptor)it.next();
 166       generateCallStructs(cn, outclassdefs, outstructs, outmethodheader, outglobaldefs, outglobaldefsprim);
 167     }
 168     outclassdefs.println("#include \"globaldefs.h\"");
 169     outclassdefs.println("#include \"globaldefsprim.h\"");
 170     outclassdefs.println("#endif");
 171     outclassdefs.close();
 172
 173     finalOutputGlobals(outglobaldefs, outglobaldefsprim);
 174
 175     if (state.TASK) {
 176       /* Map flags to integers */
 177       /* The runtime keeps track of flags using these integers */
 178       it=state.getClassSymbolTable().getDescriptorsIterator();
 179       while(it.hasNext()) {
 180         ClassDescriptor cn=(ClassDescriptor)it.next();
 181         mapFlags(cn);
 182       }
 183       /* Generate Tasks */
 184       generateTaskStructs(outstructs, outmethodheader);
 185
 186       /* Outputs generic task structures if this is a task
 187          program */
 188       outputTaskTypes(outtask);
 189     }
 190
 191     // an opportunity for subclasses to do extra
 192     // initialization
 193     preCodeGenInitialization();
 194
 195     State.logEvent("Start outputMethods");
 196     /* Build the actual methods */
 197     outputMethods(outmethod);
 198     State.logEvent("End outputMethods");
 199
 200     // opportunity for subclasses to gen extra code
 201     additionalCodeGen(outmethodheader, outstructs, outmethod);
 202
 203     if (state.TASK) {
 204       /* Output code for tasks */
 205       outputTaskCode(outtaskdefs, outmethod);
 206       outtaskdefs.close();
 207       outtask.close();
 208       /* Record maximum number of task parameters */
 209       outstructs.println("#define MAXTASKPARAMS "+maxtaskparams);
 210     } else if (state.main!=null) {
 211       /* Generate main method */
 212       outputMainMethod(outmethod);
 213     }
 214
 215     /* Generate information for task with optional parameters */
 216     if (state.TASK&&state.OPTIONAL) {
 217       generateOptionalArrays(outoptionalarrays, optionalheaders, state.getAnalysisResult(), state.getOptionalTaskDescriptors());
 218       outoptionalarrays.close();
 219       optionalheaders.close();
 220     }
 221
 222     /* Output structure definitions for repair tool */
 223     if (state.structfile!=null) {
 224       buildRepairStructs(outrepairstructs);
 225       outrepairstructs.close();
 226     }
 227
 228     /* Close files */
 229     outmethodheader.println("#endif");
 230     outmethodheader.close();
 231     outmethod.close();
 232     outstructs.println("#endif");
 233     outstructs.println();
 234     outstructs.close();
 235
 236     postCodeGenCleanUp();
 237     State.logEvent("End of buildCode");
 238   }
 239
 240   protected void initOutputGlobals(PrintWriter outglobaldefs, PrintWriter outglobaldefsprim) {
 241     // Output the C class declarations
 242     // These could mutually reference each other
 243     outglobaldefs.println("#ifndef __GLOBALDEF_H_");
 244     outglobaldefs.println("#define __GLOBALDEF_H_");
 245     outglobaldefs.println("");
 246     outglobaldefs.println("struct global_defs_t {");
 247     outglobaldefs.println("  int size;");
 248     outglobaldefs.println("  void * next;");
 249     outglobaldefs.println("  struct ArrayObject * classobjs;");
 250     outglobaldefsprim.println("#ifndef __GLOBALDEFPRIM_H_");
 251     outglobaldefsprim.println("#define __GLOBALDEFPRIM_H_");
 252     outglobaldefsprim.println("");
 253     outglobaldefsprim.println("struct global_defsprim_t {");
 254   }
 255
 256   protected void finalOutputGlobals(PrintWriter outglobaldefs, PrintWriter outglobaldefsprim) {
 257     outglobaldefs.println("};");
 258     outglobaldefs.println("");
 259     outglobaldefs.println("extern struct global_defs_t * global_defs_p;");
 260     outglobaldefs.println("#endif");
 261     outglobaldefs.flush();
 262     outglobaldefs.close();
 263
 264     outglobaldefsprim.println("};");
 265     outglobaldefsprim.println("");
 266     outglobaldefsprim.println("extern struct global_defsprim_t * global_defsprim_p;");
 267     outglobaldefsprim.println("#endif");
 268     outglobaldefsprim.flush();
 269     outglobaldefsprim.close();
 270   }
 271
 272   /* This method goes though the call graph and tag those methods that are
 273    * invoked inside static blocks
 274    */
 275   protected void tagMethodInvokedByStaticBlock() {
 276     Iterator it_sclasses = this.state.getSClassSymbolTable().getDescriptorsIterator();
 277     MethodDescriptor current_md=null;
 278     HashSet tovisit=new HashSet();
 279     HashSet visited=new HashSet();
 280
 281     while(it_sclasses.hasNext()) {
 282       ClassDescriptor cd = (ClassDescriptor)it_sclasses.next();
 283       MethodDescriptor md = (MethodDescriptor)cd.getMethodTable().get("staticblocks");
 284       if(md != null) {
 285         tovisit.add(md);
 286       }
 287     }
 288
 289     while(!tovisit.isEmpty()) {
 290       current_md=(MethodDescriptor)tovisit.iterator().next();
 291       tovisit.remove(current_md);
 292       visited.add(current_md);
 293       Iterator it_callee = this.callgraph.getCalleeSet(current_md).iterator();
 294       while(it_callee.hasNext()) {
 295         Descriptor d = (Descriptor)it_callee.next();
 296         if(d instanceof MethodDescriptor) {
 297           if(!visited.contains(d)) {
 298             ((MethodDescriptor)d).setIsInvokedByStatic(true);
 299             tovisit.add(d);
 300           }
 301         }
 302       }
 303     }
 304   }
 305
 306   /* This code generates code for each static block and static field
 307    * initialization.*/
 308   protected void outputStaticBlocks(PrintWriter outmethod) {
 309     //  execute all the static blocks and all the static field initializations
 310     // execute all the static blocks and all the static field initializations
 311     SymbolTable sctbl = this.state.getSClassSymbolTable();
 312     Iterator it_sclasses = sctbl.getDescriptorsIterator();
 313     if(it_sclasses.hasNext()) {
 314       while(it_sclasses.hasNext()) {
 315         ClassDescriptor t_cd = (ClassDescriptor)it_sclasses.next();
 316         MethodDescriptor t_md = (MethodDescriptor)t_cd.getMethodTable().get("staticblocks");
 317
 318         if(t_md != null&&callgraph.isInit(t_cd)) {
 319           outmethod.println("   {");
 320           if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
 321             outmethod.print("       struct "+t_cd.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"_params __parameterlist__={");
 322             outmethod.println("0, NULL};");
 323             outmethod.println("     "+t_cd.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"(& __parameterlist__);");
 324           } else {
 325             outmethod.println("     "+t_cd.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"();");
 326           }
 327           outmethod.println("   }");
 328         }
 329       }
 330     }
 331   }
 332
 333   /* This code generates code to create a Class object for each class for
 334    * getClass() method.
 335    * */
 336   protected void outputClassObjects(PrintWriter outmethod) {
 337     // create a global classobj array
 338     outmethod.println(" {");
 339     outmethod.println("    int i = 0;");
 340     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
 341       outmethod.println("    struct garbagelist dummy={0,NULL};");
 342       outmethod.println("    global_defs_p->classobjs = allocate_newarray(&dummy, OBJECTARRAYTYPE, "
 343                         + (state.numClasses()+state.numArrays()+state.numInterfaces()) + ");");
 344     } else {
 345       outmethod.println("    global_defs_p->classobjs = allocate_newarray(OBJECTARRAYTYPE, "
 346                         + (state.numClasses()+state.numArrays()+state.numInterfaces()) + ");");
 347     }
 348     outmethod.println("    for(i = 0; i < " + (state.numClasses()+state.numArrays()+state.numInterfaces()) + "; i++) {");
 349     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
 350       outmethod.println("        ((void **)(((char *) &(global_defs_p->classobjs->___length___))+sizeof(int)))[i] = allocate_new(NULL, " +typeutil.getClass(TypeUtil.ObjectClass).getId() + ");");
 351     } else {
 352       outmethod.println("        ((void **)(((char *) &(global_defs_p->classobjs->___length___))+sizeof(int)))[i] = allocate_new(" +typeutil.getClass(TypeUtil.ObjectClass).getId() + ");");
 353     }
 354     outmethod.println("    }");
 355     outmethod.println(" }");
 356   }
 357
 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. */
 361
 362   protected void outputMainMethod(PrintWriter outmethod) {
 363     outmethod.println("int main(int argc, const char *argv[]) {");
 364     outmethod.println("  int i;");
 365     if (state.THREAD) {
 366       outmethod.println("initializethreads();");
 367     }
 368     outmethod.println("  global_defs_p=calloc(1, sizeof(struct global_defs_t));");
 369     outmethod.println("  global_defsprim_p=calloc(1, sizeof(struct global_defsprim_t));");
 370     if (GENERATEPRECISEGC) {
 371       outmethod.println("  global_defs_p->size="+globaldefscount+";");
 372       outmethod.println("  for(i=0;i<"+globaldefscount+";i++) {");
 373       outmethod.println("    ((struct garbagelist *)global_defs_p)->array[i]=NULL;");
 374       outmethod.println("  }");
 375     }
 376     outputStaticBlocks(outmethod);
 377     outputClassObjects(outmethod);
 378
 379
 380     additionalCodeAtTopOfMain(outmethod);
 381
 382
 383     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
 384       outmethod.println("  struct ArrayObject * stringarray=allocate_newarray(NULL, STRINGARRAYTYPE, argc-1);");
 385     } else {
 386       outmethod.println("  struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc-1);");
 387     }
 388     outmethod.println("  for(i=1;i<argc;i++) {");
 389     outmethod.println("    int length=strlen(argv[i]);");
 390
 391     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
 392       outmethod.println("    struct ___String___ *newstring=NewString(NULL, argv[i], length);");
 393     } else {
 394       outmethod.println("    struct ___String___ *newstring=NewString(argv[i], length);");
 395     }
 396     outmethod.println("    ((void **)(((char *)& stringarray->___length___)+sizeof(int)))[i-1]=newstring;");
 397     outmethod.println("  }");
 398
 399     MethodDescriptor md=typeutil.getMain();
 400     ClassDescriptor cd=typeutil.getMainClass();
 401
 402     outmethod.println("   {");
 403     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
 404       outmethod.print("       struct "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
 405       outmethod.println("1, NULL,"+"stringarray};");
 406       outmethod.println("     "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(& __parameterlist__);");
 407     } else {
 408       outmethod.println("     "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(stringarray);");
 409     }
 410     outmethod.println("   }");
 411
 412     if (state.THREAD) {
 413       outmethod.println("pthread_mutex_lock(&gclistlock);");
 414       outmethod.println("threadcount--;");
 415       outmethod.println("pthread_cond_signal(&gccond);");
 416       outmethod.println("pthread_mutex_unlock(&gclistlock);");
 417     }
 418
 419     if (state.EVENTMONITOR) {
 420       outmethod.println("dumpdata();");
 421     }
 422
 423     if (state.THREAD)
 424       outmethod.println("pthread_exit(NULL);");
 425
 426
 427     additionalCodeAtBottomOfMain(outmethod);
 428
 429     outmethod.println("}");
 430   }
 431
 432   /* This method outputs code for each task. */
 433
 434   protected void outputTaskCode(PrintWriter outtaskdefs, PrintWriter outmethod) {
 435     /* Compile task based program */
 436     outtaskdefs.println("#include \"task.h\"");
 437     outtaskdefs.println("#include \"methodheaders.h\"");
 438     Iterator taskit=state.getTaskSymbolTable().getDescriptorsIterator();
 439     while(taskit.hasNext()) {
 440       TaskDescriptor td=(TaskDescriptor)taskit.next();
 441       FlatMethod fm=state.getMethodFlat(td);
 442
 443       generateFlatMethod(fm, outmethod);
 444       generateTaskDescriptor(outtaskdefs, fm, td);
 445     }
 446
 447     //Output task descriptors
 448     taskit=state.getTaskSymbolTable().getDescriptorsIterator();
 449     outtaskdefs.println("struct taskdescriptor * taskarray[]= {");
 450     boolean first=true;
 451     while(taskit.hasNext()) {
 452       TaskDescriptor td=(TaskDescriptor)taskit.next();
 453       if (first)
 454         first=false;
 455       else
 456         outtaskdefs.println(",");
 457       outtaskdefs.print("&task_"+td.getSafeSymbol());
 458     }
 459     outtaskdefs.println("};");
 460
 461     outtaskdefs.println("int numtasks="+state.getTaskSymbolTable().getValueSet().size()+";");
 462   }
 463
 464
 465   /* This method outputs most of the methods.c file.  This includes
 466    * some standard includes and then an array with the sizes of
 467    * objets and array that stores supertype and then the code for
 468    * the Java methods.. */
 469   protected void outputMethods(PrintWriter outmethod) {
 470     outmethod.println("#include \"methodheaders.h\"");
 471     outmethod.println("#include \"virtualtable.h\"");
 472     outmethod.println("#include \"runtime.h\"");
 473     if (state.JNI) {
 474       outmethod.println("#include \"jni-private.h\"");
 475     }
 476
 477     // always include: compiler directives will leave out
 478     // instrumentation when option is not set
 479     if(!state.MULTICORE) {
 480       outmethod.println("#include \"coreprof/coreprof.h\"");
 481     }
 482
 483     if (state.FASTCHECK) {
 484       outmethod.println("#include \"localobjects.h\"");
 485     }
 486     if(state.MULTICORE) {
 487       if(state.TASK) {
 488         outmethod.println("#include \"task.h\"");
 489       }
 490       outmethod.println("#include \"multicoreruntime.h\"");
 491       outmethod.println("#include \"runtime_arch.h\"");
 492     }
 493     if (state.THREAD||state.DSM||state.SINGLETM) {
 494       outmethod.println("#include <thread.h>");
 495     }
 496     if(state.MGC) {
 497       outmethod.println("#include \"thread.h\"");
 498     }
 499     if (state.main!=null) {
 500       outmethod.println("#include <string.h>");
 501     }
 502     if (state.CONSCHECK) {
 503       outmethod.println("#include \"checkers.h\"");
 504     }
 505
 506
 507     additionalIncludesMethodsImplementation(outmethod);
 508
 509     outmethod.println("struct global_defs_t * global_defs_p;");
 510     outmethod.println("struct global_defsprim_t * global_defsprim_p;");
 511     //Store the sizes of classes & array elements
 512     generateSizeArray(outmethod);
 513
 514     //Store table of supertypes
 515     generateSuperTypeTable(outmethod);
 516
 517     //Store the layout of classes
 518     generateLayoutStructs(outmethod);
 519
 520
 521     additionalCodeAtTopMethodsImplementation(outmethod);
 522
 523     generateMethods(outmethod);
 524   }
 525
 526   protected void generateMethods(PrintWriter outmethod) {
 527     /* Generate code for methods */
 528     Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();
 529     while(classit.hasNext()) {
 530       ClassDescriptor cn=(ClassDescriptor)classit.next();
 531       Iterator methodit=cn.getMethods();
 532       while(methodit.hasNext()) {
 533         /* Classify parameters */
 534         MethodDescriptor md=(MethodDescriptor)methodit.next();
 535         if (!callgraph.isCallable(md)&&(!md.isStaticBlock()||!callgraph.isInit(cn))) {
 536           continue;
 537         }
 538
 539         FlatMethod fm=state.getMethodFlat(md);
 540         if (!md.getModifiers().isNative()) {
 541           generateFlatMethod(fm, outmethod);
 542         } else if (state.JNI) {
 543           generateNativeFlatMethod(fm, outmethod);
 544         }
 545       }
 546     }
 547   }
 548
 549   protected void outputStructs(PrintWriter outstructs) {
 550     outstructs.println("#ifndef __STRUCTDEFS_H__");
 551     outstructs.println("#define __STRUCTDEFS_H__");
 552     outstructs.println("#include \"classdefs.h\"");
 553     outstructs.println("#ifndef INTPTR");
 554     outstructs.println("#ifdef BIT64");
 555     outstructs.println("#define INTPTR long");
 556     outstructs.println("#else");
 557     outstructs.println("#define INTPTR int");
 558     outstructs.println("#endif");
 559     outstructs.println("#endif");
 560
 561
 562     additionalIncludesStructsHeader(outstructs);
 563
 564
 565     /* Output #defines that the runtime uses to determine type
 566      * numbers for various objects it needs */
 567     outstructs.println("#define MAXCOUNT "+maxcount);
 568
 569     outstructs.println("#define STRINGARRAYTYPE "+
 570                        (state.getArrayNumber(
 571                           (new TypeDescriptor(typeutil.getClass(TypeUtil.StringClass))).makeArray(state))+state.numClasses()));
 572
 573     outstructs.println("#define OBJECTARRAYTYPE "+
 574                        (state.getArrayNumber(
 575                           (new TypeDescriptor(typeutil.getClass(TypeUtil.ObjectClass))).makeArray(state))+state.numClasses()));
 576
 577
 578     outstructs.println("#define STRINGTYPE "+typeutil.getClass(TypeUtil.StringClass).getId());
 579     outstructs.println("#define OBJECTTYPE "+typeutil.getClass(TypeUtil.ObjectClass).getId());
 580     outstructs.println("#define CHARARRAYTYPE "+
 581                        (state.getArrayNumber((new TypeDescriptor(TypeDescriptor.CHAR)).makeArray(state))+state.numClasses()));
 582
 583     outstructs.println("#define BYTEARRAYTYPE "+
 584                        (state.getArrayNumber((new TypeDescriptor(TypeDescriptor.BYTE)).makeArray(state))+state.numClasses()));
 585
 586     outstructs.println("#define BYTEARRAYARRAYTYPE "+
 587                        (state.getArrayNumber((new TypeDescriptor(TypeDescriptor.BYTE)).makeArray(state).makeArray(state))+state.numClasses()));
 588
 589     outstructs.println("#define NUMCLASSES "+state.numClasses());
 590     int totalClassSize = state.numClasses() + state.numArrays() + state.numInterfaces();
 591     outstructs.println("#define TOTALNUMCLASSANDARRAY "+ totalClassSize);
 592     if (state.TASK) {
 593       outstructs.println("#define STARTUPTYPE "+typeutil.getClass(TypeUtil.StartupClass).getId());
 594       outstructs.println("#define TAGTYPE "+typeutil.getClass(TypeUtil.TagClass).getId());
 595       outstructs.println("#define TAGARRAYTYPE "+
 596                          (state.getArrayNumber(new TypeDescriptor(typeutil.getClass(TypeUtil.TagClass)).makeArray(state))+state.numClasses()));
 597     }
 598   }
 599
 600   protected void outputClassDeclarations(PrintWriter outclassdefs, PrintWriter outglobaldefs, PrintWriter outglobaldefsprim) {
 601     if (state.THREAD||state.DSM||state.SINGLETM)
 602       outclassdefs.println("#include <pthread.h>");
 603     outclassdefs.println("#ifndef INTPTR");
 604     outclassdefs.println("#ifdef BIT64");
 605     outclassdefs.println("#define INTPTR long");
 606     outclassdefs.println("#else");
 607     outclassdefs.println("#define INTPTR int");
 608     outclassdefs.println("#endif");
 609     outclassdefs.println("#endif");
 610     if(state.OPTIONAL)
 611       outclassdefs.println("#include \"optionalstruct.h\"");
 612     outclassdefs.println("struct "+arraytype+";");
 613     /* Start by declaring all structs */
 614     Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
 615     while(it.hasNext()) {
 616       ClassDescriptor cn=(ClassDescriptor)it.next();
 617       outclassdefs.println("struct "+cn.getSafeSymbol()+";");
 618
 619       if((cn.getNumStaticFields() != 0) || (cn.getNumStaticBlocks() != 0)) {
 620         // this class has static fields/blocks, need to add a global flag to
 621         // indicate if its static fields have been initialized and/or if its
 622         // static blocks have been executed
 623         outglobaldefsprim.println("  int "+cn.getSafeSymbol()+"static_block_exe_flag;");
 624       }
 625     }
 626     outclassdefs.println("");
 627     //Print out definition for array type
 628     outclassdefs.println("struct "+arraytype+" {");
 629     outclassdefs.println("  int type;");
 630     outclassdefs.println("  int hashcode;");
 631
 632     additionalClassObjectFields(outclassdefs);
 633
 634
 635     if (state.EVENTMONITOR) {
 636       outclassdefs.println("  int objuid;");
 637     }
 638     if (state.THREAD) {
 639       outclassdefs.println("  volatile int tid;");
 640       outclassdefs.println("  volatile int notifycount;");
 641     }
 642     if(state.MGC) {
 643       outclassdefs.println("  int mutex;");
 644       outclassdefs.println("  volatile int notifycount;");
 645       outclassdefs.println("  volatile int objlock;");
 646       if(state.MULTICOREGC) {
 647         outclassdefs.println("  int marked;");
 648       }
 649     }
 650     if (state.TASK) {
 651       outclassdefs.println("  int flag;");
 652       outclassdefs.println("  int ___cachedCode___;");
 653       if(!state.MULTICORE) {
 654         outclassdefs.println("  void * flagptr;");
 655       } else {
 656         outclassdefs.println("  int version;");
 657         outclassdefs.println("  int * lock;");  // lock entry for this obj
 658         outclassdefs.println("  int mutex;");
 659         outclassdefs.println("  volatile int lockcount;");
 660         if(state.MULTICOREGC) {
 661           outclassdefs.println("  int marked;");
 662         }
 663       }
 664       if(state.OPTIONAL) {
 665         outclassdefs.println("  int numfses;");
 666         outclassdefs.println("  int * fses;");
 667       }
 668     }
 669
 670     printClassStruct(typeutil.getClass(TypeUtil.ObjectClass), outclassdefs, outglobaldefs, outglobaldefsprim);
 671     printedfieldstbl.clear();
 672     printExtraArrayFields(outclassdefs);
 673     if (state.ARRAYPAD) {
 674       outclassdefs.println("  int paddingforarray;");
 675     }
 676
 677     outclassdefs.println("  int ___length___;");
 678     outclassdefs.println("};\n");
 679
 680     outclassdefs.println("");
 681     outclassdefs.println("extern int classsize[];");
 682     outclassdefs.println("extern int hasflags[];");
 683     outclassdefs.println("extern unsigned INTPTR * pointerarray[];");
 684     outclassdefs.println("extern int* supertypes[];");
 685     outclassdefs.println("");
 686   }
 687
 688   /** Prints out definitions for generic task structures */
 689
 690   protected void outputTaskTypes(PrintWriter outtask) {
 691     outtask.println("#ifndef _TASK_H");
 692     outtask.println("#define _TASK_H");
 693     outtask.println("struct parameterdescriptor {");
 694     outtask.println("int type;");
 695     outtask.println("int numberterms;");
 696     outtask.println("int *intarray;");
 697     outtask.println("void * queue;");
 698     outtask.println("int numbertags;");
 699     outtask.println("int *tagarray;");
 700     outtask.println("};");
 701
 702     outtask.println("struct taskdescriptor {");
 703     outtask.println("void * taskptr;");
 704     outtask.println("int numParameters;");
 705     outtask.println("  int numTotal;");
 706     outtask.println("struct parameterdescriptor **descriptorarray;");
 707     outtask.println("char * name;");
 708     outtask.println("};");
 709     outtask.println("extern struct taskdescriptor * taskarray[];");
 710     outtask.println("extern numtasks;");
 711     outtask.println("#endif");
 712   }
 713
 714
 715   protected void buildRepairStructs(PrintWriter outrepairstructs) {
 716     Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();
 717     while(classit.hasNext()) {
 718       ClassDescriptor cn=(ClassDescriptor)classit.next();
 719       outrepairstructs.println("structure "+cn.getSymbol()+" {");
 720       outrepairstructs.println("  int __type__;");
 721       if (state.TASK) {
 722         outrepairstructs.println("  int __flag__;");
 723         if(!state.MULTICORE) {
 724           outrepairstructs.println("  int __flagptr__;");
 725         }
 726       }
 727       printRepairStruct(cn, outrepairstructs);
 728       outrepairstructs.println("}\n");
 729     }
 730
 731     for(int i=0; i<state.numArrays(); i++) {
 732       TypeDescriptor tdarray=arraytable[i];
 733       TypeDescriptor tdelement=tdarray.dereference();
 734       outrepairstructs.println("structure "+arraytype+"_"+state.getArrayNumber(tdarray)+" {");
 735       outrepairstructs.println("  int __type__;");
 736       printRepairStruct(typeutil.getClass(TypeUtil.ObjectClass), outrepairstructs);
 737       outrepairstructs.println("  int length;");
 738       outrepairstructs.println("}\n");
 739     }
 740   }
 741
 742   protected void printRepairStruct(ClassDescriptor cn, PrintWriter output) {
 743     ClassDescriptor sp=cn.getSuperDesc();
 744     if (sp!=null)
 745       printRepairStruct(sp, output);
 746
 747     Vector fields=(Vector)fieldorder.get(cn);
 748
 749     for(int i=0; i<fields.size(); i++) {
 750       FieldDescriptor fd=(FieldDescriptor)fields.get(i);
 751       if (fd.getType().isArray()) {
 752         output.println("  "+arraytype+"_"+ state.getArrayNumber(fd.getType()) +" * "+fd.getSymbol()+";");
 753       } else if (fd.getType().isClass())
 754         output.println("  "+fd.getType().getRepairSymbol()+" * "+fd.getSymbol()+";");
 755       else if (fd.getType().isFloat())
 756         output.println("  int "+fd.getSymbol()+"; /* really float */");
 757       else
 758         output.println("  "+fd.getType().getRepairSymbol()+" "+fd.getSymbol()+";");
 759     }
 760   }
 761
 762   /** This method outputs TaskDescriptor information */
 763   protected void generateTaskDescriptor(PrintWriter output, FlatMethod fm, TaskDescriptor task) {
 764     for (int i=0; i<task.numParameters(); i++) {
 765       VarDescriptor param_var=task.getParameter(i);
 766       TypeDescriptor param_type=task.getParamType(i);
 767       FlagExpressionNode param_flag=task.getFlag(param_var);
 768       TagExpressionList param_tag=task.getTag(param_var);
 769
 770       int dnfterms;
 771       if (param_flag==null) {
 772         output.println("int parameterdnf_"+i+"_"+task.getSafeSymbol()+"[]={");
 773         output.println("0x0, 0x0 };");
 774         dnfterms=1;
 775       } else {
 776         DNFFlag dflag=param_flag.getDNF();
 777         dnfterms=dflag.size();
 778
 779         Hashtable flags=(Hashtable)flagorder.get(param_type.getClassDesc());
 780         output.println("int parameterdnf_"+i+"_"+task.getSafeSymbol()+"[]={");
 781         for(int j=0; j<dflag.size(); j++) {
 782           if (j!=0)
 783             output.println(",");
 784           Vector term=dflag.get(j);
 785           int andmask=0;
 786           int checkmask=0;
 787           for(int k=0; k<term.size(); k++) {
 788             DNFFlagAtom dfa=(DNFFlagAtom)term.get(k);
 789             FlagDescriptor fd=dfa.getFlag();
 790             boolean negated=dfa.getNegated();
 791             int flagid=1<<((Integer)flags.get(fd)).intValue();
 792             andmask|=flagid;
 793             if (!negated)
 794               checkmask|=flagid;
 795           }
 796           output.print("0x"+Integer.toHexString(andmask)+", 0x"+Integer.toHexString(checkmask));
 797         }
 798         output.println("};");
 799       }
 800
 801       output.println("int parametertag_"+i+"_"+task.getSafeSymbol()+"[]={");
 802       if (param_tag!=null)
 803         for(int j=0; j<param_tag.numTags(); j++) {
 804           if (j!=0)
 805             output.println(",");
 806           /* for each tag we need */
 807           /* which slot it is */
 808           /* what type it is */
 809           TagVarDescriptor tvd=(TagVarDescriptor)task.getParameterTable().get(param_tag.getName(j));
 810           TempDescriptor tmp=param_tag.getTemp(j);
 811           int slot=fm.getTagInt(tmp);
 812           output.println(slot+", "+state.getTagId(tvd.getTag()));
 813         }
 814       output.println("};");
 815
 816       output.println("struct parameterdescriptor parameter_"+i+"_"+task.getSafeSymbol()+"={");
 817       output.println("/* type */"+param_type.getClassDesc().getId()+",");
 818       output.println("/* number of DNF terms */"+dnfterms+",");
 819       output.println("parameterdnf_"+i+"_"+task.getSafeSymbol()+",");
 820       output.println("0,");
 821       if (param_tag!=null)
 822         output.println("/* number of tags */"+param_tag.numTags()+",");
 823       else
 824         output.println("/* number of tags */ 0,");
 825       output.println("parametertag_"+i+"_"+task.getSafeSymbol());
 826       output.println("};");
 827     }
 828
 829
 830     output.println("struct parameterdescriptor * parameterdescriptors_"+task.getSafeSymbol()+"[] = {");
 831     for (int i=0; i<task.numParameters(); i++) {
 832       if (i!=0)
 833         output.println(",");
 834       output.print("&parameter_"+i+"_"+task.getSafeSymbol());
 835     }
 836     output.println("};");
 837
 838     output.println("struct taskdescriptor task_"+task.getSafeSymbol()+"={");
 839     output.println("&"+task.getSafeSymbol()+",");
 840     output.println("/* number of parameters */" +task.numParameters() + ",");
 841     int numtotal=task.numParameters()+fm.numTags();
 842     output.println("/* number total parameters */" +numtotal + ",");
 843     output.println("parameterdescriptors_"+task.getSafeSymbol()+",");
 844     output.println("\""+task.getSymbol()+"\"");
 845     output.println("};");
 846   }
 847
 848
 849   /** The buildVirtualTables method outputs the virtual dispatch
 850    * tables for methods. */
 851
 852   protected void buildVirtualTables(PrintWriter outvirtual) {
 853     Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();
 854     while(classit.hasNext()) {
 855       ClassDescriptor cd=(ClassDescriptor)classit.next();
 856       if (virtualcalls.getMethodCount(cd)>maxcount)
 857         maxcount=virtualcalls.getMethodCount(cd);
 858     }
 859     MethodDescriptor[][] virtualtable=null;
 860     virtualtable=new MethodDescriptor[state.numClasses()+state.numArrays()][maxcount];
 861
 862     /* Fill in virtual table */
 863     classit=state.getClassSymbolTable().getDescriptorsIterator();
 864     while(classit.hasNext()) {
 865       ClassDescriptor cd=(ClassDescriptor)classit.next();
 866       if(cd.isInterface()) {
 867         continue;
 868       }
 869       fillinRow(cd, virtualtable, cd.getId());
 870     }
 871
 872     ClassDescriptor objectcd=typeutil.getClass(TypeUtil.ObjectClass);
 873     Iterator arrayit=state.getArrayIterator();
 874     while(arrayit.hasNext()) {
 875       TypeDescriptor td=(TypeDescriptor)arrayit.next();
 876       int id=state.getArrayNumber(td);
 877       fillinRow(objectcd, virtualtable, id+state.numClasses());
 878     }
 879
 880     outvirtual.print("void * virtualtable[]={");
 881     boolean needcomma=false;
 882     for(int i=0; i<state.numClasses()+state.numArrays(); i++) {
 883       for(int j=0; j<maxcount; j++) {
 884         if (needcomma)
 885           outvirtual.print(", ");
 886         if (virtualtable[i][j]!=null) {
 887           MethodDescriptor md=virtualtable[i][j];
 888           outvirtual.print("& "+md.getClassDesc().getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
 889         } else {
 890           outvirtual.print("0");
 891         }
 892         needcomma=true;
 893       }
 894       outvirtual.println("");
 895     }
 896     outvirtual.println("};");
 897     outvirtual.close();
 898   }
 899
 900   protected void fillinRow(ClassDescriptor cd, MethodDescriptor[][] virtualtable, int rownum) {
 901     /* Get inherited methods */
 902     Iterator it_sifs = cd.getSuperInterfaces();
 903     while(it_sifs.hasNext()) {
 904       ClassDescriptor superif = (ClassDescriptor)it_sifs.next();
 905       fillinRow(superif, virtualtable, rownum);
 906     }
 907     if (cd.getSuperDesc()!=null)
 908       fillinRow(cd.getSuperDesc(), virtualtable, rownum);
 909     /* Override them with our methods */
 910     for(Iterator it=cd.getMethods(); it.hasNext(); ) {
 911       MethodDescriptor md=(MethodDescriptor)it.next();
 912       if (md.isStatic()||md.getReturnType()==null)
 913         continue;
 914
 915       if (!callgraph.isCallable(md)) {
 916         continue;
 917       }
 918
 919       int methodnum = virtualcalls.getMethodNumber(md);
 920       virtualtable[rownum][methodnum]=md;
 921     }
 922   }
 923
 924   /** Generate array that contains the sizes of class objects.  The
 925    * object allocation functions in the runtime use this
 926    * information. */
 927
 928   protected void generateSizeArray(PrintWriter outclassdefs) {
 929     outclassdefs.print("extern struct prefetchCountStats * evalPrefetch;\n");
 930     generateSizeArrayExtensions(outclassdefs);
 931
 932     Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
 933     cdarray=new ClassDescriptor[state.numClasses()];
 934     ifarray = new ClassDescriptor[state.numInterfaces()];
 935     cdarray[0] = null;
 936     int interfaceid = 0;
 937     while(it.hasNext()) {
 938       ClassDescriptor cd=(ClassDescriptor)it.next();
 939       if(cd.isInterface()) {
 940         ifarray[cd.getId()] = cd;
 941       } else {
 942         cdarray[cd.getId()] = cd;
 943       }
 944     }
 945
 946     arraytable=new TypeDescriptor[state.numArrays()];
 947
 948     Iterator arrayit=state.getArrayIterator();
 949     while(arrayit.hasNext()) {
 950       TypeDescriptor td=(TypeDescriptor)arrayit.next();
 951       int id=state.getArrayNumber(td);
 952       arraytable[id]=td;
 953     }
 954
 955     /* Print out types */
 956     outclassdefs.println("/* ");
 957     for(int i=0; i<state.numClasses(); i++) {
 958       ClassDescriptor cd=cdarray[i];
 959       if(cd == null) {
 960         outclassdefs.println("NULL " + i);
 961       } else {
 962         outclassdefs.println(cd +"  "+i);
 963       }
 964     }
 965
 966     for(int i=0; i<state.numArrays(); i++) {
 967       TypeDescriptor arraytd=arraytable[i];
 968       outclassdefs.println(arraytd.toPrettyString() +"  "+(i+state.numClasses()));
 969     }
 970
 971     for(int i=0; i<state.numInterfaces(); i++) {
 972       ClassDescriptor ifcd = ifarray[i];
 973       outclassdefs.println(ifcd +"  "+(i+state.numClasses()+state.numArrays()));
 974     }
 975
 976     outclassdefs.println("*/");
 977
 978
 979     outclassdefs.print("int classsize[]={");
 980
 981     boolean needcomma=false;
 982     for(int i=0; i<state.numClasses(); i++) {
 983       if (needcomma)
 984         outclassdefs.print(", ");
 985       if(i>0) {
 986         outclassdefs.print("sizeof(struct "+cdarray[i].getSafeSymbol()+")");
 987       } else {
 988         outclassdefs.print("0");
 989       }
 990       needcomma=true;
 991     }
 992
 993
 994     for(int i=0; i<state.numArrays(); i++) {
 995       if (needcomma)
 996         outclassdefs.print(", ");
 997       TypeDescriptor tdelement=arraytable[i].dereference();
 998       if (tdelement.isArray()||tdelement.isClass()||tdelement.isNull())
 999         outclassdefs.print("sizeof(void *)");
1000       else
1001         outclassdefs.print("sizeof("+tdelement.getSafeSymbol()+")");
1002       needcomma=true;
1003     }
1004
1005     for(int i=0; i<state.numInterfaces(); i++) {
1006       if (needcomma)
1007         outclassdefs.print(", ");
1008       outclassdefs.print("sizeof(struct "+ifarray[i].getSafeSymbol()+")");
1009       needcomma=true;
1010     }
1011
1012     outclassdefs.println("};");
1013
1014     ClassDescriptor objectclass=typeutil.getClass(TypeUtil.ObjectClass);
1015     needcomma=false;
1016     outclassdefs.print("int typearray[]={");
1017     for(int i=0; i<state.numClasses(); i++) {
1018       ClassDescriptor cd=cdarray[i];
1019       ClassDescriptor supercd=i>0?cd.getSuperDesc():null;
1020       if(supercd != null && supercd.isInterface()) {
1021         throw new Error("Super class can not be interfaces");
1022       }
1023       if (needcomma)
1024         outclassdefs.print(", ");
1025       if (supercd==null)
1026         outclassdefs.print("-1");
1027       else
1028         outclassdefs.print(supercd.getId());
1029       needcomma=true;
1030     }
1031
1032     for(int i=0; i<state.numArrays(); i++) {
1033       TypeDescriptor arraytd=arraytable[i];
1034       ClassDescriptor arraycd=arraytd.getClassDesc();
1035       if (arraycd==null) {
1036         if (needcomma)
1037           outclassdefs.print(", ");
1038         outclassdefs.print(objectclass.getId());
1039         needcomma=true;
1040         continue;
1041       }
1042       ClassDescriptor cd=arraycd.getSuperDesc();
1043       int type=-1;
1044       while(cd!=null) {
1045         TypeDescriptor supertd=new TypeDescriptor(cd);
1046         supertd.setArrayCount(arraytd.getArrayCount());
1047         type=state.getArrayNumber(supertd);
1048         if (type!=-1) {
1049           type+=state.numClasses();
1050           break;
1051         }
1052         cd=cd.getSuperDesc();
1053       }
1054       if (needcomma)
1055         outclassdefs.print(", ");
1056       outclassdefs.print(type);
1057       needcomma=true;
1058     }
1059
1060     for(int i=0; i<state.numInterfaces(); i++) {
1061       ClassDescriptor cd=ifarray[i];
1062       ClassDescriptor supercd=cd.getSuperDesc();
1063       if(supercd != null && supercd.isInterface()) {
1064         throw new Error("Super class can not be interfaces");
1065       }
1066       if (needcomma)
1067         outclassdefs.print(", ");
1068       if (supercd==null)
1069         outclassdefs.print("-1");
1070       else
1071         outclassdefs.print(supercd.getId());
1072       needcomma=true;
1073     }
1074
1075     outclassdefs.println("};");
1076
1077     needcomma=false;
1078
1079
1080     outclassdefs.print("int typearray2[]={");
1081     for(int i=0; i<state.numArrays(); i++) {
1082       TypeDescriptor arraytd=arraytable[i];
1083       ClassDescriptor arraycd=arraytd.getClassDesc();
1084       if (arraycd==null) {
1085         if (needcomma)
1086           outclassdefs.print(", ");
1087         outclassdefs.print("-1");
1088         needcomma=true;
1089         continue;
1090       }
1091       ClassDescriptor cd=arraycd.getSuperDesc();
1092       int level=arraytd.getArrayCount()-1;
1093       int type=-1;
1094       for(; level>0; level--) {
1095         TypeDescriptor supertd=new TypeDescriptor(objectclass);
1096         supertd.setArrayCount(level);
1097         type=state.getArrayNumber(supertd);
1098         if (type!=-1) {
1099           type+=state.numClasses();
1100           break;
1101         }
1102       }
1103       if (needcomma)
1104         outclassdefs.print(", ");
1105       outclassdefs.print(type);
1106       needcomma=true;
1107     }
1108
1109     outclassdefs.println("};");
1110   }
1111
1112   /** Constructs params and temp objects for each method or task.
1113    * These objects tell the compiler which temps need to be
1114    * allocated.  */
1115
1116   protected void generateTempStructs(FlatMethod fm) {
1117     MethodDescriptor md=fm.getMethod();
1118     TaskDescriptor task=fm.getTask();
1119     ParamsObject objectparams=md!=null?new ParamsObject(md,tag++):new ParamsObject(task, tag++);
1120     if (md!=null)
1121       paramstable.put(md, objectparams);
1122     else
1123       paramstable.put(task, objectparams);
1124
1125     for(int i=0; i<fm.numParameters(); i++) {
1126       TempDescriptor temp=fm.getParameter(i);
1127       TypeDescriptor type=temp.getType();
1128       if (type.isPtr()&&((GENERATEPRECISEGC) || (this.state.MULTICOREGC)))
1129         objectparams.addPtr(temp);
1130       else
1131         objectparams.addPrim(temp);
1132     }
1133
1134     for(int i=0; i<fm.numTags(); i++) {
1135       TempDescriptor temp=fm.getTag(i);
1136       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC))
1137         objectparams.addPtr(temp);
1138       else
1139         objectparams.addPrim(temp);
1140     }
1141
1142     TempObject objecttemps=md!=null?new TempObject(objectparams,md,tag++):new TempObject(objectparams, task, tag++);
1143     if (md!=null)
1144       tempstable.put(md, objecttemps);
1145     else
1146       tempstable.put(task, objecttemps);
1147
1148     for(Iterator nodeit=fm.getNodeSet().iterator(); nodeit.hasNext(); ) {
1149       FlatNode fn=(FlatNode)nodeit.next();
1150       TempDescriptor[] writes=fn.writesTemps();
1151       for(int i=0; i<writes.length; i++) {
1152         TempDescriptor temp=writes[i];
1153         TypeDescriptor type=temp.getType();
1154         if (type.isPtr()&&((GENERATEPRECISEGC) || (this.state.MULTICOREGC)))
1155           objecttemps.addPtr(temp);
1156         else
1157           objecttemps.addPrim(temp);
1158       }
1159     }
1160   }
1161
1162   /** This method outputs the following information about classes
1163    * and arrays:
1164    * (1) For classes, what are the locations of pointers.
1165    * (2) For arrays, does the array contain pointers or primitives.
1166    * (3) For classes, does the class contain flags.
1167    */
1168
1169   protected void generateLayoutStructs(PrintWriter output) {
1170     Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
1171     while(it.hasNext()) {
1172       ClassDescriptor cn=(ClassDescriptor)it.next();
1173       output.print("unsigned INTPTR "+cn.getSafeSymbol()+"_pointers[]={");
1174       if (javabuilder!=null&&!javabuilder.hasLayout(cn)) {
1175         output.println("0};");
1176         continue;
1177       }
1178
1179       int count=0;
1180       for(Iterator allit=cn.getFieldTable().getAllDescriptorsIterator(); allit.hasNext(); ) {
1181         FieldDescriptor fd=(FieldDescriptor)allit.next();
1182         if(fd.isStatic()) {
1183           continue;
1184         }
1185         TypeDescriptor type=fd.getType();
1186         if (type.isPtr())
1187           count++;
1188       }
1189       output.print(count);
1190       for(Iterator allit=cn.getFieldTable().getAllDescriptorsIterator(); allit.hasNext(); ) {
1191         FieldDescriptor fd=(FieldDescriptor)allit.next();
1192         if(fd.isStatic()) {
1193           continue;
1194         }
1195         TypeDescriptor type=fd.getType();
1196         if (type.isPtr()) {
1197           output.print(", ");
1198           output.print("((unsigned INTPTR)&(((struct "+cn.getSafeSymbol() +" *)0)->"+
1199                        fd.getSafeSymbol()+"))");
1200         }
1201       }
1202       output.println("};");
1203     }
1204
1205     output.println("unsigned INTPTR * pointerarray[]={");
1206     boolean needcomma=false;
1207     for(int i=0; i<state.numClasses(); i++) {
1208       ClassDescriptor cn=cdarray[i];
1209       if (needcomma)
1210         output.println(",");
1211       needcomma=true;
1212       if(cn != null) {
1213         output.print(cn.getSafeSymbol()+"_pointers");
1214       } else {
1215         output.print("NULL");
1216       }
1217     }
1218
1219     for(int i=0; i<state.numArrays(); i++) {
1220       if (needcomma)
1221         output.println(", ");
1222       TypeDescriptor tdelement=arraytable[i].dereference();
1223       if (tdelement.isArray()||tdelement.isClass())
1224         output.print("((unsigned INTPTR *)1)");
1225       else
1226         output.print("0");
1227       needcomma=true;
1228     }
1229
1230     output.println("};");
1231     needcomma=false;
1232     output.println("int hasflags[]={");
1233     for(int i=0; i<state.numClasses(); i++) {
1234       ClassDescriptor cn=cdarray[i];
1235       if (needcomma)
1236         output.println(", ");
1237       needcomma=true;
1238       if ((cn != null) && (cn.hasFlags()))
1239         output.print("1");
1240       else
1241         output.print("0");
1242     }
1243     output.println("};");
1244   }
1245
1246   private int checkarraysupertype(ClassDescriptor arraycd, TypeDescriptor arraytd) {
1247     int type=-1;
1248
1249     TypeDescriptor supertd=new TypeDescriptor(arraycd);
1250     supertd.setArrayCount(arraytd.getArrayCount());
1251     type=state.getArrayNumber(supertd);
1252     if (type!=-1) {
1253       return type;
1254     }
1255
1256     ClassDescriptor cd = arraycd.getSuperDesc();
1257     if(cd != null) {
1258       type = checkarraysupertype(cd, arraytd);
1259       if(type != -1) {
1260         return type;
1261       }
1262     }
1263
1264     Iterator it_sifs = arraycd.getSuperInterfaces();
1265     while(it_sifs.hasNext()) {
1266       ClassDescriptor ifcd = (ClassDescriptor)it_sifs.next();
1267       type = checkarraysupertype(ifcd, arraytd);
1268       if(type != -1) {
1269         return type;
1270       }
1271     }
1272
1273     return type;
1274   }
1275
1276
1277   /** Print out table to give us supertypes */
1278   protected void generateSuperTypeTable(PrintWriter output) {
1279     ClassDescriptor objectclass=typeutil.getClass(TypeUtil.ObjectClass);
1280     for(int i=0; i<state.numClasses(); i++) {
1281       ClassDescriptor cn=cdarray[i];
1282       if(cn == null) {
1283         continue;
1284       }
1285       output.print("int supertypes" + cn.getSafeSymbol() + "[] = {");
1286       boolean ncomma = false;
1287       int snum = 0;
1288       if((cn != null) && (cn.getSuperDesc() != null)) {
1289         snum++;
1290       }
1291       Iterator it_sifs = cn != null?cn.getSuperInterfaces():null;
1292       while(it_sifs != null && it_sifs.hasNext()) {
1293         snum++;
1294         it_sifs.next();
1295       }
1296       output.print(snum);
1297       ncomma = true;
1298       if ((cn != null) && (cn.getSuperDesc()!=null)) {
1299         if(ncomma) {
1300           output.print(",");
1301         }
1302         ClassDescriptor cdsuper=cn.getSuperDesc();
1303         output.print(cdsuper.getId());
1304       }
1305       it_sifs = cn != null?cn.getSuperInterfaces():null;
1306       while(it_sifs != null && it_sifs.hasNext()) {
1307         if(ncomma) {
1308           output.print(",");
1309         }
1310         output.print(((ClassDescriptor)it_sifs.next()).getId()+state.numClasses()+state.numArrays());
1311       }
1312
1313       output.println("};");
1314     }
1315
1316     for(int i=0; i<state.numArrays(); i++) {
1317       TypeDescriptor arraytd=arraytable[i];
1318       ClassDescriptor arraycd=arraytd.getClassDesc();
1319       output.print("int supertypes___arraytype___" + (i+state.numClasses()) + "[] = {");
1320       boolean ncomma = false;
1321       int snum = 0;
1322       if (arraycd==null) {
1323         snum++;
1324         output.print(snum);
1325         output.print(", ");
1326         output.print(objectclass.getId());
1327         output.println("};");
1328         continue;
1329       }
1330       if((arraycd != null) && (arraycd.getSuperDesc() != null)) {
1331         snum++;
1332       }
1333       Iterator it_sifs = arraycd != null?arraycd.getSuperInterfaces():null;
1334       while(it_sifs != null && it_sifs.hasNext()) {
1335         snum++;
1336         it_sifs.next();
1337       }
1338       output.print(snum);
1339       ncomma = true;
1340       if ((arraycd != null) && (arraycd.getSuperDesc()!=null)) {
1341         ClassDescriptor cd=arraycd.getSuperDesc();
1342         int type=-1;
1343         if(cd!=null) {
1344           type = checkarraysupertype(cd, arraytd);
1345           if(type != -1) {
1346             type += state.numClasses();
1347           }
1348         }
1349         if (ncomma)
1350           output.print(", ");
1351         output.print(type);
1352       }
1353       it_sifs = arraycd != null?arraycd.getSuperInterfaces():null;
1354       while(it_sifs != null && it_sifs.hasNext()) {
1355         ClassDescriptor ifcd = (ClassDescriptor)it_sifs.next();
1356         int type = checkarraysupertype(ifcd, arraytd);
1357         if(type != -1) {
1358           type += state.numClasses();
1359         }
1360         if (ncomma)
1361           output.print(", ");
1362         output.print(type);
1363       }
1364       output.println("};");
1365     }
1366
1367     for(int i=0; i<state.numInterfaces(); i++) {
1368       ClassDescriptor cn=ifarray[i];
1369       if(cn == null) {
1370         continue;
1371       }
1372       output.print("int supertypes" + cn.getSafeSymbol() + "[] = {");
1373       boolean ncomma = false;
1374       int snum = 0;
1375       if((cn != null) && (cn.getSuperDesc() != null)) {
1376         snum++;
1377       }
1378       Iterator it_sifs = cn != null?cn.getSuperInterfaces():null;
1379       while(it_sifs != null && it_sifs.hasNext()) {
1380         snum++;
1381         it_sifs.next();
1382       }
1383       output.print(snum);
1384       ncomma = true;
1385       if ((cn != null) && (cn.getSuperDesc()!=null)) {
1386         if(ncomma) {
1387           output.print(",");
1388         }
1389         ClassDescriptor cdsuper=cn.getSuperDesc();
1390         output.print(cdsuper.getId());
1391       }
1392       it_sifs = cn != null?cn.getSuperInterfaces():null;
1393       while(it_sifs != null && it_sifs.hasNext()) {
1394         if(ncomma) {
1395           output.print(",");
1396         }
1397         output.print(((ClassDescriptor)it_sifs.next()).getId()+state.numClasses()+state.numArrays());
1398       }
1399
1400       output.println("};");
1401     }
1402
1403     output.println("int* supertypes[]={");
1404     boolean needcomma=false;
1405     for(int i=0; i<state.numClasses(); i++) {
1406       ClassDescriptor cn=cdarray[i];
1407       if (needcomma)
1408         output.println(",");
1409       needcomma=true;
1410       if(cn != null) {
1411         output.print("supertypes" + cn.getSafeSymbol());
1412       } else {
1413         output.print(0);
1414       }
1415     }
1416
1417     for(int i=0; i<state.numArrays(); i++) {
1418       if (needcomma)
1419         output.println(",");
1420       needcomma = true;
1421       output.print("supertypes___arraytype___" + (i+state.numClasses()));
1422     }
1423
1424     for(int i=0; i<state.numInterfaces(); i++) {
1425       ClassDescriptor cn=ifarray[i];
1426       if (needcomma)
1427         output.println(",");
1428       needcomma=true;
1429       output.print("supertypes" + cn.getSafeSymbol());
1430     }
1431     output.println("};");
1432   }
1433
1434   /** Force consistent field ordering between inherited classes. */
1435
1436   protected void printClassStruct(ClassDescriptor cn, PrintWriter classdefout, PrintWriter globaldefout, PrintWriter globaldefprimout) {
1437
1438     ClassDescriptor sp=cn.getSuperDesc();
1439     if (sp!=null)
1440       printClassStruct(sp, classdefout, /*globaldefout*/ null, null);
1441
1442     SymbolTable sitbl = cn.getSuperInterfaceTable();
1443     Iterator it_sifs = sitbl.getDescriptorsIterator();
1444     while(it_sifs.hasNext()) {
1445       ClassDescriptor si = (ClassDescriptor)it_sifs.next();
1446       printClassStruct(si, classdefout, /*globaldefout*/ null, null);
1447     }
1448
1449     if (!fieldorder.containsKey(cn)) {
1450       Vector fields=new Vector();
1451       fieldorder.put(cn,fields);
1452
1453       Vector fieldvec=cn.getFieldVec();
1454 fldloop:
1455       for(int i=0; i<fieldvec.size(); i++) {
1456         FieldDescriptor fd=(FieldDescriptor)fieldvec.get(i);
1457         if((sp != null) && sp.getFieldTable().contains(fd.getSymbol())) {
1458           // a shadow field
1459         } else {
1460           it_sifs = sitbl.getDescriptorsIterator();
1461           while(it_sifs.hasNext()) {
1462             ClassDescriptor si = (ClassDescriptor)it_sifs.next();
1463             if(si.getFieldTable().contains(fd.getSymbol())) {
1464               continue fldloop;
1465             }
1466           }
1467           fields.add(fd);
1468         }
1469       }
1470     }
1471     //Vector fields=(Vector)fieldorder.get(cn);
1472
1473     Vector fields = cn.getFieldVec();
1474
1475     for(int i=0; i<fields.size(); i++) {
1476       FieldDescriptor fd=(FieldDescriptor)fields.get(i);
1477       String fstring = fd.getSafeSymbol();
1478       if(printedfieldstbl.containsKey(fstring)) {
1479         printedfieldstbl.put(fstring, cn);
1480         continue;
1481       } else {
1482         printedfieldstbl.put(fstring, cn);
1483       }
1484       if (fd.getType().isClass()
1485           && fd.getType().getClassDesc().isEnum()) {
1486         classdefout.println("  int " + fd.getSafeSymbol() + ";");
1487       } else if (fd.getType().isClass()||fd.getType().isArray()) {
1488         if (fd.isStatic()) {
1489           // TODO add version for normal Java later
1490           // static field
1491           if(globaldefout != null) {
1492             if(fd.isVolatile()) {
1493               globaldefout.println("  volatile struct "+fd.getType().getSafeSymbol()+ " * "+fd.getSafeSymbol()+";");
1494             } else {
1495               globaldefout.println("  struct "+fd.getType().getSafeSymbol()+ " * "+fd.getSafeSymbol()+";");
1496             }
1497             globaldefscount++;
1498           }
1499         } else if (fd.isVolatile()) {
1500           //volatile field
1501           classdefout.println("  volatile struct "+fd.getType().getSafeSymbol()+ " * "+fd.getSafeSymbol()+";");
1502         } else {
1503           classdefout.println("  struct "+fd.getType().getSafeSymbol()+" * "+fd.getSafeSymbol()+";");
1504         }
1505       } else if (fd.isStatic()) {
1506         // TODO add version for normal Java later
1507         // static field
1508         if(globaldefout != null) {
1509           if(fd.isVolatile()) {
1510             globaldefprimout.println("  volatile "+fd.getType().getSafeSymbol()+ " "+fd.getSafeSymbol()+";");
1511           } else {
1512             globaldefprimout.println("  "+fd.getType().getSafeSymbol()+ " "+fd.getSafeSymbol()+";");
1513           }
1514         }
1515       } else if (fd.isVolatile()) {
1516         //volatile field
1517         classdefout.println("  volatile "+fd.getType().getSafeSymbol()+ " "+fd.getSafeSymbol()+";");
1518       } else
1519         classdefout.println("  "+fd.getType().getSafeSymbol()+" "+fd.getSafeSymbol()+";");
1520     }
1521   }
1522
1523
1524   /* Map flags to integers consistently between inherited
1525    * classes. */
1526
1527   protected void mapFlags(ClassDescriptor cn) {
1528     ClassDescriptor sp=cn.getSuperDesc();
1529     if (sp!=null)
1530       mapFlags(sp);
1531     int max=0;
1532     if (!flagorder.containsKey(cn)) {
1533       Hashtable flags=new Hashtable();
1534       flagorder.put(cn,flags);
1535       if (sp!=null) {
1536         Hashtable superflags=(Hashtable)flagorder.get(sp);
1537         Iterator superflagit=superflags.keySet().iterator();
1538         while(superflagit.hasNext()) {
1539           FlagDescriptor fd=(FlagDescriptor)superflagit.next();
1540           Integer number=(Integer)superflags.get(fd);
1541           flags.put(fd, number);
1542           if ((number.intValue()+1)>max)
1543             max=number.intValue()+1;
1544         }
1545       }
1546
1547       Iterator flagit=cn.getFlags();
1548       while(flagit.hasNext()) {
1549         FlagDescriptor fd=(FlagDescriptor)flagit.next();
1550         if (sp==null||!sp.getFlagTable().contains(fd.getSymbol()))
1551           flags.put(fd, new Integer(max++));
1552       }
1553     }
1554   }
1555
1556
1557   /** This function outputs (1) structures that parameters are
1558    * passed in (when PRECISE GC is enabled) and (2) function
1559    * prototypes for the methods */
1560
1561   protected void generateCallStructs(ClassDescriptor cn, PrintWriter classdefout, PrintWriter output, PrintWriter headersout, PrintWriter globaldefout, PrintWriter globaldefprimout) {
1562     /* Output class structure */
1563     classdefout.println("struct "+cn.getSafeSymbol()+" {");
1564     classdefout.println("  int type;");
1565     classdefout.println("  int hashcode;");
1566
1567     additionalClassObjectFields(classdefout);
1568
1569
1570     if (state.EVENTMONITOR) {
1571       classdefout.println("  int objuid;");
1572     }
1573     if (state.THREAD) {
1574       classdefout.println("  volatile int tid;");
1575       classdefout.println("  volatile int notifycount;");
1576     }
1577     if (state.MGC) {
1578       classdefout.println("  int mutex;");
1579       classdefout.println("  volatile int notifycount;");
1580       classdefout.println("  volatile int objlock;");
1581       if(state.MULTICOREGC) {
1582         classdefout.println("  int marked;");
1583       }
1584     }
1585     if (state.TASK) {
1586       classdefout.println("  int flag;");
1587       classdefout.println("  int ___cachedCode___;");
1588       if((!state.MULTICORE) || (cn.getSymbol().equals("TagDescriptor"))) {
1589         classdefout.println("  void * flagptr;");
1590       } else if (state.MULTICORE) {
1591         classdefout.println("  int version;");
1592         classdefout.println("  int * lock;"); // lock entry for this obj
1593         classdefout.println("  int mutex;");
1594         classdefout.println("  volatile int lockcount;");
1595         if(state.MULTICOREGC) {
1596           classdefout.println("  int marked;");
1597         }
1598       }
1599       if (state.OPTIONAL) {
1600         classdefout.println("  int numfses;");
1601         classdefout.println("  int * fses;");
1602       }
1603     }
1604     if (javabuilder==null||javabuilder.hasLayout(cn))
1605       printClassStruct(cn, classdefout, globaldefout, globaldefprimout);
1606
1607     printedfieldstbl.clear(); // = new Hashtable<String, ClassDescriptor>();
1608     classdefout.println("};\n");
1609     generateCallStructsMethods(cn, output, headersout);
1610   }
1611
1612
1613   protected void generateCallStructsMethods(ClassDescriptor cn, PrintWriter output, PrintWriter headersout) {
1614     for(Iterator methodit=cn.getMethods(); methodit.hasNext(); ) {
1615       MethodDescriptor md=(MethodDescriptor)methodit.next();
1616
1617       FlatMethod fm=state.getMethodFlat(md);
1618
1619       if (!callgraph.isCallable(md)&&(!md.isStaticBlock()||!callgraph.isInit(cn))) {
1620         if (callgraph.isCalled(md)) {
1621           generateTempStructs(fm);
1622           generateMethodParam(cn, md, output);
1623         }
1624         continue;
1625       }
1626
1627       generateTempStructs(fm);
1628       generateMethodParam(cn, md, output);
1629
1630       generateMethod(cn, md, headersout, output);
1631     }
1632   }
1633
1634   protected void generateMethodParam(ClassDescriptor cn, MethodDescriptor md, PrintWriter output) {
1635     /* Output parameter structure */
1636     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1637       if(md.isInvokedByStatic() && !md.isStaticBlock() && !md.getModifiers().isNative()) {
1638         // generate the staticinit version
1639         String mdstring = md.getSafeMethodDescriptor() + "staticinit";
1640
1641         ParamsObject objectparams=(ParamsObject) paramstable.get(md);
1642         output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+mdstring+"_params {");
1643         output.println("  int size;");
1644         output.println("  void * next;");
1645         for(int i=0; i<objectparams.numPointers(); i++) {
1646           TempDescriptor temp=objectparams.getPointer(i);
1647           if(temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
1648             output.println("  int " + temp.getSafeSymbol() + ";");
1649           } else {
1650             output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
1651           }
1652         }
1653         output.println("};\n");
1654       }
1655
1656       ParamsObject objectparams=(ParamsObject) paramstable.get(md);
1657       output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params {");
1658       output.println("  int size;");
1659       output.println("  void * next;");
1660       for(int i=0; i<objectparams.numPointers(); i++) {
1661         TempDescriptor temp=objectparams.getPointer(i);
1662         if(temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
1663           output.println("  int " + temp.getSafeSymbol() + ";");
1664         } else {
1665           output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
1666         }
1667       }
1668       output.println("};\n");
1669     }
1670   }
1671
1672   protected void generateMethod(ClassDescriptor cn, MethodDescriptor md, PrintWriter headersout, PrintWriter output) {
1673     ParamsObject objectparams=(ParamsObject) paramstable.get(md);
1674     TempObject objecttemps=(TempObject) tempstable.get(md);
1675
1676     boolean printcomma = false;
1677
1678
1679     if(md.isInvokedByStatic() && !md.isStaticBlock() && !md.getModifiers().isNative()) {
1680       // generate the staticinit version
1681       String mdstring = md.getSafeMethodDescriptor() + "staticinit";
1682
1683       /* Output temp structure */
1684       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1685         output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+mdstring+"_locals {");
1686         output.println("  int size;");
1687         output.println("  void * next;");
1688         for(int i=0; i<objecttemps.numPointers(); i++) {
1689           TempDescriptor temp=objecttemps.getPointer(i);
1690           if (!temp.getType().isArray() && temp.getType().isNull())
1691             output.println("  void * "+temp.getSafeSymbol()+";");
1692           else
1693             output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
1694         }
1695         output.println("};\n");
1696       }
1697
1698       headersout.println("#define D"+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+mdstring+" 1");
1699       /* First the return type */
1700       if (md.getReturnType()!=null) {
1701         if(md.getReturnType().isClass() && md.getReturnType().getClassDesc().isEnum()) {
1702           headersout.println("  int ");
1703         } else if (md.getReturnType().isClass()||md.getReturnType().isArray())
1704           headersout.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
1705         else
1706           headersout.print(md.getReturnType().getSafeSymbol()+" ");
1707       } else
1708         //catch the constructor case
1709         headersout.print("void ");
1710
1711       /* Next the method name */
1712       headersout.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+mdstring+"(");
1713       printcomma=false;
1714       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1715         headersout.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+mdstring+"_params * "+paramsprefix);
1716         printcomma=true;
1717       }
1718
1719       /*  Output parameter list*/
1720       for(int i=0; i<objectparams.numPrimitives(); i++) {
1721         TempDescriptor temp=objectparams.getPrimitive(i);
1722         if (printcomma)
1723           headersout.print(", ");
1724         printcomma=true;
1725         if(temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
1726           headersout.print("int " + temp.getSafeSymbol());
1727         } else if (temp.getType().isClass()||temp.getType().isArray())
1728           headersout.print("struct " + temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol());
1729         else
1730           headersout.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
1731       }
1732       if(md.getSymbol().equals("MonitorEnter") && state.OBJECTLOCKDEBUG) {
1733         headersout.print(", int linenum");
1734       }
1735       headersout.println(");\n");
1736     }
1737
1738     /* Output temp structure */
1739     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1740       output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals {");
1741       output.println("  int size;");
1742       output.println("  void * next;");
1743       for(int i=0; i<objecttemps.numPointers(); i++) {
1744         TempDescriptor temp=objecttemps.getPointer(i);
1745         if (!temp.getType().isArray() && temp.getType().isNull())
1746           output.println("  void * "+temp.getSafeSymbol()+";");
1747         else
1748           output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
1749       }
1750       output.println("};\n");
1751     }
1752
1753     /********* Output method declaration ***********/
1754     headersout.println("#define D"+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+" 1");
1755     /* First the return type */
1756     if (md.getReturnType()!=null) {
1757       if(md.getReturnType().isClass() && md.getReturnType().getClassDesc().isEnum()) {
1758         headersout.println("  int ");
1759       } else if (md.getReturnType().isClass()||md.getReturnType().isArray())
1760         headersout.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
1761       else
1762         headersout.print(md.getReturnType().getSafeSymbol()+" ");
1763     } else
1764       //catch the constructor case
1765       headersout.print("void ");
1766
1767     /* Next the method name */
1768     headersout.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(");
1769     printcomma=false;
1770     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1771       headersout.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
1772       printcomma=true;
1773     }
1774
1775     /*  Output parameter list*/
1776     for(int i=0; i<objectparams.numPrimitives(); i++) {
1777       TempDescriptor temp=objectparams.getPrimitive(i);
1778       if (printcomma)
1779         headersout.print(", ");
1780       printcomma=true;
1781       if(temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
1782         headersout.print("int " + temp.getSafeSymbol());
1783       } else if (temp.getType().isClass()||temp.getType().isArray())
1784         headersout.print("struct " + temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol());
1785       else
1786         headersout.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
1787     }
1788     if(md.getSymbol().equals("MonitorEnter") && state.OBJECTLOCKDEBUG) {
1789       headersout.print(", int linenum");
1790     }
1791     headersout.println(");\n");
1792   }
1793
1794
1795   /** This function outputs (1) structures that parameters are
1796    * passed in (when PRECISE GC is enabled) and (2) function
1797    * prototypes for the tasks */
1798
1799   protected void generateTaskStructs(PrintWriter output, PrintWriter headersout) {
1800     /* Cycle through tasks */
1801     Iterator taskit=state.getTaskSymbolTable().getDescriptorsIterator();
1802
1803     while(taskit.hasNext()) {
1804       /* Classify parameters */
1805       TaskDescriptor task=(TaskDescriptor)taskit.next();
1806       FlatMethod fm=state.getMethodFlat(task);
1807       generateTempStructs(fm);
1808
1809       ParamsObject objectparams=(ParamsObject) paramstable.get(task);
1810       TempObject objecttemps=(TempObject) tempstable.get(task);
1811
1812       /* Output parameter structure */
1813       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1814         output.println("struct "+task.getSafeSymbol()+"_params {");
1815         output.println("  int size;");
1816         output.println("  void * next;");
1817         for(int i=0; i<objectparams.numPointers(); i++) {
1818           TempDescriptor temp=objectparams.getPointer(i);
1819           output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
1820         }
1821
1822         output.println("};\n");
1823         if ((objectparams.numPointers()+fm.numTags())>maxtaskparams) {
1824           maxtaskparams=objectparams.numPointers()+fm.numTags();
1825         }
1826       }
1827
1828       /* Output temp structure */
1829       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1830         output.println("struct "+task.getSafeSymbol()+"_locals {");
1831         output.println("  int size;");
1832         output.println("  void * next;");
1833         for(int i=0; i<objecttemps.numPointers(); i++) {
1834           TempDescriptor temp=objecttemps.getPointer(i);
1835           if (!temp.getType().isArray() && temp.getType().isNull())
1836             output.println("  void * "+temp.getSafeSymbol()+";");
1837           else if(temp.getType().isTag())
1838             output.println("  struct "+
1839                            (new TypeDescriptor(typeutil.getClass(TypeUtil.TagClass))).getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
1840           else
1841             output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
1842         }
1843         output.println("};\n");
1844       }
1845
1846       /* Output task declaration */
1847       headersout.print("void " + task.getSafeSymbol()+"(");
1848
1849       boolean printcomma=false;
1850       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1851         headersout.print("struct "+task.getSafeSymbol()+"_params * "+paramsprefix);
1852       } else
1853         headersout.print("void * parameterarray[]");
1854       headersout.println(");\n");
1855     }
1856   }
1857
1858   protected void generateNativeFlatMethod(FlatMethod fm, PrintWriter outmethod) {
1859     MethodDescriptor md=fm.getMethod();
1860     ClassDescriptor cd=md.getClassDesc();
1861     generateHeader(fm, md, outmethod);
1862     int startindex=0;
1863     outmethod.println("JNIPUSHFRAME();");
1864     if (md.getModifiers().isStatic()) {
1865       outmethod.println("jobject rec=JNIWRAP(((void **)(((char *) &(global_defs_p->classobjs->___length___))+sizeof(int)))[" + cd.getId() + "]);");
1866     } else {
1867       outmethod.println("jobject rec=JNIWRAP("+generateTemp(fm, fm.getParameter(0))+");");
1868       startindex=1;
1869     }
1870     for(int i=startindex; i<fm.numParameters(); i++) {
1871       TempDescriptor tmp=fm.getParameter(i);
1872       if (tmp.getType().isPtr()) {
1873         outmethod.println("jobject param"+i+"=JNIWRAP("+generateTemp(fm, fm.getParameter(i))+");");
1874       }
1875     }
1876     if (GENERATEPRECISEGC) {
1877       outmethod.println("stopforgc((struct garbagelist *)___params___);");
1878     }
1879     if (!md.getReturnType().isVoid()) {
1880       if (md.getReturnType().isPtr())
1881         outmethod.print("jobject retval=");
1882       else
1883         outmethod.print(md.getReturnType().getSafeSymbol()+" retval=");
1884     }
1885     outmethod.print("Java_");
1886     outmethod.print(cd.getPackage().replace('.','_'));
1887     outmethod.print("_"+md.getSymbol()+"(");
1888     outmethod.print("JNI_vtable, rec");
1889
1890     for(int i=startindex; i<fm.numParameters(); i++) {
1891       outmethod.print(", ");
1892       TempDescriptor tmp=fm.getParameter(i);
1893       if (tmp.getType().isPtr()) {
1894         outmethod.print("param"+i);
1895       } else {
1896         outmethod.print(generateTemp(fm, tmp));
1897       }
1898     }
1899     outmethod.println(");");
1900     if (GENERATEPRECISEGC) {
1901       outmethod.println("restartaftergc();");
1902     }
1903     if (!md.getReturnType().isVoid()) {
1904       if (md.getReturnType().isPtr()) {
1905         outmethod.println("struct ___Object___ * retobj=JNIUNWRAP(retval);");
1906         outmethod.println("JNIPOPFRAME();");
1907         outmethod.println("return retobj;");
1908       } else {
1909         outmethod.println("JNIPOPFRAME();");
1910         outmethod.println("return retval;");
1911       }
1912     } else
1913       outmethod.println("JNIPOPFRAME();");
1914
1915     outmethod.println("}");
1916     outmethod.println("");
1917   }
1918
1919   protected void generateFlatMethod(FlatMethod fm, PrintWriter output) {
1920     if (State.PRINTFLAT)
1921       System.out.println(fm.printMethod());
1922     MethodDescriptor md=fm.getMethod();
1923     TaskDescriptor task=fm.getTask();
1924     ClassDescriptor cn=md!=null?md.getClassDesc():null;
1925     ParamsObject objectparams=(ParamsObject)paramstable.get(md!=null?md:task);
1926
1927     if((md != null) && md.isInvokedByStatic() && !md.isStaticBlock() && !md.getModifiers().isNative()) {
1928       // generate a special static init version
1929       mgcstaticinit = true;
1930       String mdstring = md.getSafeMethodDescriptor() + "staticinit";
1931
1932       generateHeader(fm, md!=null?md:task,output);
1933       TempObject objecttemp=(TempObject) tempstable.get(md!=null?md:task);
1934
1935       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1936         output.print("   struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+mdstring+"_locals "+localsprefix+"={");
1937         output.print(objecttemp.numPointers()+",");
1938         output.print(paramsprefix);
1939         for(int j=0; j<objecttemp.numPointers(); j++)
1940           output.print(", NULL");
1941         output.println("};");
1942       }
1943
1944       for(int i=0; i<objecttemp.numPrimitives(); i++) {
1945         TempDescriptor td=objecttemp.getPrimitive(i);
1946         TypeDescriptor type=td.getType();
1947         if (type.isNull() && !type.isArray())
1948           output.println("   void * "+td.getSafeSymbol()+";");
1949         else if (type.isClass() && type.getClassDesc().isEnum()) {
1950           output.println("   int " + td.getSafeSymbol() + ";");
1951         } else if (type.isClass()||type.isArray())
1952           output.println("   struct "+type.getSafeSymbol()+" * "+td.getSafeSymbol()+";");
1953         else
1954           output.println("   "+type.getSafeSymbol()+" "+td.getSafeSymbol()+";");
1955       }
1956
1957       additionalCodeAtTopFlatMethodBody(output, fm);
1958
1959       /* Check to see if we need to do a GC if this is a
1960        * multi-threaded program...*/
1961
1962       if (((state.OOOJAVA||state.THREAD)&&GENERATEPRECISEGC) || state.MULTICOREGC) {
1963         //Don't bother if we aren't in recursive methods...The loops case will catch it
1964         if (callgraph.getAllMethods(md).contains(md)) {
1965           if (this.state.MULTICOREGC) {
1966             output.println("if(gcflag) gc("+localsprefixaddr+");");
1967           } else {
1968             output.println("if (unlikely(needtocollect)) checkcollect("+localsprefixaddr+");");
1969           }
1970         }
1971       }
1972
1973       generateCode(fm.getNext(0), fm, null, output);
1974
1975       output.println("}\n\n");
1976
1977       mgcstaticinit = false;
1978     }
1979
1980     generateHeader(fm, md!=null?md:task,output);
1981     TempObject objecttemp=(TempObject) tempstable.get(md!=null?md:task);
1982
1983     if((md != null) && (md.isStaticBlock())) {
1984       mgcstaticinit = true;
1985     }
1986
1987     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1988       if (md!=null)
1989         output.print("   struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals "+localsprefix+"={");
1990       else
1991         output.print("   struct "+task.getSafeSymbol()+"_locals "+localsprefix+"={");
1992       output.print(objecttemp.numPointers()+",");
1993       output.print(paramsprefix);
1994       for(int j=0; j<objecttemp.numPointers(); j++)
1995         output.print(", NULL");
1996       output.println("};");
1997     }
1998
1999     for(int i=0; i<objecttemp.numPrimitives(); i++) {
2000       TempDescriptor td=objecttemp.getPrimitive(i);
2001       TypeDescriptor type=td.getType();
2002       if (type.isNull() && !type.isArray())
2003         output.println("   void * "+td.getSafeSymbol()+";");
2004       else if (type.isClass() && type.getClassDesc().isEnum()) {
2005         output.println("   int " + td.getSafeSymbol() + ";");
2006       } else if (type.isClass()||type.isArray())
2007         output.println("   struct "+type.getSafeSymbol()+" * "+td.getSafeSymbol()+";");
2008       else
2009         output.println("   "+type.getSafeSymbol()+" "+td.getSafeSymbol()+";");
2010     }
2011
2012     additionalCodeAtTopFlatMethodBody(output, fm);
2013
2014     /* Check to see if we need to do a GC if this is a
2015      * multi-threaded program...*/
2016
2017     if (((state.OOOJAVA||state.THREAD)&&GENERATEPRECISEGC)
2018         || this.state.MULTICOREGC) {
2019       //Don't bother if we aren't in recursive methods...The loops case will catch it
2020       if (callgraph.getAllMethods(md).contains(md)) {
2021         if (this.state.MULTICOREGC) {
2022           output.println("if(gcflag) gc("+localsprefixaddr+");");
2023         } else {
2024           output.println("if (unlikely(needtocollect)) checkcollect("+localsprefixaddr+");");
2025         }
2026       }
2027     }
2028
2029     if(fm.getMethod()!=null&&fm.getMethod().isStaticBlock()) {
2030       // a static block, check if it has been executed
2031       output.println("  if(global_defsprim_p->" + cn.getSafeSymbol()+"static_block_exe_flag != 0) {");
2032       output.println("    return;");
2033       output.println("  }");
2034       output.println("");
2035     }
2036
2037     generateCode(fm.getNext(0), fm, null, output);
2038
2039     output.println("}\n\n");
2040
2041     mgcstaticinit = false;
2042   }
2043
2044   protected void generateCode(FlatNode first,
2045                               FlatMethod fm,
2046                               Set<FlatNode> stopset,
2047                               PrintWriter output) {
2048
2049     /* Assign labels to FlatNode's if necessary.*/
2050
2051     Hashtable<FlatNode, Integer> nodetolabel;
2052
2053     nodetolabel=assignLabels(first, stopset);
2054
2055     Set<FlatNode> storeset=null;
2056     HashSet<FlatNode> genset=null;
2057     HashSet<FlatNode> refset=null;
2058     Set<FlatNode> unionset=null;
2059
2060     /* Do the actual code generation */
2061     FlatNode current_node=null;
2062     HashSet tovisit=new HashSet();
2063     HashSet visited=new HashSet();
2064     tovisit.add(first);
2065     while(current_node!=null||!tovisit.isEmpty()) {
2066       if (current_node==null) {
2067         current_node=(FlatNode)tovisit.iterator().next();
2068         tovisit.remove(current_node);
2069       } else if (tovisit.contains(current_node)) {
2070         tovisit.remove(current_node);
2071       }
2072       visited.add(current_node);
2073       if (nodetolabel.containsKey(current_node)) {
2074         output.println("L"+nodetolabel.get(current_node)+":");
2075       }
2076       if (state.INSTRUCTIONFAILURE) {
2077         if (state.THREAD) {
2078           output.println("if ((++instructioncount)>failurecount) {instructioncount=0;injectinstructionfailure();}");
2079         } else
2080           output.println("if ((--instructioncount)==0) injectinstructionfailure();");
2081       }
2082       if (current_node.numNext()==0||stopset!=null&&stopset.contains(current_node)) {
2083         output.print("   ");
2084         generateFlatNode(fm, current_node, output);
2085
2086         if (state.OOOJAVA && stopset!=null) {
2087           assert first.getPrev(0) instanceof FlatSESEEnterNode;
2088           assert current_node       instanceof FlatSESEExitNode;
2089           FlatSESEEnterNode fsen = (FlatSESEEnterNode) first.getPrev(0);
2090           FlatSESEExitNode fsxn = (FlatSESEExitNode)  current_node;
2091           assert fsen.getFlatExit().equals(fsxn);
2092           assert fsxn.getFlatEnter().equals(fsen);
2093         }
2094         if (current_node.kind()!=FKind.FlatReturnNode) {
2095           if((fm.getMethod() != null) && (fm.getMethod().isStaticBlock())) {
2096             // a static block, check if it has been executed
2097             output.println("  global_defsprim_p->" + fm.getMethod().getClassDesc().getSafeSymbol()+"static_block_exe_flag = 1;");
2098             output.println("");
2099           }
2100           output.println("   return;");
2101         }
2102         current_node=null;
2103       } else if(current_node.numNext()==1) {
2104         FlatNode nextnode;
2105         if (state.OOOJAVA &&
2106             current_node.kind()==FKind.FlatSESEEnterNode) {
2107           FlatSESEEnterNode fsen = (FlatSESEEnterNode)current_node;
2108           generateFlatNode(fm, current_node, output);
2109           nextnode=fsen.getFlatExit().getNext(0);
2110         } else {
2111           output.print("   ");
2112           generateFlatNode(fm, current_node, output);
2113           nextnode=current_node.getNext(0);
2114         }
2115         if (visited.contains(nextnode)) {
2116           output.println("goto L"+nodetolabel.get(nextnode)+";");
2117           current_node=null;
2118         } else
2119           current_node=nextnode;
2120       } else if (current_node.numNext()==2) {
2121         /* Branch */
2122         output.print("   ");
2123         generateFlatCondBranch(fm, (FlatCondBranch)current_node, "L"+nodetolabel.get(current_node.getNext(1)), output);
2124         if (!visited.contains(current_node.getNext(1)))
2125           tovisit.add(current_node.getNext(1));
2126         if (visited.contains(current_node.getNext(0))) {
2127           output.println("goto L"+nodetolabel.get(current_node.getNext(0))+";");
2128           current_node=null;
2129         } else
2130           current_node=current_node.getNext(0);
2131       } else throw new Error();
2132     }
2133   }
2134
2135   protected Hashtable<FlatNode, Integer> assignLabels(FlatNode first, Set<FlatNode> lastset) {
2136     HashSet tovisit=new HashSet();
2137     HashSet visited=new HashSet();
2138     int labelindex=0;
2139     Hashtable<FlatNode, Integer> nodetolabel=new Hashtable<FlatNode, Integer>();
2140     tovisit.add(first);
2141
2142     /*Assign labels first.  A node needs a label if the previous
2143      * node has two exits or this node is a join point. */
2144
2145     while(!tovisit.isEmpty()) {
2146       FlatNode fn=(FlatNode)tovisit.iterator().next();
2147       tovisit.remove(fn);
2148       visited.add(fn);
2149
2150
2151       if(lastset!=null&&lastset.contains(fn)) {
2152         // if last is not null and matches, don't go
2153         // any further for assigning labels
2154         continue;
2155       }
2156
2157       for(int i=0; i<fn.numNext(); i++) {
2158         FlatNode nn=fn.getNext(i);
2159
2160         if(i>0) {
2161           //1) Edge >1 of node
2162           nodetolabel.put(nn,new Integer(labelindex++));
2163         }
2164         if (!visited.contains(nn)&&!tovisit.contains(nn)) {
2165           tovisit.add(nn);
2166         } else {
2167           //2) Join point
2168           nodetolabel.put(nn,new Integer(labelindex++));
2169         }
2170       }
2171     }
2172     return nodetolabel;
2173   }
2174
2175   /** Generate text string that corresponds to the TempDescriptor td. */
2176   protected String generateTemp(FlatMethod fm, TempDescriptor td) {
2177     MethodDescriptor md=fm.getMethod();
2178     TaskDescriptor task=fm.getTask();
2179     TempObject objecttemps=(TempObject) tempstable.get(md!=null?md:task);
2180
2181     if (objecttemps.isLocalPrim(td)||objecttemps.isParamPrim(td)) {
2182       return td.getSafeSymbol();
2183     }
2184
2185     if (objecttemps.isLocalPtr(td)) {
2186       return localsprefixderef+td.getSafeSymbol();
2187     }
2188
2189     if (objecttemps.isParamPtr(td)) {
2190       return paramsprefix+"->"+td.getSafeSymbol();
2191     }
2192
2193     throw new Error();
2194   }
2195
2196
2197
2198   protected void generateFlatNode(FlatMethod fm, FlatNode fn, PrintWriter output) {
2199     if(state.LINENUM) printSourceLineNumber(fm,fn,output);
2200     additionalCodePreNode(fm, fn, output);
2201
2202     switch(fn.kind()) {
2203     case FKind.FlatAtomicEnterNode:
2204       generateFlatAtomicEnterNode(fm, (FlatAtomicEnterNode) fn, output);
2205       break;
2206
2207     case FKind.FlatAtomicExitNode:
2208       generateFlatAtomicExitNode(fm, (FlatAtomicExitNode) fn, output);
2209       break;
2210
2211     case FKind.FlatInstanceOfNode:
2212       generateFlatInstanceOfNode(fm, (FlatInstanceOfNode)fn, output);
2213       break;
2214
2215     case FKind.FlatSESEEnterNode:
2216       generateFlatSESEEnterNode(fm, (FlatSESEEnterNode)fn, output);
2217       break;
2218
2219     case FKind.FlatSESEExitNode:
2220       generateFlatSESEExitNode(fm, (FlatSESEExitNode)fn, output);
2221       break;
2222
2223     case FKind.FlatWriteDynamicVarNode:
2224       generateFlatWriteDynamicVarNode(fm, (FlatWriteDynamicVarNode)fn, output);
2225       break;
2226
2227     case FKind.FlatGlobalConvNode:
2228       generateFlatGlobalConvNode(fm, (FlatGlobalConvNode) fn, output);
2229       break;
2230
2231     case FKind.FlatTagDeclaration:
2232       generateFlatTagDeclaration(fm, (FlatTagDeclaration) fn,output);
2233       break;
2234
2235     case FKind.FlatCall:
2236       generateFlatCall(fm, (FlatCall) fn,output);
2237       break;
2238
2239     case FKind.FlatFieldNode:
2240       generateFlatFieldNode(fm, (FlatFieldNode) fn,output);
2241       break;
2242
2243     case FKind.FlatElementNode:
2244       generateFlatElementNode(fm, (FlatElementNode) fn,output);
2245       break;
2246
2247     case FKind.FlatSetElementNode:
2248       generateFlatSetElementNode(fm, (FlatSetElementNode) fn,output);
2249       break;
2250
2251     case FKind.FlatSetFieldNode:
2252       generateFlatSetFieldNode(fm, (FlatSetFieldNode) fn,output);
2253       break;
2254
2255     case FKind.FlatNew:
2256       generateFlatNew(fm, (FlatNew) fn,output);
2257       break;
2258
2259     case FKind.FlatOpNode:
2260       generateFlatOpNode(fm, (FlatOpNode) fn,output);
2261       break;
2262
2263     case FKind.FlatCastNode:
2264       generateFlatCastNode(fm, (FlatCastNode) fn,output);
2265       break;
2266
2267     case FKind.FlatLiteralNode:
2268       generateFlatLiteralNode(fm, (FlatLiteralNode) fn,output);
2269       break;
2270
2271     case FKind.FlatReturnNode:
2272       generateFlatReturnNode(fm, (FlatReturnNode) fn,output);
2273       break;
2274
2275     case FKind.FlatNop:
2276       output.println("/* nop */");
2277       break;
2278
2279     case FKind.FlatGenReachNode:
2280       // this node is just for generating a reach graph
2281       // in disjointness analysis at a particular program point
2282       break;
2283
2284     case FKind.FlatExit:
2285       output.println("/* exit */");
2286       break;
2287
2288     case FKind.FlatBackEdge:
2289       generateFlatBackEdge(fm, (FlatBackEdge)fn, output);
2290       break;
2291
2292     case FKind.FlatCheckNode:
2293       generateFlatCheckNode(fm, (FlatCheckNode) fn, output);
2294       break;
2295
2296     case FKind.FlatFlagActionNode:
2297       generateFlatFlagActionNode(fm, (FlatFlagActionNode) fn, output);
2298       break;
2299
2300     case FKind.FlatPrefetchNode:
2301       generateFlatPrefetchNode(fm, (FlatPrefetchNode) fn, output);
2302       break;
2303
2304     case FKind.FlatOffsetNode:
2305       generateFlatOffsetNode(fm, (FlatOffsetNode)fn, output);
2306       break;
2307
2308     default:
2309       throw new Error();
2310     }
2311
2312     additionalCodePostNode(fm, fn, output);
2313   }
2314
2315   public void generateFlatBackEdge(FlatMethod fm, FlatBackEdge fn, PrintWriter output) {
2316     if (((state.OOOJAVA||state.THREAD)&&GENERATEPRECISEGC)
2317         || (this.state.MULTICOREGC)) {
2318       if(this.state.MULTICOREGC) {
2319         output.println("if (gcflag) gc("+localsprefixaddr+");");
2320       } else {
2321         output.println("if (unlikely(needtocollect)) checkcollect("+localsprefixaddr+");");
2322       }
2323     } else
2324       output.println("/* nop */");
2325   }
2326
2327   public void generateFlatOffsetNode(FlatMethod fm, FlatOffsetNode fofn, PrintWriter output) {
2328     output.println("/* FlatOffsetNode */");
2329     FieldDescriptor fd=fofn.getField();
2330     if(!fd.isStatic()) {
2331       output.println(generateTemp(fm, fofn.getDst())+ " = (short)(int) (&((struct "+fofn.getClassType().getSafeSymbol() +" *)0)->"+
2332                      fd.getSafeSymbol()+");");
2333     }
2334     output.println("/* offset */");
2335   }
2336
2337   public void generateFlatPrefetchNode(FlatMethod fm, FlatPrefetchNode fpn, PrintWriter output) {
2338   }
2339
2340   public void generateFlatGlobalConvNode(FlatMethod fm, FlatGlobalConvNode fgcn, PrintWriter output) {
2341   }
2342
2343   public void generateFlatInstanceOfNode(FlatMethod fm,  FlatInstanceOfNode fion, PrintWriter output) {
2344     int type;
2345     int otype;
2346     if (fion.getType().isArray()) {
2347       type=state.getArrayNumber(fion.getType())+state.numClasses();
2348     } else if (fion.getType().getClassDesc().isInterface()) {
2349       type=fion.getType().getClassDesc().getId()+state.numClasses()+state.numArrays();
2350     } else {
2351       type=fion.getType().getClassDesc().getId();
2352     }
2353     if (fion.getSrc().getType().isArray()) {
2354       otype=state.getArrayNumber(fion.getSrc().getType())+state.numClasses();
2355     } else if (fion.getSrc().getType().getClassDesc().isInterface()) {
2356       otype=fion.getSrc().getType().getClassDesc().getId()+state.numClasses()+state.numArrays();
2357     } else {
2358       otype=fion.getSrc().getType().getClassDesc().getId();
2359     }
2360
2361     if (fion.getType().getSymbol().equals(TypeUtil.ObjectClass))
2362       output.println(generateTemp(fm, fion.getDst())+"=(" + generateTemp(fm,fion.getSrc()) + "!= NULL);");
2363     else {
2364       output.println(generateTemp(fm, fion.getDst())+"=instanceof("+generateTemp(fm,fion.getSrc())+","+type+");");
2365     }
2366   }
2367
2368   public void generateFlatAtomicEnterNode(FlatMethod fm, FlatAtomicEnterNode faen, PrintWriter output) {
2369   }
2370
2371   public void generateFlatAtomicExitNode(FlatMethod fm,  FlatAtomicExitNode faen, PrintWriter output) {
2372   }
2373
2374   public void generateFlatSESEEnterNode(FlatMethod fm,
2375                                         FlatSESEEnterNode fsen,
2376                                         PrintWriter output) {
2377     // if OOOJAVA flag is off, okay that SESE nodes are in IR graph,
2378     // just skip over them and code generates exactly the same
2379   }
2380
2381   public void generateFlatSESEExitNode(FlatMethod fm,
2382                                        FlatSESEExitNode fsexn,
2383                                        PrintWriter output) {
2384     // if OOOJAVA flag is off, okay that SESE nodes are in IR graph,
2385     // just skip over them and code generates exactly the same
2386   }
2387
2388   public void generateFlatWriteDynamicVarNode(FlatMethod fm,
2389                                               FlatWriteDynamicVarNode fwdvn,
2390                                               PrintWriter output) {
2391   }
2392
2393
2394   protected void generateFlatCheckNode(FlatMethod fm,  FlatCheckNode fcn, PrintWriter output) {
2395     if (state.CONSCHECK) {
2396       String specname=fcn.getSpec();
2397       String varname="repairstate___";
2398       output.println("{");
2399       output.println("struct "+specname+"_state * "+varname+"=allocate"+specname+"_state();");
2400
2401       TempDescriptor[] temps=fcn.getTemps();
2402       String[] vars=fcn.getVars();
2403       for(int i=0; i<temps.length; i++) {
2404         output.println(varname+"->"+vars[i]+"=(unsigned int)"+generateTemp(fm, temps[i])+";");
2405       }
2406
2407       output.println("if (doanalysis"+specname+"("+varname+")) {");
2408       output.println("free"+specname+"_state("+varname+");");
2409       output.println("} else {");
2410       output.println("/* Bad invariant */");
2411       output.println("free"+specname+"_state("+varname+");");
2412       output.println("abort_task();");
2413       output.println("}");
2414       output.println("}");
2415     }
2416   }
2417
2418   protected void generateFlatCall(FlatMethod fm, FlatCall fc, PrintWriter output) {
2419     MethodDescriptor md=fc.getMethod();
2420     ParamsObject objectparams=(ParamsObject)paramstable.get(md);
2421
2422     ClassDescriptor cn=md.getClassDesc();
2423     String mdstring = md.getSafeMethodDescriptor();
2424     if(mgcstaticinit && !md.isStaticBlock() && !md.getModifiers().isNative()) {
2425       mdstring += "staticinit";
2426     }
2427
2428     // if the called method is a static block or a static method or a constructor
2429     // need to check if it can be invoked inside some static block
2430     if((md.isStatic() || md.isStaticBlock() || md.isConstructor()) &&
2431        ((fm.getMethod() != null) && ((fm.getMethod().isStaticBlock()) || (fm.getMethod().isInvokedByStatic())))) {
2432       if(!md.isInvokedByStatic()) {
2433         System.err.println("Error: a method that is invoked inside a static block is not tagged!");
2434       }
2435       // is a static block or is invoked in some static block
2436       ClassDescriptor cd = fm.getMethod().getClassDesc();
2437       if(cd != cn && mgcstaticinit && callgraph.isInit(cn)) {
2438         // generate static init check code if it has not done static init in main()
2439         if((cn.getNumStaticFields() != 0) || (cn.getNumStaticBlocks() != 0)) {
2440           // need to check if the class' static fields have been initialized and/or
2441           // its static blocks have been executed
2442           output.println("if(global_defsprim_p->" + cn.getSafeSymbol()+"static_block_exe_flag == 0) {");
2443           if(cn.getNumStaticBlocks() != 0) {
2444             MethodDescriptor t_md = (MethodDescriptor)cn.getMethodTable().get("staticblocks");
2445             if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2446               output.print("       struct "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"_params __parameterlist__={");
2447               output.println("0, NULL};");
2448               output.println("     "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"(& __parameterlist__);");
2449             } else {
2450               output.println("  "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"();");
2451             }
2452           } else {
2453             output.println("  global_defsprim_p->" + cn.getSafeSymbol()+"static_block_exe_flag = 1;");
2454           }
2455           output.println("}");
2456         }
2457       }
2458     }
2459     if((md.getSymbol().equals("MonitorEnter") || md.getSymbol().equals("MonitorExit")) && fc.getThis().getSymbol().equals("classobj")) {
2460       output.println("{");
2461       if(md.getSymbol().equals("MonitorEnter") && state.OBJECTLOCKDEBUG) {
2462         output.println("int monitorenterline = __LINE__;");
2463       }
2464       // call MonitorEnter/MonitorExit on a class obj
2465       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2466         output.print("       struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
2467         output.println("1," + localsprefixaddr + ", ((void **)(((char *) &(global_defs_p->classobjs->___length___))+sizeof(int)))[" + fc.getThis().getType().getClassDesc().getId() + "]};");
2468         if(md.getSymbol().equals("MonitorEnter") && state.OBJECTLOCKDEBUG) {
2469           output.println("     "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(& __parameterlist__, monitorenterline);");
2470         } else {
2471           output.println("     "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(& __parameterlist__);");
2472         }
2473       } else {
2474         output.println("       " + cn.getSafeSymbol()+md.getSafeSymbol()+"_"
2475                        + md.getSafeMethodDescriptor() + "((struct ___Object___*)(((void **)(((char *) &(global_defs_p->classobjs->___length___))+sizeof(int)))["
2476                        + fc.getThis().getType().getClassDesc().getId() + "]));");
2477       }
2478       output.println("}");
2479       return;
2480     }
2481
2482     output.println("{");
2483     if(md.getSymbol().equals("MonitorEnter")) {
2484       output.println("int monitorenterline = __LINE__;");
2485     }
2486     if (GENERATEPRECISEGC || state.MULTICOREGC) {
2487       output.print("       struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+mdstring+"_params __parameterlist__={");
2488       output.print(objectparams.numPointers());
2489       output.print(", "+localsprefixaddr);
2490       if (md.getThis()!=null) {
2491         output.print(", ");
2492         output.print("(struct "+md.getThis().getType().getSafeSymbol() +" *)"+ generateTemp(fm,fc.getThis()));
2493       }
2494       if (fc.getThis()!=null&&md.getThis()==null) {
2495         System.out.println("WARNING!!!!!!!!!!!!");
2496         System.out.println("Source code calls static method "+md+" on an object in "+fm.getMethod()+"!");
2497       }
2498
2499       for(int i=0; i<fc.numArgs(); i++) {
2500         Descriptor var=md.getParameter(i);
2501         TempDescriptor paramtemp=(TempDescriptor)temptovar.get(var);
2502         if (objectparams.isParamPtr(paramtemp)) {
2503           TempDescriptor targ=fc.getArg(i);
2504           output.print(", ");
2505           TypeDescriptor td=md.getParamType(i);
2506           if (td.isTag())
2507             output.print("(struct "+(new TypeDescriptor(typeutil.getClass(TypeUtil.TagClass))).getSafeSymbol()  +" *)"+generateTemp(fm, targ));
2508           else
2509             output.print("(struct "+md.getParamType(i).getSafeSymbol()  +" *)"+generateTemp(fm, targ));
2510         }
2511       }
2512       output.println("};");
2513     }
2514     output.print("       ");
2515
2516
2517     if (fc.getReturnTemp()!=null)
2518       output.print(generateTemp(fm,fc.getReturnTemp())+"=");
2519
2520     /* Do we need to do virtual dispatch? */
2521
2522     if (md.isStatic()||md.getReturnType()==null||singleCall(fc.getThis().getType().getClassDesc(),md)||fc.getSuper()) {
2523       //no
2524       output.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+mdstring);
2525     } else {
2526       //yes
2527       output.print("((");
2528       if (md.getReturnType().isClass() && md.getReturnType().getClassDesc().isEnum()) {
2529         output.print("int ");
2530       } else if (md.getReturnType().isClass()||md.getReturnType().isArray())
2531         output.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
2532       else
2533         output.print(md.getReturnType().getSafeSymbol()+" ");
2534       output.print("(*)(");
2535
2536       boolean printcomma=false;
2537       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2538         output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+mdstring+"_params * ");
2539         printcomma=true;
2540       }
2541
2542       for(int i=0; i<objectparams.numPrimitives(); i++) {
2543         TempDescriptor temp=objectparams.getPrimitive(i);
2544         if (printcomma)
2545           output.print(", ");
2546         printcomma=true;
2547         if (temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
2548           output.print("int ");
2549         } else if (temp.getType().isClass()||temp.getType().isArray())
2550           output.print("struct " + temp.getType().getSafeSymbol()+" * ");
2551         else
2552           output.print(temp.getType().getSafeSymbol());
2553       }
2554
2555       if(md.getSymbol().equals("MonitorEnter") && state.OBJECTLOCKDEBUG) {
2556         output.print(", int");
2557       }
2558       output.print("))virtualtable["+generateTemp(fm,fc.getThis())+"->type*"+maxcount+"+"+virtualcalls.getMethodNumber(md)+"])");
2559     }
2560
2561     output.print("(");
2562     boolean needcomma=false;
2563     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2564       output.print("&__parameterlist__");
2565       needcomma=true;
2566     }
2567
2568     if (!GENERATEPRECISEGC && !this.state.MULTICOREGC) {
2569       if (fc.getThis()!=null) {
2570         TypeDescriptor ptd=null;
2571         if(md.getThis() != null) {
2572           ptd = md.getThis().getType();
2573         } else {
2574           ptd = fc.getThis().getType();
2575         }
2576         if (needcomma)
2577           output.print(",");
2578         if(ptd.isClass() && ptd.getClassDesc().isEnum()) {
2579           // do nothing
2580         } else if (ptd.isClass()&&!ptd.isArray())
2581           output.print("(struct "+ptd.getSafeSymbol()+" *) ");
2582         output.print(generateTemp(fm,fc.getThis()));
2583         needcomma=true;
2584       }
2585     }
2586
2587     for(int i=0; i<fc.numArgs(); i++) {
2588       Descriptor var=md.getParameter(i);
2589       TempDescriptor paramtemp=(TempDescriptor)temptovar.get(var);
2590       if (objectparams.isParamPrim(paramtemp)) {
2591         TempDescriptor targ=fc.getArg(i);
2592         if (needcomma)
2593           output.print(", ");
2594
2595         TypeDescriptor ptd=md.getParamType(i);
2596         if (ptd.isClass() && ptd.getClassDesc().isEnum()) {
2597           // do nothing
2598         } else if (ptd.isClass()&&!ptd.isArray())
2599           output.print("(struct "+ptd.getSafeSymbol()+" *) ");
2600         output.print(generateTemp(fm, targ));
2601         needcomma=true;
2602       }
2603     }
2604     if(md.getSymbol().equals("MonitorEnter") && state.OBJECTLOCKDEBUG) {
2605       output.println(", monitorenterline);");
2606     } else {
2607       output.println(");");
2608     }
2609     output.println("   }");
2610   }
2611
2612   protected boolean singleCall(ClassDescriptor thiscd, MethodDescriptor md) {
2613     if(thiscd.isInterface()) {
2614       // for interfaces, always need virtual dispatch
2615       return false;
2616     } else {
2617       Set subclasses=typeutil.getSubClasses(thiscd);
2618       if (subclasses==null)
2619         return true;
2620       for(Iterator classit=subclasses.iterator(); classit.hasNext(); ) {
2621         ClassDescriptor cd=(ClassDescriptor)classit.next();
2622         Set possiblematches=cd.getMethodTable().getSetFromSameScope(md.getSymbol());
2623         for(Iterator matchit=possiblematches.iterator(); matchit.hasNext(); ) {
2624           MethodDescriptor matchmd=(MethodDescriptor)matchit.next();
2625           if (md.matches(matchmd))
2626             return false;
2627         }
2628       }
2629     }
2630     return true;
2631   }
2632
2633   protected void generateFlatFieldNode(FlatMethod fm, FlatFieldNode ffn, PrintWriter output) {
2634
2635     if(ffn.getField().isStatic()) {
2636       // static field
2637       if((fm.getMethod().isStaticBlock()) || (fm.getMethod().isInvokedByStatic())) {
2638         // is a static block or is invoked in some static block
2639         ClassDescriptor cd = fm.getMethod().getClassDesc();
2640         ClassDescriptor cn = ffn.getSrc().getType().getClassDesc();
2641         if(cd != cn && mgcstaticinit && callgraph.isInit(cn)) {
2642           // generate the static init check code if has not done the static init in main()
2643           if((cn.getNumStaticFields() != 0) || (cn.getNumStaticBlocks() != 0)) {
2644             // need to check if the class' static fields have been initialized and/or
2645             // its static blocks have been executed
2646             output.println("if(global_defsprim_p->" + cn.getSafeSymbol()+"static_block_exe_flag == 0) {");
2647             if(cn.getNumStaticBlocks() != 0) {
2648               MethodDescriptor t_md = (MethodDescriptor)cn.getMethodTable().get("staticblocks");
2649               if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2650                 output.print("       struct "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"_params __parameterlist__={");
2651                 output.println("0, NULL};");
2652                 output.println("     "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"(& __parameterlist__);");
2653               } else {
2654                 output.println("  "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"();");
2655               }
2656             } else {
2657               output.println("  global_defsprim_p->" + cn.getSafeSymbol()+"static_block_exe_flag = 1;");
2658             }
2659             output.println("}");
2660           }
2661         }
2662       }
2663       // redirect to the global_defs_p structure
2664       if (ffn.getField().getType().isPtr())
2665         output.println(generateTemp(fm, ffn.getDst())+"=global_defs_p->"+ffn.getField().getSafeSymbol()+";");
2666       else
2667         output.println(generateTemp(fm, ffn.getDst())+"=global_defsprim_p->"+ffn.getField().getSafeSymbol()+";");
2668     } else if (ffn.getField().isEnum()) {
2669       // an Enum value, directly replace the field access as int
2670       output.println(generateTemp(fm, ffn.getDst()) + "=" + ffn.getField().enumValue() + ";");
2671     } else {
2672       output.println("#ifdef MULTICORE_DEBUG");
2673       output.println("if (" + generateTemp(fm,ffn.getSrc()) + " == NULL) {");
2674       output.println("printf(\" NULL ptr error: %s, %s, %d \\n\", __FILE__, __func__, __LINE__);");
2675       if(state.MULTICOREGC) {
2676         output.println("failednullptr(&___locals___);");
2677       } else {
2678         output.println("failednullptr(NULL);");
2679       }
2680       output.println("}");
2681       output.println("#endif //MULTICORE_DEBUG");
2682       output.println(generateTemp(fm, ffn.getDst())+"="+ generateTemp(fm,ffn.getSrc())+"->"+ ffn.getField().getSafeSymbol()+";");
2683     }
2684   }
2685
2686
2687   protected void generateFlatSetFieldNode(FlatMethod fm, FlatSetFieldNode fsfn, PrintWriter output) {
2688     if (fsfn.getField().getSymbol().equals("length")&&fsfn.getDst().getType().isArray())
2689       throw new Error("Can't set array length");
2690     if (state.FASTCHECK) {
2691       String dst=generateTemp(fm, fsfn.getDst());
2692       output.println("if(!"+dst+"->"+localcopystr+") {");
2693       /* Link object into list */
2694       if (GENERATEPRECISEGC || this.state.MULTICOREGC)
2695         output.println("COPY_OBJ((struct garbagelist *)"+localsprefixaddr+",(struct ___Object___ *)"+dst+");");
2696       else
2697         output.println("COPY_OBJ("+dst+");");
2698       output.println(dst+"->"+nextobjstr+"="+fcrevert+";");
2699       output.println(fcrevert+"=(struct ___Object___ *)"+dst+";");
2700       output.println("}");
2701     }
2702
2703     if(fsfn.getField().isStatic()) {
2704       // static field
2705       if((fm.getMethod().isStaticBlock()) || (fm.getMethod().isInvokedByStatic())) {
2706         // is a static block or is invoked in some static block
2707         ClassDescriptor cd = fm.getMethod().getClassDesc();
2708         ClassDescriptor cn = fsfn.getDst().getType().getClassDesc();
2709         if(cd != cn && mgcstaticinit && callgraph.isInit(cn)) {
2710           // generate static init check code if has not done the static init in main()
2711           if((cn.getNumStaticFields() != 0) || (cn.getNumStaticBlocks() != 0)) {
2712             // need to check if the class' static fields have been initialized and/or
2713             // its static blocks have been executed
2714             output.println("if(global_defsprim_p->" + cn.getSafeSymbol()+"static_block_exe_flag == 0) {");
2715             if(cn.getNumStaticBlocks() != 0) {
2716               MethodDescriptor t_md = (MethodDescriptor)cn.getMethodTable().get("staticblocks");
2717               if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2718                 output.print("       struct "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"_params __parameterlist__={");
2719                 output.println("0, NULL};");
2720                 output.println("     "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"(& __parameterlist__);");
2721               } else {
2722                 output.println("  "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"();");
2723               }
2724             } else {
2725               output.println("  global_defsprim_p->" + cn.getSafeSymbol()+"static_block_exe_flag = 1;");
2726             }
2727             output.println("}");
2728           }
2729         }
2730       }
2731       // redirect to the global_defs_p structure
2732       if (fsfn.getField().getType().isPtr()) {
2733         if (fsfn.getField().getType()!=fsfn.getSrc().getType())
2734           output.println("global_defs_p->" +
2735                          fsfn.getField().getSafeSymbol()+"=(struct "+ fsfn.getField().getType().getSafeSymbol()+" *)"+generateTemp(fm,fsfn.getSrc())+";");
2736         else
2737           output.println("global_defs_p->" +
2738                          fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc())+";");
2739       } else
2740         output.println("global_defsprim_p->" +
2741                        fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc())+";");
2742     } else {
2743       output.println("#ifdef MULTICORE_DEBUG");
2744       output.println("if (" + generateTemp(fm,fsfn.getDst()) + " == NULL) {");
2745       output.println("printf(\" NULL ptr error: %s, %s, %d \\n\", __FILE__, __func__, __LINE__);");
2746       if(state.MULTICOREGC) {
2747         output.println("failednullptr(&___locals___);");
2748       } else {
2749         output.println("failednullptr(NULL);");
2750       }
2751       output.println("}");
2752       output.println("#endif //MULTICORE_DEBUG");
2753       if (fsfn.getSrc().getType().isPtr()&&fsfn.getSrc().getType()!=fsfn.getField().getType())
2754         output.println(generateTemp(fm, fsfn.getDst())+"->"+
2755                        fsfn.getField().getSafeSymbol()+"=(struct "+ fsfn.getField().getType().getSafeSymbol()+"*)"+generateTemp(fm,fsfn.getSrc())+";");
2756       else
2757         output.println(generateTemp(fm, fsfn.getDst())+"->"+
2758                        fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc())+";");
2759     }
2760   }
2761
2762
2763   protected void generateFlatElementNode(FlatMethod fm, FlatElementNode fen, PrintWriter output) {
2764     TypeDescriptor elementtype=fen.getSrc().getType().dereference();
2765     String type="";
2766
2767     if (elementtype.isClass() && elementtype.getClassDesc().isEnum()) {
2768       type="int ";
2769     } else if (elementtype.isArray()||elementtype.isClass())
2770       type="void *";
2771     else
2772       type=elementtype.getSafeSymbol()+" ";
2773
2774     if (this.state.ARRAYBOUNDARYCHECK && fen.needsBoundsCheck()) {
2775       output.println("if (unlikely(((unsigned int)"+generateTemp(fm, fen.getIndex())+") >= "+generateTemp(fm,fen.getSrc()) + "->___length___))");
2776       output.println("failedboundschk(" + (boundschknum++) + ");");
2777     }
2778     output.println(generateTemp(fm, fen.getDst())+"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc())+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex())+"];");
2779   }
2780
2781   protected void generateFlatSetElementNode(FlatMethod fm, FlatSetElementNode fsen, PrintWriter output) {
2782     //TODO: need dynamic check to make sure this assignment is actually legal
2783     //Because Object[] could actually be something more specific...ie. Integer[]
2784
2785     TypeDescriptor elementtype=fsen.getDst().getType().dereference();
2786     String type="";
2787
2788     if (elementtype.isClass() && elementtype.getClassDesc().isEnum()) {
2789       type="int ";
2790     } else if (elementtype.isArray()||elementtype.isClass() || (elementtype.isNull()))
2791       type="void *";
2792     else
2793       type=elementtype.getSafeSymbol()+" ";
2794
2795     if (this.state.ARRAYBOUNDARYCHECK && fsen.needsBoundsCheck()) {
2796       output.println("if (unlikely(((unsigned int)"+generateTemp(fm, fsen.getIndex())+") >= "+generateTemp(fm,fsen.getDst()) + "->___length___))");
2797       output.println("failedboundschk(" + (boundschknum++) + ");");
2798     }
2799     if (state.FASTCHECK) {
2800       String dst=generateTemp(fm, fsen.getDst());
2801       output.println("if(!"+dst+"->"+localcopystr+") {");
2802       /* Link object into list */
2803       if (GENERATEPRECISEGC || this.state.MULTICOREGC)
2804         output.println("COPY_OBJ((struct garbagelist *)"+localsprefixaddr+",(struct ___Object___ *)"+dst+");");
2805       else
2806         output.println("COPY_OBJ("+dst+");");
2807       output.println(dst+"->"+nextobjstr+"="+fcrevert+";");
2808       output.println(fcrevert+"=(struct ___Object___ *)"+dst+";");
2809       output.println("}");
2810     }
2811     output.println("(("+type +"*)(((char *) &("+ generateTemp(fm,fsen.getDst())+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex())+"]="+generateTemp(fm,fsen.getSrc())+";");
2812   }
2813
2814
2815   protected void generateFlatNew(FlatMethod fm, FlatNew fn, PrintWriter output) {
2816     if (fn.getType().isArray()) {
2817       int arrayid=state.getArrayNumber(fn.getType())+state.numClasses();
2818       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2819         output.println(generateTemp(fm,fn.getDst())+"=allocate_newarray("+localsprefixaddr+", "+arrayid+", "+generateTemp(fm, fn.getSize())+");");
2820       } else {
2821         output.println(generateTemp(fm,fn.getDst())+"=allocate_newarray("+arrayid+", "+generateTemp(fm, fn.getSize())+");");
2822       }
2823     } else {
2824       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2825         output.println(generateTemp(fm,fn.getDst())+"=allocate_new("+localsprefixaddr+", "+fn.getType().getClassDesc().getId()+");");
2826       } else {
2827         output.println(generateTemp(fm,fn.getDst())+"=allocate_new("+fn.getType().getClassDesc().getId()+");");
2828       }
2829     }
2830     if (state.FASTCHECK) {
2831       String dst=generateTemp(fm,fn.getDst());
2832       output.println(dst+"->___localcopy___=(struct ___Object___*)1;");
2833       output.println(dst+"->"+nextobjstr+"="+fcrevert+";");
2834       output.println(fcrevert+"=(struct ___Object___ *)"+dst+";");
2835     }
2836   }
2837
2838   protected void generateFlatTagDeclaration(FlatMethod fm, FlatTagDeclaration fn, PrintWriter output) {
2839     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2840       output.println(generateTemp(fm,fn.getDst())+"=allocate_tag("+localsprefixaddr+", "+state.getTagId(fn.getType())+");");
2841     } else {
2842       output.println(generateTemp(fm,fn.getDst())+"=allocate_tag("+state.getTagId(fn.getType())+");");
2843     }
2844   }
2845
2846   protected void generateFlatOpNode(FlatMethod fm, FlatOpNode fon, PrintWriter output) {
2847     if (fon.getRight()!=null) {
2848       if (fon.getOp().getOp()==Operation.URIGHTSHIFT) {
2849         if (fon.getLeft().getType().isLong())
2850           output.println(generateTemp(fm, fon.getDest())+" = ((unsigned long long)"+generateTemp(fm, fon.getLeft())+")>>"+generateTemp(fm,fon.getRight())+";");
2851         else
2852           output.println(generateTemp(fm, fon.getDest())+" = ((unsigned int)"+generateTemp(fm, fon.getLeft())+")>>"+generateTemp(fm,fon.getRight())+";");
2853
2854       } else {
2855         if (fon.getLeft().getType().isPtr()&&fon.getLeft().getType()!=fon.getRight().getType()&&!fon.getRight().getType().isNull())
2856           output.println(generateTemp(fm, fon.getDest())+" = (struct "+fon.getRight().getType().getSafeSymbol()+"*)"+generateTemp(fm, fon.getLeft())+fon.getOp().toString()+generateTemp(fm,fon.getRight())+";");
2857         else
2858           output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+fon.getOp().toString()+generateTemp(fm,fon.getRight())+";");
2859       }
2860     } else if (fon.getOp().getOp()==Operation.ASSIGN)
2861       if (fon.getDest().getType().isPtr()&&fon.getDest().getType()!=fon.getLeft().getType())
2862         output.println(generateTemp(fm, fon.getDest())+" = (struct "+fon.getDest().getType().getSafeSymbol()+"*)"+generateTemp(fm, fon.getLeft())+";");
2863       else
2864         output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+";");
2865     else if (fon.getOp().getOp()==Operation.UNARYPLUS)
2866       output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+";");
2867     else if (fon.getOp().getOp()==Operation.UNARYMINUS)
2868       output.println(generateTemp(fm, fon.getDest())+" = -"+generateTemp(fm, fon.getLeft())+";");
2869     else if (fon.getOp().getOp()==Operation.LOGIC_NOT)
2870       output.println(generateTemp(fm, fon.getDest())+" = !"+generateTemp(fm, fon.getLeft())+";");
2871     else if (fon.getOp().getOp()==Operation.COMP)
2872       output.println(generateTemp(fm, fon.getDest())+" = ~"+generateTemp(fm, fon.getLeft())+";");
2873     else if (fon.getOp().getOp()==Operation.ISAVAILABLE) {
2874       output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+"->fses==NULL;");
2875     } else
2876       output.println(generateTemp(fm, fon.getDest())+fon.getOp().toString()+generateTemp(fm, fon.getLeft())+";");
2877   }
2878
2879   protected void generateFlatCastNode(FlatMethod fm, FlatCastNode fcn, PrintWriter output) {
2880     /* TODO: Do type check here */
2881     if (fcn.getType().isArray()) {
2882       output.println(generateTemp(fm,fcn.getDst())+"=(struct ArrayObject *)"+generateTemp(fm,fcn.getSrc())+";");
2883     } else if (fcn.getType().isClass() && fcn.getType().getClassDesc().isEnum()) {
2884       output.println(generateTemp(fm,fcn.getDst())+"=(int)"+generateTemp(fm,fcn.getSrc())+";");
2885     } else if (fcn.getType().isClass())
2886       output.println(generateTemp(fm,fcn.getDst())+"=(struct "+fcn.getType().getSafeSymbol()+" *)"+generateTemp(fm,fcn.getSrc())+";");
2887     else
2888       output.println(generateTemp(fm,fcn.getDst())+"=("+fcn.getType().getSafeSymbol()+")"+generateTemp(fm,fcn.getSrc())+";");
2889   }
2890
2891   int flncount=0;
2892
2893   protected void generateFlatLiteralNode(FlatMethod fm, FlatLiteralNode fln, PrintWriter output) {
2894     if (fln.getValue()==null)
2895       output.println(generateTemp(fm, fln.getDst())+"=0;");
2896     else if (fln.getType().getSymbol().equals(TypeUtil.StringClass)) {
2897       String str=(String)fln.getValue();
2898       output.println("{");
2899       output.print("short str"+flncount+"[]={");
2900       for(int i=0; i<str.length(); i++) {
2901         if (i!=0)
2902           output.print(", ");
2903         output.print(((int)str.charAt(i)));
2904       }
2905       output.println("};");
2906       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2907         output.println(generateTemp(fm, fln.getDst())+"=NewStringShort("+localsprefixaddr+", str"+flncount+", "+((String)fln.getValue()).length()+");");
2908       } else {
2909         output.println(generateTemp(fm, fln.getDst())+"=NewStringShort(str"+flncount+" ,"+((String)fln.getValue()).length()+");");
2910       }
2911       output.println("}");
2912       flncount++;
2913     } else if (fln.getType().isBoolean()) {
2914       if (((Boolean)fln.getValue()).booleanValue())
2915         output.println(generateTemp(fm, fln.getDst())+"=1;");
2916       else
2917         output.println(generateTemp(fm, fln.getDst())+"=0;");
2918     } else if (fln.getType().isChar()) {
2919       int val=(int)(((Character)fln.getValue()).charValue());
2920       output.println(generateTemp(fm, fln.getDst())+"="+val+";");
2921     } else if (fln.getType().isLong()) {
2922       output.println(generateTemp(fm, fln.getDst())+"="+fln.getValue()+"LL;");
2923     } else
2924       output.println(generateTemp(fm, fln.getDst())+"="+fln.getValue()+";");
2925   }
2926
2927   protected void generateFlatReturnNode(FlatMethod fm, FlatReturnNode frn, PrintWriter output) {
2928     if((fm.getMethod() != null) && (fm.getMethod().isStaticBlock())) {
2929       // a static block, check if it has been executed
2930       output.println("  global_defsprim_p->" + fm.getMethod().getClassDesc().getSafeSymbol()+"static_block_exe_flag = 1;");
2931       output.println("");
2932     }
2933
2934     if (frn.getReturnTemp()!=null) {
2935       if (frn.getReturnTemp().getType().isPtr())
2936         output.println("return (struct "+fm.getMethod().getReturnType().getSafeSymbol()+"*)"+generateTemp(fm, frn.getReturnTemp())+";");
2937       else
2938         output.println("return "+generateTemp(fm, frn.getReturnTemp())+";");
2939     } else {
2940       output.println("return;");
2941     }
2942   }
2943
2944   protected void generateFlatCondBranch(FlatMethod fm, FlatCondBranch fcb, String label, PrintWriter output) {
2945     output.println("if (!"+generateTemp(fm, fcb.getTest())+") goto "+label+";");
2946   }
2947
2948   /** This method generates header information for the method or
2949    * task referenced by the Descriptor des. */
2950   protected void generateHeader(FlatMethod fm, Descriptor des, PrintWriter output) {
2951     generateHeader(fm, des, output, false);
2952   }
2953
2954   protected void generateHeader(FlatMethod fm, Descriptor des, PrintWriter output, boolean addSESErecord) {
2955     /* Print header */
2956     ParamsObject objectparams=(ParamsObject)paramstable.get(des);
2957     MethodDescriptor md=null;
2958     TaskDescriptor task=null;
2959     if (des instanceof MethodDescriptor)
2960       md=(MethodDescriptor) des;
2961     else
2962       task=(TaskDescriptor) des;
2963     String mdstring = md != null?md.getSafeMethodDescriptor():null;
2964
2965     ClassDescriptor cn=md!=null?md.getClassDesc():null;
2966
2967     if (md!=null&&md.getReturnType()!=null) {
2968       if (md.getReturnType().isClass() && md.getReturnType().getClassDesc().isEnum()) {
2969         output.print("int ");
2970       } else if (md.getReturnType().isClass()||md.getReturnType().isArray())
2971         output.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
2972       else
2973         output.print(md.getReturnType().getSafeSymbol()+" ");
2974     } else
2975       //catch the constructor case
2976       output.print("void ");
2977     if (md!=null) {
2978       if(mgcstaticinit && !md.isStaticBlock() && !md.getModifiers().isNative()) {
2979         mdstring += "staticinit";
2980       }
2981       output.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+mdstring+"(");
2982     } else
2983       output.print(task.getSafeSymbol()+"(");
2984
2985     boolean printcomma=false;
2986     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2987       if (md!=null) {
2988         output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+mdstring+"_params * "+paramsprefix);
2989       } else
2990         output.print("struct "+task.getSafeSymbol()+"_params * "+paramsprefix);
2991       printcomma=true;
2992     }
2993
2994     if (md!=null) {
2995       /* Method */
2996       for(int i=0; i<objectparams.numPrimitives(); i++) {
2997         TempDescriptor temp=objectparams.getPrimitive(i);
2998         if (printcomma)
2999           output.print(", ");
3000         printcomma=true;
3001         if(temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
3002           output.print("int " + temp.getSafeSymbol());
3003         } else if (temp.getType().isClass()||temp.getType().isArray())
3004           output.print("struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol());
3005         else
3006           output.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
3007       }
3008       output.println(") {");
3009     } else if (!GENERATEPRECISEGC && !this.state.MULTICOREGC) {
3010       /* Imprecise Task */
3011       output.println("void * parameterarray[]) {");
3012       /* Unpack variables */
3013       for(int i=0; i<objectparams.numPrimitives(); i++) {
3014         TempDescriptor temp=objectparams.getPrimitive(i);
3015         if(temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
3016           output.print("int " + temp.getSafeSymbol() + "=parameterarray["+i+"];");
3017         } else {
3018           output.println("struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+"=parameterarray["+i+"];");
3019         }
3020       }
3021       for(int i=0; i<fm.numTags(); i++) {
3022         TempDescriptor temp=fm.getTag(i);
3023         int offset=i+objectparams.numPrimitives();
3024         output.println("struct ___TagDescriptor___ * "+temp.getSafeSymbol()+"=parameterarray["+offset+"];");
3025       }
3026
3027       if ((objectparams.numPrimitives()+fm.numTags())>maxtaskparams)
3028         maxtaskparams=objectparams.numPrimitives()+fm.numTags();
3029     } else output.println(") {");
3030   }
3031
3032   public void generateFlatFlagActionNode(FlatMethod fm, FlatFlagActionNode ffan, PrintWriter output) {
3033     output.println("/* FlatFlagActionNode */");
3034
3035
3036     /* Process tag changes */
3037     Relation tagsettable=new Relation();
3038     Relation tagcleartable=new Relation();
3039
3040     Iterator tagsit=ffan.getTempTagPairs();
3041     while (tagsit.hasNext()) {
3042       TempTagPair ttp=(TempTagPair) tagsit.next();
3043       TempDescriptor objtmp=ttp.getTemp();
3044       TagDescriptor tag=ttp.getTag();
3045       TempDescriptor tagtmp=ttp.getTagTemp();
3046       boolean tagstatus=ffan.getTagChange(ttp);
3047       if (tagstatus) {
3048         tagsettable.put(objtmp, tagtmp);
3049       } else {
3050         tagcleartable.put(objtmp, tagtmp);
3051       }
3052     }
3053
3054
3055     Hashtable flagandtable=new Hashtable();
3056     Hashtable flagortable=new Hashtable();
3057
3058     /* Process flag changes */
3059     Iterator flagsit=ffan.getTempFlagPairs();
3060     while(flagsit.hasNext()) {
3061       TempFlagPair tfp=(TempFlagPair)flagsit.next();
3062       TempDescriptor temp=tfp.getTemp();
3063       Hashtable flagtable=(Hashtable)flagorder.get(temp.getType().getClassDesc());
3064       FlagDescriptor flag=tfp.getFlag();
3065       if (flag==null) {
3066         //Newly allocate objects that don't set any flags case
3067         if (flagortable.containsKey(temp)) {
3068           throw new Error();
3069         }
3070         int mask=0;
3071         flagortable.put(temp,new Integer(mask));
3072       } else {
3073         int flagid=1<<((Integer)flagtable.get(flag)).intValue();
3074         boolean flagstatus=ffan.getFlagChange(tfp);
3075         if (flagstatus) {
3076           int mask=0;
3077           if (flagortable.containsKey(temp)) {
3078             mask=((Integer)flagortable.get(temp)).intValue();
3079           }
3080           mask|=flagid;
3081           flagortable.put(temp,new Integer(mask));
3082         } else {
3083           int mask=0xFFFFFFFF;
3084           if (flagandtable.containsKey(temp)) {
3085             mask=((Integer)flagandtable.get(temp)).intValue();
3086           }
3087           mask&=(0xFFFFFFFF^flagid);
3088           flagandtable.put(temp,new Integer(mask));
3089         }
3090       }
3091     }
3092
3093
3094     HashSet flagtagset=new HashSet();
3095     flagtagset.addAll(flagortable.keySet());
3096     flagtagset.addAll(flagandtable.keySet());
3097     flagtagset.addAll(tagsettable.keySet());
3098     flagtagset.addAll(tagcleartable.keySet());
3099
3100     Iterator ftit=flagtagset.iterator();
3101     while(ftit.hasNext()) {
3102       TempDescriptor temp=(TempDescriptor)ftit.next();
3103
3104
3105       Set tagtmps=tagcleartable.get(temp);
3106       if (tagtmps!=null) {
3107         Iterator tagit=tagtmps.iterator();
3108         while(tagit.hasNext()) {
3109           TempDescriptor tagtmp=(TempDescriptor)tagit.next();
3110           if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC))
3111             output.println("tagclear("+localsprefixaddr+", (struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
3112           else
3113             output.println("tagclear((struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
3114         }
3115       }
3116
3117       tagtmps=tagsettable.get(temp);
3118       if (tagtmps!=null) {
3119         Iterator tagit=tagtmps.iterator();
3120         while(tagit.hasNext()) {
3121           TempDescriptor tagtmp=(TempDescriptor)tagit.next();
3122           if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC))
3123             output.println("tagset("+localsprefixaddr+", (struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
3124           else
3125             output.println("tagset((struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
3126         }
3127       }
3128
3129       int ormask=0;
3130       int andmask=0xFFFFFFF;
3131
3132       if (flagortable.containsKey(temp))
3133         ormask=((Integer)flagortable.get(temp)).intValue();
3134       if (flagandtable.containsKey(temp))
3135         andmask=((Integer)flagandtable.get(temp)).intValue();
3136       generateFlagOrAnd(ffan, fm, temp, output, ormask, andmask);
3137       generateObjectDistribute(ffan, fm, temp, output);
3138     }
3139   }
3140
3141   protected void generateFlagOrAnd(FlatFlagActionNode ffan, FlatMethod fm, TempDescriptor temp,
3142                                    PrintWriter output, int ormask, int andmask) {
3143     if (ffan.getTaskType()==FlatFlagActionNode.NEWOBJECT) {
3144       output.println("flagorandinit("+generateTemp(fm, temp)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
3145     } else {
3146       output.println("flagorand("+generateTemp(fm, temp)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
3147     }
3148   }
3149
3150   protected void generateObjectDistribute(FlatFlagActionNode ffan, FlatMethod fm, TempDescriptor temp, PrintWriter output) {
3151     output.println("enqueueObject("+generateTemp(fm, temp)+");");
3152   }
3153
3154   void generateOptionalHeader(PrintWriter headers) {
3155
3156     //GENERATE HEADERS
3157     headers.println("#include \"task.h\"\n\n");
3158     headers.println("#ifndef _OPTIONAL_STRUCT_");
3159     headers.println("#define _OPTIONAL_STRUCT_");
3160
3161     //STRUCT PREDICATEMEMBER
3162     headers.println("struct predicatemember{");
3163     headers.println("int type;");
3164     headers.println("int numdnfterms;");
3165     headers.println("int * flags;");
3166     headers.println("int numtags;");
3167     headers.println("int * tags;\n};\n\n");
3168
3169     //STRUCT OPTIONALTASKDESCRIPTOR
3170     headers.println("struct optionaltaskdescriptor{");
3171     headers.println("struct taskdescriptor * task;");
3172     headers.println("int index;");
3173     headers.println("int numenterflags;");
3174     headers.println("int * enterflags;");
3175     headers.println("int numpredicatemembers;");
3176     headers.println("struct predicatemember ** predicatememberarray;");
3177     headers.println("};\n\n");
3178
3179     //STRUCT TASKFAILURE
3180     headers.println("struct taskfailure {");
3181     headers.println("struct taskdescriptor * task;");
3182     headers.println("int index;");
3183     headers.println("int numoptionaltaskdescriptors;");
3184     headers.println("struct optionaltaskdescriptor ** optionaltaskdescriptorarray;\n};\n\n");
3185
3186     //STRUCT FSANALYSISWRAPPER
3187     headers.println("struct fsanalysiswrapper{");
3188     headers.println("int  flags;");
3189     headers.println("int numtags;");
3190     headers.println("int * tags;");
3191     headers.println("int numtaskfailures;");
3192     headers.println("struct taskfailure ** taskfailurearray;");
3193     headers.println("int numoptionaltaskdescriptors;");
3194     headers.println("struct optionaltaskdescriptor ** optionaltaskdescriptorarray;\n};\n\n");
3195
3196     //STRUCT CLASSANALYSISWRAPPER
3197     headers.println("struct classanalysiswrapper{");
3198     headers.println("int type;");
3199     headers.println("int numotd;");
3200     headers.println("struct optionaltaskdescriptor ** otdarray;");
3201     headers.println("int numfsanalysiswrappers;");
3202     headers.println("struct fsanalysiswrapper ** fsanalysiswrapperarray;\n};");
3203
3204     headers.println("extern struct classanalysiswrapper * classanalysiswrapperarray[];");
3205
3206     Iterator taskit=state.getTaskSymbolTable().getDescriptorsIterator();
3207     while(taskit.hasNext()) {
3208       TaskDescriptor td=(TaskDescriptor)taskit.next();
3209       headers.println("extern struct taskdescriptor task_"+td.getSafeSymbol()+";");
3210     }
3211
3212   }
3213
3214   //CHECK OVER THIS -- THERE COULD BE SOME ERRORS HERE
3215   int generateOptionalPredicate(Predicate predicate, OptionalTaskDescriptor otd, ClassDescriptor cdtemp, PrintWriter output) {
3216     int predicateindex = 0;
3217     //iterate through the classes concerned by the predicate
3218     Set c_vard = predicate.vardescriptors;
3219     Hashtable<TempDescriptor, Integer> slotnumber=new Hashtable<TempDescriptor, Integer>();
3220     int current_slot=0;
3221
3222     for(Iterator vard_it = c_vard.iterator(); vard_it.hasNext(); ) {
3223       VarDescriptor vard = (VarDescriptor)vard_it.next();
3224       TypeDescriptor typed = vard.getType();
3225
3226       //generate for flags
3227       HashSet fen_hashset = predicate.flags.get(vard.getSymbol());
3228       output.println("int predicateflags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
3229       int numberterms=0;
3230       if (fen_hashset!=null) {
3231         for (Iterator fen_it = fen_hashset.iterator(); fen_it.hasNext(); ) {
3232           FlagExpressionNode fen = (FlagExpressionNode)fen_it.next();
3233           if (fen!=null) {
3234             DNFFlag dflag=fen.getDNF();
3235             numberterms+=dflag.size();
3236
3237             Hashtable flags=(Hashtable)flagorder.get(typed.getClassDesc());
3238
3239             for(int j=0; j<dflag.size(); j++) {
3240               if (j!=0)
3241                 output.println(",");
3242               Vector term=dflag.get(j);
3243               int andmask=0;
3244               int checkmask=0;
3245               for(int k=0; k<term.size(); k++) {
3246                 DNFFlagAtom dfa=(DNFFlagAtom)term.get(k);
3247                 FlagDescriptor fd=dfa.getFlag();
3248                 boolean negated=dfa.getNegated();
3249                 int flagid=1<<((Integer)flags.get(fd)).intValue();
3250                 andmask|=flagid;
3251                 if (!negated)
3252                   checkmask|=flagid;
3253               }
3254               output.print("/*andmask*/0x"+Integer.toHexString(andmask)+", /*checkmask*/0x"+Integer.toHexString(checkmask));
3255             }
3256           }
3257         }
3258       }
3259       output.println("};\n");
3260
3261       //generate for tags
3262       TagExpressionList tagel = predicate.tags.get(vard.getSymbol());
3263       output.println("int predicatetags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
3264       int numtags = 0;
3265       if (tagel!=null) {
3266         for(int j=0; j<tagel.numTags(); j++) {
3267           if (j!=0)
3268             output.println(",");
3269           TempDescriptor tmp=tagel.getTemp(j);
3270           if (!slotnumber.containsKey(tmp)) {
3271             Integer slotint=new Integer(current_slot++);
3272             slotnumber.put(tmp,slotint);
3273           }
3274           int slot=slotnumber.get(tmp).intValue();
3275           output.println("/* slot */"+ slot+", /*tagid*/"+state.getTagId(tmp.getTag()));
3276         }
3277         numtags = tagel.numTags();
3278       }
3279       output.println("};");
3280
3281       //store the result into a predicatemember struct
3282       output.println("struct predicatemember predicatemember_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"={");
3283       output.println("/*type*/"+typed.getClassDesc().getId()+",");
3284       output.println("/* number of dnf terms */"+numberterms+",");
3285       output.println("predicateflags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
3286       output.println("/* number of tag */"+numtags+",");
3287       output.println("predicatetags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
3288       output.println("};\n");
3289       predicateindex++;
3290     }
3291
3292
3293     //generate an array that stores the entire predicate
3294     output.println("struct predicatemember * predicatememberarray_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
3295     for( int j = 0; j<predicateindex; j++) {
3296       if( j != predicateindex-1) output.println("&predicatemember_"+j+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
3297       else output.println("&predicatemember_"+j+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
3298     }
3299     output.println("};\n");
3300     return predicateindex;
3301   }
3302
3303
3304   void generateOptionalArrays(PrintWriter output, PrintWriter headers, Hashtable<ClassDescriptor, Hashtable<FlagState, Set<OptionalTaskDescriptor>>> safeexecution, Hashtable optionaltaskdescriptors) {
3305     generateOptionalHeader(headers);
3306     //GENERATE STRUCTS
3307     output.println("#include \"optionalstruct.h\"\n\n");
3308     output.println("#include \"stdlib.h\"\n");
3309
3310     HashSet processedcd = new HashSet();
3311     int maxotd=0;
3312     Enumeration e = safeexecution.keys();
3313     while (e.hasMoreElements()) {
3314       int numotd=0;
3315       //get the class
3316       ClassDescriptor cdtemp=(ClassDescriptor)e.nextElement();
3317       Hashtable flaginfo=(Hashtable)flagorder.get(cdtemp);       //will be used several times
3318
3319       //Generate the struct of optionals
3320       Collection c_otd = ((Hashtable)optionaltaskdescriptors.get(cdtemp)).values();
3321       numotd = c_otd.size();
3322       if(maxotd<numotd) maxotd = numotd;
3323       if( !c_otd.isEmpty() ) {
3324         for(Iterator otd_it = c_otd.iterator(); otd_it.hasNext(); ) {
3325           OptionalTaskDescriptor otd = (OptionalTaskDescriptor)otd_it.next();
3326
3327           //generate the int arrays for the predicate
3328           Predicate predicate = otd.predicate;
3329           int predicateindex = generateOptionalPredicate(predicate, otd, cdtemp, output);
3330           TreeSet<Integer> fsset=new TreeSet<Integer>();
3331           //iterate through possible FSes corresponding to
3332           //the state when entering
3333
3334           for(Iterator fses = otd.enterflagstates.iterator(); fses.hasNext(); ) {
3335             FlagState fs = (FlagState)fses.next();
3336             int flagid=0;
3337             for(Iterator flags = fs.getFlags(); flags.hasNext(); ) {
3338               FlagDescriptor flagd = (FlagDescriptor)flags.next();
3339               int id=1<<((Integer)flaginfo.get(flagd)).intValue();
3340               flagid|=id;
3341             }
3342             fsset.add(new Integer(flagid));
3343             //tag information not needed because tag
3344             //changes are not tolerated.
3345           }
3346
3347           output.println("int enterflag_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
3348           boolean needcomma=false;
3349           for(Iterator<Integer> it=fsset.iterator(); it.hasNext(); ) {
3350             if(needcomma)
3351               output.print(", ");
3352             output.println(it.next());
3353           }
3354
3355           output.println("};\n");
3356
3357
3358           //generate optionaltaskdescriptor that actually
3359           //includes exit fses, predicate and the task
3360           //concerned
3361           output.println("struct optionaltaskdescriptor optionaltaskdescriptor_"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"={");
3362           output.println("&task_"+otd.td.getSafeSymbol()+",");
3363           output.println("/*index*/"+otd.getIndex()+",");
3364           output.println("/*number of enter flags*/"+fsset.size()+",");
3365           output.println("enterflag_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
3366           output.println("/*number of members */"+predicateindex+",");
3367           output.println("predicatememberarray_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
3368           output.println("};\n");
3369         }
3370       } else
3371         continue;
3372       // if there are no optionals, there is no need to build the rest of the struct
3373
3374       output.println("struct optionaltaskdescriptor * otdarray"+cdtemp.getSafeSymbol()+"[]={");
3375       c_otd = ((Hashtable)optionaltaskdescriptors.get(cdtemp)).values();
3376       if( !c_otd.isEmpty() ) {
3377         boolean needcomma=false;
3378         for(Iterator otd_it = c_otd.iterator(); otd_it.hasNext(); ) {
3379           OptionalTaskDescriptor otd = (OptionalTaskDescriptor)otd_it.next();
3380           if(needcomma)
3381             output.println(",");
3382           needcomma=true;
3383           output.println("&optionaltaskdescriptor_"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
3384         }
3385       }
3386       output.println("};\n");
3387
3388       //get all the possible flagstates reachable by an object
3389       Hashtable hashtbtemp = safeexecution.get(cdtemp);
3390       int fscounter = 0;
3391       TreeSet fsts=new TreeSet(new FlagComparator(flaginfo));
3392       fsts.addAll(hashtbtemp.keySet());
3393       for(Iterator fsit=fsts.iterator(); fsit.hasNext(); ) {
3394         FlagState fs = (FlagState)fsit.next();
3395         fscounter++;
3396
3397         //get the set of OptionalTaskDescriptors corresponding
3398         HashSet<OptionalTaskDescriptor> availabletasks = (HashSet<OptionalTaskDescriptor>)hashtbtemp.get(fs);
3399         //iterate through the OptionalTaskDescriptors and
3400         //store the pointers to the optionals struct (see on
3401         //top) into an array
3402
3403         output.println("struct optionaltaskdescriptor * optionaltaskdescriptorarray_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"[] = {");
3404         for(Iterator<OptionalTaskDescriptor> mos = ordertd(availabletasks).iterator(); mos.hasNext(); ) {
3405           OptionalTaskDescriptor mm = mos.next();
3406           if(!mos.hasNext())
3407             output.println("&optionaltaskdescriptor_"+mm.getuid()+"_"+cdtemp.getSafeSymbol());
3408           else
3409             output.println("&optionaltaskdescriptor_"+mm.getuid()+"_"+cdtemp.getSafeSymbol()+",");
3410         }
3411
3412         output.println("};\n");
3413
3414         //process flag information (what the flag after failure is) so we know what optionaltaskdescriptors to choose.
3415
3416         int flagid=0;
3417         for(Iterator flags = fs.getFlags(); flags.hasNext(); ) {
3418           FlagDescriptor flagd = (FlagDescriptor)flags.next();
3419           int id=1<<((Integer)flaginfo.get(flagd)).intValue();
3420           flagid|=id;
3421         }
3422
3423         //process tag information
3424
3425         int tagcounter = 0;
3426         boolean first = true;
3427         Enumeration tag_enum = fs.getTags();
3428         output.println("int tags_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"[]={");
3429         while(tag_enum.hasMoreElements()) {
3430           tagcounter++;
3431           TagDescriptor tagd = (TagDescriptor)tag_enum.nextElement();
3432           if(first==true)
3433             first = false;
3434           else
3435             output.println(", ");
3436           output.println("/*tagid*/"+state.getTagId(tagd));
3437         }
3438         output.println("};");
3439
3440         Set<TaskIndex> tiset=sa.getTaskIndex(fs);
3441         for(Iterator<TaskIndex> itti=tiset.iterator(); itti.hasNext(); ) {
3442           TaskIndex ti=itti.next();
3443           if (ti.isRuntime())
3444             continue;
3445
3446           Set<OptionalTaskDescriptor> otdset=sa.getOptions(fs, ti);
3447
3448           output.print("struct optionaltaskdescriptor * optionaltaskfailure_FS"+fscounter+"_"+ti.getTask().getSafeSymbol()+"_"+ti.getIndex()+"_array[] = {");
3449           boolean needcomma=false;
3450           for(Iterator<OptionalTaskDescriptor> otdit=ordertd(otdset).iterator(); otdit.hasNext(); ) {
3451             OptionalTaskDescriptor otd=otdit.next();
3452             if(needcomma)
3453               output.print(", ");
3454             needcomma=true;
3455             output.println("&optionaltaskdescriptor_"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
3456           }
3457           output.println("};");
3458
3459           output.print("struct taskfailure taskfailure_FS"+fscounter+"_"+ti.getTask().getSafeSymbol()+"_"+ti.getIndex()+" = {");
3460           output.print("&task_"+ti.getTask().getSafeSymbol()+", ");
3461           output.print(ti.getIndex()+", ");
3462           output.print(otdset.size()+", ");
3463           output.print("optionaltaskfailure_FS"+fscounter+"_"+ti.getTask().getSafeSymbol()+"_"+ti.getIndex()+"_array");
3464           output.println("};");
3465         }
3466
3467         tiset=sa.getTaskIndex(fs);
3468         boolean needcomma=false;
3469         int runtimeti=0;
3470         output.println("struct taskfailure * taskfailurearray"+fscounter+"_"+cdtemp.getSafeSymbol()+"[]={");
3471         for(Iterator<TaskIndex> itti=tiset.iterator(); itti.hasNext(); ) {
3472           TaskIndex ti=itti.next();
3473           if (ti.isRuntime()) {
3474             runtimeti++;
3475             continue;
3476           }
3477           if (needcomma)
3478             output.print(", ");
3479           needcomma=true;
3480           output.print("&taskfailure_FS"+fscounter+"_"+ti.getTask().getSafeSymbol()+"_"+ti.getIndex());
3481         }
3482         output.println("};\n");
3483
3484         //Store the result in fsanalysiswrapper
3485
3486         output.println("struct fsanalysiswrapper fsanalysiswrapper_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"={");
3487         output.println("/*flag*/"+flagid+",");
3488         output.println("/* number of tags*/"+tagcounter+",");
3489         output.println("tags_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+",");
3490         output.println("/* numtask failures */"+(tiset.size()-runtimeti)+",");
3491         output.println("taskfailurearray"+fscounter+"_"+cdtemp.getSafeSymbol()+",");
3492         output.println("/* number of optionaltaskdescriptors */"+availabletasks.size()+",");
3493         output.println("optionaltaskdescriptorarray_FS"+fscounter+"_"+cdtemp.getSafeSymbol());
3494         output.println("};\n");
3495
3496       }
3497
3498       //Build the array of fsanalysiswrappers
3499       output.println("struct fsanalysiswrapper * fsanalysiswrapperarray_"+cdtemp.getSafeSymbol()+"[] = {");
3500       boolean needcomma=false;
3501       for(int i = 0; i<fscounter; i++) {
3502         if (needcomma) output.print(",");
3503         output.println("&fsanalysiswrapper_FS"+(i+1)+"_"+cdtemp.getSafeSymbol());
3504         needcomma=true;
3505       }
3506       output.println("};");
3507
3508       //Build the classanalysiswrapper referring to the previous array
3509       output.println("struct classanalysiswrapper classanalysiswrapper_"+cdtemp.getSafeSymbol()+"={");
3510       output.println("/*type*/"+cdtemp.getId()+",");
3511       output.println("/*numotd*/"+numotd+",");
3512       output.println("otdarray"+cdtemp.getSafeSymbol()+",");
3513       output.println("/* number of fsanalysiswrappers */"+fscounter+",");
3514       output.println("fsanalysiswrapperarray_"+cdtemp.getSafeSymbol()+"};\n");
3515       processedcd.add(cdtemp);
3516     }
3517
3518     //build an array containing every classes for which code has been build
3519     output.println("struct classanalysiswrapper * classanalysiswrapperarray[]={");
3520     for(int i=0; i<state.numClasses(); i++) {
3521       ClassDescriptor cn=cdarray[i];
3522       if (i>0)
3523         output.print(", ");
3524       if ((cn != null) && (processedcd.contains(cn)))
3525         output.print("&classanalysiswrapper_"+cn.getSafeSymbol());
3526       else
3527         output.print("NULL");
3528     }
3529     output.println("};");
3530
3531     output.println("#define MAXOTD "+maxotd);
3532     headers.println("#endif");
3533   }
3534
3535   public List<OptionalTaskDescriptor> ordertd(Set<OptionalTaskDescriptor> otdset) {
3536     Relation r=new Relation();
3537     for(Iterator<OptionalTaskDescriptor>otdit=otdset.iterator(); otdit.hasNext(); ) {
3538       OptionalTaskDescriptor otd=otdit.next();
3539       TaskIndex ti=new TaskIndex(otd.td, otd.getIndex());
3540       r.put(ti, otd);
3541     }
3542
3543     LinkedList<OptionalTaskDescriptor> l=new LinkedList<OptionalTaskDescriptor>();
3544     for(Iterator it=r.keySet().iterator(); it.hasNext(); ) {
3545       Set s=r.get(it.next());
3546       for(Iterator it2=s.iterator(); it2.hasNext(); ) {
3547         OptionalTaskDescriptor otd=(OptionalTaskDescriptor)it2.next();
3548         l.add(otd);
3549       }
3550     }
3551
3552     return l;
3553   }
3554
3555   // override these methods in a subclass of BuildCode
3556   // to generate code for additional systems
3557   protected void printExtraArrayFields(PrintWriter outclassdefs) {
3558   }
3559   protected void outputTransCode(PrintWriter output) {
3560   }
3561   protected void buildCodeSetup() {
3562   }
3563   protected void generateSizeArrayExtensions(PrintWriter outclassdefs) {
3564   }
3565   protected void additionalIncludesMethodsHeader(PrintWriter outmethodheader) {
3566   }
3567   protected void preCodeGenInitialization() {
3568   }
3569   protected void postCodeGenCleanUp() {
3570   }
3571   protected void additionalCodeGen(PrintWriter outmethodheader,
3572                                    PrintWriter outstructs,
3573                                    PrintWriter outmethod) {
3574   }
3575   protected void additionalCodeAtTopOfMain(PrintWriter outmethod) {
3576   }
3577   protected void additionalCodeAtBottomOfMain(PrintWriter outmethod) {
3578   }
3579   protected void additionalIncludesMethodsImplementation(PrintWriter outmethod) {
3580   }
3581   protected void additionalIncludesStructsHeader(PrintWriter outstructs) {
3582   }
3583   protected void additionalClassObjectFields(PrintWriter outclassdefs) {
3584   }
3585   protected void additionalCodeAtTopMethodsImplementation(PrintWriter outmethod) {
3586   }
3587   protected void additionalCodeAtTopFlatMethodBody(PrintWriter output, FlatMethod fm) {
3588   }
3589   protected void additionalCodePreNode(FlatMethod fm, FlatNode fn, PrintWriter output) {
3590   }
3591   protected void additionalCodePostNode(FlatMethod fm, FlatNode fn, PrintWriter output) {
3592   }
3593
3594   private void printSourceLineNumber(FlatMethod fm, FlatNode fn, PrintWriter output) {
3595     // we do not print out line number if no one explicitly set the number
3596     if(fn.getNumLine()!=-1) {
3597
3598       int lineNum=fn.getNumLine();
3599
3600       // do not generate the line number if it is same as the previous one
3601       boolean needtoprint;
3602       if(fn.prev.size()==0) {
3603         needtoprint=true;
3604       } else {
3605         needtoprint=false;
3606       }
3607
3608       for(int i=0; i<fn.prev.size(); i++) {
3609         int prevLineNum=((FlatNode)fn.prev.get(i)).getNumLine();
3610         if(prevLineNum!=lineNum) {
3611           needtoprint=true;
3612           break;
3613         }
3614       }
3615       if(needtoprint) {
3616         output.println("// "+fm.getMethod().getClassDesc().getSourceFileName()+":"+fn.getNumLine());
3617       }
3618     }
3619   }
3620
3621 }
3622
3623
3624
3625
3626
3627