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       if( state.CAPTURE_NULL_DEREFERENCES ) {
2673         output.println("#ifdef CAPTURE_NULL_DEREFERENCES");
2674         output.println("if (" + generateTemp(fm,ffn.getSrc()) + " == NULL) {");
2675         output.println("printf(\" NULL ptr error: %s, %s, %d \\n\", __FILE__, __func__, __LINE__);");
2676         if(state.MULTICOREGC) {
2677           output.println("failednullptr(&___locals___);");
2678         } else {
2679           output.println("failednullptr(NULL);");
2680         }
2681         output.println("}");
2682         output.println("#endif //CAPTURE_NULL_DEREFERENCES");
2683       }
2684       output.println(generateTemp(fm, ffn.getDst())+"="+ generateTemp(fm,ffn.getSrc())+"->"+ ffn.getField().getSafeSymbol()+";");
2685     }
2686   }
2687
2688
2689   protected void generateFlatSetFieldNode(FlatMethod fm, FlatSetFieldNode fsfn, PrintWriter output) {
2690     if (fsfn.getField().getSymbol().equals("length")&&fsfn.getDst().getType().isArray())
2691       throw new Error("Can't set array length");
2692     if (state.FASTCHECK) {
2693       String dst=generateTemp(fm, fsfn.getDst());
2694       output.println("if(!"+dst+"->"+localcopystr+") {");
2695       /* Link object into list */
2696       if (GENERATEPRECISEGC || this.state.MULTICOREGC)
2697         output.println("COPY_OBJ((struct garbagelist *)"+localsprefixaddr+",(struct ___Object___ *)"+dst+");");
2698       else
2699         output.println("COPY_OBJ("+dst+");");
2700       output.println(dst+"->"+nextobjstr+"="+fcrevert+";");
2701       output.println(fcrevert+"=(struct ___Object___ *)"+dst+";");
2702       output.println("}");
2703     }
2704
2705     if(fsfn.getField().isStatic()) {
2706       // static field
2707       if((fm.getMethod().isStaticBlock()) || (fm.getMethod().isInvokedByStatic())) {
2708         // is a static block or is invoked in some static block
2709         ClassDescriptor cd = fm.getMethod().getClassDesc();
2710         ClassDescriptor cn = fsfn.getDst().getType().getClassDesc();
2711         if(cd != cn && mgcstaticinit && callgraph.isInit(cn)) {
2712           // generate static init check code if has not done the static init in main()
2713           if((cn.getNumStaticFields() != 0) || (cn.getNumStaticBlocks() != 0)) {
2714             // need to check if the class' static fields have been initialized and/or
2715             // its static blocks have been executed
2716             output.println("if(global_defsprim_p->" + cn.getSafeSymbol()+"static_block_exe_flag == 0) {");
2717             if(cn.getNumStaticBlocks() != 0) {
2718               MethodDescriptor t_md = (MethodDescriptor)cn.getMethodTable().get("staticblocks");
2719               if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2720                 output.print("       struct "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"_params __parameterlist__={");
2721                 output.println("0, NULL};");
2722                 output.println("     "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"(& __parameterlist__);");
2723               } else {
2724                 output.println("  "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"();");
2725               }
2726             } else {
2727               output.println("  global_defsprim_p->" + cn.getSafeSymbol()+"static_block_exe_flag = 1;");
2728             }
2729             output.println("}");
2730           }
2731         }
2732       }
2733       // redirect to the global_defs_p structure
2734       if (fsfn.getField().getType().isPtr()) {
2735         if (fsfn.getField().getType()!=fsfn.getSrc().getType())
2736           output.println("global_defs_p->" +
2737                          fsfn.getField().getSafeSymbol()+"=(struct "+ fsfn.getField().getType().getSafeSymbol()+" *)"+generateTemp(fm,fsfn.getSrc())+";");
2738         else
2739           output.println("global_defs_p->" +
2740                          fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc())+";");
2741       } else
2742         output.println("global_defsprim_p->" +
2743                        fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc())+";");
2744     } else {
2745
2746       if( state.CAPTURE_NULL_DEREFERENCES ) {
2747         output.println("#ifdef CAPTURE_NULL_DEREFERENCES");
2748         output.println("if (" + generateTemp(fm,fsfn.getDst()) + " == NULL) {");
2749         output.println("printf(\" NULL ptr error: %s, %s, %d \\n\", __FILE__, __func__, __LINE__);");
2750         if(state.MULTICOREGC) {
2751           output.println("failednullptr(&___locals___);");
2752         } else {
2753           output.println("failednullptr(NULL);");
2754         }
2755         output.println("}");
2756         output.println("#endif //CAPTURE_NULL_DEREFERENCES");
2757       }
2758
2759       if (fsfn.getSrc().getType().isPtr()&&fsfn.getSrc().getType()!=fsfn.getField().getType())
2760         output.println(generateTemp(fm, fsfn.getDst())+"->"+
2761                        fsfn.getField().getSafeSymbol()+"=(struct "+ fsfn.getField().getType().getSafeSymbol()+"*)"+generateTemp(fm,fsfn.getSrc())+";");
2762       else
2763         output.println(generateTemp(fm, fsfn.getDst())+"->"+
2764                        fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc())+";");
2765     }
2766   }
2767
2768
2769   protected void generateFlatElementNode(FlatMethod fm, FlatElementNode fen, PrintWriter output) {
2770     TypeDescriptor elementtype=fen.getSrc().getType().dereference();
2771     String type="";
2772
2773     if (elementtype.isClass() && elementtype.getClassDesc().isEnum()) {
2774       type="int ";
2775     } else if (elementtype.isArray()||elementtype.isClass())
2776       type="void *";
2777     else
2778       type=elementtype.getSafeSymbol()+" ";
2779
2780     if (this.state.ARRAYBOUNDARYCHECK && fen.needsBoundsCheck()) {
2781       output.println("if (unlikely(((unsigned int)"+generateTemp(fm, fen.getIndex())+") >= "+generateTemp(fm,fen.getSrc()) + "->___length___))");
2782       output.println("failedboundschk(" + (boundschknum++) + ");");
2783     }
2784     output.println(generateTemp(fm, fen.getDst())+"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc())+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex())+"];");
2785   }
2786
2787   protected void generateFlatSetElementNode(FlatMethod fm, FlatSetElementNode fsen, PrintWriter output) {
2788     //TODO: need dynamic check to make sure this assignment is actually legal
2789     //Because Object[] could actually be something more specific...ie. Integer[]
2790
2791     TypeDescriptor elementtype=fsen.getDst().getType().dereference();
2792     String type="";
2793
2794     if (elementtype.isClass() && elementtype.getClassDesc().isEnum()) {
2795       type="int ";
2796     } else if (elementtype.isArray()||elementtype.isClass() || (elementtype.isNull()))
2797       type="void *";
2798     else
2799       type=elementtype.getSafeSymbol()+" ";
2800
2801     if (this.state.ARRAYBOUNDARYCHECK && fsen.needsBoundsCheck()) {
2802       output.println("if (unlikely(((unsigned int)"+generateTemp(fm, fsen.getIndex())+") >= "+generateTemp(fm,fsen.getDst()) + "->___length___))");
2803       output.println("failedboundschk(" + (boundschknum++) + ");");
2804     }
2805     if (state.FASTCHECK) {
2806       String dst=generateTemp(fm, fsen.getDst());
2807       output.println("if(!"+dst+"->"+localcopystr+") {");
2808       /* Link object into list */
2809       if (GENERATEPRECISEGC || this.state.MULTICOREGC)
2810         output.println("COPY_OBJ((struct garbagelist *)"+localsprefixaddr+",(struct ___Object___ *)"+dst+");");
2811       else
2812         output.println("COPY_OBJ("+dst+");");
2813       output.println(dst+"->"+nextobjstr+"="+fcrevert+";");
2814       output.println(fcrevert+"=(struct ___Object___ *)"+dst+";");
2815       output.println("}");
2816     }
2817     output.println("(("+type +"*)(((char *) &("+ generateTemp(fm,fsen.getDst())+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex())+"]="+generateTemp(fm,fsen.getSrc())+";");
2818   }
2819
2820
2821   protected void generateFlatNew(FlatMethod fm, FlatNew fn, PrintWriter output) {
2822     if (fn.getType().isArray()) {
2823       int arrayid=state.getArrayNumber(fn.getType())+state.numClasses();
2824       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2825         output.println(generateTemp(fm,fn.getDst())+"=allocate_newarray("+localsprefixaddr+", "+arrayid+", "+generateTemp(fm, fn.getSize())+");");
2826       } else {
2827         output.println(generateTemp(fm,fn.getDst())+"=allocate_newarray("+arrayid+", "+generateTemp(fm, fn.getSize())+");");
2828       }
2829     } else {
2830       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2831         output.println(generateTemp(fm,fn.getDst())+"=allocate_new("+localsprefixaddr+", "+fn.getType().getClassDesc().getId()+");");
2832       } else {
2833         output.println(generateTemp(fm,fn.getDst())+"=allocate_new("+fn.getType().getClassDesc().getId()+");");
2834       }
2835     }
2836     if (state.FASTCHECK) {
2837       String dst=generateTemp(fm,fn.getDst());
2838       output.println(dst+"->___localcopy___=(struct ___Object___*)1;");
2839       output.println(dst+"->"+nextobjstr+"="+fcrevert+";");
2840       output.println(fcrevert+"=(struct ___Object___ *)"+dst+";");
2841     }
2842   }
2843
2844   protected void generateFlatTagDeclaration(FlatMethod fm, FlatTagDeclaration fn, PrintWriter output) {
2845     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2846       output.println(generateTemp(fm,fn.getDst())+"=allocate_tag("+localsprefixaddr+", "+state.getTagId(fn.getType())+");");
2847     } else {
2848       output.println(generateTemp(fm,fn.getDst())+"=allocate_tag("+state.getTagId(fn.getType())+");");
2849     }
2850   }
2851
2852   protected void generateFlatOpNode(FlatMethod fm, FlatOpNode fon, PrintWriter output) {
2853     if (fon.getRight()!=null) {
2854       if (fon.getOp().getOp()==Operation.URIGHTSHIFT) {
2855         if (fon.getLeft().getType().isLong())
2856           output.println(generateTemp(fm, fon.getDest())+" = ((unsigned long long)"+generateTemp(fm, fon.getLeft())+")>>"+generateTemp(fm,fon.getRight())+";");
2857         else
2858           output.println(generateTemp(fm, fon.getDest())+" = ((unsigned int)"+generateTemp(fm, fon.getLeft())+")>>"+generateTemp(fm,fon.getRight())+";");
2859
2860       } else {
2861         if (fon.getLeft().getType().isPtr()&&fon.getLeft().getType()!=fon.getRight().getType()&&!fon.getRight().getType().isNull())
2862           output.println(generateTemp(fm, fon.getDest())+" = (struct "+fon.getRight().getType().getSafeSymbol()+"*)"+generateTemp(fm, fon.getLeft())+fon.getOp().toString()+generateTemp(fm,fon.getRight())+";");
2863         else
2864           output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+fon.getOp().toString()+generateTemp(fm,fon.getRight())+";");
2865       }
2866     } else if (fon.getOp().getOp()==Operation.ASSIGN)
2867       if (fon.getDest().getType().isPtr()&&fon.getDest().getType()!=fon.getLeft().getType())
2868         output.println(generateTemp(fm, fon.getDest())+" = (struct "+fon.getDest().getType().getSafeSymbol()+"*)"+generateTemp(fm, fon.getLeft())+";");
2869       else
2870         output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+";");
2871     else if (fon.getOp().getOp()==Operation.UNARYPLUS)
2872       output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+";");
2873     else if (fon.getOp().getOp()==Operation.UNARYMINUS)
2874       output.println(generateTemp(fm, fon.getDest())+" = -"+generateTemp(fm, fon.getLeft())+";");
2875     else if (fon.getOp().getOp()==Operation.LOGIC_NOT)
2876       output.println(generateTemp(fm, fon.getDest())+" = !"+generateTemp(fm, fon.getLeft())+";");
2877     else if (fon.getOp().getOp()==Operation.COMP)
2878       output.println(generateTemp(fm, fon.getDest())+" = ~"+generateTemp(fm, fon.getLeft())+";");
2879     else if (fon.getOp().getOp()==Operation.ISAVAILABLE) {
2880       output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+"->fses==NULL;");
2881     } else
2882       output.println(generateTemp(fm, fon.getDest())+fon.getOp().toString()+generateTemp(fm, fon.getLeft())+";");
2883   }
2884
2885   protected void generateFlatCastNode(FlatMethod fm, FlatCastNode fcn, PrintWriter output) {
2886     /* TODO: Do type check here */
2887     if (fcn.getType().isArray()) {
2888       output.println(generateTemp(fm,fcn.getDst())+"=(struct ArrayObject *)"+generateTemp(fm,fcn.getSrc())+";");
2889     } else if (fcn.getType().isClass() && fcn.getType().getClassDesc().isEnum()) {
2890       output.println(generateTemp(fm,fcn.getDst())+"=(int)"+generateTemp(fm,fcn.getSrc())+";");
2891     } else if (fcn.getType().isClass())
2892       output.println(generateTemp(fm,fcn.getDst())+"=(struct "+fcn.getType().getSafeSymbol()+" *)"+generateTemp(fm,fcn.getSrc())+";");
2893     else
2894       output.println(generateTemp(fm,fcn.getDst())+"=("+fcn.getType().getSafeSymbol()+")"+generateTemp(fm,fcn.getSrc())+";");
2895   }
2896
2897   int flncount=0;
2898
2899   protected void generateFlatLiteralNode(FlatMethod fm, FlatLiteralNode fln, PrintWriter output) {
2900     if (fln.getValue()==null)
2901       output.println(generateTemp(fm, fln.getDst())+"=0;");
2902     else if (fln.getType().getSymbol().equals(TypeUtil.StringClass)) {
2903       String str=(String)fln.getValue();
2904       output.println("{");
2905       output.print("short str"+flncount+"[]={");
2906       for(int i=0; i<str.length(); i++) {
2907         if (i!=0)
2908           output.print(", ");
2909         output.print(((int)str.charAt(i)));
2910       }
2911       output.println("};");
2912       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2913         output.println(generateTemp(fm, fln.getDst())+"=NewStringShort("+localsprefixaddr+", str"+flncount+", "+((String)fln.getValue()).length()+");");
2914       } else {
2915         output.println(generateTemp(fm, fln.getDst())+"=NewStringShort(str"+flncount+" ,"+((String)fln.getValue()).length()+");");
2916       }
2917       output.println("}");
2918       flncount++;
2919     } else if (fln.getType().isBoolean()) {
2920       if (((Boolean)fln.getValue()).booleanValue())
2921         output.println(generateTemp(fm, fln.getDst())+"=1;");
2922       else
2923         output.println(generateTemp(fm, fln.getDst())+"=0;");
2924     } else if (fln.getType().isChar()) {
2925       int val=(int)(((Character)fln.getValue()).charValue());
2926       output.println(generateTemp(fm, fln.getDst())+"="+val+";");
2927     } else if (fln.getType().isLong()) {
2928       output.println(generateTemp(fm, fln.getDst())+"="+fln.getValue()+"LL;");
2929     } else
2930       output.println(generateTemp(fm, fln.getDst())+"="+fln.getValue()+";");
2931   }
2932
2933   protected void generateFlatReturnNode(FlatMethod fm, FlatReturnNode frn, PrintWriter output) {
2934     if((fm.getMethod() != null) && (fm.getMethod().isStaticBlock())) {
2935       // a static block, check if it has been executed
2936       output.println("  global_defsprim_p->" + fm.getMethod().getClassDesc().getSafeSymbol()+"static_block_exe_flag = 1;");
2937       output.println("");
2938     }
2939
2940     if (frn.getReturnTemp()!=null) {
2941       if (frn.getReturnTemp().getType().isPtr())
2942         output.println("return (struct "+fm.getMethod().getReturnType().getSafeSymbol()+"*)"+generateTemp(fm, frn.getReturnTemp())+";");
2943       else
2944         output.println("return "+generateTemp(fm, frn.getReturnTemp())+";");
2945     } else {
2946       output.println("return;");
2947     }
2948   }
2949
2950   protected void generateFlatCondBranch(FlatMethod fm, FlatCondBranch fcb, String label, PrintWriter output) {
2951     output.println("if (!"+generateTemp(fm, fcb.getTest())+") goto "+label+";");
2952   }
2953
2954   /** This method generates header information for the method or
2955    * task referenced by the Descriptor des. */
2956   protected void generateHeader(FlatMethod fm, Descriptor des, PrintWriter output) {
2957     generateHeader(fm, des, output, false);
2958   }
2959
2960   protected void generateHeader(FlatMethod fm, Descriptor des, PrintWriter output, boolean addSESErecord) {
2961     /* Print header */
2962     ParamsObject objectparams=(ParamsObject)paramstable.get(des);
2963     MethodDescriptor md=null;
2964     TaskDescriptor task=null;
2965     if (des instanceof MethodDescriptor)
2966       md=(MethodDescriptor) des;
2967     else
2968       task=(TaskDescriptor) des;
2969     String mdstring = md != null?md.getSafeMethodDescriptor():null;
2970
2971     ClassDescriptor cn=md!=null?md.getClassDesc():null;
2972
2973     if (md!=null&&md.getReturnType()!=null) {
2974       if (md.getReturnType().isClass() && md.getReturnType().getClassDesc().isEnum()) {
2975         output.print("int ");
2976       } else if (md.getReturnType().isClass()||md.getReturnType().isArray())
2977         output.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
2978       else
2979         output.print(md.getReturnType().getSafeSymbol()+" ");
2980     } else
2981       //catch the constructor case
2982       output.print("void ");
2983     if (md!=null) {
2984       if(mgcstaticinit && !md.isStaticBlock() && !md.getModifiers().isNative()) {
2985         mdstring += "staticinit";
2986       }
2987       output.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+mdstring+"(");
2988     } else
2989       output.print(task.getSafeSymbol()+"(");
2990
2991     boolean printcomma=false;
2992     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2993       if (md!=null) {
2994         output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+mdstring+"_params * "+paramsprefix);
2995       } else
2996         output.print("struct "+task.getSafeSymbol()+"_params * "+paramsprefix);
2997       printcomma=true;
2998     }
2999
3000     if (md!=null) {
3001       /* Method */
3002       for(int i=0; i<objectparams.numPrimitives(); i++) {
3003         TempDescriptor temp=objectparams.getPrimitive(i);
3004         if (printcomma)
3005           output.print(", ");
3006         printcomma=true;
3007         if(temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
3008           output.print("int " + temp.getSafeSymbol());
3009         } else if (temp.getType().isClass()||temp.getType().isArray())
3010           output.print("struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol());
3011         else
3012           output.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
3013       }
3014       output.println(") {");
3015     } else if (!GENERATEPRECISEGC && !this.state.MULTICOREGC) {
3016       /* Imprecise Task */
3017       output.println("void * parameterarray[]) {");
3018       /* Unpack variables */
3019       for(int i=0; i<objectparams.numPrimitives(); i++) {
3020         TempDescriptor temp=objectparams.getPrimitive(i);
3021         if(temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
3022           output.print("int " + temp.getSafeSymbol() + "=parameterarray["+i+"];");
3023         } else {
3024           output.println("struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+"=parameterarray["+i+"];");
3025         }
3026       }
3027       for(int i=0; i<fm.numTags(); i++) {
3028         TempDescriptor temp=fm.getTag(i);
3029         int offset=i+objectparams.numPrimitives();
3030         output.println("struct ___TagDescriptor___ * "+temp.getSafeSymbol()+"=parameterarray["+offset+"];");
3031       }
3032
3033       if ((objectparams.numPrimitives()+fm.numTags())>maxtaskparams)
3034         maxtaskparams=objectparams.numPrimitives()+fm.numTags();
3035     } else output.println(") {");
3036   }
3037
3038   public void generateFlatFlagActionNode(FlatMethod fm, FlatFlagActionNode ffan, PrintWriter output) {
3039     output.println("/* FlatFlagActionNode */");
3040
3041
3042     /* Process tag changes */
3043     Relation tagsettable=new Relation();
3044     Relation tagcleartable=new Relation();
3045
3046     Iterator tagsit=ffan.getTempTagPairs();
3047     while (tagsit.hasNext()) {
3048       TempTagPair ttp=(TempTagPair) tagsit.next();
3049       TempDescriptor objtmp=ttp.getTemp();
3050       TagDescriptor tag=ttp.getTag();
3051       TempDescriptor tagtmp=ttp.getTagTemp();
3052       boolean tagstatus=ffan.getTagChange(ttp);
3053       if (tagstatus) {
3054         tagsettable.put(objtmp, tagtmp);
3055       } else {
3056         tagcleartable.put(objtmp, tagtmp);
3057       }
3058     }
3059
3060
3061     Hashtable flagandtable=new Hashtable();
3062     Hashtable flagortable=new Hashtable();
3063
3064     /* Process flag changes */
3065     Iterator flagsit=ffan.getTempFlagPairs();
3066     while(flagsit.hasNext()) {
3067       TempFlagPair tfp=(TempFlagPair)flagsit.next();
3068       TempDescriptor temp=tfp.getTemp();
3069       Hashtable flagtable=(Hashtable)flagorder.get(temp.getType().getClassDesc());
3070       FlagDescriptor flag=tfp.getFlag();
3071       if (flag==null) {
3072         //Newly allocate objects that don't set any flags case
3073         if (flagortable.containsKey(temp)) {
3074           throw new Error();
3075         }
3076         int mask=0;
3077         flagortable.put(temp,new Integer(mask));
3078       } else {
3079         int flagid=1<<((Integer)flagtable.get(flag)).intValue();
3080         boolean flagstatus=ffan.getFlagChange(tfp);
3081         if (flagstatus) {
3082           int mask=0;
3083           if (flagortable.containsKey(temp)) {
3084             mask=((Integer)flagortable.get(temp)).intValue();
3085           }
3086           mask|=flagid;
3087           flagortable.put(temp,new Integer(mask));
3088         } else {
3089           int mask=0xFFFFFFFF;
3090           if (flagandtable.containsKey(temp)) {
3091             mask=((Integer)flagandtable.get(temp)).intValue();
3092           }
3093           mask&=(0xFFFFFFFF^flagid);
3094           flagandtable.put(temp,new Integer(mask));
3095         }
3096       }
3097     }
3098
3099
3100     HashSet flagtagset=new HashSet();
3101     flagtagset.addAll(flagortable.keySet());
3102     flagtagset.addAll(flagandtable.keySet());
3103     flagtagset.addAll(tagsettable.keySet());
3104     flagtagset.addAll(tagcleartable.keySet());
3105
3106     Iterator ftit=flagtagset.iterator();
3107     while(ftit.hasNext()) {
3108       TempDescriptor temp=(TempDescriptor)ftit.next();
3109
3110
3111       Set tagtmps=tagcleartable.get(temp);
3112       if (tagtmps!=null) {
3113         Iterator tagit=tagtmps.iterator();
3114         while(tagit.hasNext()) {
3115           TempDescriptor tagtmp=(TempDescriptor)tagit.next();
3116           if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC))
3117             output.println("tagclear("+localsprefixaddr+", (struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
3118           else
3119             output.println("tagclear((struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
3120         }
3121       }
3122
3123       tagtmps=tagsettable.get(temp);
3124       if (tagtmps!=null) {
3125         Iterator tagit=tagtmps.iterator();
3126         while(tagit.hasNext()) {
3127           TempDescriptor tagtmp=(TempDescriptor)tagit.next();
3128           if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC))
3129             output.println("tagset("+localsprefixaddr+", (struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
3130           else
3131             output.println("tagset((struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
3132         }
3133       }
3134
3135       int ormask=0;
3136       int andmask=0xFFFFFFF;
3137
3138       if (flagortable.containsKey(temp))
3139         ormask=((Integer)flagortable.get(temp)).intValue();
3140       if (flagandtable.containsKey(temp))
3141         andmask=((Integer)flagandtable.get(temp)).intValue();
3142       generateFlagOrAnd(ffan, fm, temp, output, ormask, andmask);
3143       generateObjectDistribute(ffan, fm, temp, output);
3144     }
3145   }
3146
3147   protected void generateFlagOrAnd(FlatFlagActionNode ffan, FlatMethod fm, TempDescriptor temp,
3148                                    PrintWriter output, int ormask, int andmask) {
3149     if (ffan.getTaskType()==FlatFlagActionNode.NEWOBJECT) {
3150       output.println("flagorandinit("+generateTemp(fm, temp)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
3151     } else {
3152       output.println("flagorand("+generateTemp(fm, temp)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
3153     }
3154   }
3155
3156   protected void generateObjectDistribute(FlatFlagActionNode ffan, FlatMethod fm, TempDescriptor temp, PrintWriter output) {
3157     output.println("enqueueObject("+generateTemp(fm, temp)+");");
3158   }
3159
3160   void generateOptionalHeader(PrintWriter headers) {
3161
3162     //GENERATE HEADERS
3163     headers.println("#include \"task.h\"\n\n");
3164     headers.println("#ifndef _OPTIONAL_STRUCT_");
3165     headers.println("#define _OPTIONAL_STRUCT_");
3166
3167     //STRUCT PREDICATEMEMBER
3168     headers.println("struct predicatemember{");
3169     headers.println("int type;");
3170     headers.println("int numdnfterms;");
3171     headers.println("int * flags;");
3172     headers.println("int numtags;");
3173     headers.println("int * tags;\n};\n\n");
3174
3175     //STRUCT OPTIONALTASKDESCRIPTOR
3176     headers.println("struct optionaltaskdescriptor{");
3177     headers.println("struct taskdescriptor * task;");
3178     headers.println("int index;");
3179     headers.println("int numenterflags;");
3180     headers.println("int * enterflags;");
3181     headers.println("int numpredicatemembers;");
3182     headers.println("struct predicatemember ** predicatememberarray;");
3183     headers.println("};\n\n");
3184
3185     //STRUCT TASKFAILURE
3186     headers.println("struct taskfailure {");
3187     headers.println("struct taskdescriptor * task;");
3188     headers.println("int index;");
3189     headers.println("int numoptionaltaskdescriptors;");
3190     headers.println("struct optionaltaskdescriptor ** optionaltaskdescriptorarray;\n};\n\n");
3191
3192     //STRUCT FSANALYSISWRAPPER
3193     headers.println("struct fsanalysiswrapper{");
3194     headers.println("int  flags;");
3195     headers.println("int numtags;");
3196     headers.println("int * tags;");
3197     headers.println("int numtaskfailures;");
3198     headers.println("struct taskfailure ** taskfailurearray;");
3199     headers.println("int numoptionaltaskdescriptors;");
3200     headers.println("struct optionaltaskdescriptor ** optionaltaskdescriptorarray;\n};\n\n");
3201
3202     //STRUCT CLASSANALYSISWRAPPER
3203     headers.println("struct classanalysiswrapper{");
3204     headers.println("int type;");
3205     headers.println("int numotd;");
3206     headers.println("struct optionaltaskdescriptor ** otdarray;");
3207     headers.println("int numfsanalysiswrappers;");
3208     headers.println("struct fsanalysiswrapper ** fsanalysiswrapperarray;\n};");
3209
3210     headers.println("extern struct classanalysiswrapper * classanalysiswrapperarray[];");
3211
3212     Iterator taskit=state.getTaskSymbolTable().getDescriptorsIterator();
3213     while(taskit.hasNext()) {
3214       TaskDescriptor td=(TaskDescriptor)taskit.next();
3215       headers.println("extern struct taskdescriptor task_"+td.getSafeSymbol()+";");
3216     }
3217
3218   }
3219
3220   //CHECK OVER THIS -- THERE COULD BE SOME ERRORS HERE
3221   int generateOptionalPredicate(Predicate predicate, OptionalTaskDescriptor otd, ClassDescriptor cdtemp, PrintWriter output) {
3222     int predicateindex = 0;
3223     //iterate through the classes concerned by the predicate
3224     Set c_vard = predicate.vardescriptors;
3225     Hashtable<TempDescriptor, Integer> slotnumber=new Hashtable<TempDescriptor, Integer>();
3226     int current_slot=0;
3227
3228     for(Iterator vard_it = c_vard.iterator(); vard_it.hasNext(); ) {
3229       VarDescriptor vard = (VarDescriptor)vard_it.next();
3230       TypeDescriptor typed = vard.getType();
3231
3232       //generate for flags
3233       HashSet fen_hashset = predicate.flags.get(vard.getSymbol());
3234       output.println("int predicateflags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
3235       int numberterms=0;
3236       if (fen_hashset!=null) {
3237         for (Iterator fen_it = fen_hashset.iterator(); fen_it.hasNext(); ) {
3238           FlagExpressionNode fen = (FlagExpressionNode)fen_it.next();
3239           if (fen!=null) {
3240             DNFFlag dflag=fen.getDNF();
3241             numberterms+=dflag.size();
3242
3243             Hashtable flags=(Hashtable)flagorder.get(typed.getClassDesc());
3244
3245             for(int j=0; j<dflag.size(); j++) {
3246               if (j!=0)
3247                 output.println(",");
3248               Vector term=dflag.get(j);
3249               int andmask=0;
3250               int checkmask=0;
3251               for(int k=0; k<term.size(); k++) {
3252                 DNFFlagAtom dfa=(DNFFlagAtom)term.get(k);
3253                 FlagDescriptor fd=dfa.getFlag();
3254                 boolean negated=dfa.getNegated();
3255                 int flagid=1<<((Integer)flags.get(fd)).intValue();
3256                 andmask|=flagid;
3257                 if (!negated)
3258                   checkmask|=flagid;
3259               }
3260               output.print("/*andmask*/0x"+Integer.toHexString(andmask)+", /*checkmask*/0x"+Integer.toHexString(checkmask));
3261             }
3262           }
3263         }
3264       }
3265       output.println("};\n");
3266
3267       //generate for tags
3268       TagExpressionList tagel = predicate.tags.get(vard.getSymbol());
3269       output.println("int predicatetags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
3270       int numtags = 0;
3271       if (tagel!=null) {
3272         for(int j=0; j<tagel.numTags(); j++) {
3273           if (j!=0)
3274             output.println(",");
3275           TempDescriptor tmp=tagel.getTemp(j);
3276           if (!slotnumber.containsKey(tmp)) {
3277             Integer slotint=new Integer(current_slot++);
3278             slotnumber.put(tmp,slotint);
3279           }
3280           int slot=slotnumber.get(tmp).intValue();
3281           output.println("/* slot */"+ slot+", /*tagid*/"+state.getTagId(tmp.getTag()));
3282         }
3283         numtags = tagel.numTags();
3284       }
3285       output.println("};");
3286
3287       //store the result into a predicatemember struct
3288       output.println("struct predicatemember predicatemember_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"={");
3289       output.println("/*type*/"+typed.getClassDesc().getId()+",");
3290       output.println("/* number of dnf terms */"+numberterms+",");
3291       output.println("predicateflags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
3292       output.println("/* number of tag */"+numtags+",");
3293       output.println("predicatetags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
3294       output.println("};\n");
3295       predicateindex++;
3296     }
3297
3298
3299     //generate an array that stores the entire predicate
3300     output.println("struct predicatemember * predicatememberarray_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
3301     for( int j = 0; j<predicateindex; j++) {
3302       if( j != predicateindex-1) output.println("&predicatemember_"+j+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
3303       else output.println("&predicatemember_"+j+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
3304     }
3305     output.println("};\n");
3306     return predicateindex;
3307   }
3308
3309
3310   void generateOptionalArrays(PrintWriter output, PrintWriter headers, Hashtable<ClassDescriptor, Hashtable<FlagState, Set<OptionalTaskDescriptor>>> safeexecution, Hashtable optionaltaskdescriptors) {
3311     generateOptionalHeader(headers);
3312     //GENERATE STRUCTS
3313     output.println("#include \"optionalstruct.h\"\n\n");
3314     output.println("#include \"stdlib.h\"\n");
3315
3316     HashSet processedcd = new HashSet();
3317     int maxotd=0;
3318     Enumeration e = safeexecution.keys();
3319     while (e.hasMoreElements()) {
3320       int numotd=0;
3321       //get the class
3322       ClassDescriptor cdtemp=(ClassDescriptor)e.nextElement();
3323       Hashtable flaginfo=(Hashtable)flagorder.get(cdtemp);       //will be used several times
3324
3325       //Generate the struct of optionals
3326       Collection c_otd = ((Hashtable)optionaltaskdescriptors.get(cdtemp)).values();
3327       numotd = c_otd.size();
3328       if(maxotd<numotd) maxotd = numotd;
3329       if( !c_otd.isEmpty() ) {
3330         for(Iterator otd_it = c_otd.iterator(); otd_it.hasNext(); ) {
3331           OptionalTaskDescriptor otd = (OptionalTaskDescriptor)otd_it.next();
3332
3333           //generate the int arrays for the predicate
3334           Predicate predicate = otd.predicate;
3335           int predicateindex = generateOptionalPredicate(predicate, otd, cdtemp, output);
3336           TreeSet<Integer> fsset=new TreeSet<Integer>();
3337           //iterate through possible FSes corresponding to
3338           //the state when entering
3339
3340           for(Iterator fses = otd.enterflagstates.iterator(); fses.hasNext(); ) {
3341             FlagState fs = (FlagState)fses.next();
3342             int flagid=0;
3343             for(Iterator flags = fs.getFlags(); flags.hasNext(); ) {
3344               FlagDescriptor flagd = (FlagDescriptor)flags.next();
3345               int id=1<<((Integer)flaginfo.get(flagd)).intValue();
3346               flagid|=id;
3347             }
3348             fsset.add(new Integer(flagid));
3349             //tag information not needed because tag
3350             //changes are not tolerated.
3351           }
3352
3353           output.println("int enterflag_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
3354           boolean needcomma=false;
3355           for(Iterator<Integer> it=fsset.iterator(); it.hasNext(); ) {
3356             if(needcomma)
3357               output.print(", ");
3358             output.println(it.next());
3359           }
3360
3361           output.println("};\n");
3362
3363
3364           //generate optionaltaskdescriptor that actually
3365           //includes exit fses, predicate and the task
3366           //concerned
3367           output.println("struct optionaltaskdescriptor optionaltaskdescriptor_"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"={");
3368           output.println("&task_"+otd.td.getSafeSymbol()+",");
3369           output.println("/*index*/"+otd.getIndex()+",");
3370           output.println("/*number of enter flags*/"+fsset.size()+",");
3371           output.println("enterflag_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
3372           output.println("/*number of members */"+predicateindex+",");
3373           output.println("predicatememberarray_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
3374           output.println("};\n");
3375         }
3376       } else
3377         continue;
3378       // if there are no optionals, there is no need to build the rest of the struct
3379
3380       output.println("struct optionaltaskdescriptor * otdarray"+cdtemp.getSafeSymbol()+"[]={");
3381       c_otd = ((Hashtable)optionaltaskdescriptors.get(cdtemp)).values();
3382       if( !c_otd.isEmpty() ) {
3383         boolean needcomma=false;
3384         for(Iterator otd_it = c_otd.iterator(); otd_it.hasNext(); ) {
3385           OptionalTaskDescriptor otd = (OptionalTaskDescriptor)otd_it.next();
3386           if(needcomma)
3387             output.println(",");
3388           needcomma=true;
3389           output.println("&optionaltaskdescriptor_"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
3390         }
3391       }
3392       output.println("};\n");
3393
3394       //get all the possible flagstates reachable by an object
3395       Hashtable hashtbtemp = safeexecution.get(cdtemp);
3396       int fscounter = 0;
3397       TreeSet fsts=new TreeSet(new FlagComparator(flaginfo));
3398       fsts.addAll(hashtbtemp.keySet());
3399       for(Iterator fsit=fsts.iterator(); fsit.hasNext(); ) {
3400         FlagState fs = (FlagState)fsit.next();
3401         fscounter++;
3402
3403         //get the set of OptionalTaskDescriptors corresponding
3404         HashSet<OptionalTaskDescriptor> availabletasks = (HashSet<OptionalTaskDescriptor>)hashtbtemp.get(fs);
3405         //iterate through the OptionalTaskDescriptors and
3406         //store the pointers to the optionals struct (see on
3407         //top) into an array
3408
3409         output.println("struct optionaltaskdescriptor * optionaltaskdescriptorarray_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"[] = {");
3410         for(Iterator<OptionalTaskDescriptor> mos = ordertd(availabletasks).iterator(); mos.hasNext(); ) {
3411           OptionalTaskDescriptor mm = mos.next();
3412           if(!mos.hasNext())
3413             output.println("&optionaltaskdescriptor_"+mm.getuid()+"_"+cdtemp.getSafeSymbol());
3414           else
3415             output.println("&optionaltaskdescriptor_"+mm.getuid()+"_"+cdtemp.getSafeSymbol()+",");
3416         }
3417
3418         output.println("};\n");
3419
3420         //process flag information (what the flag after failure is) so we know what optionaltaskdescriptors to choose.
3421
3422         int flagid=0;
3423         for(Iterator flags = fs.getFlags(); flags.hasNext(); ) {
3424           FlagDescriptor flagd = (FlagDescriptor)flags.next();
3425           int id=1<<((Integer)flaginfo.get(flagd)).intValue();
3426           flagid|=id;
3427         }
3428
3429         //process tag information
3430
3431         int tagcounter = 0;
3432         boolean first = true;
3433         Enumeration tag_enum = fs.getTags();
3434         output.println("int tags_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"[]={");
3435         while(tag_enum.hasMoreElements()) {
3436           tagcounter++;
3437           TagDescriptor tagd = (TagDescriptor)tag_enum.nextElement();
3438           if(first==true)
3439             first = false;
3440           else
3441             output.println(", ");
3442           output.println("/*tagid*/"+state.getTagId(tagd));
3443         }
3444         output.println("};");
3445
3446         Set<TaskIndex> tiset=sa.getTaskIndex(fs);
3447         for(Iterator<TaskIndex> itti=tiset.iterator(); itti.hasNext(); ) {
3448           TaskIndex ti=itti.next();
3449           if (ti.isRuntime())
3450             continue;
3451
3452           Set<OptionalTaskDescriptor> otdset=sa.getOptions(fs, ti);
3453
3454           output.print("struct optionaltaskdescriptor * optionaltaskfailure_FS"+fscounter+"_"+ti.getTask().getSafeSymbol()+"_"+ti.getIndex()+"_array[] = {");
3455           boolean needcomma=false;
3456           for(Iterator<OptionalTaskDescriptor> otdit=ordertd(otdset).iterator(); otdit.hasNext(); ) {
3457             OptionalTaskDescriptor otd=otdit.next();
3458             if(needcomma)
3459               output.print(", ");
3460             needcomma=true;
3461             output.println("&optionaltaskdescriptor_"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
3462           }
3463           output.println("};");
3464
3465           output.print("struct taskfailure taskfailure_FS"+fscounter+"_"+ti.getTask().getSafeSymbol()+"_"+ti.getIndex()+" = {");
3466           output.print("&task_"+ti.getTask().getSafeSymbol()+", ");
3467           output.print(ti.getIndex()+", ");
3468           output.print(otdset.size()+", ");
3469           output.print("optionaltaskfailure_FS"+fscounter+"_"+ti.getTask().getSafeSymbol()+"_"+ti.getIndex()+"_array");
3470           output.println("};");
3471         }
3472
3473         tiset=sa.getTaskIndex(fs);
3474         boolean needcomma=false;
3475         int runtimeti=0;
3476         output.println("struct taskfailure * taskfailurearray"+fscounter+"_"+cdtemp.getSafeSymbol()+"[]={");
3477         for(Iterator<TaskIndex> itti=tiset.iterator(); itti.hasNext(); ) {
3478           TaskIndex ti=itti.next();
3479           if (ti.isRuntime()) {
3480             runtimeti++;
3481             continue;
3482           }
3483           if (needcomma)
3484             output.print(", ");
3485           needcomma=true;
3486           output.print("&taskfailure_FS"+fscounter+"_"+ti.getTask().getSafeSymbol()+"_"+ti.getIndex());
3487         }
3488         output.println("};\n");
3489
3490         //Store the result in fsanalysiswrapper
3491
3492         output.println("struct fsanalysiswrapper fsanalysiswrapper_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"={");
3493         output.println("/*flag*/"+flagid+",");
3494         output.println("/* number of tags*/"+tagcounter+",");
3495         output.println("tags_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+",");
3496         output.println("/* numtask failures */"+(tiset.size()-runtimeti)+",");
3497         output.println("taskfailurearray"+fscounter+"_"+cdtemp.getSafeSymbol()+",");
3498         output.println("/* number of optionaltaskdescriptors */"+availabletasks.size()+",");
3499         output.println("optionaltaskdescriptorarray_FS"+fscounter+"_"+cdtemp.getSafeSymbol());
3500         output.println("};\n");
3501
3502       }
3503
3504       //Build the array of fsanalysiswrappers
3505       output.println("struct fsanalysiswrapper * fsanalysiswrapperarray_"+cdtemp.getSafeSymbol()+"[] = {");
3506       boolean needcomma=false;
3507       for(int i = 0; i<fscounter; i++) {
3508         if (needcomma) output.print(",");
3509         output.println("&fsanalysiswrapper_FS"+(i+1)+"_"+cdtemp.getSafeSymbol());
3510         needcomma=true;
3511       }
3512       output.println("};");
3513
3514       //Build the classanalysiswrapper referring to the previous array
3515       output.println("struct classanalysiswrapper classanalysiswrapper_"+cdtemp.getSafeSymbol()+"={");
3516       output.println("/*type*/"+cdtemp.getId()+",");
3517       output.println("/*numotd*/"+numotd+",");
3518       output.println("otdarray"+cdtemp.getSafeSymbol()+",");
3519       output.println("/* number of fsanalysiswrappers */"+fscounter+",");
3520       output.println("fsanalysiswrapperarray_"+cdtemp.getSafeSymbol()+"};\n");
3521       processedcd.add(cdtemp);
3522     }
3523
3524     //build an array containing every classes for which code has been build
3525     output.println("struct classanalysiswrapper * classanalysiswrapperarray[]={");
3526     for(int i=0; i<state.numClasses(); i++) {
3527       ClassDescriptor cn=cdarray[i];
3528       if (i>0)
3529         output.print(", ");
3530       if ((cn != null) && (processedcd.contains(cn)))
3531         output.print("&classanalysiswrapper_"+cn.getSafeSymbol());
3532       else
3533         output.print("NULL");
3534     }
3535     output.println("};");
3536
3537     output.println("#define MAXOTD "+maxotd);
3538     headers.println("#endif");
3539   }
3540
3541   public List<OptionalTaskDescriptor> ordertd(Set<OptionalTaskDescriptor> otdset) {
3542     Relation r=new Relation();
3543     for(Iterator<OptionalTaskDescriptor>otdit=otdset.iterator(); otdit.hasNext(); ) {
3544       OptionalTaskDescriptor otd=otdit.next();
3545       TaskIndex ti=new TaskIndex(otd.td, otd.getIndex());
3546       r.put(ti, otd);
3547     }
3548
3549     LinkedList<OptionalTaskDescriptor> l=new LinkedList<OptionalTaskDescriptor>();
3550     for(Iterator it=r.keySet().iterator(); it.hasNext(); ) {
3551       Set s=r.get(it.next());
3552       for(Iterator it2=s.iterator(); it2.hasNext(); ) {
3553         OptionalTaskDescriptor otd=(OptionalTaskDescriptor)it2.next();
3554         l.add(otd);
3555       }
3556     }
3557
3558     return l;
3559   }
3560
3561   // override these methods in a subclass of BuildCode
3562   // to generate code for additional systems
3563   protected void printExtraArrayFields(PrintWriter outclassdefs) {
3564   }
3565   protected void outputTransCode(PrintWriter output) {
3566   }
3567   protected void buildCodeSetup() {
3568   }
3569   protected void generateSizeArrayExtensions(PrintWriter outclassdefs) {
3570   }
3571   protected void additionalIncludesMethodsHeader(PrintWriter outmethodheader) {
3572   }
3573   protected void preCodeGenInitialization() {
3574   }
3575   protected void postCodeGenCleanUp() {
3576   }
3577   protected void additionalCodeGen(PrintWriter outmethodheader,
3578                                    PrintWriter outstructs,
3579                                    PrintWriter outmethod) {
3580   }
3581   protected void additionalCodeAtTopOfMain(PrintWriter outmethod) {
3582   }
3583   protected void additionalCodeAtBottomOfMain(PrintWriter outmethod) {
3584   }
3585   protected void additionalIncludesMethodsImplementation(PrintWriter outmethod) {
3586   }
3587   protected void additionalIncludesStructsHeader(PrintWriter outstructs) {
3588   }
3589   protected void additionalClassObjectFields(PrintWriter outclassdefs) {
3590   }
3591   protected void additionalCodeAtTopMethodsImplementation(PrintWriter outmethod) {
3592   }
3593   protected void additionalCodeAtTopFlatMethodBody(PrintWriter output, FlatMethod fm) {
3594   }
3595   protected void additionalCodePreNode(FlatMethod fm, FlatNode fn, PrintWriter output) {
3596   }
3597   protected void additionalCodePostNode(FlatMethod fm, FlatNode fn, PrintWriter output) {
3598   }
3599
3600   private void printSourceLineNumber(FlatMethod fm, FlatNode fn, PrintWriter output) {
3601     // we do not print out line number if no one explicitly set the number
3602     if(fn.getNumLine()!=-1) {
3603
3604       int lineNum=fn.getNumLine();
3605
3606       // do not generate the line number if it is same as the previous one
3607       boolean needtoprint;
3608       if(fn.prev.size()==0) {
3609         needtoprint=true;
3610       } else {
3611         needtoprint=false;
3612       }
3613
3614       for(int i=0; i<fn.prev.size(); i++) {
3615         int prevLineNum=((FlatNode)fn.prev.get(i)).getNumLine();
3616         if(prevLineNum!=lineNum) {
3617           needtoprint=true;
3618           break;
3619         }
3620       }
3621       if(needtoprint) {
3622         output.println("// "+fm.getMethod().getClassDesc().getSourceFileName()+":"+fn.getNumLine());
3623       }
3624     }
3625   }
3626
3627 }
3628
3629
3630
3631
3632
3633