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