Robust/src/IR/Flat/BuildCode.java

   1 package IR.Flat;
   2 import IR.Tree.FlagExpressionNode;
   3 import IR.Tree.DNFFlag;
   4 import IR.Tree.DNFFlagAtom;
   5 import IR.Tree.TagExpressionList;
   6 import IR.*;
   7 import java.util.*;
   8 import java.io.*;
   9 import Util.Relation;
  10 import Analysis.TaskStateAnalysis.FlagState;
  11 import Analysis.TaskStateAnalysis.OptionalTaskDescriptor;
  12 import Analysis.TaskStateAnalysis.Predicate;
  13 import Analysis.Locality.LocalityAnalysis;
  14 import Analysis.Locality.LocalityBinding;
  15
  16 public class BuildCode {
  17     State state;
  18     Hashtable temptovar;
  19     Hashtable paramstable;
  20     Hashtable tempstable;
  21     Hashtable fieldorder;
  22     Hashtable flagorder;
  23     int tag=0;
  24     String localsprefix="___locals___";
  25     String paramsprefix="___params___";
  26     public static boolean GENERATEPRECISEGC=false;
  27     public static String PREFIX="";
  28     public static String arraytype="ArrayObject";
  29     Virtual virtualcalls;
  30     TypeUtil typeutil;
  31     private int maxtaskparams=0;
  32     private int maxcount=0;
  33     ClassDescriptor[] cdarray;
  34     TypeDescriptor[] arraytable;
  35     LocalityAnalysis locality;
  36
  37     public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil) {
  38         state=st;
  39         this.temptovar=temptovar;
  40         paramstable=new Hashtable();
  41         tempstable=new Hashtable();
  42         fieldorder=new Hashtable();
  43         flagorder=new Hashtable();
  44         this.typeutil=typeutil;
  45         virtualcalls=new Virtual(state);
  46     }
  47
  48     public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, LocalityAnalysis locality) {
  49         this(st, temptovar, typeutil);
  50         this.locality=locality;
  51     }
  52
  53     /** The buildCode method outputs C code for all the methods.  The Flat
  54      * versions of the methods must already be generated and stored in
  55      * the State object. */
  56
  57     public void buildCode() {
  58         /* Create output streams to write to */
  59         PrintWriter outclassdefs=null;
  60         PrintWriter outstructs=null;
  61         PrintWriter outrepairstructs=null;
  62         PrintWriter outmethodheader=null;
  63         PrintWriter outmethod=null;
  64         PrintWriter outvirtual=null;
  65         PrintWriter outtask=null;
  66         PrintWriter outtaskdefs=null;
  67         PrintWriter outoptionalarrays=null;
  68         PrintWriter optionalheaders=null;
  69
  70         try {
  71             outstructs=new PrintWriter(new FileOutputStream(PREFIX+"structdefs.h"), true);
  72             outmethodheader=new PrintWriter(new FileOutputStream(PREFIX+"methodheaders.h"), true);
  73             outclassdefs=new PrintWriter(new FileOutputStream(PREFIX+"classdefs.h"), true);
  74             outmethod=new PrintWriter(new FileOutputStream(PREFIX+"methods.c"), true);
  75             outvirtual=new PrintWriter(new FileOutputStream(PREFIX+"virtualtable.h"), true);
  76             if (state.TASK) {
  77                 outtask=new PrintWriter(new FileOutputStream(PREFIX+"task.h"), true);
  78                 outtaskdefs=new PrintWriter(new FileOutputStream(PREFIX+"taskdefs.c"), true);
  79                 if (state.OPTIONAL){
  80                     outoptionalarrays=new PrintWriter(new FileOutputStream(PREFIX+"optionalarrays.c"), true);
  81                     optionalheaders=new PrintWriter(new FileOutputStream(PREFIX+"optionalstruct.h"), true);
  82                 }
  83             }
  84             if (state.structfile!=null) {
  85                 outrepairstructs=new PrintWriter(new FileOutputStream(PREFIX+state.structfile+".struct"), true);
  86             }
  87         } catch (Exception e) {
  88             e.printStackTrace();
  89             System.exit(-1);
  90         }
  91
  92         /* Build the virtual dispatch tables */
  93         buildVirtualTables(outvirtual);
  94
  95         /* Output includes */
  96         outmethodheader.println("#ifndef METHODHEADERS_H");
  97         outmethodheader.println("#define METHODHEADERS_H");
  98         outmethodheader.println("#include \"structdefs.h\"");
  99
 100         /* Output Structures */
 101         outputStructs(outstructs);
 102
 103         // Output the C class declarations
 104         // These could mutually reference each other
 105         outputClassDeclarations(outclassdefs);
 106
 107         // Output function prototypes and structures for parameters
 108         Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
 109         while(it.hasNext()) {
 110             ClassDescriptor cn=(ClassDescriptor)it.next();
 111             generateCallStructs(cn, outclassdefs, outstructs, outmethodheader);
 112         }
 113         outclassdefs.close();
 114
 115         if (state.TASK) {
 116             /* Map flags to integers */
 117             /* The runtime keeps track of flags using these integers */
 118             it=state.getClassSymbolTable().getDescriptorsIterator();
 119             while(it.hasNext()) {
 120                 ClassDescriptor cn=(ClassDescriptor)it.next();
 121                 mapFlags(cn);
 122             }
 123             /* Generate Tasks */
 124             generateTaskStructs(outstructs, outmethodheader);
 125
 126             /* Outputs generic task structures if this is a task
 127                program */
 128             outputTaskTypes(outtask);
 129         }
 130
 131         /* Build the actual methods */
 132         outputMethods(outmethod);
 133
 134         if (state.TASK) {
 135             /* Output code for tasks */
 136             outputTaskCode(outtaskdefs, outmethod);
 137             outtaskdefs.close();
 138             /* Record maximum number of task parameters */
 139             outstructs.println("#define MAXTASKPARAMS "+maxtaskparams);
 140         } else if (state.main!=null) {
 141             /* Generate main method */
 142             outputMainMethod(outmethod);
 143         }
 144
 145         /* Generate information for task with optional parameters */
 146         if (state.TASK&&state.OPTIONAL){
 147             generateOptionalArrays(outoptionalarrays, optionalheaders, state.getAnalysisResult(), state.getOptionalTaskDescriptors());
 148             outoptionalarrays.close();
 149         }
 150
 151         /* Output structure definitions for repair tool */
 152         if (state.structfile!=null) {
 153             buildRepairStructs(outrepairstructs);
 154             outrepairstructs.close();
 155         }
 156
 157         /* Close files */
 158         outmethodheader.println("#endif");
 159         outmethodheader.close();
 160         outmethod.close();
 161         outstructs.println("#endif");
 162         outstructs.close();
 163     }
 164
 165     /* This code just generates the main C method for java programs.
 166      * The main C method packs up the arguments into a string array
 167      * and passes it to the java main method. */
 168
 169     private void outputMainMethod(PrintWriter outmethod) {
 170         outmethod.println("int main(int argc, const char *argv[]) {");
 171         outmethod.println("  int i;");
 172         if (GENERATEPRECISEGC) {
 173             outmethod.println("  struct ArrayObject * stringarray=allocate_newarray(NULL, STRINGARRAYTYPE, argc-1);");
 174         } else {
 175             outmethod.println("  struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc-1);");
 176         }
 177         if (state.THREAD) {
 178             outmethod.println("initializethreads();");
 179         }
 180         outmethod.println("  for(i=1;i<argc;i++) {");
 181         outmethod.println("    int length=strlen(argv[i]);");
 182         if (GENERATEPRECISEGC) {
 183             outmethod.println("    struct ___String___ *newstring=NewString(NULL, argv[i], length);");
 184         } else {
 185             outmethod.println("    struct ___String___ *newstring=NewString(argv[i], length);");
 186         }
 187         outmethod.println("    ((void **)(((char *)& stringarray->___length___)+sizeof(int)))[i-1]=newstring;");
 188         outmethod.println("  }");
 189
 190
 191         MethodDescriptor md=typeutil.getMain();
 192         ClassDescriptor cd=typeutil.getMainClass();
 193
 194         outmethod.println("   {");
 195         if (GENERATEPRECISEGC) {
 196             outmethod.print("       struct "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
 197             outmethod.println("1, NULL,"+"stringarray};");
 198             outmethod.println("     "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(& __parameterlist__);");
 199         } else
 200             outmethod.println("     "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(stringarray);");
 201         outmethod.println("   }");
 202
 203         if (state.THREAD) {
 204             outmethod.println("pthread_mutex_lock(&gclistlock);");
 205             outmethod.println("threadcount--;");
 206             outmethod.println("pthread_cond_signal(&gccond);");
 207             outmethod.println("pthread_mutex_unlock(&gclistlock);");
 208             outmethod.println("pthread_exit(NULL);");
 209         }
 210         outmethod.println("}");
 211     }
 212
 213     /* This method outputs code for each task. */
 214
 215     private void outputTaskCode(PrintWriter outtaskdefs, PrintWriter outmethod) {
 216         /* Compile task based program */
 217         outtaskdefs.println("#include \"task.h\"");
 218         outtaskdefs.println("#include \"methodheaders.h\"");
 219         Iterator taskit=state.getTaskSymbolTable().getDescriptorsIterator();
 220         while(taskit.hasNext()) {
 221             TaskDescriptor td=(TaskDescriptor)taskit.next();
 222             FlatMethod fm=state.getMethodFlat(td);
 223             generateFlatMethod(fm, null, outmethod);
 224             generateTaskDescriptor(outtaskdefs, fm, td);
 225         }
 226
 227         //Output task descriptors
 228         taskit=state.getTaskSymbolTable().getDescriptorsIterator();
 229         outtaskdefs.println("struct taskdescriptor * taskarray[]= {");
 230         boolean first=true;
 231         while(taskit.hasNext()) {
 232             TaskDescriptor td=(TaskDescriptor)taskit.next();
 233             if (first)
 234                 first=false;
 235             else
 236                 outtaskdefs.println(",");
 237             outtaskdefs.print("&task_"+td.getSafeSymbol());
 238         }
 239         outtaskdefs.println("};");
 240
 241         outtaskdefs.println("int numtasks="+state.getTaskSymbolTable().getValueSet().size()+";");
 242     }
 243
 244     /* This method outputs most of the methods.c file.  This includes
 245      * some standard includes and then an array with the sizes of
 246      * objets and array that stores supertype and then the code for
 247      * the Java methods.. */
 248
 249     private void outputMethods(PrintWriter outmethod) {
 250         outmethod.println("#include \"methodheaders.h\"");
 251         outmethod.println("#include \"virtualtable.h\"");
 252         outmethod.println("#include <runtime.h>");
 253         if (state.THREAD)
 254             outmethod.println("#include <thread.h>");
 255         if (state.main!=null) {
 256             outmethod.println("#include <string.h>");
 257         }
 258         if (state.CONSCHECK) {
 259             outmethod.println("#include \"checkers.h\"");
 260         }
 261         //Store the sizes of classes & array elements
 262         generateSizeArray(outmethod);
 263
 264         //Store table of supertypes
 265         generateSuperTypeTable(outmethod);
 266
 267         //Store the layout of classes
 268         generateLayoutStructs(outmethod);
 269
 270         /* Generate code for methods */
 271         if (state.DSM) {
 272             for(Iterator<LocalityBinding> lbit=locality.getLocalityBindings().iterator();lbit.hasNext();) {
 273                 LocalityBinding lb=lbit.next();
 274                 MethodDescriptor md=lb.getMethod();
 275                 FlatMethod fm=state.getMethodFlat(md);
 276                 if (!md.getModifiers().isNative()) {
 277                     generateFlatMethod(fm, lb, outmethod);
 278                 }
 279             }
 280
 281
 282         } else {
 283             Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();
 284             while(classit.hasNext()) {
 285                 ClassDescriptor cn=(ClassDescriptor)classit.next();
 286                 Iterator methodit=cn.getMethods();
 287                 while(methodit.hasNext()) {
 288                     /* Classify parameters */
 289                     MethodDescriptor md=(MethodDescriptor)methodit.next();
 290                     FlatMethod fm=state.getMethodFlat(md);
 291                     if (!md.getModifiers().isNative())
 292                         generateFlatMethod(fm, null, outmethod);
 293                 }
 294             }
 295         }
 296     }
 297
 298     private void outputStructs(PrintWriter outstructs) {
 299         outstructs.println("#ifndef STRUCTDEFS_H");
 300         outstructs.println("#define STRUCTDEFS_H");
 301         outstructs.println("#include \"classdefs.h\"");
 302
 303         /* Output #defines that the runtime uses to determine type
 304          * numbers for various objects it needs */
 305
 306         outstructs.println("#define STRINGARRAYTYPE "+
 307                            (state.getArrayNumber(
 308                                                  (new TypeDescriptor(typeutil.getClass(TypeUtil.StringClass))).makeArray(state))+state.numClasses()));
 309
 310         outstructs.println("#define OBJECTARRAYTYPE "+
 311                            (state.getArrayNumber(
 312                                                  (new TypeDescriptor(typeutil.getClass(TypeUtil.ObjectClass))).makeArray(state))+state.numClasses()));
 313
 314
 315         outstructs.println("#define STRINGTYPE "+typeutil.getClass(TypeUtil.StringClass).getId());
 316         outstructs.println("#define CHARARRAYTYPE "+
 317                            (state.getArrayNumber((new TypeDescriptor(TypeDescriptor.CHAR)).makeArray(state))+state.numClasses()));
 318
 319         outstructs.println("#define BYTEARRAYTYPE "+
 320                            (state.getArrayNumber((new TypeDescriptor(TypeDescriptor.BYTE)).makeArray(state))+state.numClasses()));
 321
 322         outstructs.println("#define BYTEARRAYARRAYTYPE "+
 323                            (state.getArrayNumber((new TypeDescriptor(TypeDescriptor.BYTE)).makeArray(state).makeArray(state))+state.numClasses()));
 324
 325         outstructs.println("#define NUMCLASSES "+state.numClasses());
 326         if (state.TASK) {
 327             outstructs.println("#define STARTUPTYPE "+typeutil.getClass(TypeUtil.StartupClass).getId());
 328             outstructs.println("#define TAGTYPE "+typeutil.getClass(TypeUtil.TagClass).getId());
 329             outstructs.println("#define TAGARRAYTYPE "+
 330                                (state.getArrayNumber(new TypeDescriptor(typeutil.getClass(TypeUtil.TagClass)).makeArray(state))+state.numClasses()));
 331         }
 332     }
 333
 334     private void outputClassDeclarations(PrintWriter outclassdefs) {
 335         if (state.THREAD)
 336             outclassdefs.println("#include <pthread.h>");
 337         outclassdefs.println("struct "+arraytype+";");
 338         /* Start by declaring all structs */
 339         Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
 340         while(it.hasNext()) {
 341             ClassDescriptor cn=(ClassDescriptor)it.next();
 342             outclassdefs.println("struct "+cn.getSafeSymbol()+";");
 343         }
 344         outclassdefs.println("");
 345         //Print out definition for array type
 346         outclassdefs.println("struct "+arraytype+" {");
 347         outclassdefs.println("  int type;");
 348         if (state.THREAD) {
 349             outclassdefs.println("  pthread_t tid;");
 350             outclassdefs.println("  void * lockentry;");
 351             outclassdefs.println("  int lockcount;");
 352         }
 353         if (state.TASK) {
 354             outclassdefs.println("  int flag;");
 355             outclassdefs.println("  void * flagptr;");
 356             if(state.OPTIONAL) outclassdefs.println("  int failedstatus;");
 357         }
 358         printClassStruct(typeutil.getClass(TypeUtil.ObjectClass), outclassdefs);
 359
 360         outclassdefs.println("  int ___length___;");
 361         outclassdefs.println("};\n");
 362         outclassdefs.println("extern int classsize[];");
 363         outclassdefs.println("extern int hasflags[];");
 364         outclassdefs.println("extern int * pointerarray[];");
 365         outclassdefs.println("extern int supertypes[];");
 366     }
 367
 368     /** Prints out definitions for generic task structures */
 369
 370     private void outputTaskTypes(PrintWriter outtask) {
 371         outtask.println("#ifndef _TASK_H");
 372         outtask.println("#define _TASK_H");
 373         outtask.println("struct parameterdescriptor {");
 374         outtask.println("int type;");
 375         outtask.println("int numberterms;");
 376         outtask.println("int *intarray;");
 377         outtask.println("void * queue;");
 378         outtask.println("int numbertags;");
 379         outtask.println("int *tagarray;");
 380         outtask.println("};");
 381
 382         outtask.println("struct taskdescriptor {");
 383         outtask.println("void * taskptr;");
 384         outtask.println("int numParameters;");
 385         outtask.println("int numTotal;");
 386         outtask.println("struct parameterdescriptor **descriptorarray;");
 387         outtask.println("char * name;");
 388         outtask.println("};");
 389         outtask.println("extern struct taskdescriptor * taskarray[];");
 390         outtask.println("extern numtasks;");
 391         outtask.println("#endif");
 392     }
 393
 394
 395     private void buildRepairStructs(PrintWriter outrepairstructs) {
 396         Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();
 397         while(classit.hasNext()) {
 398             ClassDescriptor cn=(ClassDescriptor)classit.next();
 399             outrepairstructs.println("structure "+cn.getSymbol()+" {");
 400             outrepairstructs.println("  int __type__;");
 401             if (state.TASK) {
 402                 outrepairstructs.println("  int __flag__;");
 403                 outrepairstructs.println("  int __flagptr__;");
 404             }
 405             printRepairStruct(cn, outrepairstructs);
 406             outrepairstructs.println("}\n");
 407         }
 408
 409         for(int i=0;i<state.numArrays();i++) {
 410             TypeDescriptor tdarray=arraytable[i];
 411             TypeDescriptor tdelement=tdarray.dereference();
 412             outrepairstructs.println("structure "+arraytype+"_"+state.getArrayNumber(tdarray)+" {");
 413             outrepairstructs.println("  int __type__;");
 414             printRepairStruct(typeutil.getClass(TypeUtil.ObjectClass), outrepairstructs);
 415             outrepairstructs.println("  int length;");
 416             /*
 417               // Need to add support to repair tool for this
 418               if (tdelement.isClass()||tdelement.isArray())
 419                 outrepairstructs.println("  "+tdelement.getRepairSymbol()+" * elem[this.length];");
 420             else
 421                 outrepairstructs.println("  "+tdelement.getRepairSymbol()+" elem[this.length];");
 422             */
 423             outrepairstructs.println("}\n");
 424         }
 425     }
 426
 427     private void printRepairStruct(ClassDescriptor cn, PrintWriter output) {
 428         ClassDescriptor sp=cn.getSuperDesc();
 429         if (sp!=null)
 430             printRepairStruct(sp, output);
 431
 432         Vector fields=(Vector)fieldorder.get(cn);
 433
 434         for(int i=0;i<fields.size();i++) {
 435             FieldDescriptor fd=(FieldDescriptor)fields.get(i);
 436             if (fd.getType().isArray()) {
 437                 output.println("  "+arraytype+"_"+ state.getArrayNumber(fd.getType()) +" * "+fd.getSymbol()+";");
 438             } else if (fd.getType().isClass())
 439                 output.println("  "+fd.getType().getRepairSymbol()+" * "+fd.getSymbol()+";");
 440             else if (fd.getType().isFloat())
 441                 output.println("  int "+fd.getSymbol()+"; /* really float */");
 442             else
 443                 output.println("  "+fd.getType().getRepairSymbol()+" "+fd.getSymbol()+";");
 444         }
 445     }
 446
 447     /** This method outputs TaskDescriptor information */
 448     void generateTaskDescriptor(PrintWriter output, FlatMethod fm, TaskDescriptor task) {
 449         for (int i=0;i<task.numParameters();i++) {
 450             VarDescriptor param_var=task.getParameter(i);
 451             TypeDescriptor param_type=task.getParamType(i);
 452             FlagExpressionNode param_flag=task.getFlag(param_var);
 453             TagExpressionList param_tag=task.getTag(param_var);
 454
 455             int dnfterms;
 456             if (param_flag==null) {
 457                 output.println("int parameterdnf_"+i+"_"+task.getSafeSymbol()+"[]={");
 458                 output.println("0x0, 0x0 };");
 459                 dnfterms=1;
 460             } else {
 461                 DNFFlag dflag=param_flag.getDNF();
 462                 dnfterms=dflag.size();
 463
 464                 Hashtable flags=(Hashtable)flagorder.get(param_type.getClassDesc());
 465                 output.println("int parameterdnf_"+i+"_"+task.getSafeSymbol()+"[]={");
 466                 for(int j=0;j<dflag.size();j++) {
 467                     if (j!=0)
 468                         output.println(",");
 469                     Vector term=dflag.get(j);
 470                     int andmask=0;
 471                     int checkmask=0;
 472                     for(int k=0;k<term.size();k++) {
 473                         DNFFlagAtom dfa=(DNFFlagAtom)term.get(k);
 474                         FlagDescriptor fd=dfa.getFlag();
 475                         boolean negated=dfa.getNegated();
 476                         int flagid=1<<((Integer)flags.get(fd)).intValue();
 477                         andmask|=flagid;
 478                         if (!negated)
 479                             checkmask|=flagid;
 480                     }
 481                     output.print("0x"+Integer.toHexString(andmask)+", 0x"+Integer.toHexString(checkmask));
 482                 }
 483                 output.println("};");
 484             }
 485
 486             output.println("int parametertag_"+i+"_"+task.getSafeSymbol()+"[]={");
 487             //BUG...added next line to fix, test with any task program
 488             if (param_tag!=null)
 489                 for(int j=0;j<param_tag.numTags();j++) {
 490                     if (j!=0)
 491                         output.println(",");
 492                     /* for each tag we need */
 493                     /* which slot it is */
 494                     /* what type it is */
 495                     TagVarDescriptor tvd=(TagVarDescriptor)task.getParameterTable().get(param_tag.getName(j));
 496                     TempDescriptor tmp=param_tag.getTemp(j);
 497                     int slot=fm.getTagInt(tmp);
 498                     output.println(slot+", "+state.getTagId(tvd.getTag()));
 499                 }
 500             output.println("};");
 501
 502             output.println("struct parameterdescriptor parameter_"+i+"_"+task.getSafeSymbol()+"={");
 503             output.println("/* type */"+param_type.getClassDesc().getId()+",");
 504             output.println("/* number of DNF terms */"+dnfterms+",");
 505             output.println("parameterdnf_"+i+"_"+task.getSafeSymbol()+",");
 506             output.println("0,");
 507             //BUG, added next line to fix and else statement...test
 508             //with any task program
 509             if (param_tag!=null)
 510                 output.println("/* number of tags */"+param_tag.numTags()+",");
 511             else
 512                 output.println("/* number of tags */ 0,");
 513             output.println("parametertag_"+i+"_"+task.getSafeSymbol());
 514             output.println("};");
 515         }
 516
 517
 518         output.println("struct parameterdescriptor * parameterdescriptors_"+task.getSafeSymbol()+"[] = {");
 519         for (int i=0;i<task.numParameters();i++) {
 520             if (i!=0)
 521                 output.println(",");
 522             output.print("&parameter_"+i+"_"+task.getSafeSymbol());
 523         }
 524         output.println("};");
 525
 526         output.println("struct taskdescriptor task_"+task.getSafeSymbol()+"={");
 527         output.println("&"+task.getSafeSymbol()+",");
 528         output.println("/* number of parameters */" +task.numParameters() + ",");
 529         int numtotal=task.numParameters()+fm.numTags();
 530         output.println("/* number total parameters */" +numtotal + ",");
 531         output.println("parameterdescriptors_"+task.getSafeSymbol()+",");
 532         output.println("\""+task.getSymbol()+"\"");
 533         output.println("};");
 534     }
 535
 536
 537     /** The buildVirtualTables method outputs the virtual dispatch
 538      * tables for methods. */
 539
 540     private void buildVirtualTables(PrintWriter outvirtual) {
 541         Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();
 542         while(classit.hasNext()) {
 543             ClassDescriptor cd=(ClassDescriptor)classit.next();
 544             if (virtualcalls.getMethodCount(cd)>maxcount)
 545                 maxcount=virtualcalls.getMethodCount(cd);
 546         }
 547         MethodDescriptor[][] virtualtable=new MethodDescriptor[state.numClasses()+state.numArrays()][maxcount];
 548
 549         /* Fill in virtual table */
 550         classit=state.getClassSymbolTable().getDescriptorsIterator();
 551         while(classit.hasNext()) {
 552             ClassDescriptor cd=(ClassDescriptor)classit.next();
 553             fillinRow(cd, virtualtable, cd.getId());
 554         }
 555
 556         ClassDescriptor objectcd=typeutil.getClass(TypeUtil.ObjectClass);
 557         Iterator arrayit=state.getArrayIterator();
 558         while(arrayit.hasNext()) {
 559             TypeDescriptor td=(TypeDescriptor)arrayit.next();
 560             int id=state.getArrayNumber(td);
 561             fillinRow(objectcd, virtualtable, id+state.numClasses());
 562         }
 563
 564         outvirtual.print("void * virtualtable[]={");
 565         boolean needcomma=false;
 566         for(int i=0;i<state.numClasses()+state.numArrays();i++) {
 567             for(int j=0;j<maxcount;j++) {
 568                 if (needcomma)
 569                     outvirtual.print(", ");
 570                 if (virtualtable[i][j]!=null) {
 571                     MethodDescriptor md=virtualtable[i][j];
 572                     outvirtual.print("& "+md.getClassDesc().getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
 573                 } else {
 574                     outvirtual.print("0");
 575                 }
 576                 needcomma=true;
 577             }
 578             outvirtual.println("");
 579         }
 580         outvirtual.println("};");
 581         outvirtual.close();
 582     }
 583
 584     private void fillinRow(ClassDescriptor cd, MethodDescriptor[][] virtualtable, int rownum) {
 585         /* Get inherited methods */
 586         if (cd.getSuperDesc()!=null)
 587             fillinRow(cd.getSuperDesc(), virtualtable, rownum);
 588         /* Override them with our methods */
 589         for(Iterator it=cd.getMethods();it.hasNext();) {
 590             MethodDescriptor md=(MethodDescriptor)it.next();
 591             if (md.isStatic()||md.getReturnType()==null)
 592                 continue;
 593             int methodnum=virtualcalls.getMethodNumber(md);
 594             virtualtable[rownum][methodnum]=md;
 595         }
 596     }
 597
 598     /** Generate array that contains the sizes of class objects.  The
 599      * object allocation functions in the runtime use this
 600      * information. */
 601
 602     private void generateSizeArray(PrintWriter outclassdefs) {
 603         outclassdefs.print("int classsize[]={");
 604         Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
 605         cdarray=new ClassDescriptor[state.numClasses()];
 606         while(it.hasNext()) {
 607             ClassDescriptor cd=(ClassDescriptor)it.next();
 608             cdarray[cd.getId()]=cd;
 609         }
 610         boolean needcomma=false;
 611         for(int i=0;i<state.numClasses();i++) {
 612             if (needcomma)
 613                 outclassdefs.print(", ");
 614             outclassdefs.print("sizeof(struct "+cdarray[i].getSafeSymbol()+")");
 615             needcomma=true;
 616         }
 617
 618         arraytable=new TypeDescriptor[state.numArrays()];
 619
 620         Iterator arrayit=state.getArrayIterator();
 621         while(arrayit.hasNext()) {
 622             TypeDescriptor td=(TypeDescriptor)arrayit.next();
 623             int id=state.getArrayNumber(td);
 624             arraytable[id]=td;
 625         }
 626
 627         for(int i=0;i<state.numArrays();i++) {
 628             if (needcomma)
 629                 outclassdefs.print(", ");
 630             TypeDescriptor tdelement=arraytable[i].dereference();
 631             if (tdelement.isArray()||tdelement.isClass())
 632                 outclassdefs.print("sizeof(void *)");
 633             else
 634                 outclassdefs.print("sizeof("+tdelement.getSafeSymbol()+")");
 635             needcomma=true;
 636         }
 637
 638         outclassdefs.println("};");
 639     }
 640
 641     /** Constructs params and temp objects for each method or task.
 642      * These objects tell the compiler which temps need to be
 643      * allocated.  */
 644
 645     private void generateTempStructs(FlatMethod fm) {
 646         MethodDescriptor md=fm.getMethod();
 647         TaskDescriptor task=fm.getTask();
 648
 649         ParamsObject objectparams=md!=null?new ParamsObject(md,tag++):new ParamsObject(task, tag++);
 650         if (md!=null)
 651             paramstable.put(md, objectparams);
 652         else
 653             paramstable.put(task, objectparams);
 654
 655         for(int i=0;i<fm.numParameters();i++) {
 656             TempDescriptor temp=fm.getParameter(i);
 657             TypeDescriptor type=temp.getType();
 658             if ((type.isPtr()||type.isArray())&&GENERATEPRECISEGC)
 659                 objectparams.addPtr(temp);
 660             else
 661                 objectparams.addPrim(temp);
 662         }
 663
 664         for(int i=0;i<fm.numTags();i++) {
 665             TempDescriptor temp=fm.getTag(i);
 666             if (GENERATEPRECISEGC)
 667                 objectparams.addPtr(temp);
 668             else
 669                 objectparams.addPrim(temp);
 670         }
 671
 672         TempObject objecttemps=md!=null?new TempObject(objectparams,md,tag++):new TempObject(objectparams, task, tag++);
 673         if (md!=null)
 674             tempstable.put(md, objecttemps);
 675         else
 676             tempstable.put(task, objecttemps);
 677
 678         for(Iterator nodeit=fm.getNodeSet().iterator();nodeit.hasNext();) {
 679             FlatNode fn=(FlatNode)nodeit.next();
 680             TempDescriptor[] writes=fn.writesTemps();
 681             for(int i=0;i<writes.length;i++) {
 682                 TempDescriptor temp=writes[i];
 683                 TypeDescriptor type=temp.getType();
 684                 if ((type.isPtr()||type.isArray())&&GENERATEPRECISEGC)
 685                     objecttemps.addPtr(temp);
 686                 else
 687                     objecttemps.addPrim(temp);
 688             }
 689         }
 690     }
 691
 692     /** This method outputs the following information about classes
 693      * and arrays:
 694      * (1) For classes, what are the locations of pointers.
 695      * (2) For arrays, does the array contain pointers or primitives.
 696      * (3) For classes, does the class contain flags.
 697      */
 698
 699     private void generateLayoutStructs(PrintWriter output) {
 700         Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
 701         while(it.hasNext()) {
 702             ClassDescriptor cn=(ClassDescriptor)it.next();
 703             output.println("int "+cn.getSafeSymbol()+"_pointers[]={");
 704             Iterator allit=cn.getFieldTable().getAllDescriptorsIterator();
 705             int count=0;
 706             while(allit.hasNext()) {
 707                 FieldDescriptor fd=(FieldDescriptor)allit.next();
 708                 TypeDescriptor type=fd.getType();
 709                 if (type.isPtr()||type.isArray())
 710                     count++;
 711             }
 712             output.print(count);
 713             allit=cn.getFieldTable().getAllDescriptorsIterator();
 714             while(allit.hasNext()) {
 715                 FieldDescriptor fd=(FieldDescriptor)allit.next();
 716                 TypeDescriptor type=fd.getType();
 717                 if (type.isPtr()||type.isArray()) {
 718                     output.println(",");
 719                     output.print("((int)&(((struct "+cn.getSafeSymbol() +" *)0)->"+fd.getSafeSymbol()+"))");
 720                 }
 721             }
 722             output.println("};");
 723         }
 724         output.println("int * pointerarray[]={");
 725         boolean needcomma=false;
 726         for(int i=0;i<state.numClasses();i++) {
 727             ClassDescriptor cn=cdarray[i];
 728             if (needcomma)
 729                 output.println(",");
 730             needcomma=true;
 731             output.print(cn.getSafeSymbol()+"_pointers");
 732         }
 733
 734         for(int i=0;i<state.numArrays();i++) {
 735             if (needcomma)
 736                 output.println(", ");
 737             TypeDescriptor tdelement=arraytable[i].dereference();
 738             if (tdelement.isArray()||tdelement.isClass())
 739                 output.print("((int *)1)");
 740             else
 741                 output.print("0");
 742             needcomma=true;
 743         }
 744
 745         output.println("};");
 746         needcomma=false;
 747         output.println("int hasflags[]={");
 748         for(int i=0;i<state.numClasses();i++) {
 749             ClassDescriptor cn=cdarray[i];
 750             if (needcomma)
 751                 output.println(", ");
 752             needcomma=true;
 753             if (cn.hasFlags())
 754                 output.print("1");
 755             else
 756                 output.print("0");
 757         }
 758         output.println("};");
 759     }
 760
 761     /** Print out table to give us supertypes */
 762     private void generateSuperTypeTable(PrintWriter output) {
 763         output.println("int supertypes[]={");
 764         boolean needcomma=false;
 765         for(int i=0;i<state.numClasses();i++) {
 766             ClassDescriptor cn=cdarray[i];
 767             if (needcomma)
 768                 output.println(",");
 769             needcomma=true;
 770             if (cn.getSuperDesc()!=null) {
 771                 ClassDescriptor cdsuper=cn.getSuperDesc();
 772                 output.print(cdsuper.getId());
 773             } else
 774                 output.print("-1");
 775         }
 776         output.println("};");
 777     }
 778
 779     /** Force consistent field ordering between inherited classes. */
 780
 781     private void printClassStruct(ClassDescriptor cn, PrintWriter classdefout) {
 782         ClassDescriptor sp=cn.getSuperDesc();
 783         if (sp!=null)
 784             printClassStruct(sp, classdefout);
 785
 786         if (!fieldorder.containsKey(cn)) {
 787             Vector fields=new Vector();
 788             fieldorder.put(cn,fields);
 789             Iterator fieldit=cn.getFields();
 790             while(fieldit.hasNext()) {
 791                 FieldDescriptor fd=(FieldDescriptor)fieldit.next();
 792                 if (sp==null||!sp.getFieldTable().contains(fd.getSymbol()))
 793                     fields.add(fd);
 794             }
 795         }
 796         Vector fields=(Vector)fieldorder.get(cn);
 797
 798         for(int i=0;i<fields.size();i++) {
 799             FieldDescriptor fd=(FieldDescriptor)fields.get(i);
 800             if (fd.getType().isClass()||fd.getType().isArray())
 801                 classdefout.println("  struct "+fd.getType().getSafeSymbol()+" * "+fd.getSafeSymbol()+";");
 802             else
 803                 classdefout.println("  "+fd.getType().getSafeSymbol()+" "+fd.getSafeSymbol()+";");
 804         }
 805     }
 806
 807
 808     /* Map flags to integers consistently between inherited
 809      * classes. */
 810
 811     private void mapFlags(ClassDescriptor cn) {
 812         ClassDescriptor sp=cn.getSuperDesc();
 813         if (sp!=null)
 814             mapFlags(sp);
 815         int max=0;
 816         if (!flagorder.containsKey(cn)) {
 817             Hashtable flags=new Hashtable();
 818             flagorder.put(cn,flags);
 819             if (sp!=null) {
 820                 Hashtable superflags=(Hashtable)flagorder.get(sp);
 821                 Iterator superflagit=superflags.keySet().iterator();
 822                 while(superflagit.hasNext()) {
 823                     FlagDescriptor fd=(FlagDescriptor)superflagit.next();
 824                     Integer number=(Integer)superflags.get(fd);
 825                     flags.put(fd, number);
 826                     if ((number.intValue()+1)>max)
 827                         max=number.intValue()+1;
 828                 }
 829             }
 830
 831             Iterator flagit=cn.getFlags();
 832             while(flagit.hasNext()) {
 833                 FlagDescriptor fd=(FlagDescriptor)flagit.next();
 834                 if (sp==null||!sp.getFlagTable().contains(fd.getSymbol()))
 835                     flags.put(fd, new Integer(max++));
 836             }
 837         }
 838     }
 839
 840
 841     /** This function outputs (1) structures that parameters are
 842      * passed in (when PRECISE GC is enabled) and (2) function
 843      * prototypes for the methods */
 844
 845     private void generateCallStructs(ClassDescriptor cn, PrintWriter classdefout, PrintWriter output, PrintWriter headersout) {
 846         /* Output class structure */
 847         classdefout.println("struct "+cn.getSafeSymbol()+" {");
 848         classdefout.println("  int type;");
 849         if (state.THREAD) {
 850             classdefout.println("  pthread_t tid;");
 851             classdefout.println("  void * lockentry;");
 852             classdefout.println("  int lockcount;");
 853         }
 854
 855         if (state.TASK) {
 856             classdefout.println("  int flag;");
 857             classdefout.println("  void * flagptr;");
 858             if (state.OPTIONAL) classdefout.println("  int failedstatus;");
 859         }
 860         printClassStruct(cn, classdefout);
 861         classdefout.println("};\n");
 862
 863         /* Cycle through methods */
 864         Iterator methodit=cn.getMethods();
 865         while(methodit.hasNext()) {
 866             /* Classify parameters */
 867             MethodDescriptor md=(MethodDescriptor)methodit.next();
 868             FlatMethod fm=state.getMethodFlat(md);
 869             generateTempStructs(fm);
 870
 871             ParamsObject objectparams=(ParamsObject) paramstable.get(md);
 872             TempObject objecttemps=(TempObject) tempstable.get(md);
 873
 874             /* Output parameter structure */
 875             if (GENERATEPRECISEGC) {
 876                 output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params {");
 877                 output.println("  int size;");
 878                 output.println("  void * next;");
 879                 for(int i=0;i<objectparams.numPointers();i++) {
 880                     TempDescriptor temp=objectparams.getPointer(i);
 881                     output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
 882                 }
 883                 output.println("};\n");
 884             }
 885
 886             /* Output temp structure */
 887             if (GENERATEPRECISEGC) {
 888                 output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals {");
 889                 output.println("  int size;");
 890                 output.println("  void * next;");
 891                 for(int i=0;i<objecttemps.numPointers();i++) {
 892                     TempDescriptor temp=objecttemps.getPointer(i);
 893                     if (temp.getType().isNull())
 894                         output.println("  void * "+temp.getSafeSymbol()+";");
 895                     else
 896                         output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
 897                 }
 898                 output.println("};\n");
 899             }
 900
 901             /* Output method declaration */
 902             if (md.getReturnType()!=null) {
 903                 if (md.getReturnType().isClass()||md.getReturnType().isArray())
 904                     headersout.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
 905                 else
 906                     headersout.print(md.getReturnType().getSafeSymbol()+" ");
 907             } else
 908                 //catch the constructor case
 909                 headersout.print("void ");
 910             headersout.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(");
 911
 912             boolean printcomma=false;
 913             if (GENERATEPRECISEGC) {
 914                 headersout.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
 915                 printcomma=true;
 916             }
 917
 918             //output parameter list
 919             for(int i=0;i<objectparams.numPrimitives();i++) {
 920                 TempDescriptor temp=objectparams.getPrimitive(i);
 921                 if (printcomma)
 922                     headersout.print(", ");
 923                 printcomma=true;
 924                 if (temp.getType().isClass()||temp.getType().isArray())
 925                     headersout.print("struct " + temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol());
 926                 else
 927                     headersout.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
 928             }
 929             headersout.println(");\n");
 930         }
 931     }
 932
 933
 934     /** This function outputs (1) structures that parameters are
 935      * passed in (when PRECISE GC is enabled) and (2) function
 936      * prototypes for the tasks */
 937
 938     private void generateTaskStructs(PrintWriter output, PrintWriter headersout) {
 939         /* Cycle through tasks */
 940         Iterator taskit=state.getTaskSymbolTable().getDescriptorsIterator();
 941
 942         while(taskit.hasNext()) {
 943             /* Classify parameters */
 944             TaskDescriptor task=(TaskDescriptor)taskit.next();
 945             FlatMethod fm=state.getMethodFlat(task);
 946             generateTempStructs(fm);
 947
 948             ParamsObject objectparams=(ParamsObject) paramstable.get(task);
 949             TempObject objecttemps=(TempObject) tempstable.get(task);
 950
 951             /* Output parameter structure */
 952             if (GENERATEPRECISEGC) {
 953                 output.println("struct "+task.getSafeSymbol()+"_params {");
 954
 955                 output.println("  int size;");
 956                 output.println("  void * next;");
 957                 for(int i=0;i<objectparams.numPointers();i++) {
 958                     TempDescriptor temp=objectparams.getPointer(i);
 959                     output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
 960                 }
 961
 962                 output.println("};\n");
 963                 if ((objectparams.numPointers()+fm.numTags())>maxtaskparams) {
 964                     maxtaskparams=objectparams.numPointers()+fm.numTags();
 965                 }
 966             }
 967
 968             /* Output temp structure */
 969             if (GENERATEPRECISEGC) {
 970                 output.println("struct "+task.getSafeSymbol()+"_locals {");
 971                 output.println("  int size;");
 972                 output.println("  void * next;");
 973                 for(int i=0;i<objecttemps.numPointers();i++) {
 974                     TempDescriptor temp=objecttemps.getPointer(i);
 975                     if (temp.getType().isNull())
 976                         output.println("  void * "+temp.getSafeSymbol()+";");
 977                     else if(temp.getType().isTag())
 978                         output.println("  struct "+
 979                                        (new TypeDescriptor(typeutil.getClass(TypeUtil.TagClass))).getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
 980                     else
 981                         output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
 982                 }
 983                 output.println("};\n");
 984             }
 985
 986             /* Output task declaration */
 987             headersout.print("void " + task.getSafeSymbol()+"(");
 988
 989             boolean printcomma=false;
 990             if (GENERATEPRECISEGC) {
 991                 headersout.print("struct "+task.getSafeSymbol()+"_params * "+paramsprefix);
 992             } else
 993                 headersout.print("void * parameterarray[]");
 994             headersout.println(");\n");
 995         }
 996     }
 997
 998     /** Generate code for FlatMethod fm. */
 999
1000     private void generateFlatMethod(FlatMethod fm, LocalityBinding lb, PrintWriter output) {
1001         MethodDescriptor md=fm.getMethod();
1002         TaskDescriptor task=fm.getTask();
1003
1004         ClassDescriptor cn=md!=null?md.getClassDesc():null;
1005
1006         ParamsObject objectparams=(ParamsObject)paramstable.get(md!=null?md:task);
1007
1008         generateHeader(fm, lb, md!=null?md:task,output);
1009
1010         TempObject objecttemp=(TempObject) tempstable.get(md!=null?md:task);
1011
1012         if (GENERATEPRECISEGC) {
1013             if (md!=null)
1014                 output.print("   struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals "+localsprefix+"={");
1015             else
1016                 output.print("   struct "+task.getSafeSymbol()+"_locals "+localsprefix+"={");
1017
1018             output.print(objecttemp.numPointers()+",");
1019             output.print(paramsprefix);
1020             for(int j=0;j<objecttemp.numPointers();j++)
1021                 output.print(", NULL");
1022             output.println("};");
1023         }
1024
1025         for(int i=0;i<objecttemp.numPrimitives();i++) {
1026             TempDescriptor td=objecttemp.getPrimitive(i);
1027             TypeDescriptor type=td.getType();
1028             if (type.isNull())
1029                 output.println("   void * "+td.getSafeSymbol()+";");
1030             else if (type.isClass()||type.isArray())
1031                 output.println("   struct "+type.getSafeSymbol()+" * "+td.getSafeSymbol()+";");
1032             else
1033                 output.println("   "+type.getSafeSymbol()+" "+td.getSafeSymbol()+";");
1034         }
1035
1036         /* Assign labels to FlatNode's if necessary.*/
1037
1038         Hashtable<FlatNode, Integer> nodetolabel=assignLabels(fm);
1039
1040         /* Check to see if we need to do a GC if this is a
1041          * multi-threaded program...*/
1042
1043         if (state.THREAD&&GENERATEPRECISEGC) {
1044             output.println("checkcollect(&"+localsprefix+");");
1045         }
1046
1047         /* Do the actual code generation */
1048         FlatNode current_node=null;
1049         HashSet tovisit=new HashSet();
1050         HashSet visited=new HashSet();
1051         tovisit.add(fm.getNext(0));
1052         while(current_node!=null||!tovisit.isEmpty()) {
1053             if (current_node==null) {
1054                 current_node=(FlatNode)tovisit.iterator().next();
1055                 tovisit.remove(current_node);
1056             }
1057             visited.add(current_node);
1058             if (nodetolabel.containsKey(current_node))
1059                 output.println("L"+nodetolabel.get(current_node)+":");
1060             if (state.INSTRUCTIONFAILURE) {
1061                 if (state.THREAD) {
1062                     output.println("if ((++instructioncount)>failurecount) {instructioncount=0;injectinstructionfailure();}");
1063                 }
1064                 else
1065                     output.println("if ((--instructioncount)==0) injectinstructionfailure();");
1066             }
1067             if (current_node.numNext()==0) {
1068                 output.print("   ");
1069                 generateFlatNode(fm, current_node, output);
1070                 if (current_node.kind()!=FKind.FlatReturnNode) {
1071                     output.println("   return;");
1072                 }
1073                 current_node=null;
1074             } else if(current_node.numNext()==1) {
1075                 output.print("   ");
1076                 generateFlatNode(fm, current_node, output);
1077                 FlatNode nextnode=current_node.getNext(0);
1078                 if (visited.contains(nextnode)) {
1079                     output.println("goto L"+nodetolabel.get(nextnode)+";");
1080                     current_node=null;
1081                 } else
1082                     current_node=nextnode;
1083             } else if (current_node.numNext()==2) {
1084                 /* Branch */
1085                 output.print("   ");
1086                 generateFlatCondBranch(fm, (FlatCondBranch)current_node, "L"+nodetolabel.get(current_node.getNext(1)), output);
1087                 if (!visited.contains(current_node.getNext(1)))
1088                     tovisit.add(current_node.getNext(1));
1089                 if (visited.contains(current_node.getNext(0))) {
1090                     output.println("goto L"+nodetolabel.get(current_node.getNext(0))+";");
1091                     current_node=null;
1092                 } else
1093                     current_node=current_node.getNext(0);
1094             } else throw new Error();
1095         }
1096
1097         output.println("}\n\n");
1098     }
1099
1100     /** This method assigns labels to flatnodes */
1101
1102     private Hashtable<FlatNode, Integer> assignLabels(FlatMethod fm) {
1103         HashSet tovisit=new HashSet();
1104         HashSet visited=new HashSet();
1105         int labelindex=0;
1106         Hashtable<FlatNode, Integer> nodetolabel=new Hashtable<FlatNode, Integer>();
1107         tovisit.add(fm.getNext(0));
1108
1109         /*Assign labels first.  A node needs a label if the previous
1110          * node has two exits or this node is a join point. */
1111
1112         while(!tovisit.isEmpty()) {
1113             FlatNode fn=(FlatNode)tovisit.iterator().next();
1114             tovisit.remove(fn);
1115             visited.add(fn);
1116             for(int i=0;i<fn.numNext();i++) {
1117                 FlatNode nn=fn.getNext(i);
1118                 if(i>0) {
1119                     //1) Edge >1 of node
1120                     nodetolabel.put(nn,new Integer(labelindex++));
1121                 }
1122                 if (!visited.contains(nn)&&!tovisit.contains(nn)) {
1123                     tovisit.add(nn);
1124                 } else {
1125                     //2) Join point
1126                     nodetolabel.put(nn,new Integer(labelindex++));
1127                 }
1128             }
1129         }
1130         return nodetolabel;
1131     }
1132
1133
1134     /** Generate text string that corresponds to the Temp td. */
1135     private String generateTemp(FlatMethod fm, TempDescriptor td) {
1136         MethodDescriptor md=fm.getMethod();
1137         TaskDescriptor task=fm.getTask();
1138         TempObject objecttemps=(TempObject) tempstable.get(md!=null?md:task);
1139
1140         if (objecttemps.isLocalPrim(td)||objecttemps.isParamPrim(td)) {
1141             return td.getSafeSymbol();
1142         }
1143
1144         if (objecttemps.isLocalPtr(td)) {
1145             return localsprefix+"."+td.getSafeSymbol();
1146         }
1147
1148         if (objecttemps.isParamPtr(td)) {
1149             return paramsprefix+"->"+td.getSafeSymbol();
1150         }
1151         throw new Error();
1152     }
1153
1154     private void generateFlatNode(FlatMethod fm, FlatNode fn, PrintWriter output) {
1155         switch(fn.kind()) {
1156         case FKind.FlatAtomicEnterNode:
1157             generateFlatAtomicEnterNode(fm, (FlatAtomicEnterNode) fn, output);
1158             return;
1159         case FKind.FlatAtomicExitNode:
1160             generateFlatAtomicExitNode(fm, (FlatAtomicExitNode) fn, output);
1161             return;
1162         case FKind.FlatTagDeclaration:
1163             generateFlatTagDeclaration(fm, (FlatTagDeclaration) fn,output);
1164             return;
1165         case FKind.FlatCall:
1166             generateFlatCall(fm, (FlatCall) fn,output);
1167             return;
1168         case FKind.FlatFieldNode:
1169             generateFlatFieldNode(fm, (FlatFieldNode) fn,output);
1170             return;
1171         case FKind.FlatElementNode:
1172             generateFlatElementNode(fm, (FlatElementNode) fn,output);
1173             return;
1174         case FKind.FlatSetElementNode:
1175             generateFlatSetElementNode(fm, (FlatSetElementNode) fn,output);
1176             return;
1177         case FKind.FlatSetFieldNode:
1178             generateFlatSetFieldNode(fm, (FlatSetFieldNode) fn,output);
1179             return;
1180         case FKind.FlatNew:
1181             generateFlatNew(fm, (FlatNew) fn,output);
1182             return;
1183         case FKind.FlatOpNode:
1184             generateFlatOpNode(fm, (FlatOpNode) fn,output);
1185             return;
1186         case FKind.FlatCastNode:
1187             generateFlatCastNode(fm, (FlatCastNode) fn,output);
1188             return;
1189         case FKind.FlatLiteralNode:
1190             generateFlatLiteralNode(fm, (FlatLiteralNode) fn,output);
1191             return;
1192         case FKind.FlatReturnNode:
1193             generateFlatReturnNode(fm, (FlatReturnNode) fn,output);
1194             return;
1195         case FKind.FlatNop:
1196             output.println("/* nop */");
1197             return;
1198         case FKind.FlatBackEdge:
1199             if (state.THREAD&&GENERATEPRECISEGC) {
1200                 output.println("checkcollect(&"+localsprefix+");");
1201             } else
1202                 output.println("/* nop */");
1203             return;
1204         case FKind.FlatCheckNode:
1205             generateFlatCheckNode(fm, (FlatCheckNode) fn, output);
1206             return;
1207         case FKind.FlatFlagActionNode:
1208             generateFlatFlagActionNode(fm, (FlatFlagActionNode) fn, output);
1209             return;
1210         }
1211         throw new Error();
1212
1213     }
1214
1215     public void generateFlatAtomicEnterNode(FlatMethod fm,  FlatAtomicEnterNode faen, PrintWriter output) {
1216     }
1217
1218     public void generateFlatAtomicExitNode(FlatMethod fm,  FlatAtomicExitNode faen, PrintWriter output) {
1219     }
1220
1221     private void generateFlatCheckNode(FlatMethod fm,  FlatCheckNode fcn, PrintWriter output) {
1222         if (state.CONSCHECK) {
1223             String specname=fcn.getSpec();
1224             String varname="repairstate___";
1225             output.println("{");
1226             output.println("struct "+specname+"_state * "+varname+"=allocate"+specname+"_state();");
1227
1228             TempDescriptor[] temps=fcn.getTemps();
1229             String[] vars=fcn.getVars();
1230             for(int i=0;i<temps.length;i++) {
1231                 output.println(varname+"->"+vars[i]+"=(int)"+generateTemp(fm, temps[i])+";");
1232             }
1233
1234             output.println("if (doanalysis"+specname+"("+varname+")) {");
1235             output.println("free"+specname+"_state("+varname+");");
1236             output.println("} else {");
1237             output.println("/* Bad invariant */");
1238             output.println("free"+specname+"_state("+varname+");");
1239             output.println("abort_task();");
1240             output.println("}");
1241             output.println("}");
1242         }
1243     }
1244
1245     private void generateFlatCall(FlatMethod fm, FlatCall fc, PrintWriter output) {
1246         MethodDescriptor md=fc.getMethod();
1247         ParamsObject objectparams=(ParamsObject) paramstable.get(md);
1248         ClassDescriptor cn=md.getClassDesc();
1249         output.println("{");
1250         if (GENERATEPRECISEGC) {
1251             output.print("       struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
1252
1253             output.print(objectparams.numPointers());
1254             //      output.print(objectparams.getUID());
1255             output.print(", & "+localsprefix);
1256             if (fc.getThis()!=null) {
1257                 output.print(", ");
1258                 output.print("(struct "+md.getThis().getType().getSafeSymbol() +" *)"+ generateTemp(fm,fc.getThis()));
1259             }
1260             for(int i=0;i<fc.numArgs();i++) {
1261                 Descriptor var=md.getParameter(i);
1262                 TempDescriptor paramtemp=(TempDescriptor)temptovar.get(var);
1263                 if (objectparams.isParamPtr(paramtemp)) {
1264                     TempDescriptor targ=fc.getArg(i);
1265                     output.print(", ");
1266                     TypeDescriptor td=md.getParamType(i);
1267                     if (td.isTag())
1268                         output.print("(struct "+(new TypeDescriptor(typeutil.getClass(TypeUtil.TagClass))).getSafeSymbol()  +" *)"+generateTemp(fm, targ));
1269                     else
1270                         output.print("(struct "+md.getParamType(i).getSafeSymbol()  +" *)"+generateTemp(fm, targ));
1271                 }
1272             }
1273             output.println("};");
1274         }
1275         output.print("       ");
1276
1277
1278         if (fc.getReturnTemp()!=null)
1279             output.print(generateTemp(fm,fc.getReturnTemp())+"=");
1280
1281         /* Do we need to do virtual dispatch? */
1282         if (md.isStatic()||md.getReturnType()==null||singleCall(fc.getThis().getType().getClassDesc(),md)) {
1283             output.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
1284         } else {
1285
1286             output.print("((");
1287             if (md.getReturnType().isClass()||md.getReturnType().isArray())
1288                 output.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
1289             else
1290                 output.print(md.getReturnType().getSafeSymbol()+" ");
1291             output.print("(*)(");
1292
1293             boolean printcomma=false;
1294             if (GENERATEPRECISEGC) {
1295                 output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * ");
1296                 printcomma=true;
1297             }
1298
1299
1300             for(int i=0;i<objectparams.numPrimitives();i++) {
1301                 TempDescriptor temp=objectparams.getPrimitive(i);
1302                 if (printcomma)
1303                     output.print(", ");
1304                 printcomma=true;
1305                 if (temp.getType().isClass()||temp.getType().isArray())
1306                     output.print("struct " + temp.getType().getSafeSymbol()+" * ");
1307                 else
1308                     output.print(temp.getType().getSafeSymbol());
1309             }
1310
1311             output.print("))virtualtable["+generateTemp(fm,fc.getThis())+"->type*"+maxcount+"+"+virtualcalls.getMethodNumber(md)+"])");
1312         }
1313
1314         output.print("(");
1315         boolean needcomma=false;
1316         if (GENERATEPRECISEGC) {
1317             output.print("&__parameterlist__");
1318             needcomma=true;
1319         } else {
1320             if (fc.getThis()!=null) {
1321                 TypeDescriptor ptd=md.getThis().getType();
1322                 if (ptd.isClass()&&!ptd.isArray())
1323                     output.print("(struct "+ptd.getSafeSymbol()+" *) ");
1324                 output.print(generateTemp(fm,fc.getThis()));
1325                 needcomma=true;
1326             }
1327         }
1328         for(int i=0;i<fc.numArgs();i++) {
1329             Descriptor var=md.getParameter(i);
1330             TempDescriptor paramtemp=(TempDescriptor)temptovar.get(var);
1331             if (objectparams.isParamPrim(paramtemp)) {
1332                 TempDescriptor targ=fc.getArg(i);
1333                 if (needcomma)
1334                     output.print(", ");
1335
1336                 TypeDescriptor ptd=md.getParamType(i);
1337                 if (ptd.isClass()&&!ptd.isArray())
1338                     output.print("(struct "+ptd.getSafeSymbol()+" *) ");
1339                 output.print(generateTemp(fm, targ));
1340                 needcomma=true;
1341             }
1342         }
1343         output.println(");");
1344         output.println("   }");
1345     }
1346
1347     private boolean singleCall(ClassDescriptor thiscd, MethodDescriptor md) {
1348         Set subclasses=typeutil.getSubClasses(thiscd);
1349         if (subclasses==null)
1350             return true;
1351         for(Iterator classit=subclasses.iterator();classit.hasNext();) {
1352             ClassDescriptor cd=(ClassDescriptor)classit.next();
1353             Set possiblematches=cd.getMethodTable().getSet(md.getSymbol());
1354             for(Iterator matchit=possiblematches.iterator();matchit.hasNext();) {
1355                 MethodDescriptor matchmd=(MethodDescriptor)matchit.next();
1356                 if (md.matches(matchmd))
1357                     return false;
1358             }
1359         }
1360         return true;
1361     }
1362
1363     private void generateFlatFieldNode(FlatMethod fm, FlatFieldNode ffn, PrintWriter output) {
1364         output.println(generateTemp(fm, ffn.getDst())+"="+ generateTemp(fm,ffn.getSrc())+"->"+ ffn.getField().getSafeSymbol()+";");
1365     }
1366
1367     private void generateFlatSetFieldNode(FlatMethod fm, FlatSetFieldNode fsfn, PrintWriter output) {
1368         if (fsfn.getField().getSymbol().equals("length")&&fsfn.getDst().getType().isArray())
1369             throw new Error("Can't set array length");
1370         output.println(generateTemp(fm, fsfn.getDst())+"->"+ fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc())+";");
1371     }
1372
1373     private void generateFlatElementNode(FlatMethod fm, FlatElementNode fen, PrintWriter output) {
1374         TypeDescriptor elementtype=fen.getSrc().getType().dereference();
1375         String type="";
1376
1377         if (elementtype.isArray()||elementtype.isClass())
1378             type="void *";
1379         else
1380             type=elementtype.getSafeSymbol()+" ";
1381
1382         if (fen.needsBoundsCheck()) {
1383             output.println("if ("+generateTemp(fm, fen.getIndex())+"< 0 || "+generateTemp(fm, fen.getIndex())+" >= "+generateTemp(fm,fen.getSrc()) + "->___length___)");
1384             output.println("failedboundschk();");
1385         }
1386
1387         output.println(generateTemp(fm, fen.getDst())+"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc())+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex())+"];");
1388     }
1389
1390     private void generateFlatSetElementNode(FlatMethod fm, FlatSetElementNode fsen, PrintWriter output) {
1391         //TODO: need dynamic check to make sure this assignment is actually legal
1392         //Because Object[] could actually be something more specific...ie. Integer[]
1393
1394         TypeDescriptor elementtype=fsen.getDst().getType().dereference();
1395         String type="";
1396
1397         if (elementtype.isArray()||elementtype.isClass())
1398             type="void *";
1399         else
1400             type=elementtype.getSafeSymbol()+" ";
1401
1402         if (fsen.needsBoundsCheck()) {
1403             output.println("if ("+generateTemp(fm, fsen.getIndex())+"< 0 || "+generateTemp(fm, fsen.getIndex())+" >= "+generateTemp(fm,fsen.getDst()) + "->___length___)");
1404             output.println("failedboundschk();");
1405         }
1406
1407         output.println("(("+type +"*)(((char *) &("+ generateTemp(fm,fsen.getDst())+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex())+"]="+generateTemp(fm,fsen.getSrc())+";");
1408     }
1409
1410     private void generateFlatNew(FlatMethod fm, FlatNew fn, PrintWriter output) {
1411         if (fn.getType().isArray()) {
1412             int arrayid=state.getArrayNumber(fn.getType())+state.numClasses();
1413             if (GENERATEPRECISEGC) {
1414                 output.println(generateTemp(fm,fn.getDst())+"=allocate_newarray(&"+localsprefix+", "+arrayid+", "+generateTemp(fm, fn.getSize())+");");
1415             } else {
1416                 output.println(generateTemp(fm,fn.getDst())+"=allocate_newarray("+arrayid+", "+generateTemp(fm, fn.getSize())+");");
1417             }
1418         } else {
1419             if (GENERATEPRECISEGC) {
1420                 output.println(generateTemp(fm,fn.getDst())+"=allocate_new(&"+localsprefix+", "+fn.getType().getClassDesc().getId()+");");
1421             } else {
1422                 output.println(generateTemp(fm,fn.getDst())+"=allocate_new("+fn.getType().getClassDesc().getId()+");");
1423             }
1424         }
1425     }
1426
1427
1428     private void generateFlatTagDeclaration(FlatMethod fm, FlatTagDeclaration fn, PrintWriter output) {
1429         if (GENERATEPRECISEGC) {
1430             output.println(generateTemp(fm,fn.getDst())+"=allocate_tag(&"+localsprefix+", "+state.getTagId(fn.getType())+");");
1431         } else {
1432             output.println(generateTemp(fm,fn.getDst())+"=allocate_tag("+state.getTagId(fn.getType())+");");
1433         }
1434     }
1435
1436     private void generateFlatOpNode(FlatMethod fm, FlatOpNode fon, PrintWriter output) {
1437
1438         if (fon.getRight()!=null)
1439             output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+fon.getOp().toString()+generateTemp(fm,fon.getRight())+";");
1440         else if (fon.getOp().getOp()==Operation.ASSIGN)
1441             output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+";");
1442         else if (fon.getOp().getOp()==Operation.UNARYPLUS)
1443             output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+";");
1444         else if (fon.getOp().getOp()==Operation.UNARYMINUS)
1445             output.println(generateTemp(fm, fon.getDest())+" = -"+generateTemp(fm, fon.getLeft())+";");
1446         else if (fon.getOp().getOp()==Operation.LOGIC_NOT)
1447             output.println(generateTemp(fm, fon.getDest())+" = !"+generateTemp(fm, fon.getLeft())+";");
1448         else
1449             output.println(generateTemp(fm, fon.getDest())+fon.getOp().toString()+generateTemp(fm, fon.getLeft())+";");
1450     }
1451
1452     private void generateFlatCastNode(FlatMethod fm, FlatCastNode fcn, PrintWriter output) {
1453         /* TODO: Do type check here */
1454         if (fcn.getType().isArray()) {
1455             throw new Error();
1456         } else if (fcn.getType().isClass())
1457             output.println(generateTemp(fm,fcn.getDst())+"=(struct "+fcn.getType().getSafeSymbol()+" *)"+generateTemp(fm,fcn.getSrc())+";");
1458         else
1459             output.println(generateTemp(fm,fcn.getDst())+"=("+fcn.getType().getSafeSymbol()+")"+generateTemp(fm,fcn.getSrc())+";");
1460     }
1461
1462     private void generateFlatLiteralNode(FlatMethod fm, FlatLiteralNode fln, PrintWriter output) {
1463         if (fln.getValue()==null)
1464             output.println(generateTemp(fm, fln.getDst())+"=0;");
1465         else if (fln.getType().getSymbol().equals(TypeUtil.StringClass)) {
1466             if (GENERATEPRECISEGC) {
1467                 output.println(generateTemp(fm, fln.getDst())+"=NewString(&"+localsprefix+", \""+FlatLiteralNode.escapeString((String)fln.getValue())+"\","+((String)fln.getValue()).length()+");");
1468             } else {
1469                 output.println(generateTemp(fm, fln.getDst())+"=NewString(\""+FlatLiteralNode.escapeString((String)fln.getValue())+"\","+((String)fln.getValue()).length()+");");
1470             }
1471         } else if (fln.getType().isBoolean()) {
1472             if (((Boolean)fln.getValue()).booleanValue())
1473                 output.println(generateTemp(fm, fln.getDst())+"=1;");
1474             else
1475                 output.println(generateTemp(fm, fln.getDst())+"=0;");
1476         } else if (fln.getType().isChar()) {
1477             String st=FlatLiteralNode.escapeString(fln.getValue().toString());
1478             output.println(generateTemp(fm, fln.getDst())+"='"+st+"';");
1479         } else
1480             output.println(generateTemp(fm, fln.getDst())+"="+fln.getValue()+";");
1481     }
1482
1483     private void generateFlatReturnNode(FlatMethod fm, FlatReturnNode frn, PrintWriter output) {
1484         if (frn.getReturnTemp()!=null)
1485             output.println("return "+generateTemp(fm, frn.getReturnTemp())+";");
1486         else
1487             output.println("return;");
1488     }
1489
1490     private void generateFlatCondBranch(FlatMethod fm, FlatCondBranch fcb, String label, PrintWriter output) {
1491         output.println("if (!"+generateTemp(fm, fcb.getTest())+") goto "+label+";");
1492     }
1493
1494     /** This method generates header information for the method or
1495      * task referenced by the Descriptor des. */
1496
1497     private void generateHeader(FlatMethod fm, LocalityBinding lb, Descriptor des, PrintWriter output) {
1498         /* Print header */
1499         ParamsObject objectparams=(ParamsObject)paramstable.get(des);
1500         MethodDescriptor md=null;
1501         TaskDescriptor task=null;
1502         if (des instanceof MethodDescriptor)
1503             md=(MethodDescriptor) des;
1504         else
1505             task=(TaskDescriptor) des;
1506
1507         ClassDescriptor cn=md!=null?md.getClassDesc():null;
1508
1509         if (md!=null&&md.getReturnType()!=null) {
1510             if (md.getReturnType().isClass()||md.getReturnType().isArray())
1511                 output.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
1512             else
1513                 output.print(md.getReturnType().getSafeSymbol()+" ");
1514         } else
1515             //catch the constructor case
1516             output.print("void ");
1517         if (md!=null)
1518             output.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(");
1519         else
1520             output.print(task.getSafeSymbol()+"(");
1521
1522         boolean printcomma=false;
1523         if (GENERATEPRECISEGC) {
1524             if (md!=null)
1525                 output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
1526             else
1527                 output.print("struct "+task.getSafeSymbol()+"_params * "+paramsprefix);
1528             printcomma=true;
1529         }
1530
1531         if (md!=null) {
1532             /* Method */
1533             for(int i=0;i<objectparams.numPrimitives();i++) {
1534                 TempDescriptor temp=objectparams.getPrimitive(i);
1535                 if (printcomma)
1536                     output.print(", ");
1537                 printcomma=true;
1538                 if (temp.getType().isClass()||temp.getType().isArray())
1539                     output.print("struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol());
1540                 else
1541                     output.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
1542             }
1543             output.println(") {");
1544         } else if (!GENERATEPRECISEGC) {
1545             /* Imprecise Task */
1546             output.println("void * parameterarray[]) {");
1547             /* Unpack variables */
1548             for(int i=0;i<objectparams.numPrimitives();i++) {
1549                 TempDescriptor temp=objectparams.getPrimitive(i);
1550                 output.println("struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+"=parameterarray["+i+"];");
1551             }
1552             for(int i=0;i<fm.numTags();i++) {
1553                 TempDescriptor temp=fm.getTag(i);
1554                 int offset=i+objectparams.numPrimitives();
1555                 output.println("struct ___TagDescriptor___ * "+temp.getSafeSymbol()+"=parameterarray["+offset+"];");
1556             }
1557
1558             if ((objectparams.numPrimitives()+fm.numTags())>maxtaskparams)
1559                 maxtaskparams=objectparams.numPrimitives()+fm.numTags();
1560         } else output.println(") {");
1561     }
1562
1563     public void generateFlatFlagActionNode(FlatMethod fm, FlatFlagActionNode ffan, PrintWriter output) {
1564         output.println("/* FlatFlagActionNode */");
1565
1566
1567         /* Process tag changes */
1568         Relation tagsettable=new Relation();
1569         Relation tagcleartable=new Relation();
1570
1571         Iterator tagsit=ffan.getTempTagPairs();
1572         while (tagsit.hasNext()) {
1573             TempTagPair ttp=(TempTagPair) tagsit.next();
1574             TempDescriptor objtmp=ttp.getTemp();
1575             TagDescriptor tag=ttp.getTag();
1576             TempDescriptor tagtmp=ttp.getTagTemp();
1577             boolean tagstatus=ffan.getTagChange(ttp);
1578             if (tagstatus) {
1579                 tagsettable.put(objtmp, tagtmp);
1580             } else {
1581                 tagcleartable.put(objtmp, tagtmp);
1582             }
1583         }
1584
1585
1586         Hashtable flagandtable=new Hashtable();
1587         Hashtable flagortable=new Hashtable();
1588
1589         /* Process flag changes */
1590         Iterator flagsit=ffan.getTempFlagPairs();
1591         while(flagsit.hasNext()) {
1592             TempFlagPair tfp=(TempFlagPair)flagsit.next();
1593             TempDescriptor temp=tfp.getTemp();
1594             Hashtable flagtable=(Hashtable)flagorder.get(temp.getType().getClassDesc());
1595             FlagDescriptor flag=tfp.getFlag();
1596             if (flag==null) {
1597                 //Newly allocate objects that don't set any flags case
1598                 if (flagortable.containsKey(temp)) {
1599                     throw new Error();
1600                 }
1601                 int mask=0;
1602                 flagortable.put(temp,new Integer(mask));
1603             } else {
1604                 int flagid=1<<((Integer)flagtable.get(flag)).intValue();
1605                 boolean flagstatus=ffan.getFlagChange(tfp);
1606                 if (flagstatus) {
1607                     int mask=0;
1608                     if (flagortable.containsKey(temp)) {
1609                         mask=((Integer)flagortable.get(temp)).intValue();
1610                     }
1611                     mask|=flagid;
1612                     flagortable.put(temp,new Integer(mask));
1613                 } else {
1614                     int mask=0xFFFFFFFF;
1615                     if (flagandtable.containsKey(temp)) {
1616                         mask=((Integer)flagandtable.get(temp)).intValue();
1617                     }
1618                     mask&=(0xFFFFFFFF^flagid);
1619                     flagandtable.put(temp,new Integer(mask));
1620                 }
1621             }
1622         }
1623
1624
1625         HashSet flagtagset=new HashSet();
1626         flagtagset.addAll(flagortable.keySet());
1627         flagtagset.addAll(flagandtable.keySet());
1628         flagtagset.addAll(tagsettable.keySet());
1629         flagtagset.addAll(tagcleartable.keySet());
1630
1631         Iterator ftit=flagtagset.iterator();
1632         while(ftit.hasNext()) {
1633             TempDescriptor temp=(TempDescriptor)ftit.next();
1634
1635
1636             Set tagtmps=tagcleartable.get(temp);
1637             if (tagtmps!=null) {
1638                 Iterator tagit=tagtmps.iterator();
1639                 while(tagit.hasNext()) {
1640                     TempDescriptor tagtmp=(TempDescriptor)tagit.next();
1641                     if (GENERATEPRECISEGC)
1642                         output.println("tagclear(&"+localsprefix+", (struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
1643                     else
1644                         output.println("tagclear((struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
1645                 }
1646             }
1647
1648             tagtmps=tagsettable.get(temp);
1649             if (tagtmps!=null) {
1650                 Iterator tagit=tagtmps.iterator();
1651                 while(tagit.hasNext()) {
1652                     TempDescriptor tagtmp=(TempDescriptor)tagit.next();
1653                     if (GENERATEPRECISEGC)
1654                         output.println("tagset(&"+localsprefix+", (struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
1655                     else
1656                         output.println("tagset((struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
1657                 }
1658             }
1659
1660             int ormask=0;
1661             int andmask=0xFFFFFFF;
1662
1663             if (flagortable.containsKey(temp))
1664                 ormask=((Integer)flagortable.get(temp)).intValue();
1665             if (flagandtable.containsKey(temp))
1666                 andmask=((Integer)flagandtable.get(temp)).intValue();
1667             if (ffan.getTaskType()==FlatFlagActionNode.NEWOBJECT) {
1668                 output.println("flagorandinit("+generateTemp(fm, temp)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
1669             } else {
1670                 output.println("flagorand("+generateTemp(fm, temp)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
1671             }
1672         }
1673     }
1674
1675      void generateOptionalArrays(PrintWriter output, PrintWriter headers, Hashtable<ClassDescriptor, Hashtable<FlagState, HashSet>> safeexecution, Hashtable optionaltaskdescriptors) {
1676
1677          //GENERATE HEADERS
1678          headers.println("#include \"task.h\"\n\n");
1679
1680
1681
1682          //STRUCT PREDICATEMEMBER
1683          headers.println("struct predicatemember{");
1684          headers.println("int type;");
1685          headers.println("int numdnfterms;");
1686          headers.println("int * flags;");
1687          headers.println("int numtags;");
1688          headers.println("int * tags;\n};\n\n");
1689
1690          //STRUCT EXITFLAGSTATE
1691          headers.println("struct exitflagstate{");
1692          headers.println("int numflags;");
1693          headers.println("int * flags;");
1694          /*
1695            headers.println("int numtags;");
1696            headers.println("int * tags;");
1697          */
1698          headers.println("\n};\n\n");
1699
1700          //STRUCT EXITSTATES
1701          headers.println("struct exitstates{");
1702          headers.println("int numexitflagstates;");
1703          headers.println("struct exitflagstate * exitflagstatearray;\n};\n\n");
1704
1705          //STRUCT OPTIONALTASKDESCRIPTOR
1706          headers.println("struct optionaltaskdescriptor{");
1707          headers.println("struct taskdescriptor * task;");
1708          headers.println("int numpredicatemembers;");
1709          headers.println("struct predicatemember * predicatememberarray;");
1710          headers.println("int numexitstates;");
1711          headers.println("struct existates * exitstatesarray;\n};\n\n");
1712
1713          //STRUCT FSANALYSISWRAPPER
1714          headers.println("struct fsanalysiswrapper{");
1715          headers.println("int numflags;");
1716          headers.println("int * flags;");
1717          headers.println("int numtags;");
1718          headers.println("int * tags;");
1719          headers.println("int numoptionaltaskdescriptors;");
1720          headers.println("struct optionaltaskdescriptor * optionaltaskdescriptorarray;\n};\n\n");
1721
1722          //STRUCT CLASSANALYSISWRAPPER
1723          headers.println("struct classanalyiswrapper{");
1724          headers.println("int type;");
1725          headers.println("int numfsanalysiswrappers;");
1726          headers.println("struct fsanalysiswrapper * fsanalysiswrapperarray;\n};\n\n");
1727
1728          Iterator taskit=state.getTaskSymbolTable().getDescriptorsIterator();
1729          while(taskit.hasNext()) {
1730              TaskDescriptor td=(TaskDescriptor)taskit.next();
1731              headers.println("extern struct taskdescriptor task_"+td.getSafeSymbol()+";");
1732          }
1733
1734
1735
1736          //GENERATE STRUCTS
1737          output.println("#include \"optionalstruct.h\"\n\n");
1738          HashSet processedcd = new HashSet();
1739
1740
1741          Enumeration e = safeexecution.keys();
1742          while (e.hasMoreElements()) {
1743
1744              //get the class
1745              ClassDescriptor cdtemp=(ClassDescriptor)e.nextElement();
1746              Hashtable flaginfo=(Hashtable)flagorder.get(cdtemp);//will be used several times
1747
1748              //Generate the struct of optionals
1749              if((Hashtable)optionaltaskdescriptors.get(cdtemp)==null) System.out.println("Was in cd :"+cdtemp.getSymbol());
1750              Collection c_otd = ((Hashtable)optionaltaskdescriptors.get(cdtemp)).values();
1751              if( !c_otd.isEmpty() ){
1752                  for(Iterator otd_it = c_otd.iterator(); otd_it.hasNext();){
1753                      OptionalTaskDescriptor otd = (OptionalTaskDescriptor)otd_it.next();
1754
1755                      //generate the int arrays for the predicate
1756                      Predicate predicate = otd.predicate;
1757                      int predicateindex = 0;
1758                      //iterate through the classes concerned by the predicate
1759                      Collection c_vard = predicate.vardescriptors.values();
1760                      for(Iterator vard_it = c_vard.iterator(); vard_it.hasNext();){
1761                          VarDescriptor vard = (VarDescriptor)vard_it.next();
1762                          TypeDescriptor typed = vard.getType();
1763
1764                          //generate for flags
1765                          HashSet fen_hashset = predicate.flags.get(vard.getSymbol());
1766                          output.println("int predicateflags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
1767                          int numberterms=0;
1768                          if (fen_hashset!=null){
1769                              for (Iterator fen_it = fen_hashset.iterator(); fen_it.hasNext();){
1770                                  FlagExpressionNode fen = (FlagExpressionNode)fen_it.next();
1771                                  if (fen==null) {
1772                                      //output.println("0x0, 0x0 };");
1773                                      //numberterms+=1;
1774                                  }
1775                                  else {
1776
1777                                      DNFFlag dflag=fen.getDNF();
1778                                      numberterms+=dflag.size();
1779
1780                                      Hashtable flags=(Hashtable)flagorder.get(typed.getClassDesc());
1781
1782                                      for(int j=0;j<dflag.size();j++) {
1783                                          if (j!=0)
1784                                              output.println(",");
1785                                          Vector term=dflag.get(j);
1786                                          int andmask=0;
1787                                          int checkmask=0;
1788                                          for(int k=0;k<term.size();k++) {
1789                                              DNFFlagAtom dfa=(DNFFlagAtom)term.get(k);
1790                                              FlagDescriptor fd=dfa.getFlag();
1791                                              boolean negated=dfa.getNegated();
1792                                              int flagid=1<<((Integer)flags.get(fd)).intValue();
1793                                              andmask|=flagid;
1794                                              if (!negated)
1795                                                  checkmask|=flagid;
1796                                          }
1797                                          output.print("/*andmask*/0x"+Integer.toHexString(andmask)+", /*checkmask*/0x"+Integer.toHexString(checkmask));
1798                                      }
1799                                  }
1800                              }
1801                          }
1802                          output.println("};\n");
1803
1804                          //generate for tags
1805                          TagExpressionList tagel = predicate.tags.get(vard.getSymbol());
1806                          output.println("int predicatetags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
1807                          //BUG...added next line to fix, test with any task program
1808                          int numtags = 0;
1809                          if (tagel!=null){
1810                              for(int j=0;j<tagel.numTags();j++) {
1811                                  if (j!=0)
1812                                      output.println(",");
1813                                  /* for each tag we need */
1814                                  /* which slot it is */
1815                                  /* what type it is */
1816                                  //TagVarDescriptor tvd=(TagVarDescriptor)task.getParameterTable().get(tagel.getName(j));
1817                                  TempDescriptor tmp=tagel.getTemp(j);
1818                                  //got rid of slot
1819                                  output.println("/*tagid*/"+state.getTagId(tmp.getTag()));
1820                              }
1821                              numtags = tagel.numTags();
1822                          }
1823                          output.println("};");
1824
1825                          //store the result into a predicatemember struct
1826                          output.println("struct predicatemember predicatemember_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"={");
1827                          output.println("/*type*/"+typed.getClassDesc().getId()+",");
1828                          output.println("/* number of dnf terms */"+numberterms+",");
1829                          output.println("predicateflags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
1830                          output.println("/* number of tag */"+numtags+",");
1831                          output.println("predicatetags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
1832                          output.println("};\n");
1833                          predicateindex++;
1834                      }
1835
1836
1837                      //generate an array that stores the entire predicate
1838                      output.println("struct predicatemember * predicatememberarray_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
1839                      for( int j = 0; j<predicateindex; j++){
1840                          if( j != predicateindex-1)output.println("&predicatemember_"+j+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
1841                          else output.println("&predicatemember_"+j+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"};\n");
1842                      }
1843
1844                      //generate the struct for possible exitfses
1845                      HashSet<HashSet> exitfses = otd.exitfses;
1846                      int exitindex = 0;
1847                      int nbexit = exitfses.size();
1848                      int fsnumber;
1849
1850                      //iterate through possible exits
1851                      for(Iterator exitfseshash = exitfses.iterator(); exitfseshash.hasNext();){
1852                          HashSet temp_hashset = (HashSet)exitfseshash.next();
1853                          fsnumber = 0 ;
1854
1855                          //iterate through possible FSes corresponding to the exit
1856                          for(Iterator exfses = temp_hashset.iterator(); exfses.hasNext();){
1857                             FlagState fs = (FlagState)exfses.next();
1858                             fsnumber++;
1859                             output.println("int flags"+fsnumber+"_EXIT"+exitindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
1860                             int counterflag = 0;
1861                             for(Iterator flags = fs.getFlags(); flags.hasNext();){
1862                                 FlagDescriptor flagd = (FlagDescriptor)flags.next();
1863                                 int flagid=1<<((Integer)flaginfo.get(flagd)).intValue();
1864                                 if( flags.hasNext() ) output.print("0x"+Integer.toHexString(flagid)+" /*"+Integer.toBinaryString(flagid)+"*/,");
1865                                 else  output.print("0x"+Integer.toHexString(flagid)+" /*"+Integer.toBinaryString(flagid)+"*/");
1866                                 counterflag++;
1867                             }
1868                             output.println("};\n");
1869                             //do the same for tags;
1870                             //maybe not needed because no tag changes tolerated.
1871
1872                             //store the information into a struct
1873                             output.println("struct exitflagstate exitflagstate"+fsnumber+"_EXIT"+exitindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"={");
1874                             output.println("/*number of flags*/"+counterflag+",");
1875                             output.println("flags"+fsnumber+"_EXIT"+exitindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
1876                             output.println("};\n");
1877                          }
1878
1879                          //store fses corresponding to this exit into an array
1880                          output.println("struct exitflagstate * exitflagstatearray"+"_EXIT"+exitindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+" [] = {");
1881                          for( int j = 0; j<fsnumber; j++){
1882                              if( j != fsnumber-1)output.println("&exitflagstate"+(j+1)+"_EXIT"+exitindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"'");
1883                              else output.println("&exitflagstate"+(j+1)+"_EXIT"+exitindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"};\n");
1884                          }
1885
1886                          //store that information in a struct
1887                          output.println("struct exitstates exitstates"+exitindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"={");
1888                          output.println("/*number of exitflagstate*/"+fsnumber+",");
1889                          output.println("exitflagstatearray"+"_EXIT"+exitindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
1890                          output.println("};\n");
1891
1892                          exitindex++;
1893                      }
1894
1895                      //store the information concerning all exits into an array
1896                      output.println("struct exitstates * exitstatesarray_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
1897                      for( int j = 0; j<nbexit; j++){
1898                          if( j != nbexit-1)output.println("&exitstates"+j+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
1899                          else output.println("&exitstates"+j+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"};\n");
1900                      }
1901
1902
1903                      //generate optionaltaskdescriptor that actually includes exit fses, predicate and the task concerned
1904                      output.println("struct optionaltaskdescriptor optionaltaskdescriptor_"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"={");
1905                      output.println("task_"+otd.td.getSafeSymbol()+",");
1906                      output.println("/*number of members */"+predicateindex+",");
1907                      output.println("predicatememberarray_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
1908                      output.println("/*number of exit fses */"+nbexit+",");
1909                      output.println("exitstatearray_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
1910                      output.println("};\n");
1911                  }
1912              }
1913              else continue; // if there is no optionals, there is no need to build the rest of the struct
1914
1915              //get all the possible falgstates reachable by an object
1916              Hashtable hashtbtemp = safeexecution.get(cdtemp);
1917              Enumeration fses = hashtbtemp.keys();
1918              int fscounter = 0;
1919              while(fses.hasMoreElements()){
1920                  FlagState fs = (FlagState)fses.nextElement();
1921                  fscounter++;
1922
1923                  //get the set of OptionalTaskDescriptors corresponding
1924                  HashSet availabletasks = (HashSet)hashtbtemp.get(fs);
1925                  //iterate through the OptionalTaskDescriptors and store the pointers to the optionals struct (see on top) into an array
1926
1927                  output.println("struct optionaltaskdescriptor * optionaltaskdescriptorarray_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"[] = {");
1928                  for(Iterator mos = availabletasks.iterator(); mos.hasNext();){
1929                      OptionalTaskDescriptor mm = (OptionalTaskDescriptor)mos.next();
1930                      if(!mos.hasNext()) output.println("&optionaltaskdescriptor_"+mm.getuid()+"_"+cdtemp.getSafeSymbol()+"};\n");
1931
1932                      else output.println("&optionaltaskdescriptor_"+mm.getuid()+"_"+cdtemp.getSafeSymbol()+",");
1933                  }
1934
1935                  //process flag information (what the flag after failure is) so we know what optionaltaskdescriptors to choose.
1936
1937                  output.println("int flags_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"[]={");
1938                  for(Iterator flags = fs.getFlags(); flags.hasNext();){
1939                      FlagDescriptor flagd = (FlagDescriptor)flags.next();
1940                      int flagid=1<<((Integer)flaginfo.get(flagd)).intValue();
1941                      if( flags.hasNext() ) output.print("0x"+Integer.toHexString(flagid)+" /*"+Integer.toBinaryString(flagid)+"*/,");
1942                      else  output.print("0x"+Integer.toHexString(flagid)+" /*"+Integer.toBinaryString(flagid)+"*/");
1943
1944                  }
1945                  //process tag information
1946
1947                  int tagcounter = 0;
1948                  //TagExpressionList tagel = fs.getTags();
1949                  //output.println("int predicatetags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
1950                  //BUG...added next line to fix, test with any task program
1951
1952                  //if (tagel!=null){
1953                  //    for(int j=0;j<tagel.numTags();j++) {
1954                  //      if (j!=0)
1955                  //          output.println(",");
1956                  //      TempDescriptor tmp=tagel.getTemp(j);
1957                  //      output.println("/*tagid*/"+state.getTagId(tmp.getTag()));
1958                  //   }
1959                  //  numtags = tagel.numTags();
1960                  //}
1961                  //output.println("};");
1962
1963
1964                  //Store the result in fsanalysiswrapper
1965                  output.println("};\n");
1966                  output.println("struct fsanalysiswrapper fsanalysiswrapper_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"={");
1967                  output.println("/* number of flags*/"+fs.numFlags()+",");
1968                  output.println("flags_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+",");
1969                  output.println("/* number of tags*/"+tagcounter+",");
1970                  output.println("tags_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+",");
1971                  output.println("/* number of optionaltaskdescriptors */"+availabletasks.size()+",");
1972                  output.println("optionaltaskdescriptorarray_FS"+fscounter+"_"+cdtemp.getSafeSymbol());
1973                  output.println("};\n");
1974
1975              }
1976
1977              //Build the array of fsanalysiswrappers
1978              output.println("struct fsanalysiswrapper * fsanalysiswrapperarray_"+cdtemp.getSafeSymbol()+"[] = {");
1979              for(int i = 0; i<fscounter; i++){
1980                  if(i==fscounter-1) output.println("&fsanalysiswrapper_FS"+(i+1)+"_"+cdtemp.getSafeSymbol()+"};\n");
1981
1982                      else output.println("&fsanalysiswrapper_FS"+(i+1)+"_"+cdtemp.getSafeSymbol()+",");
1983              }
1984
1985              //Build the classanalysiswrapper referring to the previous array
1986              output.println("struct classanalysiswrapper classanalysiswrapper_"+cdtemp.getSafeSymbol()+"={");
1987              output.println("/*type*/"+cdtemp.getId()+",");
1988              output.println("/* number of fsanalysiswrappers */"+fscounter+",");
1989              output.println("fsanalysiswrapperarray_"+cdtemp.getSafeSymbol()+"};\n");
1990              fscounter = 0;
1991              processedcd.add(cdtemp);
1992          }
1993
1994          //build an array containing every classes for which code has been build
1995          output.println("struct classanalysiswrapper * classanalysiswrapperarray[]={");
1996          for(Iterator classit = processedcd.iterator(); classit.hasNext();){
1997              ClassDescriptor cdtemp=(ClassDescriptor)classit.next();
1998              if(!classit.hasNext()) output.println("&classanalysiswrapper_"+cdtemp.getSafeSymbol()+"};\n");
1999              else output.println("&classanalysiswrapper_"+cdtemp.getSafeSymbol()+",");
2000          }
2001          output.println("int numclasses = "+processedcd.size()+";");
2002
2003      }
2004
2005 }
2006
2007
2008
2009
2010
2011