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