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       if(state.TASK) {
1190         // the lock field is also a pointer
1191         count++;
1192       }
1193       output.print(count);
1194       for(Iterator allit=cn.getFieldTable().getAllDescriptorsIterator(); allit.hasNext(); ) {
1195         FieldDescriptor fd=(FieldDescriptor)allit.next();
1196         if(fd.isStatic()) {
1197           continue;
1198         }
1199         TypeDescriptor type=fd.getType();
1200         if (type.isPtr()) {
1201           output.print(", ");
1202           output.print("((unsigned INTPTR)&(((struct "+cn.getSafeSymbol() +" *)0)->"+
1203                        fd.getSafeSymbol()+"))");
1204         }
1205       }
1206       if(state.TASK) {
1207         // output the lock field
1208         output.print(", ");
1209         output.print("((unsigned INTPTR)&(((struct "+cn.getSafeSymbol() +" *)0)->lock))");
1210       }
1211       output.println("};");
1212     }
1213
1214     output.println("unsigned INTPTR * pointerarray[]={");
1215     boolean needcomma=false;
1216     for(int i=0; i<state.numClasses(); i++) {
1217       ClassDescriptor cn=cdarray[i];
1218       if (needcomma)
1219         output.println(",");
1220       needcomma=true;
1221       if(cn != null) {
1222         output.print(cn.getSafeSymbol()+"_pointers");
1223       } else {
1224         output.print("NULL");
1225       }
1226     }
1227
1228     for(int i=0; i<state.numArrays(); i++) {
1229       if (needcomma)
1230         output.println(", ");
1231       TypeDescriptor tdelement=arraytable[i].dereference();
1232       if (tdelement.isArray()||tdelement.isClass())
1233         output.print("((unsigned INTPTR *)1)");
1234       else
1235         output.print("0");
1236       needcomma=true;
1237     }
1238
1239     output.println("};");
1240     needcomma=false;
1241     output.println("int hasflags[]={");
1242     for(int i=0; i<state.numClasses(); i++) {
1243       ClassDescriptor cn=cdarray[i];
1244       if (needcomma)
1245         output.println(", ");
1246       needcomma=true;
1247       if ((cn != null) && (cn.hasFlags()))
1248         output.print("1");
1249       else
1250         output.print("0");
1251     }
1252     output.println("};");
1253   }
1254
1255   private int checkarraysupertype(ClassDescriptor arraycd, TypeDescriptor arraytd) {
1256     int type=-1;
1257
1258     TypeDescriptor supertd=new TypeDescriptor(arraycd);
1259     supertd.setArrayCount(arraytd.getArrayCount());
1260     type=state.getArrayNumber(supertd);
1261     if (type!=-1) {
1262       return type;
1263     }
1264
1265     ClassDescriptor cd = arraycd.getSuperDesc();
1266     if(cd != null) {
1267       type = checkarraysupertype(cd, arraytd);
1268       if(type != -1) {
1269         return type;
1270       }
1271     }
1272
1273     Iterator it_sifs = arraycd.getSuperInterfaces();
1274     while(it_sifs.hasNext()) {
1275       ClassDescriptor ifcd = (ClassDescriptor)it_sifs.next();
1276       type = checkarraysupertype(ifcd, arraytd);
1277       if(type != -1) {
1278         return type;
1279       }
1280     }
1281
1282     return type;
1283   }
1284
1285
1286   /** Print out table to give us supertypes */
1287   protected void generateSuperTypeTable(PrintWriter output) {
1288     ClassDescriptor objectclass=typeutil.getClass(TypeUtil.ObjectClass);
1289     for(int i=0; i<state.numClasses(); i++) {
1290       ClassDescriptor cn=cdarray[i];
1291       if(cn == null) {
1292         continue;
1293       }
1294       output.print("int supertypes" + cn.getSafeSymbol() + "[] = {");
1295       boolean ncomma = false;
1296       int snum = 0;
1297       if((cn != null) && (cn.getSuperDesc() != null)) {
1298         snum++;
1299       }
1300       Iterator it_sifs = cn != null?cn.getSuperInterfaces():null;
1301       while(it_sifs != null && it_sifs.hasNext()) {
1302         snum++;
1303         it_sifs.next();
1304       }
1305       output.print(snum);
1306       ncomma = true;
1307       if ((cn != null) && (cn.getSuperDesc()!=null)) {
1308         if(ncomma) {
1309           output.print(",");
1310         }
1311         ClassDescriptor cdsuper=cn.getSuperDesc();
1312         output.print(cdsuper.getId());
1313       }
1314       it_sifs = cn != null?cn.getSuperInterfaces():null;
1315       while(it_sifs != null && it_sifs.hasNext()) {
1316         if(ncomma) {
1317           output.print(",");
1318         }
1319         output.print(((ClassDescriptor)it_sifs.next()).getId()+state.numClasses()+state.numArrays());
1320       }
1321
1322       output.println("};");
1323     }
1324
1325     for(int i=0; i<state.numArrays(); i++) {
1326       TypeDescriptor arraytd=arraytable[i];
1327       ClassDescriptor arraycd=arraytd.getClassDesc();
1328       output.print("int supertypes___arraytype___" + (i+state.numClasses()) + "[] = {");
1329       boolean ncomma = false;
1330       int snum = 0;
1331       if (arraycd==null) {
1332         snum++;
1333         output.print(snum);
1334         output.print(", ");
1335         output.print(objectclass.getId());
1336         output.println("};");
1337         continue;
1338       }
1339       if((arraycd != null) && (arraycd.getSuperDesc() != null)) {
1340         snum++;
1341       }
1342       Iterator it_sifs = arraycd != null?arraycd.getSuperInterfaces():null;
1343       while(it_sifs != null && it_sifs.hasNext()) {
1344         snum++;
1345         it_sifs.next();
1346       }
1347       output.print(snum);
1348       ncomma = true;
1349       if ((arraycd != null) && (arraycd.getSuperDesc()!=null)) {
1350         ClassDescriptor cd=arraycd.getSuperDesc();
1351         int type=-1;
1352         if(cd!=null) {
1353           type = checkarraysupertype(cd, arraytd);
1354           if(type != -1) {
1355             type += state.numClasses();
1356           }
1357         }
1358         if (ncomma)
1359           output.print(", ");
1360         output.print(type);
1361       }
1362       it_sifs = arraycd != null?arraycd.getSuperInterfaces():null;
1363       while(it_sifs != null && it_sifs.hasNext()) {
1364         ClassDescriptor ifcd = (ClassDescriptor)it_sifs.next();
1365         int type = checkarraysupertype(ifcd, arraytd);
1366         if(type != -1) {
1367           type += state.numClasses();
1368         }
1369         if (ncomma)
1370           output.print(", ");
1371         output.print(type);
1372       }
1373       output.println("};");
1374     }
1375
1376     for(int i=0; i<state.numInterfaces(); i++) {
1377       ClassDescriptor cn=ifarray[i];
1378       if(cn == null) {
1379         continue;
1380       }
1381       output.print("int supertypes" + cn.getSafeSymbol() + "[] = {");
1382       boolean ncomma = false;
1383       int snum = 0;
1384       if((cn != null) && (cn.getSuperDesc() != null)) {
1385         snum++;
1386       }
1387       Iterator it_sifs = cn != null?cn.getSuperInterfaces():null;
1388       while(it_sifs != null && it_sifs.hasNext()) {
1389         snum++;
1390         it_sifs.next();
1391       }
1392       output.print(snum);
1393       ncomma = true;
1394       if ((cn != null) && (cn.getSuperDesc()!=null)) {
1395         if(ncomma) {
1396           output.print(",");
1397         }
1398         ClassDescriptor cdsuper=cn.getSuperDesc();
1399         output.print(cdsuper.getId());
1400       }
1401       it_sifs = cn != null?cn.getSuperInterfaces():null;
1402       while(it_sifs != null && it_sifs.hasNext()) {
1403         if(ncomma) {
1404           output.print(",");
1405         }
1406         output.print(((ClassDescriptor)it_sifs.next()).getId()+state.numClasses()+state.numArrays());
1407       }
1408
1409       output.println("};");
1410     }
1411
1412     output.println("int* supertypes[]={");
1413     boolean needcomma=false;
1414     for(int i=0; i<state.numClasses(); i++) {
1415       ClassDescriptor cn=cdarray[i];
1416       if (needcomma)
1417         output.println(",");
1418       needcomma=true;
1419       if(cn != null) {
1420         output.print("supertypes" + cn.getSafeSymbol());
1421       } else {
1422         output.print(0);
1423       }
1424     }
1425
1426     for(int i=0; i<state.numArrays(); i++) {
1427       if (needcomma)
1428         output.println(",");
1429       needcomma = true;
1430       output.print("supertypes___arraytype___" + (i+state.numClasses()));
1431     }
1432
1433     for(int i=0; i<state.numInterfaces(); i++) {
1434       ClassDescriptor cn=ifarray[i];
1435       if (needcomma)
1436         output.println(",");
1437       needcomma=true;
1438       output.print("supertypes" + cn.getSafeSymbol());
1439     }
1440     output.println("};");
1441   }
1442
1443   /** Force consistent field ordering between inherited classes. */
1444
1445   protected void printClassStruct(ClassDescriptor cn, PrintWriter classdefout, PrintWriter globaldefout, PrintWriter globaldefprimout) {
1446
1447     ClassDescriptor sp=cn.getSuperDesc();
1448     if (sp!=null)
1449       printClassStruct(sp, classdefout, /*globaldefout*/ null, null);
1450
1451     SymbolTable sitbl = cn.getSuperInterfaceTable();
1452     Iterator it_sifs = sitbl.getDescriptorsIterator();
1453     while(it_sifs.hasNext()) {
1454       ClassDescriptor si = (ClassDescriptor)it_sifs.next();
1455       printClassStruct(si, classdefout, /*globaldefout*/ null, null);
1456     }
1457
1458     if (!fieldorder.containsKey(cn)) {
1459       Vector fields=new Vector();
1460       fieldorder.put(cn,fields);
1461
1462       Vector fieldvec=cn.getFieldVec();
1463 fldloop:
1464       for(int i=0; i<fieldvec.size(); i++) {
1465         FieldDescriptor fd=(FieldDescriptor)fieldvec.get(i);
1466         if((sp != null) && sp.getFieldTable().contains(fd.getSymbol())) {
1467           // a shadow field
1468         } else {
1469           it_sifs = sitbl.getDescriptorsIterator();
1470           while(it_sifs.hasNext()) {
1471             ClassDescriptor si = (ClassDescriptor)it_sifs.next();
1472             if(si.getFieldTable().contains(fd.getSymbol())) {
1473               continue fldloop;
1474             }
1475           }
1476           fields.add(fd);
1477         }
1478       }
1479     }
1480     //Vector fields=(Vector)fieldorder.get(cn);
1481
1482     Vector fields = cn.getFieldVec();
1483
1484     for(int i=0; i<fields.size(); i++) {
1485       FieldDescriptor fd=(FieldDescriptor)fields.get(i);
1486       String fstring = fd.getSafeSymbol();
1487       if(printedfieldstbl.containsKey(fstring)) {
1488         printedfieldstbl.put(fstring, cn);
1489         continue;
1490       } else {
1491         printedfieldstbl.put(fstring, cn);
1492       }
1493       if (fd.getType().isClass()
1494           && fd.getType().getClassDesc().isEnum()) {
1495         classdefout.println("  int " + fd.getSafeSymbol() + ";");
1496       } else if (fd.getType().isClass()||fd.getType().isArray()) {
1497         if (fd.isStatic()) {
1498           // TODO add version for normal Java later
1499           // static field
1500           if(globaldefout != null) {
1501             if(fd.isVolatile()) {
1502               globaldefout.println("  volatile struct "+fd.getType().getSafeSymbol()+ " * "+fd.getSafeSymbol()+";");
1503             } else {
1504               globaldefout.println("  struct "+fd.getType().getSafeSymbol()+ " * "+fd.getSafeSymbol()+";");
1505             }
1506             globaldefscount++;
1507           }
1508         } else if (fd.isVolatile()) {
1509           //volatile field
1510           classdefout.println("  volatile struct "+fd.getType().getSafeSymbol()+ " * "+fd.getSafeSymbol()+";");
1511         } else {
1512           classdefout.println("  struct "+fd.getType().getSafeSymbol()+" * "+fd.getSafeSymbol()+";");
1513         }
1514       } else if (fd.isStatic()) {
1515         // TODO add version for normal Java later
1516         // static field
1517         if(globaldefout != null) {
1518           if(fd.isVolatile()) {
1519             globaldefprimout.println("  volatile "+fd.getType().getSafeSymbol()+ " "+fd.getSafeSymbol()+";");
1520           } else {
1521             globaldefprimout.println("  "+fd.getType().getSafeSymbol()+ " "+fd.getSafeSymbol()+";");
1522           }
1523         }
1524       } else if (fd.isVolatile()) {
1525         //volatile field
1526         classdefout.println("  volatile "+fd.getType().getSafeSymbol()+ " "+fd.getSafeSymbol()+";");
1527       } else
1528         classdefout.println("  "+fd.getType().getSafeSymbol()+" "+fd.getSafeSymbol()+";");
1529     }
1530   }
1531
1532
1533   /* Map flags to integers consistently between inherited
1534    * classes. */
1535
1536   protected void mapFlags(ClassDescriptor cn) {
1537     ClassDescriptor sp=cn.getSuperDesc();
1538     if (sp!=null)
1539       mapFlags(sp);
1540     int max=0;
1541     if (!flagorder.containsKey(cn)) {
1542       Hashtable flags=new Hashtable();
1543       flagorder.put(cn,flags);
1544       if (sp!=null) {
1545         Hashtable superflags=(Hashtable)flagorder.get(sp);
1546         Iterator superflagit=superflags.keySet().iterator();
1547         while(superflagit.hasNext()) {
1548           FlagDescriptor fd=(FlagDescriptor)superflagit.next();
1549           Integer number=(Integer)superflags.get(fd);
1550           flags.put(fd, number);
1551           if ((number.intValue()+1)>max)
1552             max=number.intValue()+1;
1553         }
1554       }
1555
1556       Iterator flagit=cn.getFlags();
1557       while(flagit.hasNext()) {
1558         FlagDescriptor fd=(FlagDescriptor)flagit.next();
1559         if (sp==null||!sp.getFlagTable().contains(fd.getSymbol()))
1560           flags.put(fd, new Integer(max++));
1561       }
1562     }
1563   }
1564
1565
1566   /** This function outputs (1) structures that parameters are
1567    * passed in (when PRECISE GC is enabled) and (2) function
1568    * prototypes for the methods */
1569
1570   protected void generateCallStructs(ClassDescriptor cn, PrintWriter classdefout, PrintWriter output, PrintWriter headersout, PrintWriter globaldefout, PrintWriter globaldefprimout) {
1571     /* Output class structure */
1572     classdefout.println("struct "+cn.getSafeSymbol()+" {");
1573     classdefout.println("  int type;");
1574     classdefout.println("  int hashcode;");
1575
1576     additionalClassObjectFields(classdefout);
1577
1578
1579     if (state.EVENTMONITOR) {
1580       classdefout.println("  int objuid;");
1581     }
1582     if (state.THREAD) {
1583       classdefout.println("  volatile int tid;");
1584       classdefout.println("  volatile int notifycount;");
1585     }
1586     if (state.MGC) {
1587       classdefout.println("  int mutex;");
1588       classdefout.println("  volatile int notifycount;");
1589       classdefout.println("  volatile int objlock;");
1590       if(state.MULTICOREGC) {
1591         classdefout.println("  int marked;");
1592       }
1593     }
1594     if (state.TASK) {
1595       classdefout.println("  int flag;");
1596       classdefout.println("  int ___cachedCode___;");
1597       if((!state.MULTICORE) || (cn.getSymbol().equals("TagDescriptor"))) {
1598         classdefout.println("  void * flagptr;");
1599       }
1600       if (state.MULTICORE) {
1601         classdefout.println("  int version;");
1602         classdefout.println("  int * lock;"); // lock entry for this obj
1603         classdefout.println("  int mutex;");
1604         classdefout.println("  volatile int lockcount;");
1605         if(state.MULTICOREGC) {
1606           classdefout.println("  int marked;");
1607         }
1608       }
1609       if (state.OPTIONAL) {
1610         classdefout.println("  int numfses;");
1611         classdefout.println("  int * fses;");
1612       }
1613     }
1614     if (javabuilder==null||javabuilder.hasLayout(cn))
1615       printClassStruct(cn, classdefout, globaldefout, globaldefprimout);
1616
1617     printedfieldstbl.clear(); // = new Hashtable<String, ClassDescriptor>();
1618     classdefout.println("};\n");
1619     generateCallStructsMethods(cn, output, headersout);
1620   }
1621
1622
1623   protected void generateCallStructsMethods(ClassDescriptor cn, PrintWriter output, PrintWriter headersout) {
1624     for(Iterator methodit=cn.getMethods(); methodit.hasNext(); ) {
1625       MethodDescriptor md=(MethodDescriptor)methodit.next();
1626
1627       FlatMethod fm=state.getMethodFlat(md);
1628
1629       if (!callgraph.isCallable(md)&&(!md.isStaticBlock()||!callgraph.isInit(cn))) {
1630         if (callgraph.isCalled(md)) {
1631           generateTempStructs(fm);
1632           generateMethodParam(cn, md, output);
1633         }
1634         continue;
1635       }
1636
1637       generateTempStructs(fm);
1638       generateMethodParam(cn, md, output);
1639
1640       generateMethod(cn, md, headersout, output);
1641     }
1642   }
1643
1644   protected void generateMethodParam(ClassDescriptor cn, MethodDescriptor md, PrintWriter output) {
1645     /* Output parameter structure */
1646     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1647       if(md.isInvokedByStatic() && !md.isStaticBlock() && !md.getModifiers().isNative()) {
1648         // generate the staticinit version
1649         String mdstring = md.getSafeMethodDescriptor() + "staticinit";
1650
1651         ParamsObject objectparams=(ParamsObject) paramstable.get(md);
1652         output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+mdstring+"_params {");
1653         output.println("  int size;");
1654         output.println("  void * next;");
1655         for(int i=0; i<objectparams.numPointers(); i++) {
1656           TempDescriptor temp=objectparams.getPointer(i);
1657           if(temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
1658             output.println("  int " + temp.getSafeSymbol() + ";");
1659           } else {
1660             output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
1661           }
1662         }
1663         output.println("};\n");
1664       }
1665
1666       ParamsObject objectparams=(ParamsObject) paramstable.get(md);
1667       output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params {");
1668       output.println("  int size;");
1669       output.println("  void * next;");
1670       for(int i=0; i<objectparams.numPointers(); i++) {
1671         TempDescriptor temp=objectparams.getPointer(i);
1672         if(temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
1673           output.println("  int " + temp.getSafeSymbol() + ";");
1674         } else {
1675           output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
1676         }
1677       }
1678       output.println("};\n");
1679     }
1680   }
1681
1682   protected void generateMethod(ClassDescriptor cn, MethodDescriptor md, PrintWriter headersout, PrintWriter output) {
1683     ParamsObject objectparams=(ParamsObject) paramstable.get(md);
1684     TempObject objecttemps=(TempObject) tempstable.get(md);
1685
1686     boolean printcomma = false;
1687
1688
1689     if(md.isInvokedByStatic() && !md.isStaticBlock() && !md.getModifiers().isNative()) {
1690       // generate the staticinit version
1691       String mdstring = md.getSafeMethodDescriptor() + "staticinit";
1692
1693       /* Output temp structure */
1694       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1695         output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+mdstring+"_locals {");
1696         output.println("  int size;");
1697         output.println("  void * next;");
1698         for(int i=0; i<objecttemps.numPointers(); i++) {
1699           TempDescriptor temp=objecttemps.getPointer(i);
1700           if (!temp.getType().isArray() && temp.getType().isNull())
1701             output.println("  void * "+temp.getSafeSymbol()+";");
1702           else
1703             output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
1704         }
1705         output.println("};\n");
1706       }
1707
1708       headersout.println("#define D"+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+mdstring+" 1");
1709       /* First the return type */
1710       if (md.getReturnType()!=null) {
1711         if(md.getReturnType().isClass() && md.getReturnType().getClassDesc().isEnum()) {
1712           headersout.println("  int ");
1713         } else if (md.getReturnType().isClass()||md.getReturnType().isArray())
1714           headersout.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
1715         else
1716           headersout.print(md.getReturnType().getSafeSymbol()+" ");
1717       } else
1718         //catch the constructor case
1719         headersout.print("void ");
1720
1721       /* Next the method name */
1722       headersout.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+mdstring+"(");
1723       printcomma=false;
1724       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1725         headersout.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+mdstring+"_params * "+paramsprefix);
1726         printcomma=true;
1727       }
1728
1729       /*  Output parameter list*/
1730       for(int i=0; i<objectparams.numPrimitives(); i++) {
1731         TempDescriptor temp=objectparams.getPrimitive(i);
1732         if (printcomma)
1733           headersout.print(", ");
1734         printcomma=true;
1735         if(temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
1736           headersout.print("int " + temp.getSafeSymbol());
1737         } else if (temp.getType().isClass()||temp.getType().isArray())
1738           headersout.print("struct " + temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol());
1739         else
1740           headersout.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
1741       }
1742       if(md.getSymbol().equals("MonitorEnter") && state.OBJECTLOCKDEBUG) {
1743         headersout.print(", int linenum");
1744       }
1745       headersout.println(");\n");
1746     }
1747
1748     /* Output temp structure */
1749     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1750       output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals {");
1751       output.println("  int size;");
1752       output.println("  void * next;");
1753       for(int i=0; i<objecttemps.numPointers(); i++) {
1754         TempDescriptor temp=objecttemps.getPointer(i);
1755         if (!temp.getType().isArray() && temp.getType().isNull())
1756           output.println("  void * "+temp.getSafeSymbol()+";");
1757         else
1758           output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
1759       }
1760       output.println("};\n");
1761     }
1762
1763     /********* Output method declaration ***********/
1764     headersout.println("#define D"+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+" 1");
1765     /* First the return type */
1766     if (md.getReturnType()!=null) {
1767       if(md.getReturnType().isClass() && md.getReturnType().getClassDesc().isEnum()) {
1768         headersout.println("  int ");
1769       } else if (md.getReturnType().isClass()||md.getReturnType().isArray())
1770         headersout.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
1771       else
1772         headersout.print(md.getReturnType().getSafeSymbol()+" ");
1773     } else
1774       //catch the constructor case
1775       headersout.print("void ");
1776
1777     /* Next the method name */
1778     headersout.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(");
1779     printcomma=false;
1780     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1781       headersout.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
1782       printcomma=true;
1783     }
1784
1785     /*  Output parameter list*/
1786     for(int i=0; i<objectparams.numPrimitives(); i++) {
1787       TempDescriptor temp=objectparams.getPrimitive(i);
1788       if (printcomma)
1789         headersout.print(", ");
1790       printcomma=true;
1791       if(temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
1792         headersout.print("int " + temp.getSafeSymbol());
1793       } else if (temp.getType().isClass()||temp.getType().isArray())
1794         headersout.print("struct " + temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol());
1795       else
1796         headersout.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
1797     }
1798     if(md.getSymbol().equals("MonitorEnter") && state.OBJECTLOCKDEBUG) {
1799       headersout.print(", int linenum");
1800     }
1801     headersout.println(");\n");
1802   }
1803
1804
1805   /** This function outputs (1) structures that parameters are
1806    * passed in (when PRECISE GC is enabled) and (2) function
1807    * prototypes for the tasks */
1808
1809   protected void generateTaskStructs(PrintWriter output, PrintWriter headersout) {
1810     /* Cycle through tasks */
1811     Iterator taskit=state.getTaskSymbolTable().getDescriptorsIterator();
1812
1813     while(taskit.hasNext()) {
1814       /* Classify parameters */
1815       TaskDescriptor task=(TaskDescriptor)taskit.next();
1816       FlatMethod fm=state.getMethodFlat(task);
1817       generateTempStructs(fm);
1818
1819       ParamsObject objectparams=(ParamsObject) paramstable.get(task);
1820       TempObject objecttemps=(TempObject) tempstable.get(task);
1821
1822       /* Output parameter structure */
1823       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1824         output.println("struct "+task.getSafeSymbol()+"_params {");
1825         output.println("  int size;");
1826         output.println("  void * next;");
1827         for(int i=0; i<objectparams.numPointers(); i++) {
1828           TempDescriptor temp=objectparams.getPointer(i);
1829           output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
1830         }
1831
1832         output.println("};\n");
1833         if ((objectparams.numPointers()+fm.numTags())>maxtaskparams) {
1834           maxtaskparams=objectparams.numPointers()+fm.numTags();
1835         }
1836       }
1837
1838       /* Output temp structure */
1839       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1840         output.println("struct "+task.getSafeSymbol()+"_locals {");
1841         output.println("  int size;");
1842         output.println("  void * next;");
1843         for(int i=0; i<objecttemps.numPointers(); i++) {
1844           TempDescriptor temp=objecttemps.getPointer(i);
1845           if (!temp.getType().isArray() && temp.getType().isNull())
1846             output.println("  void * "+temp.getSafeSymbol()+";");
1847           else if(temp.getType().isTag())
1848             output.println("  struct "+
1849                            (new TypeDescriptor(typeutil.getClass(TypeUtil.TagClass))).getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
1850           else
1851             output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
1852         }
1853         output.println("};\n");
1854       }
1855
1856       /* Output task declaration */
1857       headersout.print("void " + task.getSafeSymbol()+"(");
1858
1859       boolean printcomma=false;
1860       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1861         headersout.print("struct "+task.getSafeSymbol()+"_params * "+paramsprefix);
1862       } else
1863         headersout.print("void * parameterarray[]");
1864       headersout.println(");\n");
1865     }
1866   }
1867
1868   protected void generateNativeFlatMethod(FlatMethod fm, PrintWriter outmethod) {
1869     MethodDescriptor md=fm.getMethod();
1870     ClassDescriptor cd=md.getClassDesc();
1871     generateHeader(fm, md, outmethod);
1872     int startindex=0;
1873     outmethod.println("JNIPUSHFRAME();");
1874     if (md.getModifiers().isStatic()) {
1875       outmethod.println("jobject rec=JNIWRAP(((void **)(((char *) &(global_defs_p->classobjs->___length___))+sizeof(int)))[" + cd.getId() + "]);");
1876     } else {
1877       outmethod.println("jobject rec=JNIWRAP("+generateTemp(fm, fm.getParameter(0))+");");
1878       startindex=1;
1879     }
1880     for(int i=startindex; i<fm.numParameters(); i++) {
1881       TempDescriptor tmp=fm.getParameter(i);
1882       if (tmp.getType().isPtr()) {
1883         outmethod.println("jobject param"+i+"=JNIWRAP("+generateTemp(fm, fm.getParameter(i))+");");
1884       }
1885     }
1886     if (GENERATEPRECISEGC) {
1887       outmethod.println("stopforgc((struct garbagelist *)___params___);");
1888     }
1889     if (!md.getReturnType().isVoid()) {
1890       if (md.getReturnType().isPtr())
1891         outmethod.print("jobject retval=");
1892       else
1893         outmethod.print(md.getReturnType().getSafeSymbol()+" retval=");
1894     }
1895     outmethod.print("Java_");
1896     outmethod.print(cd.getPackage().replace('.','_'));
1897     outmethod.print("_"+md.getSymbol()+"(");
1898     outmethod.print("JNI_vtable, rec");
1899
1900     for(int i=startindex; i<fm.numParameters(); i++) {
1901       outmethod.print(", ");
1902       TempDescriptor tmp=fm.getParameter(i);
1903       if (tmp.getType().isPtr()) {
1904         outmethod.print("param"+i);
1905       } else {
1906         outmethod.print(generateTemp(fm, tmp));
1907       }
1908     }
1909     outmethod.println(");");
1910     if (GENERATEPRECISEGC) {
1911       outmethod.println("restartaftergc();");
1912     }
1913     if (!md.getReturnType().isVoid()) {
1914       if (md.getReturnType().isPtr()) {
1915         outmethod.println("struct ___Object___ * retobj=JNIUNWRAP(retval);");
1916         outmethod.println("JNIPOPFRAME();");
1917         outmethod.println("return retobj;");
1918       } else {
1919         outmethod.println("JNIPOPFRAME();");
1920         outmethod.println("return retval;");
1921       }
1922     } else
1923       outmethod.println("JNIPOPFRAME();");
1924
1925     outmethod.println("}");
1926     outmethod.println("");
1927   }
1928
1929   protected void generateFlatMethod(FlatMethod fm, PrintWriter output) {
1930     if (State.PRINTFLAT)
1931       System.out.println(fm.printMethod());
1932     MethodDescriptor md=fm.getMethod();
1933     TaskDescriptor task=fm.getTask();
1934     ClassDescriptor cn=md!=null?md.getClassDesc():null;
1935     ParamsObject objectparams=(ParamsObject)paramstable.get(md!=null?md:task);
1936
1937     if((md != null) && md.isInvokedByStatic() && !md.isStaticBlock() && !md.getModifiers().isNative()) {
1938       // generate a special static init version
1939       mgcstaticinit = true;
1940       String mdstring = md.getSafeMethodDescriptor() + "staticinit";
1941
1942       generateHeader(fm, md!=null?md:task,output);
1943       TempObject objecttemp=(TempObject) tempstable.get(md!=null?md:task);
1944
1945       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1946         output.print("   struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+mdstring+"_locals "+localsprefix+"={");
1947         output.print(objecttemp.numPointers()+",");
1948         output.print(paramsprefix);
1949         for(int j=0; j<objecttemp.numPointers(); j++)
1950           output.print(", NULL");
1951         output.println("};");
1952       }
1953
1954       for(int i=0; i<objecttemp.numPrimitives(); i++) {
1955         TempDescriptor td=objecttemp.getPrimitive(i);
1956         TypeDescriptor type=td.getType();
1957         if (type.isNull() && !type.isArray())
1958           output.println("   void * "+td.getSafeSymbol()+";");
1959         else if (type.isClass() && type.getClassDesc().isEnum()) {
1960           output.println("   int " + td.getSafeSymbol() + ";");
1961         } else if (type.isClass()||type.isArray())
1962           output.println("   struct "+type.getSafeSymbol()+" * "+td.getSafeSymbol()+";");
1963         else
1964           output.println("   "+type.getSafeSymbol()+" "+td.getSafeSymbol()+";");
1965       }
1966
1967       additionalCodeAtTopFlatMethodBody(output, fm);
1968
1969       /* Check to see if we need to do a GC if this is a
1970        * multi-threaded program...*/
1971
1972       if (((state.OOOJAVA||state.THREAD)&&GENERATEPRECISEGC) || state.MULTICOREGC) {
1973         //Don't bother if we aren't in recursive methods...The loops case will catch it
1974         if (callgraph.getAllMethods(md).contains(md)) {
1975           if (this.state.MULTICOREGC) {
1976             output.println("if(gcflag) gc("+localsprefixaddr+");");
1977           } else {
1978             output.println("if (unlikely(needtocollect)) checkcollect("+localsprefixaddr+");");
1979           }
1980         }
1981       }
1982
1983       generateCode(fm.getNext(0), fm, null, output);
1984
1985       output.println("}\n\n");
1986
1987       mgcstaticinit = false;
1988     }
1989
1990     generateHeader(fm, md!=null?md:task,output);
1991     TempObject objecttemp=(TempObject) tempstable.get(md!=null?md:task);
1992
1993     if((md != null) && (md.isStaticBlock())) {
1994       mgcstaticinit = true;
1995     }
1996
1997     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
1998       if (md!=null)
1999         output.print("   struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals "+localsprefix+"={");
2000       else
2001         output.print("   struct "+task.getSafeSymbol()+"_locals "+localsprefix+"={");
2002       output.print(objecttemp.numPointers()+",");
2003       output.print(paramsprefix);
2004       for(int j=0; j<objecttemp.numPointers(); j++)
2005         output.print(", NULL");
2006       output.println("};");
2007     }
2008
2009     for(int i=0; i<objecttemp.numPrimitives(); i++) {
2010       TempDescriptor td=objecttemp.getPrimitive(i);
2011       TypeDescriptor type=td.getType();
2012       if (type.isNull() && !type.isArray())
2013         output.println("   void * "+td.getSafeSymbol()+";");
2014       else if (type.isClass() && type.getClassDesc().isEnum()) {
2015         output.println("   int " + td.getSafeSymbol() + ";");
2016       } else if (type.isClass()||type.isArray())
2017         output.println("   struct "+type.getSafeSymbol()+" * "+td.getSafeSymbol()+";");
2018       else
2019         output.println("   "+type.getSafeSymbol()+" "+td.getSafeSymbol()+";");
2020     }
2021
2022     additionalCodeAtTopFlatMethodBody(output, fm);
2023
2024     /* Check to see if we need to do a GC if this is a
2025      * multi-threaded program...*/
2026
2027     if (((state.OOOJAVA||state.THREAD)&&GENERATEPRECISEGC)
2028         || this.state.MULTICOREGC) {
2029       //Don't bother if we aren't in recursive methods...The loops case will catch it
2030       if (callgraph.getAllMethods(md).contains(md)) {
2031         if (this.state.MULTICOREGC) {
2032           output.println("if(gcflag) gc("+localsprefixaddr+");");
2033         } else {
2034           output.println("if (unlikely(needtocollect)) checkcollect("+localsprefixaddr+");");
2035         }
2036       }
2037     }
2038
2039     if(fm.getMethod()!=null&&fm.getMethod().isStaticBlock()) {
2040       // a static block, check if it has been executed
2041       output.println("  if(global_defsprim_p->" + cn.getSafeSymbol()+"static_block_exe_flag != 0) {");
2042       output.println("    return;");
2043       output.println("  }");
2044       output.println("");
2045     }
2046
2047     generateCode(fm.getNext(0), fm, null, output);
2048
2049     output.println("}\n\n");
2050
2051     mgcstaticinit = false;
2052   }
2053
2054   protected void generateCode(FlatNode first,
2055                               FlatMethod fm,
2056                               Set<FlatNode> stopset,
2057                               PrintWriter output) {
2058
2059     /* Assign labels to FlatNode's if necessary.*/
2060
2061     Hashtable<FlatNode, Integer> nodetolabel;
2062
2063     nodetolabel=assignLabels(first, stopset);
2064
2065     Set<FlatNode> storeset=null;
2066     HashSet<FlatNode> genset=null;
2067     HashSet<FlatNode> refset=null;
2068     Set<FlatNode> unionset=null;
2069
2070     /* Do the actual code generation */
2071     FlatNode current_node=null;
2072     HashSet tovisit=new HashSet();
2073     HashSet visited=new HashSet();
2074     tovisit.add(first);
2075     while(current_node!=null||!tovisit.isEmpty()) {
2076       if (current_node==null) {
2077         current_node=(FlatNode)tovisit.iterator().next();
2078         tovisit.remove(current_node);
2079       } else if (tovisit.contains(current_node)) {
2080         tovisit.remove(current_node);
2081       }
2082       visited.add(current_node);
2083       if (nodetolabel.containsKey(current_node)) {
2084         output.println("L"+nodetolabel.get(current_node)+":");
2085       }
2086       if (state.INSTRUCTIONFAILURE) {
2087         if (state.THREAD) {
2088           output.println("if ((++instructioncount)>failurecount) {instructioncount=0;injectinstructionfailure();}");
2089         } else
2090           output.println("if ((--instructioncount)==0) injectinstructionfailure();");
2091       }
2092       if (current_node.numNext()==0||stopset!=null&&stopset.contains(current_node)) {
2093         output.print("   ");
2094         generateFlatNode(fm, current_node, output);
2095
2096         if (state.OOOJAVA && stopset!=null) {
2097           assert first.getPrev(0) instanceof FlatSESEEnterNode;
2098           assert current_node       instanceof FlatSESEExitNode;
2099           FlatSESEEnterNode fsen = (FlatSESEEnterNode) first.getPrev(0);
2100           FlatSESEExitNode fsxn = (FlatSESEExitNode)  current_node;
2101           assert fsen.getFlatExit().equals(fsxn);
2102           assert fsxn.getFlatEnter().equals(fsen);
2103         }
2104         if (current_node.kind()!=FKind.FlatReturnNode) {
2105           if((fm.getMethod() != null) && (fm.getMethod().isStaticBlock())) {
2106             // a static block, check if it has been executed
2107             output.println("  global_defsprim_p->" + fm.getMethod().getClassDesc().getSafeSymbol()+"static_block_exe_flag = 1;");
2108             output.println("");
2109           }
2110           output.println("   return;");
2111         }
2112         current_node=null;
2113       } else if(current_node.numNext()==1) {
2114         FlatNode nextnode;
2115         if (state.OOOJAVA &&
2116             current_node.kind()==FKind.FlatSESEEnterNode) {
2117           FlatSESEEnterNode fsen = (FlatSESEEnterNode)current_node;
2118           generateFlatNode(fm, current_node, output);
2119           nextnode=fsen.getFlatExit().getNext(0);
2120         } else {
2121           output.print("   ");
2122           generateFlatNode(fm, current_node, output);
2123           nextnode=current_node.getNext(0);
2124         }
2125         if (visited.contains(nextnode)) {
2126           output.println("goto L"+nodetolabel.get(nextnode)+";");
2127           current_node=null;
2128         } else
2129           current_node=nextnode;
2130       } else if (current_node.numNext()==2) {
2131         /* Branch */
2132         output.print("   ");
2133         generateFlatCondBranch(fm, (FlatCondBranch)current_node, "L"+nodetolabel.get(current_node.getNext(1)), output);
2134         if (!visited.contains(current_node.getNext(1)))
2135           tovisit.add(current_node.getNext(1));
2136         if (visited.contains(current_node.getNext(0))) {
2137           output.println("goto L"+nodetolabel.get(current_node.getNext(0))+";");
2138           current_node=null;
2139         } else
2140           current_node=current_node.getNext(0);
2141       } else throw new Error();
2142     }
2143   }
2144
2145   protected Hashtable<FlatNode, Integer> assignLabels(FlatNode first, Set<FlatNode> lastset) {
2146     HashSet tovisit=new HashSet();
2147     HashSet visited=new HashSet();
2148     int labelindex=0;
2149     Hashtable<FlatNode, Integer> nodetolabel=new Hashtable<FlatNode, Integer>();
2150     tovisit.add(first);
2151
2152     /*Assign labels first.  A node needs a label if the previous
2153      * node has two exits or this node is a join point. */
2154
2155     while(!tovisit.isEmpty()) {
2156       FlatNode fn=(FlatNode)tovisit.iterator().next();
2157       tovisit.remove(fn);
2158       visited.add(fn);
2159
2160
2161       if(lastset!=null&&lastset.contains(fn)) {
2162         // if last is not null and matches, don't go
2163         // any further for assigning labels
2164         continue;
2165       }
2166
2167       for(int i=0; i<fn.numNext(); i++) {
2168         FlatNode nn=fn.getNext(i);
2169
2170         if(i>0) {
2171           //1) Edge >1 of node
2172           nodetolabel.put(nn,new Integer(labelindex++));
2173         }
2174         if (!visited.contains(nn)&&!tovisit.contains(nn)) {
2175           tovisit.add(nn);
2176         } else {
2177           //2) Join point
2178           nodetolabel.put(nn,new Integer(labelindex++));
2179         }
2180       }
2181     }
2182     return nodetolabel;
2183   }
2184
2185   /** Generate text string that corresponds to the TempDescriptor td. */
2186   protected String generateTemp(FlatMethod fm, TempDescriptor td) {
2187     MethodDescriptor md=fm.getMethod();
2188     TaskDescriptor task=fm.getTask();
2189     TempObject objecttemps=(TempObject) tempstable.get(md!=null?md:task);
2190
2191     if (objecttemps.isLocalPrim(td)||objecttemps.isParamPrim(td)) {
2192       return td.getSafeSymbol();
2193     }
2194
2195     if (objecttemps.isLocalPtr(td)) {
2196       return localsprefixderef+td.getSafeSymbol();
2197     }
2198
2199     if (objecttemps.isParamPtr(td)) {
2200       return paramsprefix+"->"+td.getSafeSymbol();
2201     }
2202
2203     throw new Error();
2204   }
2205
2206
2207
2208   protected void generateFlatNode(FlatMethod fm, FlatNode fn, PrintWriter output) {
2209     if(state.LINENUM) printSourceLineNumber(fm,fn,output);
2210     additionalCodePreNode(fm, fn, output);
2211
2212     switch(fn.kind()) {
2213     case FKind.FlatAtomicEnterNode:
2214       generateFlatAtomicEnterNode(fm, (FlatAtomicEnterNode) fn, output);
2215       break;
2216
2217     case FKind.FlatAtomicExitNode:
2218       generateFlatAtomicExitNode(fm, (FlatAtomicExitNode) fn, output);
2219       break;
2220
2221     case FKind.FlatInstanceOfNode:
2222       generateFlatInstanceOfNode(fm, (FlatInstanceOfNode)fn, output);
2223       break;
2224
2225     case FKind.FlatSESEEnterNode:
2226       generateFlatSESEEnterNode(fm, (FlatSESEEnterNode)fn, output);
2227       break;
2228
2229     case FKind.FlatSESEExitNode:
2230       generateFlatSESEExitNode(fm, (FlatSESEExitNode)fn, output);
2231       break;
2232
2233     case FKind.FlatWriteDynamicVarNode:
2234       generateFlatWriteDynamicVarNode(fm, (FlatWriteDynamicVarNode)fn, output);
2235       break;
2236
2237     case FKind.FlatGlobalConvNode:
2238       generateFlatGlobalConvNode(fm, (FlatGlobalConvNode) fn, output);
2239       break;
2240
2241     case FKind.FlatTagDeclaration:
2242       generateFlatTagDeclaration(fm, (FlatTagDeclaration) fn,output);
2243       break;
2244
2245     case FKind.FlatCall:
2246       generateFlatCall(fm, (FlatCall) fn,output);
2247       break;
2248
2249     case FKind.FlatFieldNode:
2250       generateFlatFieldNode(fm, (FlatFieldNode) fn,output);
2251       break;
2252
2253     case FKind.FlatElementNode:
2254       generateFlatElementNode(fm, (FlatElementNode) fn,output);
2255       break;
2256
2257     case FKind.FlatSetElementNode:
2258       generateFlatSetElementNode(fm, (FlatSetElementNode) fn,output);
2259       break;
2260
2261     case FKind.FlatSetFieldNode:
2262       generateFlatSetFieldNode(fm, (FlatSetFieldNode) fn,output);
2263       break;
2264
2265     case FKind.FlatNew:
2266       generateFlatNew(fm, (FlatNew) fn,output);
2267       break;
2268
2269     case FKind.FlatOpNode:
2270       generateFlatOpNode(fm, (FlatOpNode) fn,output);
2271       break;
2272
2273     case FKind.FlatCastNode:
2274       generateFlatCastNode(fm, (FlatCastNode) fn,output);
2275       break;
2276
2277     case FKind.FlatLiteralNode:
2278       generateFlatLiteralNode(fm, (FlatLiteralNode) fn,output);
2279       break;
2280
2281     case FKind.FlatReturnNode:
2282       generateFlatReturnNode(fm, (FlatReturnNode) fn,output);
2283       break;
2284
2285     case FKind.FlatNop:
2286       output.println("/* nop */");
2287       break;
2288
2289     case FKind.FlatGenReachNode:
2290       // this node is just for generating a reach graph
2291       // in disjointness analysis at a particular program point
2292       break;
2293
2294     case FKind.FlatExit:
2295       output.println("/* exit */");
2296       break;
2297
2298     case FKind.FlatBackEdge:
2299       generateFlatBackEdge(fm, (FlatBackEdge)fn, output);
2300       break;
2301
2302     case FKind.FlatCheckNode:
2303       generateFlatCheckNode(fm, (FlatCheckNode) fn, output);
2304       break;
2305
2306     case FKind.FlatFlagActionNode:
2307       generateFlatFlagActionNode(fm, (FlatFlagActionNode) fn, output);
2308       break;
2309
2310     case FKind.FlatPrefetchNode:
2311       generateFlatPrefetchNode(fm, (FlatPrefetchNode) fn, output);
2312       break;
2313
2314     case FKind.FlatOffsetNode:
2315       generateFlatOffsetNode(fm, (FlatOffsetNode)fn, output);
2316       break;
2317
2318     default:
2319       throw new Error();
2320     }
2321
2322     additionalCodePostNode(fm, fn, output);
2323   }
2324
2325   public void generateFlatBackEdge(FlatMethod fm, FlatBackEdge fn, PrintWriter output) {
2326     if (((state.OOOJAVA||state.THREAD)&&GENERATEPRECISEGC)
2327         || (this.state.MULTICOREGC)) {
2328       if(this.state.MULTICOREGC) {
2329         output.println("if (gcflag) gc("+localsprefixaddr+");");
2330       } else {
2331         output.println("if (unlikely(needtocollect)) checkcollect("+localsprefixaddr+");");
2332       }
2333     } else
2334       output.println("/* nop */");
2335   }
2336
2337   public void generateFlatOffsetNode(FlatMethod fm, FlatOffsetNode fofn, PrintWriter output) {
2338     output.println("/* FlatOffsetNode */");
2339     FieldDescriptor fd=fofn.getField();
2340     if(!fd.isStatic()) {
2341       output.println(generateTemp(fm, fofn.getDst())+ " = (short)(int) (&((struct "+fofn.getClassType().getSafeSymbol() +" *)0)->"+
2342                      fd.getSafeSymbol()+");");
2343     }
2344     output.println("/* offset */");
2345   }
2346
2347   public void generateFlatPrefetchNode(FlatMethod fm, FlatPrefetchNode fpn, PrintWriter output) {
2348   }
2349
2350   public void generateFlatGlobalConvNode(FlatMethod fm, FlatGlobalConvNode fgcn, PrintWriter output) {
2351   }
2352
2353   public void generateFlatInstanceOfNode(FlatMethod fm,  FlatInstanceOfNode fion, PrintWriter output) {
2354     int type;
2355     int otype;
2356     if (fion.getType().isArray()) {
2357       type=state.getArrayNumber(fion.getType())+state.numClasses();
2358     } else if (fion.getType().getClassDesc().isInterface()) {
2359       type=fion.getType().getClassDesc().getId()+state.numClasses()+state.numArrays();
2360     } else {
2361       type=fion.getType().getClassDesc().getId();
2362     }
2363     if (fion.getSrc().getType().isArray()) {
2364       otype=state.getArrayNumber(fion.getSrc().getType())+state.numClasses();
2365     } else if (fion.getSrc().getType().getClassDesc().isInterface()) {
2366       otype=fion.getSrc().getType().getClassDesc().getId()+state.numClasses()+state.numArrays();
2367     } else {
2368       otype=fion.getSrc().getType().getClassDesc().getId();
2369     }
2370
2371     if (fion.getType().getSymbol().equals(TypeUtil.ObjectClass))
2372       output.println(generateTemp(fm, fion.getDst())+"=(" + generateTemp(fm,fion.getSrc()) + "!= NULL);");
2373     else {
2374       output.println(generateTemp(fm, fion.getDst())+"=instanceof("+generateTemp(fm,fion.getSrc())+","+type+");");
2375     }
2376   }
2377
2378   public void generateFlatAtomicEnterNode(FlatMethod fm, FlatAtomicEnterNode faen, PrintWriter output) {
2379   }
2380
2381   public void generateFlatAtomicExitNode(FlatMethod fm,  FlatAtomicExitNode faen, PrintWriter output) {
2382   }
2383
2384   public void generateFlatSESEEnterNode(FlatMethod fm,
2385                                         FlatSESEEnterNode fsen,
2386                                         PrintWriter output) {
2387     // if OOOJAVA flag is off, okay that SESE nodes are in IR graph,
2388     // just skip over them and code generates exactly the same
2389   }
2390
2391   public void generateFlatSESEExitNode(FlatMethod fm,
2392                                        FlatSESEExitNode fsexn,
2393                                        PrintWriter output) {
2394     // if OOOJAVA flag is off, okay that SESE nodes are in IR graph,
2395     // just skip over them and code generates exactly the same
2396   }
2397
2398   public void generateFlatWriteDynamicVarNode(FlatMethod fm,
2399                                               FlatWriteDynamicVarNode fwdvn,
2400                                               PrintWriter output) {
2401   }
2402
2403
2404   protected void generateFlatCheckNode(FlatMethod fm,  FlatCheckNode fcn, PrintWriter output) {
2405     if (state.CONSCHECK) {
2406       String specname=fcn.getSpec();
2407       String varname="repairstate___";
2408       output.println("{");
2409       output.println("struct "+specname+"_state * "+varname+"=allocate"+specname+"_state();");
2410
2411       TempDescriptor[] temps=fcn.getTemps();
2412       String[] vars=fcn.getVars();
2413       for(int i=0; i<temps.length; i++) {
2414         output.println(varname+"->"+vars[i]+"=(unsigned int)"+generateTemp(fm, temps[i])+";");
2415       }
2416
2417       output.println("if (doanalysis"+specname+"("+varname+")) {");
2418       output.println("free"+specname+"_state("+varname+");");
2419       output.println("} else {");
2420       output.println("/* Bad invariant */");
2421       output.println("free"+specname+"_state("+varname+");");
2422       output.println("abort_task();");
2423       output.println("}");
2424       output.println("}");
2425     }
2426   }
2427
2428   protected void generateFlatCall(FlatMethod fm, FlatCall fc, PrintWriter output) {
2429     MethodDescriptor md=fc.getMethod();
2430     ParamsObject objectparams=(ParamsObject)paramstable.get(md);
2431
2432     ClassDescriptor cn=md.getClassDesc();
2433     String mdstring = md.getSafeMethodDescriptor();
2434     if(mgcstaticinit && !md.isStaticBlock() && !md.getModifiers().isNative()) {
2435       mdstring += "staticinit";
2436     }
2437
2438     // if the called method is a static block or a static method or a constructor
2439     // need to check if it can be invoked inside some static block
2440     if((md.isStatic() || md.isStaticBlock() || md.isConstructor()) &&
2441        ((fm.getMethod() != null) && ((fm.getMethod().isStaticBlock()) || (fm.getMethod().isInvokedByStatic())))) {
2442       if(!md.isInvokedByStatic()) {
2443         System.err.println("Error: a method that is invoked inside a static block is not tagged!");
2444       }
2445       // is a static block or is invoked in some static block
2446       ClassDescriptor cd = fm.getMethod().getClassDesc();
2447       if(cd != cn && mgcstaticinit && callgraph.isInit(cn)) {
2448         // generate static init check code if it has not done static init in main()
2449         if((cn.getNumStaticFields() != 0) || (cn.getNumStaticBlocks() != 0)) {
2450           // need to check if the class' static fields have been initialized and/or
2451           // its static blocks have been executed
2452           output.println("if(global_defsprim_p->" + cn.getSafeSymbol()+"static_block_exe_flag == 0) {");
2453           if(cn.getNumStaticBlocks() != 0) {
2454             MethodDescriptor t_md = (MethodDescriptor)cn.getMethodTable().get("staticblocks");
2455             if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2456               output.print("       struct "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"_params __parameterlist__={");
2457               output.println("0, NULL};");
2458               output.println("     "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"(& __parameterlist__);");
2459             } else {
2460               output.println("  "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"();");
2461             }
2462           } else {
2463             output.println("  global_defsprim_p->" + cn.getSafeSymbol()+"static_block_exe_flag = 1;");
2464           }
2465           output.println("}");
2466         }
2467       }
2468     }
2469     if((md.getSymbol().equals("MonitorEnter") || md.getSymbol().equals("MonitorExit")) && fc.getThis().getSymbol().equals("classobj")) {
2470       output.println("{");
2471       if(md.getSymbol().equals("MonitorEnter") && state.OBJECTLOCKDEBUG) {
2472         output.println("int monitorenterline = __LINE__;");
2473       }
2474       // call MonitorEnter/MonitorExit on a class obj
2475       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2476         output.print("       struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
2477         output.println("1," + localsprefixaddr + ", ((void **)(((char *) &(global_defs_p->classobjs->___length___))+sizeof(int)))[" + fc.getThis().getType().getClassDesc().getId() + "]};");
2478         if(md.getSymbol().equals("MonitorEnter") && state.OBJECTLOCKDEBUG) {
2479           output.println("     "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(& __parameterlist__, monitorenterline);");
2480         } else {
2481           output.println("     "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(& __parameterlist__);");
2482         }
2483       } else {
2484         output.println("       " + cn.getSafeSymbol()+md.getSafeSymbol()+"_"
2485                        + md.getSafeMethodDescriptor() + "((struct ___Object___*)(((void **)(((char *) &(global_defs_p->classobjs->___length___))+sizeof(int)))["
2486                        + fc.getThis().getType().getClassDesc().getId() + "]));");
2487       }
2488       output.println("}");
2489       return;
2490     }
2491
2492     output.println("{");
2493     if(md.getSymbol().equals("MonitorEnter")) {
2494       output.println("int monitorenterline = __LINE__;");
2495     }
2496     if (GENERATEPRECISEGC || state.MULTICOREGC) {
2497       output.print("       struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+mdstring+"_params __parameterlist__={");
2498       output.print(objectparams.numPointers());
2499       output.print(", "+localsprefixaddr);
2500       if (md.getThis()!=null) {
2501         output.print(", ");
2502         output.print("(struct "+md.getThis().getType().getSafeSymbol() +" *)"+ generateTemp(fm,fc.getThis()));
2503       }
2504       if (fc.getThis()!=null&&md.getThis()==null) {
2505         System.out.println("WARNING!!!!!!!!!!!!");
2506         System.out.println("Source code calls static method "+md+" on an object in "+fm.getMethod()+"!");
2507       }
2508
2509       for(int i=0; i<fc.numArgs(); i++) {
2510         Descriptor var=md.getParameter(i);
2511         TempDescriptor paramtemp=(TempDescriptor)temptovar.get(var);
2512         if (objectparams.isParamPtr(paramtemp)) {
2513           TempDescriptor targ=fc.getArg(i);
2514           output.print(", ");
2515           TypeDescriptor td=md.getParamType(i);
2516           if (td.isTag())
2517             output.print("(struct "+(new TypeDescriptor(typeutil.getClass(TypeUtil.TagClass))).getSafeSymbol()  +" *)"+generateTemp(fm, targ));
2518           else
2519             output.print("(struct "+md.getParamType(i).getSafeSymbol()  +" *)"+generateTemp(fm, targ));
2520         }
2521       }
2522       output.println("};");
2523     }
2524     output.print("       ");
2525
2526
2527     if (fc.getReturnTemp()!=null)
2528       output.print(generateTemp(fm,fc.getReturnTemp())+"=");
2529
2530     /* Do we need to do virtual dispatch? */
2531
2532     if (md.isStatic()||md.getReturnType()==null||singleCall(fc.getThis().getType().getClassDesc(),md)||fc.getSuper()) {
2533       //no
2534       output.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+mdstring);
2535     } else {
2536       //yes
2537       output.print("((");
2538       if (md.getReturnType().isClass() && md.getReturnType().getClassDesc().isEnum()) {
2539         output.print("int ");
2540       } else if (md.getReturnType().isClass()||md.getReturnType().isArray())
2541         output.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
2542       else
2543         output.print(md.getReturnType().getSafeSymbol()+" ");
2544       output.print("(*)(");
2545
2546       boolean printcomma=false;
2547       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2548         output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+mdstring+"_params * ");
2549         printcomma=true;
2550       }
2551
2552       for(int i=0; i<objectparams.numPrimitives(); i++) {
2553         TempDescriptor temp=objectparams.getPrimitive(i);
2554         if (printcomma)
2555           output.print(", ");
2556         printcomma=true;
2557         if (temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
2558           output.print("int ");
2559         } else if (temp.getType().isClass()||temp.getType().isArray())
2560           output.print("struct " + temp.getType().getSafeSymbol()+" * ");
2561         else
2562           output.print(temp.getType().getSafeSymbol());
2563       }
2564
2565       if(md.getSymbol().equals("MonitorEnter") && state.OBJECTLOCKDEBUG) {
2566         output.print(", int");
2567       }
2568       output.print("))virtualtable["+generateTemp(fm,fc.getThis())+"->type*"+maxcount+"+"+virtualcalls.getMethodNumber(md)+"])");
2569     }
2570
2571     output.print("(");
2572     boolean needcomma=false;
2573     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2574       output.print("&__parameterlist__");
2575       needcomma=true;
2576     }
2577
2578     if (!GENERATEPRECISEGC && !this.state.MULTICOREGC) {
2579       if (fc.getThis()!=null) {
2580         TypeDescriptor ptd=null;
2581         if(md.getThis() != null) {
2582           ptd = md.getThis().getType();
2583         } else {
2584           ptd = fc.getThis().getType();
2585         }
2586         if (needcomma)
2587           output.print(",");
2588         if(ptd.isClass() && ptd.getClassDesc().isEnum()) {
2589           // do nothing
2590         } else if (ptd.isClass()&&!ptd.isArray())
2591           output.print("(struct "+ptd.getSafeSymbol()+" *) ");
2592         output.print(generateTemp(fm,fc.getThis()));
2593         needcomma=true;
2594       }
2595     }
2596
2597     for(int i=0; i<fc.numArgs(); i++) {
2598       Descriptor var=md.getParameter(i);
2599       TempDescriptor paramtemp=(TempDescriptor)temptovar.get(var);
2600       if (objectparams.isParamPrim(paramtemp)) {
2601         TempDescriptor targ=fc.getArg(i);
2602         if (needcomma)
2603           output.print(", ");
2604
2605         TypeDescriptor ptd=md.getParamType(i);
2606         if (ptd.isClass() && ptd.getClassDesc().isEnum()) {
2607           // do nothing
2608         } else if (ptd.isClass()&&!ptd.isArray())
2609           output.print("(struct "+ptd.getSafeSymbol()+" *) ");
2610         output.print(generateTemp(fm, targ));
2611         needcomma=true;
2612       }
2613     }
2614     if(md.getSymbol().equals("MonitorEnter") && state.OBJECTLOCKDEBUG) {
2615       output.println(", monitorenterline);");
2616     } else {
2617       output.println(");");
2618     }
2619     output.println("   }");
2620   }
2621
2622   protected boolean singleCall(ClassDescriptor thiscd, MethodDescriptor md) {
2623     if(thiscd.isInterface()) {
2624       // for interfaces, always need virtual dispatch
2625       return false;
2626     } else {
2627       Set subclasses=typeutil.getSubClasses(thiscd);
2628       if (subclasses==null)
2629         return true;
2630       for(Iterator classit=subclasses.iterator(); classit.hasNext(); ) {
2631         ClassDescriptor cd=(ClassDescriptor)classit.next();
2632         Set possiblematches=cd.getMethodTable().getSetFromSameScope(md.getSymbol());
2633         for(Iterator matchit=possiblematches.iterator(); matchit.hasNext(); ) {
2634           MethodDescriptor matchmd=(MethodDescriptor)matchit.next();
2635           if (md.matches(matchmd))
2636             return false;
2637         }
2638       }
2639     }
2640     return true;
2641   }
2642
2643   protected void generateFlatFieldNode(FlatMethod fm, FlatFieldNode ffn, PrintWriter output) {
2644
2645     if(ffn.getField().isStatic()) {
2646       // static field
2647       if((fm.getMethod().isStaticBlock()) || (fm.getMethod().isInvokedByStatic())) {
2648         // is a static block or is invoked in some static block
2649         ClassDescriptor cd = fm.getMethod().getClassDesc();
2650         ClassDescriptor cn = ffn.getSrc().getType().getClassDesc();
2651         if(cd != cn && mgcstaticinit && callgraph.isInit(cn)) {
2652           // generate the static init check code if has not done the static init in main()
2653           if((cn.getNumStaticFields() != 0) || (cn.getNumStaticBlocks() != 0)) {
2654             // need to check if the class' static fields have been initialized and/or
2655             // its static blocks have been executed
2656             output.println("if(global_defsprim_p->" + cn.getSafeSymbol()+"static_block_exe_flag == 0) {");
2657             if(cn.getNumStaticBlocks() != 0) {
2658               MethodDescriptor t_md = (MethodDescriptor)cn.getMethodTable().get("staticblocks");
2659               if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2660                 output.print("       struct "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"_params __parameterlist__={");
2661                 output.println("0, NULL};");
2662                 output.println("     "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"(& __parameterlist__);");
2663               } else {
2664                 output.println("  "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"();");
2665               }
2666             } else {
2667               output.println("  global_defsprim_p->" + cn.getSafeSymbol()+"static_block_exe_flag = 1;");
2668             }
2669             output.println("}");
2670           }
2671         }
2672       }
2673       // redirect to the global_defs_p structure
2674       if (ffn.getField().getType().isPtr())
2675         output.println(generateTemp(fm, ffn.getDst())+"=global_defs_p->"+ffn.getField().getSafeSymbol()+";");
2676       else
2677         output.println(generateTemp(fm, ffn.getDst())+"=global_defsprim_p->"+ffn.getField().getSafeSymbol()+";");
2678     } else if (ffn.getField().isEnum()) {
2679       // an Enum value, directly replace the field access as int
2680       output.println(generateTemp(fm, ffn.getDst()) + "=" + ffn.getField().enumValue() + ";");
2681     } else {
2682       if( state.CAPTURE_NULL_DEREFERENCES ) {
2683         output.println("#ifdef CAPTURE_NULL_DEREFERENCES");
2684         output.println("if (" + generateTemp(fm,ffn.getSrc()) + " == NULL) {");
2685         output.println("printf(\" NULL ptr error: %s, %s, %d \\n\", __FILE__, __func__, __LINE__);");
2686         if(state.MULTICOREGC) {
2687           output.println("failednullptr(&___locals___);");
2688         } else {
2689           output.println("failednullptr(NULL);");
2690         }
2691         output.println("}");
2692         output.println("#endif //CAPTURE_NULL_DEREFERENCES");
2693       }
2694       output.println(generateTemp(fm, ffn.getDst())+"="+ generateTemp(fm,ffn.getSrc())+"->"+ ffn.getField().getSafeSymbol()+";");
2695     }
2696   }
2697
2698
2699   protected void generateFlatSetFieldNode(FlatMethod fm, FlatSetFieldNode fsfn, PrintWriter output) {
2700     if (fsfn.getField().getSymbol().equals("length")&&fsfn.getDst().getType().isArray())
2701       throw new Error("Can't set array length");
2702     if (state.FASTCHECK) {
2703       String dst=generateTemp(fm, fsfn.getDst());
2704       output.println("if(!"+dst+"->"+localcopystr+") {");
2705       /* Link object into list */
2706       if (GENERATEPRECISEGC || this.state.MULTICOREGC)
2707         output.println("COPY_OBJ((struct garbagelist *)"+localsprefixaddr+",(struct ___Object___ *)"+dst+");");
2708       else
2709         output.println("COPY_OBJ("+dst+");");
2710       output.println(dst+"->"+nextobjstr+"="+fcrevert+";");
2711       output.println(fcrevert+"=(struct ___Object___ *)"+dst+";");
2712       output.println("}");
2713     }
2714
2715     if(fsfn.getField().isStatic()) {
2716       // static field
2717       if((fm.getMethod().isStaticBlock()) || (fm.getMethod().isInvokedByStatic())) {
2718         // is a static block or is invoked in some static block
2719         ClassDescriptor cd = fm.getMethod().getClassDesc();
2720         ClassDescriptor cn = fsfn.getDst().getType().getClassDesc();
2721         if(cd != cn && mgcstaticinit && callgraph.isInit(cn)) {
2722           // generate static init check code if has not done the static init in main()
2723           if((cn.getNumStaticFields() != 0) || (cn.getNumStaticBlocks() != 0)) {
2724             // need to check if the class' static fields have been initialized and/or
2725             // its static blocks have been executed
2726             output.println("if(global_defsprim_p->" + cn.getSafeSymbol()+"static_block_exe_flag == 0) {");
2727             if(cn.getNumStaticBlocks() != 0) {
2728               MethodDescriptor t_md = (MethodDescriptor)cn.getMethodTable().get("staticblocks");
2729               if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2730                 output.print("       struct "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"_params __parameterlist__={");
2731                 output.println("0, NULL};");
2732                 output.println("     "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"(& __parameterlist__);");
2733               } else {
2734                 output.println("  "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"();");
2735               }
2736             } else {
2737               output.println("  global_defsprim_p->" + cn.getSafeSymbol()+"static_block_exe_flag = 1;");
2738             }
2739             output.println("}");
2740           }
2741         }
2742       }
2743       // redirect to the global_defs_p structure
2744       if (fsfn.getField().getType().isPtr()) {
2745         if (fsfn.getField().getType()!=fsfn.getSrc().getType())
2746           output.println("global_defs_p->" +
2747                          fsfn.getField().getSafeSymbol()+"=(struct "+ fsfn.getField().getType().getSafeSymbol()+" *)"+generateTemp(fm,fsfn.getSrc())+";");
2748         else
2749           output.println("global_defs_p->" +
2750                          fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc())+";");
2751       } else
2752         output.println("global_defsprim_p->" +
2753                        fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc())+";");
2754     } else {
2755
2756       if( state.CAPTURE_NULL_DEREFERENCES ) {
2757         output.println("#ifdef CAPTURE_NULL_DEREFERENCES");
2758         output.println("if (" + generateTemp(fm,fsfn.getDst()) + " == NULL) {");
2759         output.println("printf(\" NULL ptr error: %s, %s, %d \\n\", __FILE__, __func__, __LINE__);");
2760         if(state.MULTICOREGC) {
2761           output.println("failednullptr(&___locals___);");
2762         } else {
2763           output.println("failednullptr(NULL);");
2764         }
2765         output.println("}");
2766         output.println("#endif //CAPTURE_NULL_DEREFERENCES");
2767       }
2768
2769       if (fsfn.getSrc().getType().isPtr()&&fsfn.getSrc().getType()!=fsfn.getField().getType())
2770         output.println(generateTemp(fm, fsfn.getDst())+"->"+
2771                        fsfn.getField().getSafeSymbol()+"=(struct "+ fsfn.getField().getType().getSafeSymbol()+"*)"+generateTemp(fm,fsfn.getSrc())+";");
2772       else
2773         output.println(generateTemp(fm, fsfn.getDst())+"->"+
2774                        fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc())+";");
2775     }
2776   }
2777
2778
2779   protected void generateFlatElementNode(FlatMethod fm, FlatElementNode fen, PrintWriter output) {
2780     TypeDescriptor elementtype=fen.getSrc().getType().dereference();
2781     String type="";
2782
2783     if (elementtype.isClass() && elementtype.getClassDesc().isEnum()) {
2784       type="int ";
2785     } else if (elementtype.isArray()||elementtype.isClass())
2786       type="void *";
2787     else
2788       type=elementtype.getSafeSymbol()+" ";
2789
2790     if (this.state.ARRAYBOUNDARYCHECK && fen.needsBoundsCheck()) {
2791       output.println("if (unlikely(((unsigned int)"+generateTemp(fm, fen.getIndex())+") >= "+generateTemp(fm,fen.getSrc()) + "->___length___))");
2792       output.println("failedboundschk(" + (boundschknum++) + ");");
2793     }
2794     output.println(generateTemp(fm, fen.getDst())+"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc())+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex())+"];");
2795   }
2796
2797   protected void generateFlatSetElementNode(FlatMethod fm, FlatSetElementNode fsen, PrintWriter output) {
2798     //TODO: need dynamic check to make sure this assignment is actually legal
2799     //Because Object[] could actually be something more specific...ie. Integer[]
2800
2801     TypeDescriptor elementtype=fsen.getDst().getType().dereference();
2802     String type="";
2803
2804     if (elementtype.isClass() && elementtype.getClassDesc().isEnum()) {
2805       type="int ";
2806     } else if (elementtype.isArray()||elementtype.isClass() || (elementtype.isNull()))
2807       type="void *";
2808     else
2809       type=elementtype.getSafeSymbol()+" ";
2810
2811     if (this.state.ARRAYBOUNDARYCHECK && fsen.needsBoundsCheck()) {
2812       output.println("if (unlikely(((unsigned int)"+generateTemp(fm, fsen.getIndex())+") >= "+generateTemp(fm,fsen.getDst()) + "->___length___))");
2813       output.println("failedboundschk(" + (boundschknum++) + ");");
2814     }
2815     if (state.FASTCHECK) {
2816       String dst=generateTemp(fm, fsen.getDst());
2817       output.println("if(!"+dst+"->"+localcopystr+") {");
2818       /* Link object into list */
2819       if (GENERATEPRECISEGC || this.state.MULTICOREGC)
2820         output.println("COPY_OBJ((struct garbagelist *)"+localsprefixaddr+",(struct ___Object___ *)"+dst+");");
2821       else
2822         output.println("COPY_OBJ("+dst+");");
2823       output.println(dst+"->"+nextobjstr+"="+fcrevert+";");
2824       output.println(fcrevert+"=(struct ___Object___ *)"+dst+";");
2825       output.println("}");
2826     }
2827     output.println("(("+type +"*)(((char *) &("+ generateTemp(fm,fsen.getDst())+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex())+"]="+generateTemp(fm,fsen.getSrc())+";");
2828   }
2829
2830
2831   protected void generateFlatNew(FlatMethod fm, FlatNew fn, PrintWriter output) {
2832     if (fn.getType().isArray()) {
2833       int arrayid=state.getArrayNumber(fn.getType())+state.numClasses();
2834       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2835         output.println(generateTemp(fm,fn.getDst())+"=allocate_newarray("+localsprefixaddr+", "+arrayid+", "+generateTemp(fm, fn.getSize())+");");
2836       } else {
2837         output.println(generateTemp(fm,fn.getDst())+"=allocate_newarray("+arrayid+", "+generateTemp(fm, fn.getSize())+");");
2838       }
2839     } else {
2840       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2841         output.println(generateTemp(fm,fn.getDst())+"=allocate_new("+localsprefixaddr+", "+fn.getType().getClassDesc().getId()+");");
2842       } else {
2843         output.println(generateTemp(fm,fn.getDst())+"=allocate_new("+fn.getType().getClassDesc().getId()+");");
2844       }
2845     }
2846     if (state.FASTCHECK) {
2847       String dst=generateTemp(fm,fn.getDst());
2848       output.println(dst+"->___localcopy___=(struct ___Object___*)1;");
2849       output.println(dst+"->"+nextobjstr+"="+fcrevert+";");
2850       output.println(fcrevert+"=(struct ___Object___ *)"+dst+";");
2851     }
2852   }
2853
2854   protected void generateFlatTagDeclaration(FlatMethod fm, FlatTagDeclaration fn, PrintWriter output) {
2855     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2856       output.println(generateTemp(fm,fn.getDst())+"=allocate_tag("+localsprefixaddr+", "+state.getTagId(fn.getType())+");");
2857     } else {
2858       output.println(generateTemp(fm,fn.getDst())+"=allocate_tag("+state.getTagId(fn.getType())+");");
2859     }
2860   }
2861
2862   protected void generateFlatOpNode(FlatMethod fm, FlatOpNode fon, PrintWriter output) {
2863     if (fon.getRight()!=null) {
2864       if (fon.getOp().getOp()==Operation.URIGHTSHIFT) {
2865         if (fon.getLeft().getType().isLong())
2866           output.println(generateTemp(fm, fon.getDest())+" = ((unsigned long long)"+generateTemp(fm, fon.getLeft())+")>>"+generateTemp(fm,fon.getRight())+";");
2867         else
2868           output.println(generateTemp(fm, fon.getDest())+" = ((unsigned int)"+generateTemp(fm, fon.getLeft())+")>>"+generateTemp(fm,fon.getRight())+";");
2869
2870       } else {
2871         if (fon.getLeft().getType().isPtr()&&fon.getLeft().getType()!=fon.getRight().getType()&&!fon.getRight().getType().isNull())
2872           output.println(generateTemp(fm, fon.getDest())+" = (struct "+fon.getRight().getType().getSafeSymbol()+"*)"+generateTemp(fm, fon.getLeft())+fon.getOp().toString()+generateTemp(fm,fon.getRight())+";");
2873         else
2874           output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+fon.getOp().toString()+generateTemp(fm,fon.getRight())+";");
2875       }
2876     } else if (fon.getOp().getOp()==Operation.ASSIGN)
2877       if (fon.getDest().getType().isPtr()&&fon.getDest().getType()!=fon.getLeft().getType())
2878         output.println(generateTemp(fm, fon.getDest())+" = (struct "+fon.getDest().getType().getSafeSymbol()+"*)"+generateTemp(fm, fon.getLeft())+";");
2879       else
2880         output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+";");
2881     else if (fon.getOp().getOp()==Operation.UNARYPLUS)
2882       output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+";");
2883     else if (fon.getOp().getOp()==Operation.UNARYMINUS)
2884       output.println(generateTemp(fm, fon.getDest())+" = -"+generateTemp(fm, fon.getLeft())+";");
2885     else if (fon.getOp().getOp()==Operation.LOGIC_NOT)
2886       output.println(generateTemp(fm, fon.getDest())+" = !"+generateTemp(fm, fon.getLeft())+";");
2887     else if (fon.getOp().getOp()==Operation.COMP)
2888       output.println(generateTemp(fm, fon.getDest())+" = ~"+generateTemp(fm, fon.getLeft())+";");
2889     else if (fon.getOp().getOp()==Operation.ISAVAILABLE) {
2890       output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+"->fses==NULL;");
2891     } else
2892       output.println(generateTemp(fm, fon.getDest())+fon.getOp().toString()+generateTemp(fm, fon.getLeft())+";");
2893   }
2894
2895   protected void generateFlatCastNode(FlatMethod fm, FlatCastNode fcn, PrintWriter output) {
2896     /* TODO: Do type check here */
2897     if (fcn.getType().isArray()) {
2898       output.println(generateTemp(fm,fcn.getDst())+"=(struct ArrayObject *)"+generateTemp(fm,fcn.getSrc())+";");
2899     } else if (fcn.getType().isClass() && fcn.getType().getClassDesc().isEnum()) {
2900       output.println(generateTemp(fm,fcn.getDst())+"=(int)"+generateTemp(fm,fcn.getSrc())+";");
2901     } else if (fcn.getType().isClass())
2902       output.println(generateTemp(fm,fcn.getDst())+"=(struct "+fcn.getType().getSafeSymbol()+" *)"+generateTemp(fm,fcn.getSrc())+";");
2903     else
2904       output.println(generateTemp(fm,fcn.getDst())+"=("+fcn.getType().getSafeSymbol()+")"+generateTemp(fm,fcn.getSrc())+";");
2905   }
2906
2907   int flncount=0;
2908
2909   protected void generateFlatLiteralNode(FlatMethod fm, FlatLiteralNode fln, PrintWriter output) {
2910     if (fln.getValue()==null)
2911       output.println(generateTemp(fm, fln.getDst())+"=0;");
2912     else if (fln.getType().getSymbol().equals(TypeUtil.StringClass)) {
2913       String str=(String)fln.getValue();
2914       output.println("{");
2915       output.print("short str"+flncount+"[]={");
2916       for(int i=0; i<str.length(); i++) {
2917         if (i!=0)
2918           output.print(", ");
2919         output.print(((int)str.charAt(i)));
2920       }
2921       output.println("};");
2922       if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
2923         output.println(generateTemp(fm, fln.getDst())+"=NewStringShort("+localsprefixaddr+", str"+flncount+", "+((String)fln.getValue()).length()+");");
2924       } else {
2925         output.println(generateTemp(fm, fln.getDst())+"=NewStringShort(str"+flncount+" ,"+((String)fln.getValue()).length()+");");
2926       }
2927       output.println("}");
2928       flncount++;
2929     } else if (fln.getType().isBoolean()) {
2930       if (((Boolean)fln.getValue()).booleanValue())
2931         output.println(generateTemp(fm, fln.getDst())+"=1;");
2932       else
2933         output.println(generateTemp(fm, fln.getDst())+"=0;");
2934     } else if (fln.getType().isChar()) {
2935       int val=(int)(((Character)fln.getValue()).charValue());
2936       output.println(generateTemp(fm, fln.getDst())+"="+val+";");
2937     } else if (fln.getType().isLong()) {
2938       output.println(generateTemp(fm, fln.getDst())+"="+fln.getValue()+"LL;");
2939     } else
2940       output.println(generateTemp(fm, fln.getDst())+"="+fln.getValue()+";");
2941   }
2942
2943   protected void generateFlatReturnNode(FlatMethod fm, FlatReturnNode frn, PrintWriter output) {
2944     if((fm.getMethod() != null) && (fm.getMethod().isStaticBlock())) {
2945       // a static block, check if it has been executed
2946       output.println("  global_defsprim_p->" + fm.getMethod().getClassDesc().getSafeSymbol()+"static_block_exe_flag = 1;");
2947       output.println("");
2948     }
2949
2950     if (frn.getReturnTemp()!=null) {
2951       if (frn.getReturnTemp().getType().isPtr())
2952         output.println("return (struct "+fm.getMethod().getReturnType().getSafeSymbol()+"*)"+generateTemp(fm, frn.getReturnTemp())+";");
2953       else
2954         output.println("return "+generateTemp(fm, frn.getReturnTemp())+";");
2955     } else {
2956       output.println("return;");
2957     }
2958   }
2959
2960   protected void generateFlatCondBranch(FlatMethod fm, FlatCondBranch fcb, String label, PrintWriter output) {
2961     output.println("if (!"+generateTemp(fm, fcb.getTest())+") goto "+label+";");
2962   }
2963
2964   /** This method generates header information for the method or
2965    * task referenced by the Descriptor des. */
2966   protected void generateHeader(FlatMethod fm, Descriptor des, PrintWriter output) {
2967     generateHeader(fm, des, output, false);
2968   }
2969
2970   protected void generateHeader(FlatMethod fm, Descriptor des, PrintWriter output, boolean addSESErecord) {
2971     /* Print header */
2972     ParamsObject objectparams=(ParamsObject)paramstable.get(des);
2973     MethodDescriptor md=null;
2974     TaskDescriptor task=null;
2975     if (des instanceof MethodDescriptor)
2976       md=(MethodDescriptor) des;
2977     else
2978       task=(TaskDescriptor) des;
2979     String mdstring = md != null?md.getSafeMethodDescriptor():null;
2980
2981     ClassDescriptor cn=md!=null?md.getClassDesc():null;
2982
2983     if (md!=null&&md.getReturnType()!=null) {
2984       if (md.getReturnType().isClass() && md.getReturnType().getClassDesc().isEnum()) {
2985         output.print("int ");
2986       } else if (md.getReturnType().isClass()||md.getReturnType().isArray())
2987         output.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
2988       else
2989         output.print(md.getReturnType().getSafeSymbol()+" ");
2990     } else
2991       //catch the constructor case
2992       output.print("void ");
2993     if (md!=null) {
2994       if(mgcstaticinit && !md.isStaticBlock() && !md.getModifiers().isNative()) {
2995         mdstring += "staticinit";
2996       }
2997       output.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+mdstring+"(");
2998     } else
2999       output.print(task.getSafeSymbol()+"(");
3000
3001     boolean printcomma=false;
3002     if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
3003       if (md!=null) {
3004         output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+mdstring+"_params * "+paramsprefix);
3005       } else
3006         output.print("struct "+task.getSafeSymbol()+"_params * "+paramsprefix);
3007       printcomma=true;
3008     }
3009
3010     if (md!=null) {
3011       /* Method */
3012       for(int i=0; i<objectparams.numPrimitives(); i++) {
3013         TempDescriptor temp=objectparams.getPrimitive(i);
3014         if (printcomma)
3015           output.print(", ");
3016         printcomma=true;
3017         if(temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
3018           output.print("int " + temp.getSafeSymbol());
3019         } else if (temp.getType().isClass()||temp.getType().isArray())
3020           output.print("struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol());
3021         else
3022           output.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
3023       }
3024       output.println(") {");
3025     } else if (!GENERATEPRECISEGC && !this.state.MULTICOREGC) {
3026       /* Imprecise Task */
3027       output.println("void * parameterarray[]) {");
3028       /* Unpack variables */
3029       for(int i=0; i<objectparams.numPrimitives(); i++) {
3030         TempDescriptor temp=objectparams.getPrimitive(i);
3031         if(temp.getType().isClass() && temp.getType().getClassDesc().isEnum()) {
3032           output.print("int " + temp.getSafeSymbol() + "=parameterarray["+i+"];");
3033         } else {
3034           output.println("struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+"=parameterarray["+i+"];");
3035         }
3036       }
3037       for(int i=0; i<fm.numTags(); i++) {
3038         TempDescriptor temp=fm.getTag(i);
3039         int offset=i+objectparams.numPrimitives();
3040         output.println("struct ___TagDescriptor___ * "+temp.getSafeSymbol()+"=parameterarray["+offset+"];");
3041       }
3042
3043       if ((objectparams.numPrimitives()+fm.numTags())>maxtaskparams)
3044         maxtaskparams=objectparams.numPrimitives()+fm.numTags();
3045     } else output.println(") {");
3046   }
3047
3048   public void generateFlatFlagActionNode(FlatMethod fm, FlatFlagActionNode ffan, PrintWriter output) {
3049     output.println("/* FlatFlagActionNode */");
3050
3051
3052     /* Process tag changes */
3053     Relation tagsettable=new Relation();
3054     Relation tagcleartable=new Relation();
3055
3056     Iterator tagsit=ffan.getTempTagPairs();
3057     while (tagsit.hasNext()) {
3058       TempTagPair ttp=(TempTagPair) tagsit.next();
3059       TempDescriptor objtmp=ttp.getTemp();
3060       TagDescriptor tag=ttp.getTag();
3061       TempDescriptor tagtmp=ttp.getTagTemp();
3062       boolean tagstatus=ffan.getTagChange(ttp);
3063       if (tagstatus) {
3064         tagsettable.put(objtmp, tagtmp);
3065       } else {
3066         tagcleartable.put(objtmp, tagtmp);
3067       }
3068     }
3069
3070
3071     Hashtable flagandtable=new Hashtable();
3072     Hashtable flagortable=new Hashtable();
3073
3074     /* Process flag changes */
3075     Iterator flagsit=ffan.getTempFlagPairs();
3076     while(flagsit.hasNext()) {
3077       TempFlagPair tfp=(TempFlagPair)flagsit.next();
3078       TempDescriptor temp=tfp.getTemp();
3079       Hashtable flagtable=(Hashtable)flagorder.get(temp.getType().getClassDesc());
3080       FlagDescriptor flag=tfp.getFlag();
3081       if (flag==null) {
3082         //Newly allocate objects that don't set any flags case
3083         if (flagortable.containsKey(temp)) {
3084           throw new Error();
3085         }
3086         int mask=0;
3087         flagortable.put(temp,new Integer(mask));
3088       } else {
3089         int flagid=1<<((Integer)flagtable.get(flag)).intValue();
3090         boolean flagstatus=ffan.getFlagChange(tfp);
3091         if (flagstatus) {
3092           int mask=0;
3093           if (flagortable.containsKey(temp)) {
3094             mask=((Integer)flagortable.get(temp)).intValue();
3095           }
3096           mask|=flagid;
3097           flagortable.put(temp,new Integer(mask));
3098         } else {
3099           int mask=0xFFFFFFFF;
3100           if (flagandtable.containsKey(temp)) {
3101             mask=((Integer)flagandtable.get(temp)).intValue();
3102           }
3103           mask&=(0xFFFFFFFF^flagid);
3104           flagandtable.put(temp,new Integer(mask));
3105         }
3106       }
3107     }
3108
3109
3110     HashSet flagtagset=new HashSet();
3111     flagtagset.addAll(flagortable.keySet());
3112     flagtagset.addAll(flagandtable.keySet());
3113     flagtagset.addAll(tagsettable.keySet());
3114     flagtagset.addAll(tagcleartable.keySet());
3115
3116     Iterator ftit=flagtagset.iterator();
3117     while(ftit.hasNext()) {
3118       TempDescriptor temp=(TempDescriptor)ftit.next();
3119
3120
3121       Set tagtmps=tagcleartable.get(temp);
3122       if (tagtmps!=null) {
3123         Iterator tagit=tagtmps.iterator();
3124         while(tagit.hasNext()) {
3125           TempDescriptor tagtmp=(TempDescriptor)tagit.next();
3126           if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC))
3127             output.println("tagclear("+localsprefixaddr+", (struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
3128           else
3129             output.println("tagclear((struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
3130         }
3131       }
3132
3133       tagtmps=tagsettable.get(temp);
3134       if (tagtmps!=null) {
3135         Iterator tagit=tagtmps.iterator();
3136         while(tagit.hasNext()) {
3137           TempDescriptor tagtmp=(TempDescriptor)tagit.next();
3138           if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC))
3139             output.println("tagset("+localsprefixaddr+", (struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
3140           else
3141             output.println("tagset((struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
3142         }
3143       }
3144
3145       int ormask=0;
3146       int andmask=0xFFFFFFF;
3147
3148       if (flagortable.containsKey(temp))
3149         ormask=((Integer)flagortable.get(temp)).intValue();
3150       if (flagandtable.containsKey(temp))
3151         andmask=((Integer)flagandtable.get(temp)).intValue();
3152       generateFlagOrAnd(ffan, fm, temp, output, ormask, andmask);
3153       generateObjectDistribute(ffan, fm, temp, output);
3154     }
3155   }
3156
3157   protected void generateFlagOrAnd(FlatFlagActionNode ffan, FlatMethod fm, TempDescriptor temp,
3158                                    PrintWriter output, int ormask, int andmask) {
3159     if (ffan.getTaskType()==FlatFlagActionNode.NEWOBJECT) {
3160       output.println("flagorandinit("+generateTemp(fm, temp)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
3161     } else {
3162       output.println("flagorand("+generateTemp(fm, temp)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
3163     }
3164   }
3165
3166   protected void generateObjectDistribute(FlatFlagActionNode ffan, FlatMethod fm, TempDescriptor temp, PrintWriter output) {
3167     output.println("enqueueObject("+generateTemp(fm, temp)+");");
3168   }
3169
3170   void generateOptionalHeader(PrintWriter headers) {
3171
3172     //GENERATE HEADERS
3173     headers.println("#include \"task.h\"\n\n");
3174     headers.println("#ifndef _OPTIONAL_STRUCT_");
3175     headers.println("#define _OPTIONAL_STRUCT_");
3176
3177     //STRUCT PREDICATEMEMBER
3178     headers.println("struct predicatemember{");
3179     headers.println("int type;");
3180     headers.println("int numdnfterms;");
3181     headers.println("int * flags;");
3182     headers.println("int numtags;");
3183     headers.println("int * tags;\n};\n\n");
3184
3185     //STRUCT OPTIONALTASKDESCRIPTOR
3186     headers.println("struct optionaltaskdescriptor{");
3187     headers.println("struct taskdescriptor * task;");
3188     headers.println("int index;");
3189     headers.println("int numenterflags;");
3190     headers.println("int * enterflags;");
3191     headers.println("int numpredicatemembers;");
3192     headers.println("struct predicatemember ** predicatememberarray;");
3193     headers.println("};\n\n");
3194
3195     //STRUCT TASKFAILURE
3196     headers.println("struct taskfailure {");
3197     headers.println("struct taskdescriptor * task;");
3198     headers.println("int index;");
3199     headers.println("int numoptionaltaskdescriptors;");
3200     headers.println("struct optionaltaskdescriptor ** optionaltaskdescriptorarray;\n};\n\n");
3201
3202     //STRUCT FSANALYSISWRAPPER
3203     headers.println("struct fsanalysiswrapper{");
3204     headers.println("int  flags;");
3205     headers.println("int numtags;");
3206     headers.println("int * tags;");
3207     headers.println("int numtaskfailures;");
3208     headers.println("struct taskfailure ** taskfailurearray;");
3209     headers.println("int numoptionaltaskdescriptors;");
3210     headers.println("struct optionaltaskdescriptor ** optionaltaskdescriptorarray;\n};\n\n");
3211
3212     //STRUCT CLASSANALYSISWRAPPER
3213     headers.println("struct classanalysiswrapper{");
3214     headers.println("int type;");
3215     headers.println("int numotd;");
3216     headers.println("struct optionaltaskdescriptor ** otdarray;");
3217     headers.println("int numfsanalysiswrappers;");
3218     headers.println("struct fsanalysiswrapper ** fsanalysiswrapperarray;\n};");
3219
3220     headers.println("extern struct classanalysiswrapper * classanalysiswrapperarray[];");
3221
3222     Iterator taskit=state.getTaskSymbolTable().getDescriptorsIterator();
3223     while(taskit.hasNext()) {
3224       TaskDescriptor td=(TaskDescriptor)taskit.next();
3225       headers.println("extern struct taskdescriptor task_"+td.getSafeSymbol()+";");
3226     }
3227
3228   }
3229
3230   //CHECK OVER THIS -- THERE COULD BE SOME ERRORS HERE
3231   int generateOptionalPredicate(Predicate predicate, OptionalTaskDescriptor otd, ClassDescriptor cdtemp, PrintWriter output) {
3232     int predicateindex = 0;
3233     //iterate through the classes concerned by the predicate
3234     Set c_vard = predicate.vardescriptors;
3235     Hashtable<TempDescriptor, Integer> slotnumber=new Hashtable<TempDescriptor, Integer>();
3236     int current_slot=0;
3237
3238     for(Iterator vard_it = c_vard.iterator(); vard_it.hasNext(); ) {
3239       VarDescriptor vard = (VarDescriptor)vard_it.next();
3240       TypeDescriptor typed = vard.getType();
3241
3242       //generate for flags
3243       HashSet fen_hashset = predicate.flags.get(vard.getSymbol());
3244       output.println("int predicateflags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
3245       int numberterms=0;
3246       if (fen_hashset!=null) {
3247         for (Iterator fen_it = fen_hashset.iterator(); fen_it.hasNext(); ) {
3248           FlagExpressionNode fen = (FlagExpressionNode)fen_it.next();
3249           if (fen!=null) {
3250             DNFFlag dflag=fen.getDNF();
3251             numberterms+=dflag.size();
3252
3253             Hashtable flags=(Hashtable)flagorder.get(typed.getClassDesc());
3254
3255             for(int j=0; j<dflag.size(); j++) {
3256               if (j!=0)
3257                 output.println(",");
3258               Vector term=dflag.get(j);
3259               int andmask=0;
3260               int checkmask=0;
3261               for(int k=0; k<term.size(); k++) {
3262                 DNFFlagAtom dfa=(DNFFlagAtom)term.get(k);
3263                 FlagDescriptor fd=dfa.getFlag();
3264                 boolean negated=dfa.getNegated();
3265                 int flagid=1<<((Integer)flags.get(fd)).intValue();
3266                 andmask|=flagid;
3267                 if (!negated)
3268                   checkmask|=flagid;
3269               }
3270               output.print("/*andmask*/0x"+Integer.toHexString(andmask)+", /*checkmask*/0x"+Integer.toHexString(checkmask));
3271             }
3272           }
3273         }
3274       }
3275       output.println("};\n");
3276
3277       //generate for tags
3278       TagExpressionList tagel = predicate.tags.get(vard.getSymbol());
3279       output.println("int predicatetags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
3280       int numtags = 0;
3281       if (tagel!=null) {
3282         for(int j=0; j<tagel.numTags(); j++) {
3283           if (j!=0)
3284             output.println(",");
3285           TempDescriptor tmp=tagel.getTemp(j);
3286           if (!slotnumber.containsKey(tmp)) {
3287             Integer slotint=new Integer(current_slot++);
3288             slotnumber.put(tmp,slotint);
3289           }
3290           int slot=slotnumber.get(tmp).intValue();
3291           output.println("/* slot */"+ slot+", /*tagid*/"+state.getTagId(tmp.getTag()));
3292         }
3293         numtags = tagel.numTags();
3294       }
3295       output.println("};");
3296
3297       //store the result into a predicatemember struct
3298       output.println("struct predicatemember predicatemember_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"={");
3299       output.println("/*type*/"+typed.getClassDesc().getId()+",");
3300       output.println("/* number of dnf terms */"+numberterms+",");
3301       output.println("predicateflags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
3302       output.println("/* number of tag */"+numtags+",");
3303       output.println("predicatetags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
3304       output.println("};\n");
3305       predicateindex++;
3306     }
3307
3308
3309     //generate an array that stores the entire predicate
3310     output.println("struct predicatemember * predicatememberarray_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
3311     for( int j = 0; j<predicateindex; j++) {
3312       if( j != predicateindex-1) output.println("&predicatemember_"+j+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
3313       else output.println("&predicatemember_"+j+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
3314     }
3315     output.println("};\n");
3316     return predicateindex;
3317   }
3318
3319
3320   void generateOptionalArrays(PrintWriter output, PrintWriter headers, Hashtable<ClassDescriptor, Hashtable<FlagState, Set<OptionalTaskDescriptor>>> safeexecution, Hashtable optionaltaskdescriptors) {
3321     generateOptionalHeader(headers);
3322     //GENERATE STRUCTS
3323     output.println("#include \"optionalstruct.h\"\n\n");
3324     output.println("#include \"stdlib.h\"\n");
3325
3326     HashSet processedcd = new HashSet();
3327     int maxotd=0;
3328     Enumeration e = safeexecution.keys();
3329     while (e.hasMoreElements()) {
3330       int numotd=0;
3331       //get the class
3332       ClassDescriptor cdtemp=(ClassDescriptor)e.nextElement();
3333       Hashtable flaginfo=(Hashtable)flagorder.get(cdtemp);       //will be used several times
3334
3335       //Generate the struct of optionals
3336       Collection c_otd = ((Hashtable)optionaltaskdescriptors.get(cdtemp)).values();
3337       numotd = c_otd.size();
3338       if(maxotd<numotd) maxotd = numotd;
3339       if( !c_otd.isEmpty() ) {
3340         for(Iterator otd_it = c_otd.iterator(); otd_it.hasNext(); ) {
3341           OptionalTaskDescriptor otd = (OptionalTaskDescriptor)otd_it.next();
3342
3343           //generate the int arrays for the predicate
3344           Predicate predicate = otd.predicate;
3345           int predicateindex = generateOptionalPredicate(predicate, otd, cdtemp, output);
3346           TreeSet<Integer> fsset=new TreeSet<Integer>();
3347           //iterate through possible FSes corresponding to
3348           //the state when entering
3349
3350           for(Iterator fses = otd.enterflagstates.iterator(); fses.hasNext(); ) {
3351             FlagState fs = (FlagState)fses.next();
3352             int flagid=0;
3353             for(Iterator flags = fs.getFlags(); flags.hasNext(); ) {
3354               FlagDescriptor flagd = (FlagDescriptor)flags.next();
3355               int id=1<<((Integer)flaginfo.get(flagd)).intValue();
3356               flagid|=id;
3357             }
3358             fsset.add(new Integer(flagid));
3359             //tag information not needed because tag
3360             //changes are not tolerated.
3361           }
3362
3363           output.println("int enterflag_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
3364           boolean needcomma=false;
3365           for(Iterator<Integer> it=fsset.iterator(); it.hasNext(); ) {
3366             if(needcomma)
3367               output.print(", ");
3368             output.println(it.next());
3369           }
3370
3371           output.println("};\n");
3372
3373
3374           //generate optionaltaskdescriptor that actually
3375           //includes exit fses, predicate and the task
3376           //concerned
3377           output.println("struct optionaltaskdescriptor optionaltaskdescriptor_"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"={");
3378           output.println("&task_"+otd.td.getSafeSymbol()+",");
3379           output.println("/*index*/"+otd.getIndex()+",");
3380           output.println("/*number of enter flags*/"+fsset.size()+",");
3381           output.println("enterflag_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
3382           output.println("/*number of members */"+predicateindex+",");
3383           output.println("predicatememberarray_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
3384           output.println("};\n");
3385         }
3386       } else
3387         continue;
3388       // if there are no optionals, there is no need to build the rest of the struct
3389
3390       output.println("struct optionaltaskdescriptor * otdarray"+cdtemp.getSafeSymbol()+"[]={");
3391       c_otd = ((Hashtable)optionaltaskdescriptors.get(cdtemp)).values();
3392       if( !c_otd.isEmpty() ) {
3393         boolean needcomma=false;
3394         for(Iterator otd_it = c_otd.iterator(); otd_it.hasNext(); ) {
3395           OptionalTaskDescriptor otd = (OptionalTaskDescriptor)otd_it.next();
3396           if(needcomma)
3397             output.println(",");
3398           needcomma=true;
3399           output.println("&optionaltaskdescriptor_"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
3400         }
3401       }
3402       output.println("};\n");
3403
3404       //get all the possible flagstates reachable by an object
3405       Hashtable hashtbtemp = safeexecution.get(cdtemp);
3406       int fscounter = 0;
3407       TreeSet fsts=new TreeSet(new FlagComparator(flaginfo));
3408       fsts.addAll(hashtbtemp.keySet());
3409       for(Iterator fsit=fsts.iterator(); fsit.hasNext(); ) {
3410         FlagState fs = (FlagState)fsit.next();
3411         fscounter++;
3412
3413         //get the set of OptionalTaskDescriptors corresponding
3414         HashSet<OptionalTaskDescriptor> availabletasks = (HashSet<OptionalTaskDescriptor>)hashtbtemp.get(fs);
3415         //iterate through the OptionalTaskDescriptors and
3416         //store the pointers to the optionals struct (see on
3417         //top) into an array
3418
3419         output.println("struct optionaltaskdescriptor * optionaltaskdescriptorarray_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"[] = {");
3420         for(Iterator<OptionalTaskDescriptor> mos = ordertd(availabletasks).iterator(); mos.hasNext(); ) {
3421           OptionalTaskDescriptor mm = mos.next();
3422           if(!mos.hasNext())
3423             output.println("&optionaltaskdescriptor_"+mm.getuid()+"_"+cdtemp.getSafeSymbol());
3424           else
3425             output.println("&optionaltaskdescriptor_"+mm.getuid()+"_"+cdtemp.getSafeSymbol()+",");
3426         }
3427
3428         output.println("};\n");
3429
3430         //process flag information (what the flag after failure is) so we know what optionaltaskdescriptors to choose.
3431
3432         int flagid=0;
3433         for(Iterator flags = fs.getFlags(); flags.hasNext(); ) {
3434           FlagDescriptor flagd = (FlagDescriptor)flags.next();
3435           int id=1<<((Integer)flaginfo.get(flagd)).intValue();
3436           flagid|=id;
3437         }
3438
3439         //process tag information
3440
3441         int tagcounter = 0;
3442         boolean first = true;
3443         Enumeration tag_enum = fs.getTags();
3444         output.println("int tags_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"[]={");
3445         while(tag_enum.hasMoreElements()) {
3446           tagcounter++;
3447           TagDescriptor tagd = (TagDescriptor)tag_enum.nextElement();
3448           if(first==true)
3449             first = false;
3450           else
3451             output.println(", ");
3452           output.println("/*tagid*/"+state.getTagId(tagd));
3453         }
3454         output.println("};");
3455
3456         Set<TaskIndex> tiset=sa.getTaskIndex(fs);
3457         for(Iterator<TaskIndex> itti=tiset.iterator(); itti.hasNext(); ) {
3458           TaskIndex ti=itti.next();
3459           if (ti.isRuntime())
3460             continue;
3461
3462           Set<OptionalTaskDescriptor> otdset=sa.getOptions(fs, ti);
3463
3464           output.print("struct optionaltaskdescriptor * optionaltaskfailure_FS"+fscounter+"_"+ti.getTask().getSafeSymbol()+"_"+ti.getIndex()+"_array[] = {");
3465           boolean needcomma=false;
3466           for(Iterator<OptionalTaskDescriptor> otdit=ordertd(otdset).iterator(); otdit.hasNext(); ) {
3467             OptionalTaskDescriptor otd=otdit.next();
3468             if(needcomma)
3469               output.print(", ");
3470             needcomma=true;
3471             output.println("&optionaltaskdescriptor_"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
3472           }
3473           output.println("};");
3474
3475           output.print("struct taskfailure taskfailure_FS"+fscounter+"_"+ti.getTask().getSafeSymbol()+"_"+ti.getIndex()+" = {");
3476           output.print("&task_"+ti.getTask().getSafeSymbol()+", ");
3477           output.print(ti.getIndex()+", ");
3478           output.print(otdset.size()+", ");
3479           output.print("optionaltaskfailure_FS"+fscounter+"_"+ti.getTask().getSafeSymbol()+"_"+ti.getIndex()+"_array");
3480           output.println("};");
3481         }
3482
3483         tiset=sa.getTaskIndex(fs);
3484         boolean needcomma=false;
3485         int runtimeti=0;
3486         output.println("struct taskfailure * taskfailurearray"+fscounter+"_"+cdtemp.getSafeSymbol()+"[]={");
3487         for(Iterator<TaskIndex> itti=tiset.iterator(); itti.hasNext(); ) {
3488           TaskIndex ti=itti.next();
3489           if (ti.isRuntime()) {
3490             runtimeti++;
3491             continue;
3492           }
3493           if (needcomma)
3494             output.print(", ");
3495           needcomma=true;
3496           output.print("&taskfailure_FS"+fscounter+"_"+ti.getTask().getSafeSymbol()+"_"+ti.getIndex());
3497         }
3498         output.println("};\n");
3499
3500         //Store the result in fsanalysiswrapper
3501
3502         output.println("struct fsanalysiswrapper fsanalysiswrapper_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"={");
3503         output.println("/*flag*/"+flagid+",");
3504         output.println("/* number of tags*/"+tagcounter+",");
3505         output.println("tags_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+",");
3506         output.println("/* numtask failures */"+(tiset.size()-runtimeti)+",");
3507         output.println("taskfailurearray"+fscounter+"_"+cdtemp.getSafeSymbol()+",");
3508         output.println("/* number of optionaltaskdescriptors */"+availabletasks.size()+",");
3509         output.println("optionaltaskdescriptorarray_FS"+fscounter+"_"+cdtemp.getSafeSymbol());
3510         output.println("};\n");
3511
3512       }
3513
3514       //Build the array of fsanalysiswrappers
3515       output.println("struct fsanalysiswrapper * fsanalysiswrapperarray_"+cdtemp.getSafeSymbol()+"[] = {");
3516       boolean needcomma=false;
3517       for(int i = 0; i<fscounter; i++) {
3518         if (needcomma) output.print(",");
3519         output.println("&fsanalysiswrapper_FS"+(i+1)+"_"+cdtemp.getSafeSymbol());
3520         needcomma=true;
3521       }
3522       output.println("};");
3523
3524       //Build the classanalysiswrapper referring to the previous array
3525       output.println("struct classanalysiswrapper classanalysiswrapper_"+cdtemp.getSafeSymbol()+"={");
3526       output.println("/*type*/"+cdtemp.getId()+",");
3527       output.println("/*numotd*/"+numotd+",");
3528       output.println("otdarray"+cdtemp.getSafeSymbol()+",");
3529       output.println("/* number of fsanalysiswrappers */"+fscounter+",");
3530       output.println("fsanalysiswrapperarray_"+cdtemp.getSafeSymbol()+"};\n");
3531       processedcd.add(cdtemp);
3532     }
3533
3534     //build an array containing every classes for which code has been build
3535     output.println("struct classanalysiswrapper * classanalysiswrapperarray[]={");
3536     for(int i=0; i<state.numClasses(); i++) {
3537       ClassDescriptor cn=cdarray[i];
3538       if (i>0)
3539         output.print(", ");
3540       if ((cn != null) && (processedcd.contains(cn)))
3541         output.print("&classanalysiswrapper_"+cn.getSafeSymbol());
3542       else
3543         output.print("NULL");
3544     }
3545     output.println("};");
3546
3547     output.println("#define MAXOTD "+maxotd);
3548     headers.println("#endif");
3549   }
3550
3551   public List<OptionalTaskDescriptor> ordertd(Set<OptionalTaskDescriptor> otdset) {
3552     Relation r=new Relation();
3553     for(Iterator<OptionalTaskDescriptor>otdit=otdset.iterator(); otdit.hasNext(); ) {
3554       OptionalTaskDescriptor otd=otdit.next();
3555       TaskIndex ti=new TaskIndex(otd.td, otd.getIndex());
3556       r.put(ti, otd);
3557     }
3558
3559     LinkedList<OptionalTaskDescriptor> l=new LinkedList<OptionalTaskDescriptor>();
3560     for(Iterator it=r.keySet().iterator(); it.hasNext(); ) {
3561       Set s=r.get(it.next());
3562       for(Iterator it2=s.iterator(); it2.hasNext(); ) {
3563         OptionalTaskDescriptor otd=(OptionalTaskDescriptor)it2.next();
3564         l.add(otd);
3565       }
3566     }
3567
3568     return l;
3569   }
3570
3571   // override these methods in a subclass of BuildCode
3572   // to generate code for additional systems
3573   protected void printExtraArrayFields(PrintWriter outclassdefs) {
3574   }
3575   protected void outputTransCode(PrintWriter output) {
3576   }
3577   protected void buildCodeSetup() {
3578   }
3579   protected void generateSizeArrayExtensions(PrintWriter outclassdefs) {
3580   }
3581   protected void additionalIncludesMethodsHeader(PrintWriter outmethodheader) {
3582   }
3583   protected void preCodeGenInitialization() {
3584   }
3585   protected void postCodeGenCleanUp() {
3586   }
3587   protected void additionalCodeGen(PrintWriter outmethodheader,
3588                                    PrintWriter outstructs,
3589                                    PrintWriter outmethod) {
3590   }
3591   protected void additionalCodeAtTopOfMain(PrintWriter outmethod) {
3592   }
3593   protected void additionalCodeAtBottomOfMain(PrintWriter outmethod) {
3594   }
3595   protected void additionalIncludesMethodsImplementation(PrintWriter outmethod) {
3596   }
3597   protected void additionalIncludesStructsHeader(PrintWriter outstructs) {
3598   }
3599   protected void additionalClassObjectFields(PrintWriter outclassdefs) {
3600   }
3601   protected void additionalCodeAtTopMethodsImplementation(PrintWriter outmethod) {
3602   }
3603   protected void additionalCodeAtTopFlatMethodBody(PrintWriter output, FlatMethod fm) {
3604   }
3605   protected void additionalCodePreNode(FlatMethod fm, FlatNode fn, PrintWriter output) {
3606   }
3607   protected void additionalCodePostNode(FlatMethod fm, FlatNode fn, PrintWriter output) {
3608   }
3609
3610   private void printSourceLineNumber(FlatMethod fm, FlatNode fn, PrintWriter output) {
3611     // we do not print out line number if no one explicitly set the number
3612     if(fn.getNumLine()!=-1) {
3613
3614       int lineNum=fn.getNumLine();
3615
3616       // do not generate the line number if it is same as the previous one
3617       boolean needtoprint;
3618       if(fn.prev.size()==0) {
3619         needtoprint=true;
3620       } else {
3621         needtoprint=false;
3622       }
3623
3624       for(int i=0; i<fn.prev.size(); i++) {
3625         int prevLineNum=((FlatNode)fn.prev.get(i)).getNumLine();
3626         if(prevLineNum!=lineNum) {
3627           needtoprint=true;
3628           break;
3629         }
3630       }
3631       if(needtoprint) {
3632         output.println("// "+fm.getMethod().getClassDesc().getSourceFileName()+":"+fn.getNumLine());
3633       }
3634     }
3635   }
3636
3637 }
3638
3639
3640
3641
3642
3643