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.*;
   6 import java.util.*;
   7 import java.io.*;
   8
   9 public class BuildCode {
  10     State state;
  11     Hashtable temptovar;
  12     Hashtable paramstable;
  13     Hashtable tempstable;
  14     Hashtable fieldorder;
  15     Hashtable flagorder;
  16     int tag=0;
  17     String localsprefix="___locals___";
  18     String paramsprefix="___params___";
  19     public static boolean GENERATEPRECISEGC=false;
  20     public static String PREFIX="";
  21     public static String arraytype="ArrayObject";
  22     Virtual virtualcalls;
  23     TypeUtil typeutil;
  24     private int maxtaskparams=0;
  25     ClassDescriptor[] cdarray;
  26     TypeDescriptor[] arraytable;
  27
  28     public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil) {
  29         state=st;
  30         this.temptovar=temptovar;
  31         paramstable=new Hashtable();
  32         tempstable=new Hashtable();
  33         fieldorder=new Hashtable();
  34         flagorder=new Hashtable();
  35         this.typeutil=typeutil;
  36         virtualcalls=new Virtual(state);
  37     }
  38
  39     /** The buildCode method outputs C code for all the methods.  The Flat
  40      * versions of the methods must already be generated and stored in
  41      * the State object. */
  42
  43     public void buildCode() {
  44         /* Create output streams to write to */
  45         PrintWriter outclassdefs=null;
  46         PrintWriter outstructs=null;
  47         PrintWriter outrepairstructs=null;
  48         PrintWriter outmethodheader=null;
  49         PrintWriter outmethod=null;
  50         PrintWriter outvirtual=null;
  51         PrintWriter outtask=null;
  52         PrintWriter outtaskdefs=null;
  53
  54         try {
  55             OutputStream str=new FileOutputStream(PREFIX+"structdefs.h");
  56             outstructs=new java.io.PrintWriter(str, true);
  57             str=new FileOutputStream(PREFIX+"methodheaders.h");
  58             outmethodheader=new java.io.PrintWriter(str, true);
  59             str=new FileOutputStream(PREFIX+"classdefs.h");
  60             outclassdefs=new java.io.PrintWriter(str, true);
  61             str=new FileOutputStream(PREFIX+"methods.c");
  62             outmethod=new java.io.PrintWriter(str, true);
  63             str=new FileOutputStream(PREFIX+"virtualtable.h");
  64             outvirtual=new java.io.PrintWriter(str, true);
  65             if (state.TASK) {
  66                 str=new FileOutputStream(PREFIX+"task.h");
  67                 outtask=new java.io.PrintWriter(str, true);
  68                 str=new FileOutputStream(PREFIX+"taskdefs.c");
  69                 outtaskdefs=new java.io.PrintWriter(str, true);
  70             }
  71             if (state.structfile!=null) {
  72                 str=new FileOutputStream(PREFIX+state.structfile+".struct");
  73                 outrepairstructs=new java.io.PrintWriter(str, true);
  74             }
  75         } catch (Exception e) {
  76             e.printStackTrace();
  77             System.exit(-1);
  78         }
  79
  80         /* Build the virtual dispatch tables */
  81         buildVirtualTables(outvirtual);
  82
  83
  84         /* Output includes */
  85
  86         outmethodheader.println("#ifndef METHODHEADERS_H");
  87         outmethodheader.println("#define METHODHEADERS_H");
  88         outmethodheader.println("#include \"structdefs.h\"");
  89
  90         outstructs.println("#ifndef STRUCTDEFS_H");
  91         outstructs.println("#define STRUCTDEFS_H");
  92         outstructs.println("#include \"classdefs.h\"");
  93
  94
  95
  96         /* Output types for short array and string */
  97         outstructs.println("#define STRINGARRAYTYPE "+
  98                            (state.getArrayNumber(
  99                                                  (new TypeDescriptor(typeutil.getClass(TypeUtil.StringClass))).makeArray(state))+state.numClasses()));
 100
 101         outstructs.println("#define STRINGTYPE "+typeutil.getClass(TypeUtil.StringClass).getId());
 102         outstructs.println("#define CHARARRAYTYPE "+
 103                            (state.getArrayNumber((new TypeDescriptor(TypeDescriptor.CHAR)).makeArray(state))+state.numClasses()));
 104         outstructs.println("#define NUMCLASSES "+state.numClasses());
 105         if (state.TASK)
 106             outstructs.println("#define STARTUPTYPE "+typeutil.getClass(TypeUtil.StartupClass).getId());
 107
 108         // Output the C class declarations
 109         // These could mutually reference each other
 110         if (state.THREAD)
 111             outclassdefs.println("#include <pthread.h>");
 112
 113         outclassdefs.println("struct "+arraytype+";");
 114
 115         Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
 116         while(it.hasNext()) {
 117             ClassDescriptor cn=(ClassDescriptor)it.next();
 118             outclassdefs.println("struct "+cn.getSafeSymbol()+";");
 119         }
 120         outclassdefs.println("");
 121         {
 122             //Print out definition for array type
 123             outclassdefs.println("struct "+arraytype+" {");
 124             outclassdefs.println("  int type;");
 125             if (state.THREAD) {
 126                 outclassdefs.println("  pthread_t tid;");
 127                 outclassdefs.println("  void * lockentry;");
 128                 outclassdefs.println("  int lockcount;");
 129             }
 130
 131             if (state.TASK) {
 132                 outclassdefs.println("  int flag;");
 133                 outclassdefs.println("  void * flagptr;");
 134             }
 135             printClassStruct(typeutil.getClass(TypeUtil.ObjectClass), outclassdefs);
 136             outclassdefs.println("  int ___length___;");
 137             outclassdefs.println("};\n");
 138
 139             if (state.TASK) {
 140             //Print out definitions for task types
 141                 outtask.println("struct parameterdescriptor {");
 142                 outtask.println("int type;");
 143                 outtask.println("int numberterms;");
 144                 outtask.println("int *intarray;");
 145                 outtask.println("void * queue;");
 146                 outtask.println("};");
 147
 148                 outtask.println("struct taskdescriptor {");
 149                 outtask.println("void * taskptr;");
 150                 outtask.println("int numParameters;");
 151                 outtask.println("struct parameterdescriptor **descriptorarray;");
 152                 outtask.println("char * name;");
 153                 outtask.println("};");
 154                 outtask.println("extern struct taskdescriptor * taskarray[];");
 155                 outtask.println("extern numtasks;");
 156             }
 157         }
 158
 159         // Output function prototypes and structures for parameters
 160         it=state.getClassSymbolTable().getDescriptorsIterator();
 161         while(it.hasNext()) {
 162             ClassDescriptor cn=(ClassDescriptor)it.next();
 163             generateCallStructs(cn, outclassdefs, outstructs, outmethodheader);
 164         }
 165
 166
 167         if (state.TASK) {
 168             /* Map flags to integers */
 169             it=state.getClassSymbolTable().getDescriptorsIterator();
 170             while(it.hasNext()) {
 171                 ClassDescriptor cn=(ClassDescriptor)it.next();
 172                 mapFlags(cn);
 173             }
 174             /* Generate Tasks */
 175             generateTaskStructs(outstructs, outmethodheader);
 176         }
 177
 178         outmethodheader.println("#endif");
 179
 180         outmethodheader.close();
 181
 182         /* Build the actual methods */
 183         outmethod.println("#include \"methodheaders.h\"");
 184         outmethod.println("#include \"virtualtable.h\"");
 185         outmethod.println("#include <runtime.h>");
 186         if (state.THREAD)
 187             outmethod.println("#include <thread.h>");
 188         if (state.main!=null) {
 189             outmethod.println("#include <string.h>");
 190         }
 191
 192         if (state.CONSCHECK) {
 193             outmethod.println("#include \"checkers.h\"");
 194         }
 195         outclassdefs.println("extern int classsize[];");
 196         outclassdefs.println("extern int hasflags[];");
 197         outclassdefs.println("extern int * pointerarray[];");
 198         outclassdefs.println("extern int supertypes[];");
 199
 200         //Store the sizes of classes & array elements
 201         generateSizeArray(outmethod);
 202
 203         //Store table of supertypes
 204         generateSuperTypeTable(outmethod);
 205
 206         //Store the layout of classes
 207         generateLayoutStructs(outmethod);
 208
 209         /* Generate code for methods */
 210         Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();
 211         while(classit.hasNext()) {
 212             ClassDescriptor cn=(ClassDescriptor)classit.next();
 213             Iterator methodit=cn.getMethods();
 214             while(methodit.hasNext()) {
 215                 /* Classify parameters */
 216                 MethodDescriptor md=(MethodDescriptor)methodit.next();
 217                 FlatMethod fm=state.getMethodFlat(md);
 218                 if (!md.getModifiers().isNative())
 219                     generateFlatMethod(fm,outmethod);
 220             }
 221         }
 222
 223         if (state.TASK) {
 224             /* Compile task based program */
 225             outtaskdefs.println("#include \"task.h\"");
 226             outtaskdefs.println("#include \"methodheaders.h\"");
 227             Iterator taskit=state.getTaskSymbolTable().getDescriptorsIterator();
 228             while(taskit.hasNext()) {
 229                 TaskDescriptor td=(TaskDescriptor)taskit.next();
 230                 FlatMethod fm=state.getMethodFlat(td);
 231                 generateFlatMethod(fm, outmethod);
 232                 generateTaskDescriptor(outtaskdefs, td);
 233             }
 234
 235             {
 236                 //Output task descriptors
 237                 taskit=state.getTaskSymbolTable().getDescriptorsIterator();
 238                 outtaskdefs.println("struct taskdescriptor * taskarray[]= {");
 239                 boolean first=true;
 240                 while(taskit.hasNext()) {
 241                     TaskDescriptor td=(TaskDescriptor)taskit.next();
 242                     if (first)
 243                         first=false;
 244                     else
 245                         outtaskdefs.println(",");
 246                     outtaskdefs.print("&task_"+td.getSafeSymbol());
 247                 }
 248                 outtaskdefs.println("};");
 249             }
 250
 251             outtaskdefs.println("int numtasks="+state.getTaskSymbolTable().getValueSet().size()+";");
 252
 253         } else if (state.main!=null) {
 254             /* Generate main method */
 255             outmethod.println("int main(int argc, const char *argv[]) {");
 256             outmethod.println("  int i;");
 257             if (GENERATEPRECISEGC) {
 258                 outmethod.println("  struct ArrayObject * stringarray=allocate_newarray(NULL, STRINGARRAYTYPE, argc-1);");
 259             } else {
 260                 outmethod.println("  struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc-1);");
 261             }
 262             if (state.THREAD) {
 263                 outmethod.println("initializethreads();");
 264             }
 265             outmethod.println("  for(i=1;i<argc;i++) {");
 266             outmethod.println("    int length=strlen(argv[i]);");
 267             if (GENERATEPRECISEGC) {
 268                 outmethod.println("    struct ___String___ *newstring=NewString(NULL, argv[i], length);");
 269             } else {
 270                 outmethod.println("    struct ___String___ *newstring=NewString(argv[i], length);");
 271             }
 272             outmethod.println("    ((void **)(((char *)& stringarray->___length___)+sizeof(int)))[i-1]=newstring;");
 273             outmethod.println("  }");
 274
 275
 276             ClassDescriptor cd=typeutil.getClass(state.main);
 277             Set mainset=cd.getMethodTable().getSet("main");
 278             for(Iterator mainit=mainset.iterator();mainit.hasNext();) {
 279                 MethodDescriptor md=(MethodDescriptor)mainit.next();
 280                 if (md.numParameters()!=1)
 281                     continue;
 282                 if (md.getParameter(0).getType().getArrayCount()!=1)
 283                     continue;
 284                 if (!md.getParameter(0).getType().getSymbol().equals("String"))
 285                     continue;
 286
 287                 if (!md.getModifiers().isStatic())
 288                     throw new Error("Error: Non static main");
 289                 outmethod.println("   {");
 290                 if (GENERATEPRECISEGC) {
 291                     outmethod.print("       struct "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
 292                     outmethod.println("1, NULL,"+"stringarray};");
 293                     outmethod.println("     "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(& __parameterlist__);");
 294                 } else
 295                     outmethod.println("     "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(stringarray);");
 296                 outmethod.println("   }");
 297                 break;
 298             }
 299             if (state.THREAD) {
 300                 outmethod.println("pthread_mutex_lock(&gclistlock);");
 301                 outmethod.println("threadcount--;");
 302                 outmethod.println("pthread_cond_signal(&gccond);");
 303                 outmethod.println("pthread_mutex_unlock(&gclistlock);");
 304                 outmethod.println("pthread_exit(NULL);");
 305             }
 306             outmethod.println("}");
 307         }
 308         if (state.TASK)
 309             outstructs.println("#define MAXTASKPARAMS "+maxtaskparams);
 310
 311
 312         /* Output structure definitions for repair tool */
 313         if (state.structfile!=null) {
 314             buildRepairStructs(outrepairstructs);
 315             outrepairstructs.close();
 316         }
 317         outstructs.println("#endif");
 318
 319         outstructs.close();
 320         outmethod.close();
 321     }
 322
 323     private int maxcount=0;
 324
 325     private void buildRepairStructs(PrintWriter outrepairstructs) {
 326         Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();
 327         while(classit.hasNext()) {
 328             ClassDescriptor cn=(ClassDescriptor)classit.next();
 329             outrepairstructs.println("structure "+cn.getSymbol()+" {");
 330             outrepairstructs.println("  int __type__;");
 331             if (state.TASK) {
 332                 outrepairstructs.println("  int __flag__;");
 333                 outrepairstructs.println("  int __flagptr__;");
 334             }
 335             printRepairStruct(cn, outrepairstructs);
 336             outrepairstructs.println("}\n");
 337         }
 338
 339         for(int i=0;i<state.numArrays();i++) {
 340             TypeDescriptor tdarray=arraytable[i];
 341             TypeDescriptor tdelement=tdarray.dereference();
 342             outrepairstructs.println("structure "+arraytype+"_"+state.getArrayNumber(tdarray)+" {");
 343             outrepairstructs.println("  int __type__;");
 344             printRepairStruct(typeutil.getClass(TypeUtil.ObjectClass), outrepairstructs);
 345             outrepairstructs.println("  int length;");
 346             /*
 347               // Need to add support to repair tool for this
 348               if (tdelement.isClass()||tdelement.isArray())
 349                 outrepairstructs.println("  "+tdelement.getRepairSymbol()+" * elem[this.length];");
 350             else
 351                 outrepairstructs.println("  "+tdelement.getRepairSymbol()+" elem[this.length];");
 352             */
 353             outrepairstructs.println("}\n");
 354         }
 355
 356     }
 357
 358     private void printRepairStruct(ClassDescriptor cn, PrintWriter output) {
 359         ClassDescriptor sp=cn.getSuperDesc();
 360         if (sp!=null)
 361             printRepairStruct(sp, output);
 362
 363         Vector fields=(Vector)fieldorder.get(cn);
 364
 365         for(int i=0;i<fields.size();i++) {
 366             FieldDescriptor fd=(FieldDescriptor)fields.get(i);
 367             if (fd.getType().isArray()) {
 368                 output.println("  "+arraytype+"_"+ state.getArrayNumber(fd.getType()) +" * "+fd.getSymbol()+";");
 369             } else if (fd.getType().isClass())
 370                 output.println("  "+fd.getType().getRepairSymbol()+" * "+fd.getSymbol()+";");
 371             else if (fd.getType().isFloat())
 372                 output.println("  int "+fd.getSymbol()+"; /* really float */");
 373             else
 374                 output.println("  "+fd.getType().getRepairSymbol()+" "+fd.getSymbol()+";");
 375         }
 376     }
 377
 378     /** This method outputs TaskDescriptor information */
 379     void generateTaskDescriptor(PrintWriter output, TaskDescriptor task) {
 380         for (int i=0;i<task.numParameters();i++) {
 381             VarDescriptor param_var=task.getParameter(i);
 382             TypeDescriptor param_type=task.getParamType(i);
 383             FlagExpressionNode param_flag=task.getFlag(param_var);
 384             DNFFlag dflag=param_flag.getDNF();
 385
 386             Hashtable flags=(Hashtable)flagorder.get(param_type.getClassDesc());
 387
 388             output.println("int parameterdnf_"+i+"_"+task.getSafeSymbol()+"[]={");
 389             for(int j=0;j<dflag.size();j++) {
 390                 if (j!=0)
 391                     output.println(",");
 392                 Vector term=dflag.get(j);
 393                 int andmask=0;
 394                 int checkmask=0;
 395                 for(int k=0;k<term.size();k++) {
 396                     DNFFlagAtom dfa=(DNFFlagAtom)term.get(k);
 397                     FlagDescriptor fd=dfa.getFlag();
 398                     boolean negated=dfa.getNegated();
 399                     int flagid=1<<((Integer)flags.get(fd)).intValue();
 400                     andmask|=flagid;
 401                     if (!negated)
 402                         checkmask|=flagid;
 403                 }
 404                 output.print("0x"+Integer.toHexString(andmask)+", 0x"+Integer.toHexString(checkmask));
 405             }
 406             output.println("};");
 407
 408             output.println("struct parameterdescriptor parameter_"+i+"_"+task.getSafeSymbol()+"={");
 409             output.println("/* type */"+param_type.getClassDesc().getId()+",");
 410             output.println("/* number of DNF terms */"+dflag.size()+",");
 411             output.println("parameterdnf_"+i+"_"+task.getSafeSymbol()+",");
 412             output.println("0");
 413             output.println("};");
 414         }
 415
 416
 417         output.println("struct parameterdescriptor * parameterdescriptors_"+task.getSafeSymbol()+"[] = {");
 418         for (int i=0;i<task.numParameters();i++) {
 419             if (i!=0)
 420                 output.println(",");
 421             output.print("&parameter_"+i+"_"+task.getSafeSymbol());
 422         }
 423         output.println("};");
 424
 425         output.println("struct taskdescriptor task_"+task.getSafeSymbol()+"={");
 426         output.println("&"+task.getSafeSymbol()+",");
 427         output.println("/* number of parameters */" +task.numParameters() + ",");
 428         output.println("parameterdescriptors_"+task.getSafeSymbol()+",");
 429         output.println("\""+task.getSymbol()+"\"");
 430         output.println("};");
 431     }
 432
 433
 434     /** The buildVirtualTables method outputs the virtual dispatch
 435      * tables for methods. */
 436
 437     private void buildVirtualTables(PrintWriter outvirtual) {
 438         Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();
 439         while(classit.hasNext()) {
 440             ClassDescriptor cd=(ClassDescriptor)classit.next();
 441             if (virtualcalls.getMethodCount(cd)>maxcount)
 442                 maxcount=virtualcalls.getMethodCount(cd);
 443         }
 444         MethodDescriptor[][] virtualtable=new MethodDescriptor[state.numClasses()+state.numArrays()][maxcount];
 445
 446         /* Fill in virtual table */
 447         classit=state.getClassSymbolTable().getDescriptorsIterator();
 448         while(classit.hasNext()) {
 449             ClassDescriptor cd=(ClassDescriptor)classit.next();
 450             fillinRow(cd, virtualtable, cd.getId());
 451         }
 452
 453         ClassDescriptor objectcd=typeutil.getClass(TypeUtil.ObjectClass);
 454         Iterator arrayit=state.getArrayIterator();
 455         while(arrayit.hasNext()) {
 456             TypeDescriptor td=(TypeDescriptor)arrayit.next();
 457             int id=state.getArrayNumber(td);
 458             fillinRow(objectcd, virtualtable, id+state.numClasses());
 459         }
 460
 461         outvirtual.print("void * virtualtable[]={");
 462         boolean needcomma=false;
 463         for(int i=0;i<state.numClasses()+state.numArrays();i++) {
 464             for(int j=0;j<maxcount;j++) {
 465                 if (needcomma)
 466                     outvirtual.print(", ");
 467                 if (virtualtable[i][j]!=null) {
 468                     MethodDescriptor md=virtualtable[i][j];
 469                     outvirtual.print("& "+md.getClassDesc().getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
 470                 } else {
 471                     outvirtual.print("0");
 472                 }
 473                 needcomma=true;
 474             }
 475             outvirtual.println("");
 476         }
 477         outvirtual.println("};");
 478         outvirtual.close();
 479     }
 480
 481     private void fillinRow(ClassDescriptor cd, MethodDescriptor[][] virtualtable, int rownum) {
 482         /* Get inherited methods */
 483         if (cd.getSuperDesc()!=null)
 484             fillinRow(cd.getSuperDesc(), virtualtable, rownum);
 485         /* Override them with our methods */
 486         for(Iterator it=cd.getMethods();it.hasNext();) {
 487             MethodDescriptor md=(MethodDescriptor)it.next();
 488             if (md.isStatic()||md.getReturnType()==null)
 489                 continue;
 490             int methodnum=virtualcalls.getMethodNumber(md);
 491             virtualtable[rownum][methodnum]=md;
 492         }
 493     }
 494
 495     /** Generate array that contains the sizes of class objects.  The
 496      * object allocation functions in the runtime use this
 497      * information. */
 498
 499     private void generateSizeArray(PrintWriter outclassdefs) {
 500         outclassdefs.print("int classsize[]={");
 501         Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
 502         cdarray=new ClassDescriptor[state.numClasses()];
 503         while(it.hasNext()) {
 504             ClassDescriptor cd=(ClassDescriptor)it.next();
 505             cdarray[cd.getId()]=cd;
 506         }
 507         boolean needcomma=false;
 508         for(int i=0;i<state.numClasses();i++) {
 509             if (needcomma)
 510                 outclassdefs.print(", ");
 511             outclassdefs.print("sizeof(struct "+cdarray[i].getSafeSymbol()+")");
 512             needcomma=true;
 513         }
 514
 515         arraytable=new TypeDescriptor[state.numArrays()];
 516
 517         Iterator arrayit=state.getArrayIterator();
 518         while(arrayit.hasNext()) {
 519             TypeDescriptor td=(TypeDescriptor)arrayit.next();
 520             int id=state.getArrayNumber(td);
 521             arraytable[id]=td;
 522         }
 523
 524         for(int i=0;i<state.numArrays();i++) {
 525             if (needcomma)
 526                 outclassdefs.print(", ");
 527             TypeDescriptor tdelement=arraytable[i].dereference();
 528             if (tdelement.isArray()||tdelement.isClass())
 529                 outclassdefs.print("sizeof(void *)");
 530             else
 531                 outclassdefs.print("sizeof("+tdelement.getSafeSymbol()+")");
 532             needcomma=true;
 533         }
 534
 535         outclassdefs.println("};");
 536     }
 537
 538     /** Constructs params and temp objects for each method or task.
 539      * These objects tell the compiler which temps need to be
 540      * allocated.  */
 541
 542     private void generateTempStructs(FlatMethod fm) {
 543         MethodDescriptor md=fm.getMethod();
 544         TaskDescriptor task=fm.getTask();
 545
 546         ParamsObject objectparams=md!=null?new ParamsObject(md,tag++):new ParamsObject(task, tag++);
 547         if (md!=null)
 548             paramstable.put(md, objectparams);
 549         else
 550             paramstable.put(task, objectparams);
 551
 552         for(int i=0;i<fm.numParameters();i++) {
 553             TempDescriptor temp=fm.getParameter(i);
 554             TypeDescriptor type=temp.getType();
 555             if ((type.isPtr()||type.isArray())&&GENERATEPRECISEGC)
 556                 objectparams.addPtr(temp);
 557             else
 558                 objectparams.addPrim(temp);
 559         }
 560
 561         TempObject objecttemps=md!=null?new TempObject(objectparams,md,tag++):new TempObject(objectparams, task, tag++);
 562         if (md!=null)
 563             tempstable.put(md, objecttemps);
 564         else
 565             tempstable.put(task, objecttemps);
 566
 567         for(Iterator nodeit=fm.getNodeSet().iterator();nodeit.hasNext();) {
 568             FlatNode fn=(FlatNode)nodeit.next();
 569             TempDescriptor[] writes=fn.writesTemps();
 570             for(int i=0;i<writes.length;i++) {
 571                 TempDescriptor temp=writes[i];
 572                 TypeDescriptor type=temp.getType();
 573                 if ((type.isPtr()||type.isArray())&&GENERATEPRECISEGC)
 574                     objecttemps.addPtr(temp);
 575                 else
 576                     objecttemps.addPrim(temp);
 577             }
 578         }
 579     }
 580
 581     private void generateLayoutStructs(PrintWriter output) {
 582         Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
 583         while(it.hasNext()) {
 584             ClassDescriptor cn=(ClassDescriptor)it.next();
 585             output.println("int "+cn.getSafeSymbol()+"_pointers[]={");
 586             Iterator allit=cn.getFieldTable().getAllDescriptorsIterator();
 587             int count=0;
 588             while(allit.hasNext()) {
 589                 FieldDescriptor fd=(FieldDescriptor)allit.next();
 590                 TypeDescriptor type=fd.getType();
 591                 if (type.isPtr()||type.isArray())
 592                     count++;
 593             }
 594             output.print(count);
 595             allit=cn.getFieldTable().getAllDescriptorsIterator();
 596             while(allit.hasNext()) {
 597                 FieldDescriptor fd=(FieldDescriptor)allit.next();
 598                 TypeDescriptor type=fd.getType();
 599                 if (type.isPtr()||type.isArray()) {
 600                     output.println(",");
 601                     output.print("((int)&(((struct "+cn.getSafeSymbol() +" *)0)->"+fd.getSafeSymbol()+"))");
 602                 }
 603             }
 604             output.println("};");
 605         }
 606         output.println("int * pointerarray[]={");
 607         boolean needcomma=false;
 608         for(int i=0;i<state.numClasses();i++) {
 609             ClassDescriptor cn=cdarray[i];
 610             if (needcomma)
 611                 output.println(",");
 612             needcomma=true;
 613             output.print(cn.getSafeSymbol()+"_pointers");
 614         }
 615
 616         for(int i=0;i<state.numArrays();i++) {
 617             if (needcomma)
 618                 output.println(", ");
 619             TypeDescriptor tdelement=arraytable[i].dereference();
 620             if (tdelement.isArray()||tdelement.isClass())
 621                 output.print("((int *)1)");
 622             else
 623                 output.print("0");
 624             needcomma=true;
 625         }
 626
 627         output.println("};");
 628         needcomma=false;
 629         output.println("int hasflags[]={");
 630         for(int i=0;i<state.numClasses();i++) {
 631             ClassDescriptor cn=cdarray[i];
 632             if (needcomma)
 633                 output.println(", ");
 634             needcomma=true;
 635             if (cn.hasFlags())
 636                 output.print("1");
 637             else
 638                 output.print("0");
 639         }
 640         output.println("};");
 641     }
 642
 643     /** Print out table to give us supertypes */
 644     private void generateSuperTypeTable(PrintWriter output) {
 645         output.println("int supertypes[]={");
 646         boolean needcomma=false;
 647         for(int i=0;i<state.numClasses();i++) {
 648             ClassDescriptor cn=cdarray[i];
 649             if (needcomma)
 650                 output.println(",");
 651             needcomma=true;
 652             if (cn.getSuperDesc()!=null) {
 653                 ClassDescriptor cdsuper=cn.getSuperDesc();
 654                 output.print(cdsuper.getId());
 655             } else
 656                 output.print("-1");
 657         }
 658         output.println("};");
 659     }
 660
 661     /** Force consistent field ordering between inherited classes. */
 662
 663     private void printClassStruct(ClassDescriptor cn, PrintWriter classdefout) {
 664         ClassDescriptor sp=cn.getSuperDesc();
 665         if (sp!=null)
 666             printClassStruct(sp, classdefout);
 667
 668         if (!fieldorder.containsKey(cn)) {
 669             Vector fields=new Vector();
 670             fieldorder.put(cn,fields);
 671             Iterator fieldit=cn.getFields();
 672             while(fieldit.hasNext()) {
 673                 FieldDescriptor fd=(FieldDescriptor)fieldit.next();
 674                 if (sp==null||!sp.getFieldTable().contains(fd.getSymbol()))
 675                     fields.add(fd);
 676             }
 677         }
 678         Vector fields=(Vector)fieldorder.get(cn);
 679
 680         for(int i=0;i<fields.size();i++) {
 681             FieldDescriptor fd=(FieldDescriptor)fields.get(i);
 682             if (fd.getType().isClass()||fd.getType().isArray())
 683                 classdefout.println("  struct "+fd.getType().getSafeSymbol()+" * "+fd.getSafeSymbol()+";");
 684             else
 685                 classdefout.println("  "+fd.getType().getSafeSymbol()+" "+fd.getSafeSymbol()+";");
 686         }
 687     }
 688
 689
 690     /* Map flags to integers consistently between inherited
 691      * classes. */
 692
 693     private void mapFlags(ClassDescriptor cn) {
 694         ClassDescriptor sp=cn.getSuperDesc();
 695         if (sp!=null)
 696             mapFlags(sp);
 697         int max=0;
 698         if (!flagorder.containsKey(cn)) {
 699             Hashtable flags=new Hashtable();
 700             flagorder.put(cn,flags);
 701             if (sp!=null) {
 702                 Hashtable superflags=(Hashtable)flagorder.get(sp);
 703                 Iterator superflagit=superflags.keySet().iterator();
 704                 while(superflagit.hasNext()) {
 705                     FlagDescriptor fd=(FlagDescriptor)superflagit.next();
 706                     Integer number=(Integer)superflags.get(fd);
 707                     flags.put(fd, number);
 708                     if ((number.intValue()+1)>max)
 709                         max=number.intValue()+1;
 710                 }
 711             }
 712
 713             Iterator flagit=cn.getFlags();
 714             while(flagit.hasNext()) {
 715                 FlagDescriptor fd=(FlagDescriptor)flagit.next();
 716                 if (sp==null||!sp.getFlagTable().contains(fd.getSymbol()))
 717                     flags.put(fd, new Integer(max++));
 718             }
 719         }
 720     }
 721
 722
 723     /** This function outputs (1) structures that parameters are
 724      * passed in (when PRECISE GC is enabled) and (2) function
 725      * prototypes for the methods */
 726
 727     private void generateCallStructs(ClassDescriptor cn, PrintWriter classdefout, PrintWriter output, PrintWriter headersout) {
 728         /* Output class structure */
 729         classdefout.println("struct "+cn.getSafeSymbol()+" {");
 730         classdefout.println("  int type;");
 731         if (state.THREAD) {
 732             classdefout.println("  pthread_t tid;");
 733             classdefout.println("  void * lockentry;");
 734             classdefout.println("  int lockcount;");
 735         }
 736
 737         if (state.TASK) {
 738             classdefout.println("  int flag;");
 739             classdefout.println("  void * flagptr;");
 740         }
 741         printClassStruct(cn, classdefout);
 742         classdefout.println("};\n");
 743
 744         /* Cycle through methods */
 745         Iterator methodit=cn.getMethods();
 746         while(methodit.hasNext()) {
 747             /* Classify parameters */
 748             MethodDescriptor md=(MethodDescriptor)methodit.next();
 749             FlatMethod fm=state.getMethodFlat(md);
 750             generateTempStructs(fm);
 751
 752             ParamsObject objectparams=(ParamsObject) paramstable.get(md);
 753             TempObject objecttemps=(TempObject) tempstable.get(md);
 754
 755             /* Output parameter structure */
 756             if (GENERATEPRECISEGC) {
 757                 output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params {");
 758                 output.println("  int size;");
 759                 output.println("  void * next;");
 760                 for(int i=0;i<objectparams.numPointers();i++) {
 761                     TempDescriptor temp=objectparams.getPointer(i);
 762                     output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
 763                 }
 764                 output.println("};\n");
 765             }
 766
 767             /* Output temp structure */
 768             if (GENERATEPRECISEGC) {
 769                 output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals {");
 770                 output.println("  int size;");
 771                 output.println("  void * next;");
 772                 for(int i=0;i<objecttemps.numPointers();i++) {
 773                     TempDescriptor temp=objecttemps.getPointer(i);
 774                     if (temp.getType().isNull())
 775                         output.println("  void * "+temp.getSafeSymbol()+";");
 776                     else
 777                         output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
 778                 }
 779                 output.println("};\n");
 780             }
 781
 782             /* Output method declaration */
 783             if (md.getReturnType()!=null) {
 784                 if (md.getReturnType().isClass()||md.getReturnType().isArray())
 785                     headersout.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
 786                 else
 787                     headersout.print(md.getReturnType().getSafeSymbol()+" ");
 788             } else
 789                 //catch the constructor case
 790                 headersout.print("void ");
 791             headersout.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(");
 792
 793             boolean printcomma=false;
 794             if (GENERATEPRECISEGC) {
 795                 headersout.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
 796                 printcomma=true;
 797             }
 798
 799             //output parameter list
 800             for(int i=0;i<objectparams.numPrimitives();i++) {
 801                 TempDescriptor temp=objectparams.getPrimitive(i);
 802                 if (printcomma)
 803                     headersout.print(", ");
 804                 printcomma=true;
 805                 if (temp.getType().isClass()||temp.getType().isArray())
 806                     headersout.print("struct " + temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol());
 807                 else
 808                     headersout.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
 809             }
 810             headersout.println(");\n");
 811         }
 812     }
 813
 814
 815     /** This function outputs (1) structures that parameters are
 816      * passed in (when PRECISE GC is enabled) and (2) function
 817      * prototypes for the tasks */
 818
 819     private void generateTaskStructs(PrintWriter output, PrintWriter headersout) {
 820         /* Cycle through tasks */
 821         Iterator taskit=state.getTaskSymbolTable().getDescriptorsIterator();
 822
 823         while(taskit.hasNext()) {
 824             /* Classify parameters */
 825             TaskDescriptor task=(TaskDescriptor)taskit.next();
 826             FlatMethod fm=state.getMethodFlat(task);
 827             generateTempStructs(fm);
 828
 829             ParamsObject objectparams=(ParamsObject) paramstable.get(task);
 830             TempObject objecttemps=(TempObject) tempstable.get(task);
 831
 832             /* Output parameter structure */
 833             if (GENERATEPRECISEGC) {
 834                 output.println("struct "+task.getSafeSymbol()+"_params {");
 835
 836                 output.println("  int size;");
 837                 output.println("  void * next;");
 838                 for(int i=0;i<objectparams.numPointers();i++) {
 839                     TempDescriptor temp=objectparams.getPointer(i);
 840                     output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
 841                 }
 842                 output.println("};\n");
 843                 if (objectparams.numPointers()>maxtaskparams)
 844                     maxtaskparams=objectparams.numPointers();
 845             }
 846
 847             /* Output temp structure */
 848             if (GENERATEPRECISEGC) {
 849                 output.println("struct "+task.getSafeSymbol()+"_locals {");
 850                 output.println("  int size;");
 851                 output.println("  void * next;");
 852                 for(int i=0;i<objecttemps.numPointers();i++) {
 853                     TempDescriptor temp=objecttemps.getPointer(i);
 854                     if (temp.getType().isNull())
 855                         output.println("  void * "+temp.getSafeSymbol()+";");
 856                     else
 857                         output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
 858                 }
 859                 output.println("};\n");
 860             }
 861
 862             /* Output task declaration */
 863             headersout.print("void " + task.getSafeSymbol()+"(");
 864
 865             boolean printcomma=false;
 866             if (GENERATEPRECISEGC) {
 867                 headersout.print("struct "+task.getSafeSymbol()+"_params * "+paramsprefix);
 868             } else
 869                 headersout.print("void * parameterarray[]");
 870             headersout.println(");\n");
 871         }
 872     }
 873
 874     /** Generate code for flatmethod fm. */
 875
 876     private void generateFlatMethod(FlatMethod fm, PrintWriter output) {
 877         MethodDescriptor md=fm.getMethod();
 878         TaskDescriptor task=fm.getTask();
 879
 880         ClassDescriptor cn=md!=null?md.getClassDesc():null;
 881
 882         ParamsObject objectparams=(ParamsObject)paramstable.get(md!=null?md:task);
 883
 884         generateHeader(md!=null?md:task,output);
 885
 886         TempObject objecttemp=(TempObject) tempstable.get(md!=null?md:task);
 887
 888         /* Print code */
 889         if (GENERATEPRECISEGC) {
 890             if (md!=null)
 891                 output.print("   struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals "+localsprefix+"={");
 892             else
 893                 output.print("   struct "+task.getSafeSymbol()+"_locals "+localsprefix+"={");
 894
 895             output.print(objecttemp.numPointers()+",");
 896             output.print(paramsprefix);
 897             for(int j=0;j<objecttemp.numPointers();j++)
 898                 output.print(", NULL");
 899             output.println("};");
 900         }
 901
 902         for(int i=0;i<objecttemp.numPrimitives();i++) {
 903             TempDescriptor td=objecttemp.getPrimitive(i);
 904             TypeDescriptor type=td.getType();
 905             if (type.isNull())
 906                 output.println("   void * "+td.getSafeSymbol()+";");
 907             else if (type.isClass()||type.isArray())
 908                 output.println("   struct "+type.getSafeSymbol()+" * "+td.getSafeSymbol()+";");
 909             else
 910                 output.println("   "+type.getSafeSymbol()+" "+td.getSafeSymbol()+";");
 911         }
 912
 913         /* Generate labels first */
 914         HashSet tovisit=new HashSet();
 915         HashSet visited=new HashSet();
 916         int labelindex=0;
 917         Hashtable nodetolabel=new Hashtable();
 918         tovisit.add(fm.methodEntryNode());
 919         FlatNode current_node=null;
 920
 921         //Assign labels 1st
 922         //Node needs a label if it is
 923         while(!tovisit.isEmpty()) {
 924             FlatNode fn=(FlatNode)tovisit.iterator().next();
 925             tovisit.remove(fn);
 926             visited.add(fn);
 927             for(int i=0;i<fn.numNext();i++) {
 928                 FlatNode nn=fn.getNext(i);
 929                 if(i>0) {
 930                     //1) Edge >1 of node
 931                     nodetolabel.put(nn,new Integer(labelindex++));
 932                 }
 933                 if (!visited.contains(nn)&&!tovisit.contains(nn)) {
 934                     tovisit.add(nn);
 935                 } else {
 936                     //2) Join point
 937                     nodetolabel.put(nn,new Integer(labelindex++));
 938                 }
 939             }
 940         }
 941
 942         if (state.THREAD&&GENERATEPRECISEGC) {
 943             output.println("checkcollect(&"+localsprefix+");");
 944         }
 945
 946         //Do the actual code generation
 947         tovisit=new HashSet();
 948         visited=new HashSet();
 949         tovisit.add(fm.methodEntryNode());
 950         while(current_node!=null||!tovisit.isEmpty()) {
 951             if (current_node==null) {
 952                 current_node=(FlatNode)tovisit.iterator().next();
 953                 tovisit.remove(current_node);
 954             }
 955             visited.add(current_node);
 956             if (nodetolabel.containsKey(current_node))
 957                 output.println("L"+nodetolabel.get(current_node)+":");
 958             if (state.INSTRUCTIONFAILURE) {
 959                 if (state.THREAD) {
 960                     output.println("if ((++instructioncount)>failurecount) {instructioncount=0;injectinstructionfailure();}");
 961                 }
 962                 else
 963                     output.println("if ((--instructioncount)==0) injectinstructionfailure();");
 964             }
 965             if (current_node.numNext()==0) {
 966                 output.print("   ");
 967                 generateFlatNode(fm, current_node, output);
 968                 if (current_node.kind()!=FKind.FlatReturnNode) {
 969                     output.println("   return;");
 970                 }
 971                 current_node=null;
 972             } else if(current_node.numNext()==1) {
 973                 output.print("   ");
 974                 generateFlatNode(fm, current_node, output);
 975                 FlatNode nextnode=current_node.getNext(0);
 976                 if (visited.contains(nextnode)) {
 977                     output.println("goto L"+nodetolabel.get(nextnode)+";");
 978                     current_node=null;
 979                 } else
 980                     current_node=nextnode;
 981             } else if (current_node.numNext()==2) {
 982                 /* Branch */
 983                 output.print("   ");
 984                 generateFlatCondBranch(fm, (FlatCondBranch)current_node, "L"+nodetolabel.get(current_node.getNext(1)), output);
 985                 if (!visited.contains(current_node.getNext(1)))
 986                     tovisit.add(current_node.getNext(1));
 987                 if (visited.contains(current_node.getNext(0))) {
 988                     output.println("goto L"+nodetolabel.get(current_node.getNext(0))+";");
 989                     current_node=null;
 990                 } else
 991                     current_node=current_node.getNext(0);
 992             } else throw new Error();
 993         }
 994
 995
 996         output.println("}\n\n");
 997     }
 998
 999     /** Generate text string that corresponds to the Temp td. */
1000     private String generateTemp(FlatMethod fm, TempDescriptor td) {
1001         MethodDescriptor md=fm.getMethod();
1002         TaskDescriptor task=fm.getTask();
1003         TempObject objecttemps=(TempObject) tempstable.get(md!=null?md:task);
1004
1005         if (objecttemps.isLocalPrim(td)||objecttemps.isParamPrim(td)) {
1006             return td.getSafeSymbol();
1007         }
1008
1009         if (objecttemps.isLocalPtr(td)) {
1010             return localsprefix+"."+td.getSafeSymbol();
1011         }
1012
1013         if (objecttemps.isParamPtr(td)) {
1014             return paramsprefix+"->"+td.getSafeSymbol();
1015         }
1016         throw new Error();
1017     }
1018
1019     private void generateFlatNode(FlatMethod fm, FlatNode fn, PrintWriter output) {
1020         switch(fn.kind()) {
1021         case FKind.FlatCall:
1022             generateFlatCall(fm, (FlatCall) fn,output);
1023             return;
1024         case FKind.FlatFieldNode:
1025             generateFlatFieldNode(fm, (FlatFieldNode) fn,output);
1026             return;
1027         case FKind.FlatElementNode:
1028             generateFlatElementNode(fm, (FlatElementNode) fn,output);
1029             return;
1030         case FKind.FlatSetElementNode:
1031             generateFlatSetElementNode(fm, (FlatSetElementNode) fn,output);
1032             return;
1033         case FKind.FlatSetFieldNode:
1034             generateFlatSetFieldNode(fm, (FlatSetFieldNode) fn,output);
1035             return;
1036         case FKind.FlatNew:
1037             generateFlatNew(fm, (FlatNew) fn,output);
1038             return;
1039         case FKind.FlatOpNode:
1040             generateFlatOpNode(fm, (FlatOpNode) fn,output);
1041             return;
1042         case FKind.FlatCastNode:
1043             generateFlatCastNode(fm, (FlatCastNode) fn,output);
1044             return;
1045         case FKind.FlatLiteralNode:
1046             generateFlatLiteralNode(fm, (FlatLiteralNode) fn,output);
1047             return;
1048         case FKind.FlatReturnNode:
1049             generateFlatReturnNode(fm, (FlatReturnNode) fn,output);
1050             return;
1051         case FKind.FlatNop:
1052             output.println("/* nop */");
1053             return;
1054         case FKind.FlatBackEdge:
1055             if (state.THREAD&&GENERATEPRECISEGC) {
1056                 output.println("checkcollect(&"+localsprefix+");");
1057             } else
1058                 output.println("/* nop */");
1059             return;
1060         case FKind.FlatCheckNode:
1061             generateFlatCheckNode(fm, (FlatCheckNode) fn, output);
1062             return;
1063         case FKind.FlatFlagActionNode:
1064             generateFlatFlagActionNode(fm, (FlatFlagActionNode) fn, output);
1065             return;
1066         }
1067         throw new Error();
1068
1069     }
1070
1071     private void generateFlatCheckNode(FlatMethod fm,  FlatCheckNode fcn, PrintWriter output) {
1072
1073         if (state.CONSCHECK) {
1074             String specname=fcn.getSpec();
1075             String varname="repairstate___";
1076             output.println("{");
1077             output.println("struct "+specname+"_state * "+varname+"=allocate"+specname+"_state();");
1078
1079             TempDescriptor[] temps=fcn.getTemps();
1080             String[] vars=fcn.getVars();
1081             for(int i=0;i<temps.length;i++) {
1082                 output.println(varname+"->"+vars[i]+"=(int)"+generateTemp(fm, temps[i])+";");
1083             }
1084
1085             output.println("if (doanalysis"+specname+"("+varname+")) {");
1086             output.println("free"+specname+"_state("+varname+");");
1087             output.println("} else {");
1088             output.println("/* Bad invariant */");
1089             output.println("free"+specname+"_state("+varname+");");
1090             output.println("abort_task();");
1091             output.println("}");
1092
1093             output.println("}");
1094         }
1095     }
1096
1097     private void generateFlatCall(FlatMethod fm, FlatCall fc, PrintWriter output) {
1098         MethodDescriptor md=fc.getMethod();
1099         ParamsObject objectparams=(ParamsObject) paramstable.get(md);
1100         ClassDescriptor cn=md.getClassDesc();
1101         output.println("{");
1102         if (GENERATEPRECISEGC) {
1103             output.print("       struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
1104
1105             output.print(objectparams.numPointers());
1106             //      output.print(objectparams.getUID());
1107             output.print(", & "+localsprefix);
1108             if (fc.getThis()!=null) {
1109                 output.print(", ");
1110                 output.print("(struct "+md.getThis().getType().getSafeSymbol() +" *)"+ generateTemp(fm,fc.getThis()));
1111             }
1112             for(int i=0;i<fc.numArgs();i++) {
1113                 VarDescriptor var=md.getParameter(i);
1114                 TempDescriptor paramtemp=(TempDescriptor)temptovar.get(var);
1115                 if (objectparams.isParamPtr(paramtemp)) {
1116                     TempDescriptor targ=fc.getArg(i);
1117                     output.print(", ");
1118                     output.print("(struct "+md.getParamType(i).getSafeSymbol()  +" *)"+generateTemp(fm, targ));
1119                 }
1120             }
1121             output.println("};");
1122         }
1123         output.print("       ");
1124
1125
1126         if (fc.getReturnTemp()!=null)
1127             output.print(generateTemp(fm,fc.getReturnTemp())+"=");
1128
1129         /* Do we need to do virtual dispatch? */
1130         if (md.isStatic()||md.getReturnType()==null||singleCall(fc.getThis().getType().getClassDesc(),md)) {
1131             output.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
1132         } else {
1133
1134             output.print("((");
1135             if (md.getReturnType().isClass()||md.getReturnType().isArray())
1136                 output.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
1137             else
1138                 output.print(md.getReturnType().getSafeSymbol()+" ");
1139             output.print("(*)(");
1140
1141             boolean printcomma=false;
1142             if (GENERATEPRECISEGC) {
1143                 output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * ");
1144                 printcomma=true;
1145             }
1146
1147
1148             for(int i=0;i<objectparams.numPrimitives();i++) {
1149                 TempDescriptor temp=objectparams.getPrimitive(i);
1150                 if (printcomma)
1151                     output.print(", ");
1152                 printcomma=true;
1153                 if (temp.getType().isClass()||temp.getType().isArray())
1154                     output.print("struct " + temp.getType().getSafeSymbol()+" * ");
1155                 else
1156                     output.print(temp.getType().getSafeSymbol());
1157             }
1158
1159             output.print("))virtualtable["+generateTemp(fm,fc.getThis())+"->type*"+maxcount+"+"+virtualcalls.getMethodNumber(md)+"])");
1160         }
1161
1162         output.print("(");
1163         boolean needcomma=false;
1164         if (GENERATEPRECISEGC) {
1165             output.print("&__parameterlist__");
1166             needcomma=true;
1167         } else {
1168             if (fc.getThis()!=null) {
1169                 TypeDescriptor ptd=md.getThis().getType();
1170                 if (ptd.isClass()&&!ptd.isArray())
1171                     output.print("(struct "+ptd.getSafeSymbol()+" *) ");
1172                 output.print(generateTemp(fm,fc.getThis()));
1173                 needcomma=true;
1174             }
1175         }
1176         for(int i=0;i<fc.numArgs();i++) {
1177             VarDescriptor var=md.getParameter(i);
1178             TempDescriptor paramtemp=(TempDescriptor)temptovar.get(var);
1179             if (objectparams.isParamPrim(paramtemp)) {
1180                 TempDescriptor targ=fc.getArg(i);
1181                 if (needcomma)
1182                     output.print(", ");
1183
1184                 TypeDescriptor ptd=md.getParamType(i);
1185                 if (ptd.isClass()&&!ptd.isArray())
1186                     output.print("(struct "+ptd.getSafeSymbol()+" *) ");
1187                 output.print(generateTemp(fm, targ));
1188                 needcomma=true;
1189             }
1190         }
1191         output.println(");");
1192         output.println("   }");
1193     }
1194
1195     private boolean singleCall(ClassDescriptor thiscd, MethodDescriptor md) {
1196         Set subclasses=typeutil.getSubClasses(thiscd);
1197         if (subclasses==null)
1198             return true;
1199         for(Iterator classit=subclasses.iterator();classit.hasNext();) {
1200             ClassDescriptor cd=(ClassDescriptor)classit.next();
1201             Set possiblematches=cd.getMethodTable().getSet(md.getSymbol());
1202             for(Iterator matchit=possiblematches.iterator();matchit.hasNext();) {
1203                 MethodDescriptor matchmd=(MethodDescriptor)matchit.next();
1204                 if (md.matches(matchmd))
1205                     return false;
1206             }
1207         }
1208         return true;
1209     }
1210
1211     private void generateFlatFieldNode(FlatMethod fm, FlatFieldNode ffn, PrintWriter output) {
1212         output.println(generateTemp(fm, ffn.getDst())+"="+ generateTemp(fm,ffn.getSrc())+"->"+ ffn.getField().getSafeSymbol()+";");
1213     }
1214
1215     private void generateFlatSetFieldNode(FlatMethod fm, FlatSetFieldNode fsfn, PrintWriter output) {
1216         if (fsfn.getField().getSymbol().equals("length")&&fsfn.getDst().getType().isArray())
1217             throw new Error("Can't set array length");
1218         output.println(generateTemp(fm, fsfn.getDst())+"->"+ fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc())+";");
1219     }
1220
1221     private void generateFlatElementNode(FlatMethod fm, FlatElementNode fen, PrintWriter output) {
1222         TypeDescriptor elementtype=fen.getSrc().getType().dereference();
1223         String type="";
1224
1225         if (elementtype.isArray()||elementtype.isClass())
1226             type="void *";
1227         else
1228             type=elementtype.getSafeSymbol()+" ";
1229
1230         if (fen.needsBoundsCheck()) {
1231             output.println("if ("+generateTemp(fm, fen.getIndex())+"< 0 || "+generateTemp(fm, fen.getIndex())+" >= "+generateTemp(fm,fen.getSrc()) + "->___length___)");
1232             output.println("failedboundschk();");
1233         }
1234
1235         output.println(generateTemp(fm, fen.getDst())+"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc())+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex())+"];");
1236     }
1237
1238     private void generateFlatSetElementNode(FlatMethod fm, FlatSetElementNode fsen, PrintWriter output) {
1239         //TODO: need dynamic check to make sure this assignment is actually legal
1240         //Because Object[] could actually be something more specific...ie. Integer[]
1241
1242         TypeDescriptor elementtype=fsen.getDst().getType().dereference();
1243         String type="";
1244
1245         if (elementtype.isArray()||elementtype.isClass())
1246             type="void *";
1247         else
1248             type=elementtype.getSafeSymbol()+" ";
1249
1250         if (fsen.needsBoundsCheck()) {
1251             output.println("if ("+generateTemp(fm, fsen.getIndex())+"< 0 || "+generateTemp(fm, fsen.getIndex())+" >= "+generateTemp(fm,fsen.getDst()) + "->___length___)");
1252             output.println("failedboundschk();");
1253         }
1254
1255         output.println("(("+type +"*)(((char *) &("+ generateTemp(fm,fsen.getDst())+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex())+"]="+generateTemp(fm,fsen.getSrc())+";");
1256     }
1257
1258     private void generateFlatNew(FlatMethod fm, FlatNew fn, PrintWriter output) {
1259         if (fn.getType().isArray()) {
1260             int arrayid=state.getArrayNumber(fn.getType())+state.numClasses();
1261             if (GENERATEPRECISEGC) {
1262                 output.println(generateTemp(fm,fn.getDst())+"=allocate_newarray(&"+localsprefix+", "+arrayid+", "+generateTemp(fm, fn.getSize())+");");
1263             } else {
1264                 output.println(generateTemp(fm,fn.getDst())+"=allocate_newarray("+arrayid+", "+generateTemp(fm, fn.getSize())+");");
1265             }
1266         } else {
1267             if (GENERATEPRECISEGC) {
1268                 output.println(generateTemp(fm,fn.getDst())+"=allocate_new(&"+localsprefix+", "+fn.getType().getClassDesc().getId()+");");
1269             } else {
1270                 output.println(generateTemp(fm,fn.getDst())+"=allocate_new("+fn.getType().getClassDesc().getId()+");");
1271             }
1272         }
1273     }
1274
1275     private void generateFlatOpNode(FlatMethod fm, FlatOpNode fon, PrintWriter output) {
1276
1277         if (fon.getRight()!=null)
1278             output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+fon.getOp().toString()+generateTemp(fm,fon.getRight())+";");
1279         else if (fon.getOp().getOp()==Operation.ASSIGN)
1280             output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+";");
1281         else if (fon.getOp().getOp()==Operation.UNARYPLUS)
1282             output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+";");
1283         else if (fon.getOp().getOp()==Operation.UNARYMINUS)
1284             output.println(generateTemp(fm, fon.getDest())+" = -"+generateTemp(fm, fon.getLeft())+";");
1285         else if (fon.getOp().getOp()==Operation.LOGIC_NOT)
1286             output.println(generateTemp(fm, fon.getDest())+" = !"+generateTemp(fm, fon.getLeft())+";");
1287         else
1288             output.println(generateTemp(fm, fon.getDest())+fon.getOp().toString()+generateTemp(fm, fon.getLeft())+";");
1289     }
1290
1291     private void generateFlatCastNode(FlatMethod fm, FlatCastNode fcn, PrintWriter output) {
1292         /* TODO: Do type check here */
1293         if (fcn.getType().isArray()) {
1294             throw new Error();
1295         } else if (fcn.getType().isClass())
1296             output.println(generateTemp(fm,fcn.getDst())+"=(struct "+fcn.getType().getSafeSymbol()+" *)"+generateTemp(fm,fcn.getSrc())+";");
1297         else
1298             output.println(generateTemp(fm,fcn.getDst())+"=("+fcn.getType().getSafeSymbol()+")"+generateTemp(fm,fcn.getSrc())+";");
1299     }
1300
1301     private void generateFlatLiteralNode(FlatMethod fm, FlatLiteralNode fln, PrintWriter output) {
1302         if (fln.getValue()==null)
1303             output.println(generateTemp(fm, fln.getDst())+"=0;");
1304         else if (fln.getType().getSymbol().equals(TypeUtil.StringClass)) {
1305             if (GENERATEPRECISEGC) {
1306                 output.println(generateTemp(fm, fln.getDst())+"=NewString(&"+localsprefix+", \""+FlatLiteralNode.escapeString((String)fln.getValue())+"\","+((String)fln.getValue()).length()+");");
1307             } else {
1308                 output.println(generateTemp(fm, fln.getDst())+"=NewString(\""+FlatLiteralNode.escapeString((String)fln.getValue())+"\","+((String)fln.getValue()).length()+");");
1309             }
1310         } else if (fln.getType().isBoolean()) {
1311             if (((Boolean)fln.getValue()).booleanValue())
1312                 output.println(generateTemp(fm, fln.getDst())+"=1;");
1313             else
1314                 output.println(generateTemp(fm, fln.getDst())+"=0;");
1315         } else if (fln.getType().isChar()) {
1316             String st=FlatLiteralNode.escapeString(fln.getValue().toString());
1317             output.println(generateTemp(fm, fln.getDst())+"='"+st+"';");
1318         } else
1319             output.println(generateTemp(fm, fln.getDst())+"="+fln.getValue()+";");
1320     }
1321
1322     private void generateFlatReturnNode(FlatMethod fm, FlatReturnNode frn, PrintWriter output) {
1323
1324         if (frn.getReturnTemp()!=null)
1325             output.println("return "+generateTemp(fm, frn.getReturnTemp())+";");
1326         else
1327             output.println("return;");
1328     }
1329
1330     private void generateFlatCondBranch(FlatMethod fm, FlatCondBranch fcb, String label, PrintWriter output) {
1331         output.println("if (!"+generateTemp(fm, fcb.getTest())+") goto "+label+";");
1332     }
1333
1334     private void generateHeader(Descriptor des, PrintWriter output) {
1335         /* Print header */
1336         ParamsObject objectparams=(ParamsObject)paramstable.get(des);
1337         MethodDescriptor md=null;
1338         TaskDescriptor task=null;
1339         if (des instanceof MethodDescriptor)
1340             md=(MethodDescriptor) des;
1341         else
1342             task=(TaskDescriptor) des;
1343
1344         ClassDescriptor cn=md!=null?md.getClassDesc():null;
1345
1346         if (md!=null&&md.getReturnType()!=null) {
1347             if (md.getReturnType().isClass()||md.getReturnType().isArray())
1348                 output.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
1349             else
1350                 output.print(md.getReturnType().getSafeSymbol()+" ");
1351         } else
1352             //catch the constructor case
1353             output.print("void ");
1354         if (md!=null)
1355             output.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(");
1356         else
1357             output.print(task.getSafeSymbol()+"(");
1358
1359         boolean printcomma=false;
1360         if (GENERATEPRECISEGC) {
1361             if (md!=null)
1362                 output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
1363             else
1364                 output.print("struct "+task.getSafeSymbol()+"_params * "+paramsprefix);
1365             printcomma=true;
1366         }
1367
1368         if (md!=null) {
1369             for(int i=0;i<objectparams.numPrimitives();i++) {
1370                 TempDescriptor temp=objectparams.getPrimitive(i);
1371                 if (printcomma)
1372                     output.print(", ");
1373                 printcomma=true;
1374                 if (temp.getType().isClass()||temp.getType().isArray())
1375                     output.print("struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol());
1376                 else
1377                     output.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
1378             }
1379             output.println(") {");
1380         } else if (!GENERATEPRECISEGC){
1381             output.println("void * parameterarray[]) {");
1382             for(int i=0;i<objectparams.numPrimitives();i++) {
1383                 TempDescriptor temp=objectparams.getPrimitive(i);
1384                 output.println("struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+"=parameterarray["+i+"];");
1385             }
1386             if (objectparams.numPrimitives()>maxtaskparams)
1387                 maxtaskparams=objectparams.numPrimitives();
1388         } else output.println(") {");
1389     }
1390
1391     public void generateFlatFlagActionNode(FlatMethod fm, FlatFlagActionNode ffan, PrintWriter output) {
1392         output.println("/* FlatFlagActionNode */");
1393         Hashtable flagandtable=new Hashtable();
1394         Hashtable flagortable=new Hashtable();
1395
1396
1397         Iterator flagsit=ffan.getTempFlagPairs();
1398         while(flagsit.hasNext()) {
1399             TempFlagPair tfp=(TempFlagPair)flagsit.next();
1400             TempDescriptor temp=tfp.getTemp();
1401             Hashtable flagtable=(Hashtable)flagorder.get(temp.getType().getClassDesc());
1402             FlagDescriptor flag=tfp.getFlag();
1403             int flagid=1<<((Integer)flagtable.get(flag)).intValue();
1404             boolean flagstatus=ffan.getFlagChange(tfp);
1405             if (flagstatus) {
1406                 int mask=0;
1407                 if (flagortable.containsKey(temp)) {
1408                     mask=((Integer)flagortable.get(temp)).intValue();
1409                 }
1410                 mask|=flagid;
1411                 flagortable.put(temp,new Integer(mask));
1412             } else {
1413                 int mask=0xFFFFFFFF;
1414                 if (flagandtable.containsKey(temp)) {
1415                     mask=((Integer)flagandtable.get(temp)).intValue();
1416                 }
1417                 mask&=(0xFFFFFFFF^flagid);
1418                 flagandtable.put(temp,new Integer(mask));
1419             }
1420         }
1421         Iterator orit=flagortable.keySet().iterator();
1422         while(orit.hasNext()) {
1423             TempDescriptor temp=(TempDescriptor)orit.next();
1424             int ormask=((Integer)flagortable.get(temp)).intValue();
1425             int andmask=0xFFFFFFF;
1426             if (flagandtable.containsKey(temp))
1427                 andmask=((Integer)flagandtable.get(temp)).intValue();
1428             output.println("flagorand("+generateTemp(fm, temp)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
1429         }
1430         Iterator andit=flagandtable.keySet().iterator();
1431         while(andit.hasNext()) {
1432             TempDescriptor temp=(TempDescriptor)andit.next();
1433             int andmask=((Integer)flagandtable.get(temp)).intValue();
1434             if (!flagortable.containsKey(temp))
1435                 output.println("flagorand("+generateTemp(fm, temp)+", 0, 0x"+Integer.toHexString(andmask)+");");
1436         }
1437     }
1438 }