int tag=0;
String localsprefix="___locals___";
String paramsprefix="___params___";
+ String oidstr="___nextobject___";
+ String nextobjstr="___nextobject___";
+ String localcopystr="___localcopy___";
public static boolean GENERATEPRECISEGC=false;
public static String PREFIX="";
public static String arraytype="ArrayObject";
TypeDescriptor[] arraytable;
LocalityAnalysis locality;
Hashtable<TempDescriptor, TempDescriptor> backuptable;
+ Hashtable<LocalityBinding, TempDescriptor> reverttable;
public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil) {
+ this(st, temptovar, typeutil, null);
+ }
+
+ public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, LocalityAnalysis locality) {
state=st;
this.temptovar=temptovar;
- paramstable=new Hashtable();
+ paramstable=new Hashtable();
tempstable=new Hashtable();
fieldorder=new Hashtable();
flagorder=new Hashtable();
this.typeutil=typeutil;
- virtualcalls=new Virtual(state);
- }
-
- public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, LocalityAnalysis locality) {
- this(st, temptovar, typeutil);
- this.locality=locality;
- this.backuptable=new Hashtable<TempDescriptor, TempDescriptor>();
+ virtualcalls=new Virtual(state,locality);
+ if (locality!=null) {
+ this.locality=locality;
+ this.backuptable=new Hashtable<TempDescriptor, TempDescriptor>();
+ this.reverttable=new Hashtable<LocalityBinding, TempDescriptor>();
+ }
}
/** The buildCode method outputs C code for all the methods. The Flat
outmethodheader.println("#ifndef METHODHEADERS_H");
outmethodheader.println("#define METHODHEADERS_H");
outmethodheader.println("#include \"structdefs.h\"");
+ if (state.DSM)
+ outmethodheader.println("#include \"dstm.h\"");
/* Output Structures */
outputStructs(outstructs);
private void outputMainMethod(PrintWriter outmethod) {
outmethod.println("int main(int argc, const char *argv[]) {");
outmethod.println(" int i;");
- if (GENERATEPRECISEGC) {
- outmethod.println(" struct ArrayObject * stringarray=allocate_newarray(NULL, STRINGARRAYTYPE, argc-1);");
+ if (state.DSM) {
+ outmethod.println("if (dstmStartup(argv[1])) {");
+ if (GENERATEPRECISEGC) {
+ outmethod.println(" struct ArrayObject * stringarray=allocate_newarray(NULL, STRINGARRAYTYPE, argc-2);");
+ } else {
+ outmethod.println(" struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc-2);");
+ }
} else {
- outmethod.println(" struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc-1);");
+ if (GENERATEPRECISEGC) {
+ outmethod.println(" struct ArrayObject * stringarray=allocate_newarray(NULL, STRINGARRAYTYPE, argc-1);");
+ } else {
+ outmethod.println(" struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc-1);");
+ }
}
if (state.THREAD) {
outmethod.println("initializethreads();");
}
- outmethod.println(" for(i=1;i<argc;i++) {");
+ if (state.DSM) {
+ outmethod.println(" for(i=2;i<argc;i++) {");
+ } else
+ outmethod.println(" for(i=1;i<argc;i++) {");
outmethod.println(" int length=strlen(argv[i]);");
if (GENERATEPRECISEGC) {
outmethod.println(" struct ___String___ *newstring=NewString(NULL, argv[i], length);");
} else {
outmethod.println(" struct ___String___ *newstring=NewString(argv[i], length);");
}
- outmethod.println(" ((void **)(((char *)& stringarray->___length___)+sizeof(int)))[i-1]=newstring;");
+ if (state.DSM)
+ outmethod.println(" ((void **)(((char *)& stringarray->___length___)+sizeof(int)))[i-2]=newstring;");
+ else
+ outmethod.println(" ((void **)(((char *)& stringarray->___length___)+sizeof(int)))[i-1]=newstring;");
outmethod.println(" }");
outmethod.println(" {");
if (GENERATEPRECISEGC) {
- outmethod.print(" struct "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
+ if (state.DSM) {
+ outmethod.print(" struct "+cd.getSafeSymbol()+locality.getMain().getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
+ } else
+ outmethod.print(" struct "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
outmethod.println("1, NULL,"+"stringarray};");
- outmethod.println(" "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(& __parameterlist__);");
- } else
- outmethod.println(" "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(stringarray);");
+ if (state.DSM)
+ outmethod.println(" "+cd.getSafeSymbol()+locality.getMain().getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(& __parameterlist__);");
+ else
+ outmethod.println(" "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(& __parameterlist__);");
+ } else {
+ if (state.DSM)
+ outmethod.println(" "+cd.getSafeSymbol()+locality.getMain().getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(stringarray);");
+ else
+ outmethod.println(" "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(stringarray);");
+ }
outmethod.println(" }");
-
+
+ if (state.DSM) {
+ outmethod.println("}");
+ }
+
if (state.THREAD) {
outmethod.println("pthread_mutex_lock(&gclistlock);");
outmethod.println("threadcount--;");
outmethod.println("pthread_mutex_unlock(&gclistlock);");
outmethod.println("pthread_exit(NULL);");
}
+
+
outmethod.println("}");
}
outmethod.println("#include \"methodheaders.h\"");
outmethod.println("#include \"virtualtable.h\"");
outmethod.println("#include <runtime.h>");
+ if (state.DSM) {
+ outmethod.println("#include \"localobjects.h\"");
+ }
if (state.THREAD)
outmethod.println("#include <thread.h>");
if (state.main!=null) {
private void outputClassDeclarations(PrintWriter outclassdefs) {
if (state.THREAD)
outclassdefs.println("#include <pthread.h>");
+ if(state.OPTIONAL)
+ outclassdefs.println("#include \"optionalstruct.h\"");
outclassdefs.println("struct "+arraytype+";");
/* Start by declaring all structs */
Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
if (state.TASK) {
outclassdefs.println(" int flag;");
outclassdefs.println(" void * flagptr;");
- if(state.OPTIONAL)
+ if(state.OPTIONAL){
outclassdefs.println(" int failedstatus;");
+ outclassdefs.println(" int hashcode;");
+ outclassdefs.println(" int numexitfses;");
+ outclassdefs.println(" int * exitfses;");
+ outclassdefs.println(" int numotds;");
+ outclassdefs.println(" struct optionaltaskdescriptor ** otds;");
+ }
}
printClassStruct(typeutil.getClass(TypeUtil.ObjectClass), outclassdefs);
outclassdefs.println("};\n");
outclassdefs.println("extern int classsize[];");
outclassdefs.println("extern int hasflags[];");
- outclassdefs.println("extern int * pointerarray[];");
+ outclassdefs.println("extern unsigned int * pointerarray[];");
outclassdefs.println("extern int supertypes[];");
}
if (virtualcalls.getMethodCount(cd)>maxcount)
maxcount=virtualcalls.getMethodCount(cd);
}
- MethodDescriptor[][] virtualtable=new MethodDescriptor[state.numClasses()+state.numArrays()][maxcount];
+ MethodDescriptor[][] virtualtable=null;
+ LocalityBinding[][] lbvirtualtable=null;
+ if (state.DSM)
+ lbvirtualtable=new LocalityBinding[state.numClasses()+state.numArrays()][maxcount];
+ else
+ virtualtable=new MethodDescriptor[state.numClasses()+state.numArrays()][maxcount];
/* Fill in virtual table */
classit=state.getClassSymbolTable().getDescriptorsIterator();
while(classit.hasNext()) {
ClassDescriptor cd=(ClassDescriptor)classit.next();
- fillinRow(cd, virtualtable, cd.getId());
+ if (state.DSM)
+ fillinRow(cd, lbvirtualtable, cd.getId());
+ else
+ fillinRow(cd, virtualtable, cd.getId());
}
ClassDescriptor objectcd=typeutil.getClass(TypeUtil.ObjectClass);
while(arrayit.hasNext()) {
TypeDescriptor td=(TypeDescriptor)arrayit.next();
int id=state.getArrayNumber(td);
- fillinRow(objectcd, virtualtable, id+state.numClasses());
+ if (state.DSM)
+ fillinRow(objectcd, lbvirtualtable, id+state.numClasses());
+ else
+ fillinRow(objectcd, virtualtable, id+state.numClasses());
}
outvirtual.print("void * virtualtable[]={");
for(int j=0;j<maxcount;j++) {
if (needcomma)
outvirtual.print(", ");
- if (virtualtable[i][j]!=null) {
+ if (state.DSM&&lbvirtualtable[i][j]!=null) {
+ LocalityBinding lb=lbvirtualtable[i][j];
+ MethodDescriptor md=lb.getMethod();
+ outvirtual.print("& "+md.getClassDesc().getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
+ } else if (!state.DSM&&virtualtable[i][j]!=null) {
MethodDescriptor md=virtualtable[i][j];
outvirtual.print("& "+md.getClassDesc().getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
} else {
}
}
+ private void fillinRow(ClassDescriptor cd, LocalityBinding[][] virtualtable, int rownum) {
+ /* Get inherited methods */
+ if (cd.getSuperDesc()!=null)
+ fillinRow(cd.getSuperDesc(), virtualtable, rownum);
+ /* Override them with our methods */
+ if (locality.getClassBindings(cd)!=null)
+ for(Iterator<LocalityBinding> lbit=locality.getClassBindings(cd).iterator();lbit.hasNext();) {
+ LocalityBinding lb=lbit.next();
+ MethodDescriptor md=lb.getMethod();
+ //Is the method static or a constructor
+ if (md.isStatic()||md.getReturnType()==null)
+ continue;
+ int methodnum=virtualcalls.getLocalityNumber(lb);
+ virtualtable[rownum][methodnum]=lb;
+ }
+ }
+
+
/** Generate array that contains the sizes of class objects. The
* object allocation functions in the runtime use this
* information. */
private void generateTempStructs(FlatMethod fm, LocalityBinding lb) {
MethodDescriptor md=fm.getMethod();
TaskDescriptor task=fm.getTask();
- Set<TempDescriptor> saveset=state.DSM?locality.getTempSet(lb):null;
+ Set<TempDescriptor> saveset=lb!=null?locality.getTempSet(lb):null;
ParamsObject objectparams=md!=null?new ParamsObject(md,tag++):new ParamsObject(task, tag++);
- if (md!=null)
+ if (lb!=null)
+ paramstable.put(lb, objectparams);
+ else if (md!=null)
paramstable.put(md, objectparams);
else
paramstable.put(task, objectparams);
objectparams.addPtr(temp);
else
objectparams.addPrim(temp);
- if(state.DSM&&saveset.contains(temp)) {
+ if(lb!=null&&saveset.contains(temp)) {
backuptable.put(temp, temp.createNew());
}
}
}
TempObject objecttemps=md!=null?new TempObject(objectparams,md,tag++):new TempObject(objectparams, task, tag++);
- if (md!=null)
+ if (lb!=null)
+ tempstable.put(lb, objecttemps);
+ else if (md!=null)
tempstable.put(md, objecttemps);
else
tempstable.put(task, objecttemps);
objecttemps.addPtr(temp);
else
objecttemps.addPrim(temp);
- if(state.DSM&&saveset.contains(temp)&&
+ if(lb!=null&&saveset.contains(temp)&&
!backuptable.containsKey(temp))
backuptable.put(temp, temp.createNew());
}
}
/* Create backup temps */
- if (state.DSM)
+ if (lb!=null) {
for(Iterator<TempDescriptor> tmpit=backuptable.values().iterator();tmpit.hasNext();) {
TempDescriptor tmp=tmpit.next();
TypeDescriptor type=tmp.getType();
else
objecttemps.addPrim(tmp);
}
+ /* Create temp to hold revert table */
+ if (lb.getHasAtomic()) {
+ TempDescriptor reverttmp=new TempDescriptor("revertlist", typeutil.getClass(TypeUtil.ObjectClass));
+ if (GENERATEPRECISEGC)
+ objecttemps.addPtr(reverttmp);
+ else
+ objecttemps.addPrim(reverttmp);
+ reverttable.put(lb, reverttmp);
+ }
+ }
}
/** This method outputs the following information about classes
Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
while(it.hasNext()) {
ClassDescriptor cn=(ClassDescriptor)it.next();
- output.println("int "+cn.getSafeSymbol()+"_pointers[]={");
+ output.println("unsigned int "+cn.getSafeSymbol()+"_pointers[]={");
Iterator allit=cn.getFieldTable().getAllDescriptorsIterator();
int count=0;
while(allit.hasNext()) {
FieldDescriptor fd=(FieldDescriptor)allit.next();
TypeDescriptor type=fd.getType();
+ if (state.DSM&&fd.isGlobal()) //Don't GC the global objects for now
+ continue;
if (type.isPtr()||type.isArray())
count++;
}
while(allit.hasNext()) {
FieldDescriptor fd=(FieldDescriptor)allit.next();
TypeDescriptor type=fd.getType();
+ if (state.DSM&&fd.isGlobal()) //Don't GC the global objects for now
+ continue;
if (type.isPtr()||type.isArray()) {
output.println(",");
- output.print("((int)&(((struct "+cn.getSafeSymbol() +" *)0)->"+fd.getSafeSymbol()+"))");
+ output.print("((unsigned int)&(((struct "+cn.getSafeSymbol() +" *)0)->"+fd.getSafeSymbol()+"))");
}
}
output.println("};");
}
- output.println("int * pointerarray[]={");
+ output.println("unsigned int * pointerarray[]={");
boolean needcomma=false;
for(int i=0;i<state.numClasses();i++) {
ClassDescriptor cn=cdarray[i];
output.println(", ");
TypeDescriptor tdelement=arraytable[i].dereference();
if (tdelement.isArray()||tdelement.isClass())
- output.print("((int *)1)");
+ output.print("((unsigned int *)1)");
else
output.print("0");
needcomma=true;
/** Force consistent field ordering between inherited classes. */
private void printClassStruct(ClassDescriptor cn, PrintWriter classdefout) {
+
ClassDescriptor sp=cn.getSuperDesc();
if (sp!=null)
printClassStruct(sp, classdefout);
if (state.TASK) {
classdefout.println(" int flag;");
classdefout.println(" void * flagptr;");
- if (state.OPTIONAL) classdefout.println(" int failedstatus;");
+ if (state.OPTIONAL){
+ classdefout.println(" int failedstatus;");
+ classdefout.println(" int hashcode;");
+ classdefout.println(" int numexitfses;");
+ classdefout.println(" int * exitfses;");
+ classdefout.println(" int numotds;");
+ classdefout.println(" struct optionaltaskdescriptor ** otds;");
+ }
}
printClassStruct(cn, classdefout);
classdefout.println("};\n");
if (state.DSM) {
/* Cycle through LocalityBindings */
- for(Iterator<LocalityBinding> lbit=locality.getClassBindings(cn).iterator();lbit.hasNext();) {
- LocalityBinding lb=lbit.next();
- MethodDescriptor md=lb.getMethod();
- generateMethod(cn, md, lb, headersout, output);
+ HashSet<MethodDescriptor> nativemethods=new HashSet<MethodDescriptor>();
+ Set<LocalityBinding> lbset=locality.getClassBindings(cn);
+ if (lbset!=null) {
+ for(Iterator<LocalityBinding> lbit=lbset.iterator();lbit.hasNext();) {
+ LocalityBinding lb=lbit.next();
+ MethodDescriptor md=lb.getMethod();
+ if (md.getModifiers().isNative()) {
+ //make sure we only print a native method once
+ if (nativemethods.contains(md)) {
+ FlatMethod fm=state.getMethodFlat(md);
+ generateTempStructs(fm, lb);
+ continue;
+ } else
+ nativemethods.add(md);
+ }
+ generateMethod(cn, md, lb, headersout, output);
+ }
}
- } else {
- /* Cycle through methods */
for(Iterator methodit=cn.getMethods();methodit.hasNext();) {
- /* Classify parameters */
+ MethodDescriptor md=(MethodDescriptor)methodit.next();
+ if (md.getModifiers().isNative()&&!nativemethods.contains(md)) {
+ //Need to build param structure for library code
+ FlatMethod fm=state.getMethodFlat(md);
+ generateTempStructs(fm, null);
+ generateMethodParam(cn, md, null, output);
+ }
+ }
+
+ } else
+ for(Iterator methodit=cn.getMethods();methodit.hasNext();) {
MethodDescriptor md=(MethodDescriptor)methodit.next();
generateMethod(cn, md, null, headersout, output);
}
- }
}
- private void generateMethod(ClassDescriptor cn, MethodDescriptor md, LocalityBinding lb, PrintWriter headersout, PrintWriter output) {
- FlatMethod fm=state.getMethodFlat(md);
- generateTempStructs(fm, null);
-
- ParamsObject objectparams=(ParamsObject) paramstable.get(md);
- TempObject objecttemps=(TempObject) tempstable.get(md);
-
+ private void generateMethodParam(ClassDescriptor cn, MethodDescriptor md, LocalityBinding lb, PrintWriter output) {
/* Output parameter structure */
if (GENERATEPRECISEGC) {
- output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params {");
+ ParamsObject objectparams=(ParamsObject) paramstable.get(lb!=null?lb:md);
+ if (state.DSM&&lb!=null)
+ output.println("struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params {");
+ else
+ output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params {");
output.println(" int size;");
output.println(" void * next;");
for(int i=0;i<objectparams.numPointers();i++) {
}
output.println("};\n");
}
+ }
+
+
+ private void generateMethod(ClassDescriptor cn, MethodDescriptor md, LocalityBinding lb, PrintWriter headersout, PrintWriter output) {
+ FlatMethod fm=state.getMethodFlat(md);
+ generateTempStructs(fm, lb);
+
+ ParamsObject objectparams=(ParamsObject) paramstable.get(lb!=null?lb:md);
+ TempObject objecttemps=(TempObject) tempstable.get(lb!=null?lb:md);
+
+ generateMethodParam(cn, md, lb, output);
/* Output temp structure */
if (GENERATEPRECISEGC) {
- output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals {");
+ if (state.DSM)
+ output.println("struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals {");
+ else
+ output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals {");
output.println(" int size;");
output.println(" void * next;");
for(int i=0;i<objecttemps.numPointers();i++) {
boolean printcomma=false;
if (GENERATEPRECISEGC) {
- headersout.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
+ if (state.DSM) {
+ headersout.print("struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
+ } else
+ headersout.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
printcomma=true;
}
}
}
- /** Generate code for FlatMethod fm. */
+ /***** Generate code for FlatMethod fm. *****/
private void generateFlatMethod(FlatMethod fm, LocalityBinding lb, PrintWriter output) {
MethodDescriptor md=fm.getMethod();
ClassDescriptor cn=md!=null?md.getClassDesc():null;
- ParamsObject objectparams=(ParamsObject)paramstable.get(md!=null?md:task);
+ ParamsObject objectparams=(ParamsObject)paramstable.get(lb!=null?lb:md!=null?md:task);
generateHeader(fm, lb, md!=null?md:task,output);
- TempObject objecttemp=(TempObject) tempstable.get(md!=null?md:task);
+ TempObject objecttemp=(TempObject) tempstable.get(lb!=null?lb:md!=null?md:task);
if (state.DSM&&lb.getHasAtomic()) {
output.println("transrecord_t * trans;");
}
if (GENERATEPRECISEGC) {
- if (md!=null)
+ if (md!=null&&state.DSM)
+ output.print(" struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals "+localsprefix+"={");
+ else if (md!=null&&!state.DSM)
output.print(" struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals "+localsprefix+"={");
else
output.print(" struct "+task.getSafeSymbol()+"_locals "+localsprefix+"={");
} else if (current_node.numNext()==2) {
/* Branch */
output.print(" ");
- generateFlatCondBranch(fm, (FlatCondBranch)current_node, "L"+nodetolabel.get(current_node.getNext(1)), output);
+ generateFlatCondBranch(fm, lb, (FlatCondBranch)current_node, "L"+nodetolabel.get(current_node.getNext(1)), output);
if (!visited.contains(current_node.getNext(1)))
tovisit.add(current_node.getNext(1));
if (visited.contains(current_node.getNext(0))) {
/** Generate text string that corresponds to the TempDescriptor td. */
- private String generateTemp(FlatMethod fm, TempDescriptor td) {
+ private String generateTemp(FlatMethod fm, TempDescriptor td, LocalityBinding lb) {
MethodDescriptor md=fm.getMethod();
TaskDescriptor task=fm.getTask();
- TempObject objecttemps=(TempObject) tempstable.get(md!=null?md:task);
+ TempObject objecttemps=(TempObject) tempstable.get(lb!=null?lb:md!=null?md:task);
if (objecttemps.isLocalPrim(td)||objecttemps.isParamPrim(td)) {
return td.getSafeSymbol();
case FKind.FlatAtomicExitNode:
generateFlatAtomicExitNode(fm, lb, (FlatAtomicExitNode) fn, output);
return;
+ case FKind.FlatGlobalConvNode:
+ generateFlatGlobalConvNode(fm, lb, (FlatGlobalConvNode) fn, output);
+ return;
case FKind.FlatTagDeclaration:
- generateFlatTagDeclaration(fm, (FlatTagDeclaration) fn,output);
+ generateFlatTagDeclaration(fm, lb, (FlatTagDeclaration) fn,output);
return;
case FKind.FlatCall:
- generateFlatCall(fm, (FlatCall) fn,output);
+ generateFlatCall(fm, lb, (FlatCall) fn,output);
return;
case FKind.FlatFieldNode:
- generateFlatFieldNode(fm, (FlatFieldNode) fn,output);
+ generateFlatFieldNode(fm, lb, (FlatFieldNode) fn,output);
return;
case FKind.FlatElementNode:
- generateFlatElementNode(fm, (FlatElementNode) fn,output);
+ generateFlatElementNode(fm, lb, (FlatElementNode) fn,output);
return;
case FKind.FlatSetElementNode:
- generateFlatSetElementNode(fm, (FlatSetElementNode) fn,output);
+ generateFlatSetElementNode(fm, lb, (FlatSetElementNode) fn,output);
return;
case FKind.FlatSetFieldNode:
- generateFlatSetFieldNode(fm, (FlatSetFieldNode) fn,output);
+ generateFlatSetFieldNode(fm, lb, (FlatSetFieldNode) fn,output);
return;
case FKind.FlatNew:
- generateFlatNew(fm, (FlatNew) fn,output);
+ generateFlatNew(fm, lb, (FlatNew) fn,output);
return;
case FKind.FlatOpNode:
- generateFlatOpNode(fm, (FlatOpNode) fn,output);
+ generateFlatOpNode(fm, lb, (FlatOpNode) fn,output);
return;
case FKind.FlatCastNode:
- generateFlatCastNode(fm, (FlatCastNode) fn,output);
+ generateFlatCastNode(fm, lb, (FlatCastNode) fn,output);
return;
case FKind.FlatLiteralNode:
- generateFlatLiteralNode(fm, (FlatLiteralNode) fn,output);
+ generateFlatLiteralNode(fm, lb, (FlatLiteralNode) fn,output);
return;
case FKind.FlatReturnNode:
- generateFlatReturnNode(fm, (FlatReturnNode) fn,output);
+ generateFlatReturnNode(fm, lb, (FlatReturnNode) fn,output);
return;
case FKind.FlatNop:
output.println("/* nop */");
output.println("/* nop */");
return;
case FKind.FlatCheckNode:
- generateFlatCheckNode(fm, (FlatCheckNode) fn, output);
+ generateFlatCheckNode(fm, lb, (FlatCheckNode) fn, output);
return;
case FKind.FlatFlagActionNode:
- generateFlatFlagActionNode(fm, (FlatFlagActionNode) fn, output);
+ generateFlatFlagActionNode(fm, lb, (FlatFlagActionNode) fn, output);
return;
}
throw new Error();
}
+ public void generateFlatGlobalConvNode(FlatMethod fm, LocalityBinding lb, FlatGlobalConvNode fgcn, PrintWriter output) {
+ if (lb!=fgcn.getLocality())
+ return;
+ /* Have to generate flat globalconv */
+ if (fgcn.getMakePtr()) {
+ output.println(generateTemp(fm, fgcn.getSrc(),lb)+"=(void *)transRead(trans, (unsigned int) "+generateTemp(fm, fgcn.getSrc(),lb)+");");
+ } else {
+ /* Need to convert to OID */
+ output.println(generateTemp(fm, fgcn.getSrc(),lb)+"=OID("+generateTemp(fm, fgcn.getSrc(),lb)+");");
+ }
+ }
+
public void generateFlatAtomicEnterNode(FlatMethod fm, LocalityBinding lb, FlatAtomicEnterNode faen, PrintWriter output) {
/* Check to see if we need to generate code for this atomic */
if (locality.getAtomic(lb).get(faen.getPrev(0)).intValue()>0)
/* Backup the temps. */
for(Iterator<TempDescriptor> tmpit=locality.getTemps(lb).get(faen).iterator();tmpit.hasNext();) {
TempDescriptor tmp=tmpit.next();
- output.println(generateTemp(fm, backuptable.get(tmp))+"="+generateTemp(fm,tmp)+";");
+ output.println(generateTemp(fm, backuptable.get(tmp),lb)+"="+generateTemp(fm,tmp,lb)+";");
}
output.println("goto transstart"+faen.getIdentifier()+";");
- /******* Print code to abort transaction *******/
- output.println("transabort"+faen.getIdentifier()+":");
+ /******* Print code to retry aborted transaction *******/
+ output.println("transretry"+faen.getIdentifier()+":");
/* Restore temps */
for(Iterator<TempDescriptor> tmpit=locality.getTemps(lb).get(faen).iterator();tmpit.hasNext();) {
TempDescriptor tmp=tmpit.next();
- output.println(generateTemp(fm, tmp)+"="+generateTemp(fm,backuptable.get(tmp))+";");
+ output.println(generateTemp(fm, tmp,lb)+"="+generateTemp(fm,backuptable.get(tmp),lb)+";");
}
+ /********* Need to revert local object store ********/
+ String revertptr=generateTemp(fm, reverttable.get(lb),lb);
+
+ output.println("while ("+revertptr+") {");
+ output.println("struct ___Object___ * tmpptr;");
+ output.println("tmpptr="+revertptr+"->"+nextobjstr+";");
+ output.println("REVERT_OBJ("+revertptr+");");
+ output.println(revertptr+"=tmpptr;");
+ output.println("}");
+
/******* Tell the runtime to start the transaction *******/
output.println("transstart"+faen.getIdentifier()+":");
/* Check to see if we need to generate code for this atomic */
if (locality.getAtomic(lb).get(faen).intValue()>0)
return;
-
+ //store the revert list before we lose the transaction object
+ String revertptr=generateTemp(fm, reverttable.get(lb),lb);
+ output.println(revertptr+"=trans->revertlist;");
+ output.println("if (transCommit(trans)) {");
+ /* Transaction aborts if it returns true */
+ output.println("goto transretry"+faen.getAtomicEnter().getIdentifier()+";");
+ output.println("} else {");
+ /* Need to commit local object store */
+ output.println("while ("+revertptr+") {");
+ output.println("struct ___Object___ * tmpptr;");
+ output.println("tmpptr="+revertptr+"->"+nextobjstr+";");
+ output.println("COMMIT_OBJ("+revertptr+");");
+ output.println(revertptr+"=tmpptr;");
+ output.println("}");
+ output.println("}");
}
- private void generateFlatCheckNode(FlatMethod fm, FlatCheckNode fcn, PrintWriter output) {
+ private void generateFlatCheckNode(FlatMethod fm, LocalityBinding lb, FlatCheckNode fcn, PrintWriter output) {
if (state.CONSCHECK) {
String specname=fcn.getSpec();
String varname="repairstate___";
TempDescriptor[] temps=fcn.getTemps();
String[] vars=fcn.getVars();
for(int i=0;i<temps.length;i++) {
- output.println(varname+"->"+vars[i]+"=(int)"+generateTemp(fm, temps[i])+";");
+ output.println(varname+"->"+vars[i]+"=(unsigned int)"+generateTemp(fm, temps[i],lb)+";");
}
output.println("if (doanalysis"+specname+"("+varname+")) {");
}
}
- private void generateFlatCall(FlatMethod fm, FlatCall fc, PrintWriter output) {
+ private void generateFlatCall(FlatMethod fm, LocalityBinding lb, FlatCall fc, PrintWriter output) {
MethodDescriptor md=fc.getMethod();
- ParamsObject objectparams=(ParamsObject) paramstable.get(md);
+ ParamsObject objectparams=(ParamsObject)paramstable.get(state.DSM?locality.getBinding(lb, fc):md);
ClassDescriptor cn=md.getClassDesc();
output.println("{");
if (GENERATEPRECISEGC) {
- output.print(" struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
+ if (state.DSM) {
+ LocalityBinding fclb=locality.getBinding(lb, fc);
+ output.print(" struct "+cn.getSafeSymbol()+fclb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
+ } else
+ output.print(" struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
output.print(objectparams.numPointers());
- // output.print(objectparams.getUID());
output.print(", & "+localsprefix);
if (fc.getThis()!=null) {
output.print(", ");
- output.print("(struct "+md.getThis().getType().getSafeSymbol() +" *)"+ generateTemp(fm,fc.getThis()));
+ output.print("(struct "+md.getThis().getType().getSafeSymbol() +" *)"+ generateTemp(fm,fc.getThis(),lb));
}
for(int i=0;i<fc.numArgs();i++) {
Descriptor var=md.getParameter(i);
output.print(", ");
TypeDescriptor td=md.getParamType(i);
if (td.isTag())
- output.print("(struct "+(new TypeDescriptor(typeutil.getClass(TypeUtil.TagClass))).getSafeSymbol() +" *)"+generateTemp(fm, targ));
+ output.print("(struct "+(new TypeDescriptor(typeutil.getClass(TypeUtil.TagClass))).getSafeSymbol() +" *)"+generateTemp(fm, targ,lb));
else
- output.print("(struct "+md.getParamType(i).getSafeSymbol() +" *)"+generateTemp(fm, targ));
+ output.print("(struct "+md.getParamType(i).getSafeSymbol() +" *)"+generateTemp(fm, targ,lb));
}
}
output.println("};");
if (fc.getReturnTemp()!=null)
- output.print(generateTemp(fm,fc.getReturnTemp())+"=");
+ output.print(generateTemp(fm,fc.getReturnTemp(),lb)+"=");
/* Do we need to do virtual dispatch? */
if (md.isStatic()||md.getReturnType()==null||singleCall(fc.getThis().getType().getClassDesc(),md)) {
- output.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
+ //no
+ if (state.DSM) {
+ LocalityBinding fclb=locality.getBinding(lb, fc);
+ output.print(cn.getSafeSymbol()+fclb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
+ } else {
+ output.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
+ }
} else {
+ //yes
output.print("((");
if (md.getReturnType().isClass()||md.getReturnType().isArray())
output.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
boolean printcomma=false;
if (GENERATEPRECISEGC) {
- output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * ");
+ if (state.DSM) {
+ LocalityBinding fclb=locality.getBinding(lb, fc);
+ output.print("struct "+cn.getSafeSymbol()+fclb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * ");
+ } else
+ output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * ");
printcomma=true;
- }
-
+ }
for(int i=0;i<objectparams.numPrimitives();i++) {
TempDescriptor temp=objectparams.getPrimitive(i);
output.print(temp.getType().getSafeSymbol());
}
- output.print("))virtualtable["+generateTemp(fm,fc.getThis())+"->type*"+maxcount+"+"+virtualcalls.getMethodNumber(md)+"])");
+ if (state.DSM) {
+ LocalityBinding fclb=locality.getBinding(lb, fc);
+ output.print("))virtualtable["+generateTemp(fm,fc.getThis(),lb)+"->type*"+maxcount+"+"+virtualcalls.getLocalityNumber(fclb)+"])");
+ } else
+ output.print("))virtualtable["+generateTemp(fm,fc.getThis(),lb)+"->type*"+maxcount+"+"+virtualcalls.getMethodNumber(md)+"])");
}
output.print("(");
if (GENERATEPRECISEGC) {
output.print("&__parameterlist__");
needcomma=true;
- } else {
+ }
+
+ if (state.DSM&&locality.getBinding(lb,fc).isAtomic()) {
+ if (needcomma)
+ output.print(",");
+ output.print("trans");
+ needcomma=true;
+ }
+
+ if (!GENERATEPRECISEGC) {
if (fc.getThis()!=null) {
TypeDescriptor ptd=md.getThis().getType();
+ if (needcomma)
+ output.print(",");
if (ptd.isClass()&&!ptd.isArray())
output.print("(struct "+ptd.getSafeSymbol()+" *) ");
- output.print(generateTemp(fm,fc.getThis()));
+ output.print(generateTemp(fm,fc.getThis(),lb));
needcomma=true;
}
}
+
for(int i=0;i<fc.numArgs();i++) {
Descriptor var=md.getParameter(i);
TempDescriptor paramtemp=(TempDescriptor)temptovar.get(var);
TypeDescriptor ptd=md.getParamType(i);
if (ptd.isClass()&&!ptd.isArray())
output.print("(struct "+ptd.getSafeSymbol()+" *) ");
- output.print(generateTemp(fm, targ));
+ output.print(generateTemp(fm, targ,lb));
needcomma=true;
}
}
return true;
}
- private void generateFlatFieldNode(FlatMethod fm, FlatFieldNode ffn, PrintWriter output) {
- output.println(generateTemp(fm, ffn.getDst())+"="+ generateTemp(fm,ffn.getSrc())+"->"+ ffn.getField().getSafeSymbol()+";");
+ private void generateFlatFieldNode(FlatMethod fm, LocalityBinding lb, FlatFieldNode ffn, PrintWriter output) {
+ if (state.DSM) {
+ Integer status=locality.getNodeTempInfo(lb).get(ffn).get(ffn.getSrc());
+ if (status==LocalityAnalysis.GLOBAL) {
+ String field=ffn.getField().getSafeSymbol();
+ String src="((struct "+ffn.getSrc().getType().getSafeSymbol()+" *)((unsigned int)"+generateTemp(fm, ffn.getSrc(),lb)+"+sizeof(objheader_t)))";
+ String dst=generateTemp(fm, ffn.getDst(),lb);
+
+ if (ffn.getField().getType().isPtr()||
+ ffn.getField().getType().isArray()) {
+
+ //TODO: Uncomment this when we have runtime support
+ //if (ffn.getSrc()==ffn.getDst()) {
+ //output.println("{");
+ //output.println("void * temp="+src+";");
+ //output.println("if (temp&0x1) {");
+ //output.println("temp=(void *) transRead(trans, (unsigned int) temp);");
+ //output.println(src+"->"+field+"="+temp+";");
+ //output.println("}");
+ //output.println(dst+"=temp;");
+ //output.println("}");
+ //} else {
+ output.println(dst+"="+ src +"->"+field+ ";");
+ //output.println("if ("+dst+"&0x1) {");
+ output.println(dst+"=(void *) transRead(trans, (unsigned int) "+dst+");");
+ //output.println(src+"->"+field+"="+src+"->"+field+";");
+ //output.println("}");
+ //}
+ } else {
+ output.println(dst+"="+ src+"->"+field+";");
+ }
+ } else if (status==LocalityAnalysis.LOCAL) {
+ output.println(generateTemp(fm, ffn.getDst(),lb)+"="+ generateTemp(fm,ffn.getSrc(),lb)+"->"+ ffn.getField().getSafeSymbol()+";");
+ } else if (status==LocalityAnalysis.EITHER) {
+ //Code is reading from a null pointer
+ output.println("if ("+generateTemp(fm, ffn.getSrc(),lb)+") {");
+ output.println("printf(\"BIG ERROR\n\");exit(-1);}");
+ //This should throw a suitable null pointer error
+ output.println(generateTemp(fm, ffn.getDst(),lb)+"="+ generateTemp(fm,ffn.getSrc(),lb)+"->"+ ffn.getField().getSafeSymbol()+";");
+ } else
+ throw new Error("Read from non-global/non-local in:"+lb.getExplanation());
+ } else
+ output.println(generateTemp(fm, ffn.getDst(),lb)+"="+ generateTemp(fm,ffn.getSrc(),lb)+"->"+ ffn.getField().getSafeSymbol()+";");
}
- private void generateFlatSetFieldNode(FlatMethod fm, FlatSetFieldNode fsfn, PrintWriter output) {
+ private void generateFlatSetFieldNode(FlatMethod fm, LocalityBinding lb, FlatSetFieldNode fsfn, PrintWriter output) {
if (fsfn.getField().getSymbol().equals("length")&&fsfn.getDst().getType().isArray())
throw new Error("Can't set array length");
- output.println(generateTemp(fm, fsfn.getDst())+"->"+ fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc())+";");
+ if (state.DSM && locality.getAtomic(lb).get(fsfn).intValue()>0) {
+ Integer statussrc=locality.getNodeTempInfo(lb).get(fsfn).get(fsfn.getSrc());
+ Integer statusdst=locality.getNodeTempInfo(lb).get(fsfn).get(fsfn.getDst());
+ boolean srcglobal=statussrc==LocalityAnalysis.GLOBAL;
+
+ String src=generateTemp(fm,fsfn.getSrc(),lb);
+ String dst=generateTemp(fm,fsfn.getDst(),lb);
+ if (srcglobal) {
+ output.println("{");
+ output.println("int srcoid="+src+"->"+oidstr+";");
+ }
+ if (statusdst.equals(LocalityAnalysis.GLOBAL)) {
+ String glbdst="((struct "+fsfn.getDst().getType().getSafeSymbol()+" *)((unsigned int)"+dst+" +sizeof(objheader_t)))";
+ //mark it dirty
+ output.println("*((unsigned int *)&("+dst+"->___localcopy___))|=DIRTY;");
+ if (srcglobal) {
+ output.println("*((unsigned int *)&("+glbdst+"->"+ fsfn.getField().getSafeSymbol()+"))=srcoid;");
+ output.println("}");
+ } else
+ output.println(glbdst+"->"+ fsfn.getField().getSafeSymbol()+"="+ src+";");
+ } else if (statusdst.equals(LocalityAnalysis.LOCAL)) {
+ /** Check if we need to copy */
+ output.println("if(!"+dst+"->"+localcopystr+") {");
+ /* Link object into list */
+ output.println(dst+"->"+nextobjstr+"=trans->localtrans;");
+ output.println("trans->localtrans="+dst+";");
+ if (GENERATEPRECISEGC)
+ output.println("COPY_OBJ((struct garbagelist *)&"+localsprefix+",(struct ___Object___ *)"+dst+");");
+ else
+ output.println("COPY_OBJ("+dst+");");
+ output.println("}");
+ if (srcglobal)
+ output.println(dst+"->"+ fsfn.getField().getSafeSymbol()+"=srcoid;");
+ else
+ output.println(dst+"->"+ fsfn.getField().getSafeSymbol()+"="+ src+";");
+ } else if (statusdst.equals(LocalityAnalysis.EITHER)) {
+ //writing to a null...bad
+ output.println("if ("+dst+") {");
+ output.println("printf(\"BIG ERROR 2\n\");exit(-1);}");
+ if (srcglobal)
+ output.println(dst+"->"+ fsfn.getField().getSafeSymbol()+"=srcoid;");
+ else
+ output.println(dst+"->"+ fsfn.getField().getSafeSymbol()+"="+ src+";");
+ }
+ if (srcglobal) {
+ output.println("}");
+ }
+ } else {
+ output.println(generateTemp(fm, fsfn.getDst(),lb)+"->"+ fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc(),lb)+";");
+ }
}
- private void generateFlatElementNode(FlatMethod fm, FlatElementNode fen, PrintWriter output) {
+ private void generateFlatElementNode(FlatMethod fm, LocalityBinding lb, FlatElementNode fen, PrintWriter output) {
TypeDescriptor elementtype=fen.getSrc().getType().dereference();
String type="";
type=elementtype.getSafeSymbol()+" ";
if (fen.needsBoundsCheck()) {
- output.println("if ("+generateTemp(fm, fen.getIndex())+"< 0 || "+generateTemp(fm, fen.getIndex())+" >= "+generateTemp(fm,fen.getSrc()) + "->___length___)");
+ output.println("if ("+generateTemp(fm, fen.getIndex(),lb)+"< 0 || "+generateTemp(fm, fen.getIndex(),lb)+" >= "+generateTemp(fm,fen.getSrc(),lb) + "->___length___)");
output.println("failedboundschk();");
}
- output.println(generateTemp(fm, fen.getDst())+"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc())+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex())+"];");
+ output.println(generateTemp(fm, fen.getDst(),lb)+"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex(),lb)+"];");
}
- private void generateFlatSetElementNode(FlatMethod fm, FlatSetElementNode fsen, PrintWriter output) {
+ private void generateFlatSetElementNode(FlatMethod fm, LocalityBinding lb, FlatSetElementNode fsen, PrintWriter output) {
//TODO: need dynamic check to make sure this assignment is actually legal
//Because Object[] could actually be something more specific...ie. Integer[]
type=elementtype.getSafeSymbol()+" ";
if (fsen.needsBoundsCheck()) {
- output.println("if ("+generateTemp(fm, fsen.getIndex())+"< 0 || "+generateTemp(fm, fsen.getIndex())+" >= "+generateTemp(fm,fsen.getDst()) + "->___length___)");
+ output.println("if ("+generateTemp(fm, fsen.getIndex(),lb)+"< 0 || "+generateTemp(fm, fsen.getIndex(),lb)+" >= "+generateTemp(fm,fsen.getDst(),lb) + "->___length___)");
output.println("failedboundschk();");
}
- output.println("(("+type +"*)(((char *) &("+ generateTemp(fm,fsen.getDst())+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex())+"]="+generateTemp(fm,fsen.getSrc())+";");
+ output.println("(("+type +"*)(((char *) &("+ generateTemp(fm,fsen.getDst(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex(),lb)+"]="+generateTemp(fm,fsen.getSrc(),lb)+";");
}
- private void generateFlatNew(FlatMethod fm, FlatNew fn, PrintWriter output) {
+ private void generateFlatNew(FlatMethod fm, LocalityBinding lb, FlatNew fn, PrintWriter output) {
if (fn.getType().isArray()) {
int arrayid=state.getArrayNumber(fn.getType())+state.numClasses();
- if (GENERATEPRECISEGC) {
- output.println(generateTemp(fm,fn.getDst())+"=allocate_newarray(&"+localsprefix+", "+arrayid+", "+generateTemp(fm, fn.getSize())+");");
+ if (fn.isGlobal()) {
+ output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_newarrayglobal(trans, "+arrayid+", "+generateTemp(fm, fn.getSize(),lb)+");");
+ } else if (GENERATEPRECISEGC) {
+ output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_newarray(&"+localsprefix+", "+arrayid+", "+generateTemp(fm, fn.getSize(),lb)+");");
} else {
- output.println(generateTemp(fm,fn.getDst())+"=allocate_newarray("+arrayid+", "+generateTemp(fm, fn.getSize())+");");
+ output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_newarray("+arrayid+", "+generateTemp(fm, fn.getSize(),lb)+");");
}
} else {
- if (GENERATEPRECISEGC) {
- output.println(generateTemp(fm,fn.getDst())+"=allocate_new(&"+localsprefix+", "+fn.getType().getClassDesc().getId()+");");
+ if (fn.isGlobal()) {
+ output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_newglobal(trans, "+fn.getType().getClassDesc().getId()+");");
+ } else if (GENERATEPRECISEGC) {
+ output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_new(&"+localsprefix+", "+fn.getType().getClassDesc().getId()+");");
} else {
- output.println(generateTemp(fm,fn.getDst())+"=allocate_new("+fn.getType().getClassDesc().getId()+");");
+ output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_new("+fn.getType().getClassDesc().getId()+");");
}
}
}
-
- private void generateFlatTagDeclaration(FlatMethod fm, FlatTagDeclaration fn, PrintWriter output) {
+ private void generateFlatTagDeclaration(FlatMethod fm, LocalityBinding lb, FlatTagDeclaration fn, PrintWriter output) {
if (GENERATEPRECISEGC) {
- output.println(generateTemp(fm,fn.getDst())+"=allocate_tag(&"+localsprefix+", "+state.getTagId(fn.getType())+");");
+ output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_tag(&"+localsprefix+", "+state.getTagId(fn.getType())+");");
} else {
- output.println(generateTemp(fm,fn.getDst())+"=allocate_tag("+state.getTagId(fn.getType())+");");
+ output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_tag("+state.getTagId(fn.getType())+");");
}
}
- private void generateFlatOpNode(FlatMethod fm, FlatOpNode fon, PrintWriter output) {
-
+ private void generateFlatOpNode(FlatMethod fm, LocalityBinding lb, FlatOpNode fon, PrintWriter output) {
if (fon.getRight()!=null)
- output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+fon.getOp().toString()+generateTemp(fm,fon.getRight())+";");
+ output.println(generateTemp(fm, fon.getDest(),lb)+" = "+generateTemp(fm, fon.getLeft(),lb)+fon.getOp().toString()+generateTemp(fm,fon.getRight(),lb)+";");
else if (fon.getOp().getOp()==Operation.ASSIGN)
- output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+";");
+ output.println(generateTemp(fm, fon.getDest(),lb)+" = "+generateTemp(fm, fon.getLeft(),lb)+";");
else if (fon.getOp().getOp()==Operation.UNARYPLUS)
- output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+";");
+ output.println(generateTemp(fm, fon.getDest(),lb)+" = "+generateTemp(fm, fon.getLeft(),lb)+";");
else if (fon.getOp().getOp()==Operation.UNARYMINUS)
- output.println(generateTemp(fm, fon.getDest())+" = -"+generateTemp(fm, fon.getLeft())+";");
+ output.println(generateTemp(fm, fon.getDest(),lb)+" = -"+generateTemp(fm, fon.getLeft(),lb)+";");
else if (fon.getOp().getOp()==Operation.LOGIC_NOT)
- output.println(generateTemp(fm, fon.getDest())+" = !"+generateTemp(fm, fon.getLeft())+";");
+ output.println(generateTemp(fm, fon.getDest(),lb)+" = !"+generateTemp(fm, fon.getLeft(),lb)+";");
else
- output.println(generateTemp(fm, fon.getDest())+fon.getOp().toString()+generateTemp(fm, fon.getLeft())+";");
+ output.println(generateTemp(fm, fon.getDest(),lb)+fon.getOp().toString()+generateTemp(fm, fon.getLeft(),lb)+";");
}
- private void generateFlatCastNode(FlatMethod fm, FlatCastNode fcn, PrintWriter output) {
+ private void generateFlatCastNode(FlatMethod fm, LocalityBinding lb, FlatCastNode fcn, PrintWriter output) {
/* TODO: Do type check here */
if (fcn.getType().isArray()) {
throw new Error();
} else if (fcn.getType().isClass())
- output.println(generateTemp(fm,fcn.getDst())+"=(struct "+fcn.getType().getSafeSymbol()+" *)"+generateTemp(fm,fcn.getSrc())+";");
+ output.println(generateTemp(fm,fcn.getDst(),lb)+"=(struct "+fcn.getType().getSafeSymbol()+" *)"+generateTemp(fm,fcn.getSrc(),lb)+";");
else
- output.println(generateTemp(fm,fcn.getDst())+"=("+fcn.getType().getSafeSymbol()+")"+generateTemp(fm,fcn.getSrc())+";");
+ output.println(generateTemp(fm,fcn.getDst(),lb)+"=("+fcn.getType().getSafeSymbol()+")"+generateTemp(fm,fcn.getSrc(),lb)+";");
}
- private void generateFlatLiteralNode(FlatMethod fm, FlatLiteralNode fln, PrintWriter output) {
+ private void generateFlatLiteralNode(FlatMethod fm, LocalityBinding lb, FlatLiteralNode fln, PrintWriter output) {
if (fln.getValue()==null)
- output.println(generateTemp(fm, fln.getDst())+"=0;");
+ output.println(generateTemp(fm, fln.getDst(),lb)+"=0;");
else if (fln.getType().getSymbol().equals(TypeUtil.StringClass)) {
if (GENERATEPRECISEGC) {
- output.println(generateTemp(fm, fln.getDst())+"=NewString(&"+localsprefix+", \""+FlatLiteralNode.escapeString((String)fln.getValue())+"\","+((String)fln.getValue()).length()+");");
+ output.println(generateTemp(fm, fln.getDst(),lb)+"=NewString(&"+localsprefix+", \""+FlatLiteralNode.escapeString((String)fln.getValue())+"\","+((String)fln.getValue()).length()+");");
} else {
- output.println(generateTemp(fm, fln.getDst())+"=NewString(\""+FlatLiteralNode.escapeString((String)fln.getValue())+"\","+((String)fln.getValue()).length()+");");
+ output.println(generateTemp(fm, fln.getDst(),lb)+"=NewString(\""+FlatLiteralNode.escapeString((String)fln.getValue())+"\","+((String)fln.getValue()).length()+");");
}
} else if (fln.getType().isBoolean()) {
if (((Boolean)fln.getValue()).booleanValue())
- output.println(generateTemp(fm, fln.getDst())+"=1;");
+ output.println(generateTemp(fm, fln.getDst(),lb)+"=1;");
else
- output.println(generateTemp(fm, fln.getDst())+"=0;");
+ output.println(generateTemp(fm, fln.getDst(),lb)+"=0;");
} else if (fln.getType().isChar()) {
String st=FlatLiteralNode.escapeString(fln.getValue().toString());
- output.println(generateTemp(fm, fln.getDst())+"='"+st+"';");
+ output.println(generateTemp(fm, fln.getDst(),lb)+"='"+st+"';");
} else
- output.println(generateTemp(fm, fln.getDst())+"="+fln.getValue()+";");
+ output.println(generateTemp(fm, fln.getDst(),lb)+"="+fln.getValue()+";");
}
- private void generateFlatReturnNode(FlatMethod fm, FlatReturnNode frn, PrintWriter output) {
+ private void generateFlatReturnNode(FlatMethod fm, LocalityBinding lb, FlatReturnNode frn, PrintWriter output) {
if (frn.getReturnTemp()!=null)
- output.println("return "+generateTemp(fm, frn.getReturnTemp())+";");
+ output.println("return "+generateTemp(fm, frn.getReturnTemp(), lb)+";");
else
output.println("return;");
}
- private void generateFlatCondBranch(FlatMethod fm, FlatCondBranch fcb, String label, PrintWriter output) {
- output.println("if (!"+generateTemp(fm, fcb.getTest())+") goto "+label+";");
+ private void generateFlatCondBranch(FlatMethod fm, LocalityBinding lb, FlatCondBranch fcb, String label, PrintWriter output) {
+ output.println("if (!"+generateTemp(fm, fcb.getTest(),lb)+") goto "+label+";");
}
/** This method generates header information for the method or
private void generateHeader(FlatMethod fm, LocalityBinding lb, Descriptor des, PrintWriter output) {
/* Print header */
- ParamsObject objectparams=(ParamsObject)paramstable.get(des);
+ ParamsObject objectparams=(ParamsObject)paramstable.get(lb!=null?lb:des);
MethodDescriptor md=null;
TaskDescriptor task=null;
if (des instanceof MethodDescriptor)
boolean printcomma=false;
if (GENERATEPRECISEGC) {
- if (md!=null)
- output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
- else
+ if (md!=null) {
+ if (state.DSM) {
+ output.print("struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
+ } else
+ output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
+ } else
output.print("struct "+task.getSafeSymbol()+"_params * "+paramsprefix);
printcomma=true;
}
} else output.println(") {");
}
- public void generateFlatFlagActionNode(FlatMethod fm, FlatFlagActionNode ffan, PrintWriter output) {
+ public void generateFlatFlagActionNode(FlatMethod fm, LocalityBinding lb, FlatFlagActionNode ffan, PrintWriter output) {
output.println("/* FlatFlagActionNode */");
while(tagit.hasNext()) {
TempDescriptor tagtmp=(TempDescriptor)tagit.next();
if (GENERATEPRECISEGC)
- output.println("tagclear(&"+localsprefix+", (struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
+ output.println("tagclear(&"+localsprefix+", (struct ___Object___ *)"+generateTemp(fm, temp,lb)+", "+generateTemp(fm,tagtmp,lb)+");");
else
- output.println("tagclear((struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
+ output.println("tagclear((struct ___Object___ *)"+generateTemp(fm, temp,lb)+", "+generateTemp(fm,tagtmp,lb)+");");
}
}
while(tagit.hasNext()) {
TempDescriptor tagtmp=(TempDescriptor)tagit.next();
if (GENERATEPRECISEGC)
- output.println("tagset(&"+localsprefix+", (struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
+ output.println("tagset(&"+localsprefix+", (struct ___Object___ *)"+generateTemp(fm, temp,lb)+", "+generateTemp(fm,tagtmp,lb)+");");
else
- output.println("tagset((struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
+ output.println("tagset((struct ___Object___ *)"+generateTemp(fm, temp, lb)+", "+generateTemp(fm,tagtmp, lb)+");");
}
}
if (flagandtable.containsKey(temp))
andmask=((Integer)flagandtable.get(temp)).intValue();
if (ffan.getTaskType()==FlatFlagActionNode.NEWOBJECT) {
- output.println("flagorandinit("+generateTemp(fm, temp)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
+ output.println("flagorandinit("+generateTemp(fm, temp, lb)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
} else {
- output.println("flagorand("+generateTemp(fm, temp)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
+ output.println("flagorand("+generateTemp(fm, temp, lb)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
}
}
}
//GENERATE HEADERS
headers.println("#include \"task.h\"\n\n");
+ headers.println("#ifndef _OPTIONAL_STRUCT_");
+ headers.println("#define _OPTIONAL_STRUCT_");
+
+
//STRUCT PREDICATEMEMBER
headers.println("int numtags;");
headers.println("int * tags;\n};\n\n");
- //STRUCT EXITFLAGSTATE
- headers.println("struct exitflagstate{");
- headers.println("int numflags;");
- headers.println("int * flags;");
- /*
- headers.println("int numtags;");
- headers.println("int * tags;");
- */
- headers.println("\n};\n\n");
-
- //STRUCT EXITSTATES
+ /*//STRUCT EXITSTATES
headers.println("struct exitstates{");
- headers.println("int numexitflagstates;");
- headers.println("struct exitflagstate * exitflagstatearray;\n};\n\n");
+ headers.println("int numflagstates;");
+ headers.println("int * flagstatearray;\n};\n\n");*///appeared to be useless
//STRUCT OPTIONALTASKDESCRIPTOR
headers.println("struct optionaltaskdescriptor{");
headers.println("struct taskdescriptor * task;");
+ headers.println("int numenterflags;");
+ headers.println("int * enterflags;");
headers.println("int numpredicatemembers;");
- headers.println("struct predicatemember * predicatememberarray;");
- headers.println("int numexitstates;");
- headers.println("struct existates * exitstatesarray;\n};\n\n");
+ headers.println("struct predicatemember ** predicatememberarray;");
+ //headers.println("int numexitstates;");
+ //headers.println("int numTotal;");
+ //headers.println("struct exitstates ** exitstatesarray;\n};\n\n");
+ headers.println("\n};\n\n");
//STRUCT FSANALYSISWRAPPER
headers.println("struct fsanalysiswrapper{");
- headers.println("int numflags;");
- headers.println("int * flags;");
+ headers.println("int flags;");
headers.println("int numtags;");
headers.println("int * tags;");
headers.println("int numoptionaltaskdescriptors;");
- headers.println("struct optionaltaskdescriptor * optionaltaskdescriptorarray;\n};\n\n");
+ headers.println("struct optionaltaskdescriptor ** optionaltaskdescriptorarray;\n};\n\n");
//STRUCT CLASSANALYSISWRAPPER
- headers.println("struct classanalyiswrapper{");
+ headers.println("struct classanalysiswrapper{");
headers.println("int type;");
+ headers.println("int numotd;");
+ headers.println("struct optionaltaskdescriptor ** otdarray;");
headers.println("int numfsanalysiswrappers;");
- headers.println("struct fsanalysiswrapper * fsanalysiswrapperarray;\n};\n\n");
+ headers.println("struct fsanalysiswrapper ** fsanalysiswrapperarray;\n};");
+
+ headers.println("extern struct classanalysiswrapper * classanalysiswrapperarray[];");
Iterator taskit=state.getTaskSymbolTable().getDescriptorsIterator();
while(taskit.hasNext()) {
headers.println("extern struct taskdescriptor task_"+td.getSafeSymbol()+";");
}
-
//GENERATE STRUCTS
- output.println("#include \"optionalstruct.h\"\n\n");
+ if (state.OPTIONAL)
+ output.println("#include \"optionalstruct.h\"\n\n");
HashSet processedcd = new HashSet();
-
+ int maxotd=0;
Enumeration e = safeexecution.keys();
while (e.hasMoreElements()) {
-
+ int numotd=0;
//get the class
ClassDescriptor cdtemp=(ClassDescriptor)e.nextElement();
Hashtable flaginfo=(Hashtable)flagorder.get(cdtemp);//will be used several times
+ //////////////////////////DEBUG
+ System.out.println(cdtemp.getSymbol()+" "+cdtemp.getId());
+ for(Iterator flags = cdtemp.getFlags(); flags.hasNext();){
+ FlagDescriptor flagd = (FlagDescriptor)flags.next();
+ int flagid=1<<((Integer)flaginfo.get(flagd)).intValue();
+ System.out.println(" Flag "+flagd.getSymbol()+" 0x"+Integer.toHexString(flagid)+" int "+flagid);
+ }
+ ///////////////////////////
+
//Generate the struct of optionals
if((Hashtable)optionaltaskdescriptors.get(cdtemp)==null) System.out.println("Was in cd :"+cdtemp.getSymbol());
Collection c_otd = ((Hashtable)optionaltaskdescriptors.get(cdtemp)).values();
+ numotd = c_otd.size();
+ if(maxotd<numotd) maxotd = numotd;
if( !c_otd.isEmpty() ){
for(Iterator otd_it = c_otd.iterator(); otd_it.hasNext();){
OptionalTaskDescriptor otd = (OptionalTaskDescriptor)otd_it.next();
for (Iterator fen_it = fen_hashset.iterator(); fen_it.hasNext();){
FlagExpressionNode fen = (FlagExpressionNode)fen_it.next();
if (fen==null) {
- //output.println("0x0, 0x0 };");
- //numberterms+=1;
- }
+ }
else {
DNFFlag dflag=fen.getDNF();
for(int j=0;j<tagel.numTags();j++) {
if (j!=0)
output.println(",");
- /* for each tag we need */
- /* which slot it is */
- /* what type it is */
- //TagVarDescriptor tvd=(TagVarDescriptor)task.getParameterTable().get(tagel.getName(j));
TempDescriptor tmp=tagel.getTemp(j);
- //got rid of slot
+ //got rid of slot, maybe some improvments to do ???
output.println("/*tagid*/"+state.getTagId(tmp.getTag()));
}
numtags = tagel.numTags();
output.println("struct predicatemember * predicatememberarray_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
for( int j = 0; j<predicateindex; j++){
if( j != predicateindex-1)output.println("&predicatemember_"+j+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
- else output.println("&predicatemember_"+j+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"};\n");
+ else output.println("&predicatemember_"+j+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
}
+ output.println("};\n");
- //generate the struct for possible exitfses
- HashSet<HashSet> exitfses = otd.exitfses;
+ //generate the struct for possible exitfses, appeared to be useless
+ /*HashSet<HashSet> exitfses = otd.exitfses;
int exitindex = 0;
int nbexit = exitfses.size();
int fsnumber;
//iterate through possible exits
+ int nbtotal=0;
for(Iterator exitfseshash = exitfses.iterator(); exitfseshash.hasNext();){
HashSet temp_hashset = (HashSet)exitfseshash.next();
fsnumber = 0 ;
-
+ output.println("int flag_EXIT"+exitindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
//iterate through possible FSes corresponding to the exit
for(Iterator exfses = temp_hashset.iterator(); exfses.hasNext();){
- FlagState fs = (FlagState)exfses.next();
- fsnumber++;
- output.println("int flags"+fsnumber+"_EXIT"+exitindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
- int counterflag = 0;
- for(Iterator flags = fs.getFlags(); flags.hasNext();){
- FlagDescriptor flagd = (FlagDescriptor)flags.next();
- int flagid=1<<((Integer)flaginfo.get(flagd)).intValue();
- if( flags.hasNext() ) output.print("0x"+Integer.toHexString(flagid)+" /*"+Integer.toBinaryString(flagid)+"*/,");
- else output.print("0x"+Integer.toHexString(flagid)+" /*"+Integer.toBinaryString(flagid)+"*/");
- counterflag++;
- }
- output.println("};\n");
- //do the same for tags;
- //maybe not needed because no tag changes tolerated.
-
- //store the information into a struct
- output.println("struct exitflagstate exitflagstate"+fsnumber+"_EXIT"+exitindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"={");
- output.println("/*number of flags*/"+counterflag+",");
- output.println("flags"+fsnumber+"_EXIT"+exitindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
- output.println("};\n");
+ FlagState fs = (FlagState)exfses.next();
+ fsnumber++;
+ nbtotal++;
+ int flagid=0;
+ for(Iterator flags = fs.getFlags(); flags.hasNext();){
+ FlagDescriptor flagd = (FlagDescriptor)flags.next();
+ int id=1<<((Integer)flaginfo.get(flagd)).intValue();
+ flagid+=id;
+ }
+ if(fsnumber!=1) output.print(",");
+ output.print(flagid);
+ //do the same for tags.
+ //maybe not needed because no tag changes tolerated.
}
+ output.println("};\n");
- //store fses corresponding to this exit into an array
- output.println("struct exitflagstate * exitflagstatearray"+"_EXIT"+exitindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+" [] = {");
- for( int j = 0; j<fsnumber; j++){
- if( j != fsnumber-1)output.println("&exitflagstate"+(j+1)+"_EXIT"+exitindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"'");
- else output.println("&exitflagstate"+(j+1)+"_EXIT"+exitindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"};\n");
- }
//store that information in a struct
output.println("struct exitstates exitstates"+exitindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"={");
- output.println("/*number of exitflagstate*/"+fsnumber+",");
- output.println("exitflagstatearray"+"_EXIT"+exitindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
+ output.println(fsnumber+",");
+ output.println("flag_EXIT"+exitindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
output.println("};\n");
exitindex++;
for( int j = 0; j<nbexit; j++){
if( j != nbexit-1)output.println("&exitstates"+j+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
else output.println("&exitstates"+j+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"};\n");
+ }*/
+
+ int fsnumber = 0 ;
+ output.println("int enterflag_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
+ //iterate through possible FSes corresponding to the state when entering
+ for(Iterator fses = otd.flagstates.iterator(); fses.hasNext();){
+ FlagState fs = (FlagState)fses.next();
+ fsnumber++;
+ int flagid=0;
+ for(Iterator flags = fs.getFlags(); flags.hasNext();){
+ FlagDescriptor flagd = (FlagDescriptor)flags.next();
+ int id=1<<((Integer)flaginfo.get(flagd)).intValue();
+ flagid+=id;
+ }
+ if(fsnumber!=1) output.print(",");
+ output.print(flagid);
+ //tag information not needed because tag changes are not tolerated.
}
-
-
+ output.println("};\n");
+
+
//generate optionaltaskdescriptor that actually includes exit fses, predicate and the task concerned
output.println("struct optionaltaskdescriptor optionaltaskdescriptor_"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"={");
- output.println("task_"+otd.td.getSafeSymbol()+",");
+ output.println("&task_"+otd.td.getSafeSymbol()+",");
+ output.println("/*number of enter flags*/"+fsnumber+",");
+ output.println("enterflag_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
output.println("/*number of members */"+predicateindex+",");
output.println("predicatememberarray_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
- output.println("/*number of exit fses */"+nbexit+",");
- output.println("exitstatearray_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
+ //output.println("/*number of exitstates */"+nbexit+",");
+ //output.println("/*total number of fses*/"+nbtotal+",");
+ //output.println("exitstatesarray_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
output.println("};\n");
}
}
else continue; // if there is no optionals, there is no need to build the rest of the struct
+ output.println("struct optionaltaskdescriptor * otdarray"+cdtemp.getSafeSymbol()+"[]={");
+ c_otd = ((Hashtable)optionaltaskdescriptors.get(cdtemp)).values();
+ int x=0;
+ if( !c_otd.isEmpty() ){
+ for(Iterator otd_it = c_otd.iterator(); otd_it.hasNext();){
+ OptionalTaskDescriptor otd = (OptionalTaskDescriptor)otd_it.next();
+ if(x!=0) output.println(",");
+ x++;
+ output.println("&optionaltaskdescriptor_"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
+ }
+ }
+ output.println("};\n");
+
//get all the possible falgstates reachable by an object
Hashtable hashtbtemp = safeexecution.get(cdtemp);
Enumeration fses = hashtbtemp.keys();
output.println("struct optionaltaskdescriptor * optionaltaskdescriptorarray_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"[] = {");
for(Iterator mos = availabletasks.iterator(); mos.hasNext();){
OptionalTaskDescriptor mm = (OptionalTaskDescriptor)mos.next();
- if(!mos.hasNext()) output.println("&optionaltaskdescriptor_"+mm.getuid()+"_"+cdtemp.getSafeSymbol()+"};\n");
+ if(!mos.hasNext()) output.println("&optionaltaskdescriptor_"+mm.getuid()+"_"+cdtemp.getSafeSymbol());
else output.println("&optionaltaskdescriptor_"+mm.getuid()+"_"+cdtemp.getSafeSymbol()+",");
}
+ output.println("};\n");
+
//process flag information (what the flag after failure is) so we know what optionaltaskdescriptors to choose.
- output.println("int flags_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"[]={");
+ int flagid=0;
for(Iterator flags = fs.getFlags(); flags.hasNext();){
FlagDescriptor flagd = (FlagDescriptor)flags.next();
- int flagid=1<<((Integer)flaginfo.get(flagd)).intValue();
- if( flags.hasNext() ) output.print("0x"+Integer.toHexString(flagid)+" /*"+Integer.toBinaryString(flagid)+"*/,");
- else output.print("0x"+Integer.toHexString(flagid)+" /*"+Integer.toBinaryString(flagid)+"*/");
-
+ int id=1<<((Integer)flaginfo.get(flagd)).intValue();
+ flagid+=id;
}
+
+
//process tag information
int tagcounter = 0;
- //TagExpressionList tagel = fs.getTags();
- //output.println("int predicatetags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
- //BUG...added next line to fix, test with any task program
-
- //if (tagel!=null){
- // for(int j=0;j<tagel.numTags();j++) {
- // if (j!=0)
- // output.println(",");
- // TempDescriptor tmp=tagel.getTemp(j);
- // output.println("/*tagid*/"+state.getTagId(tmp.getTag()));
- // }
- // numtags = tagel.numTags();
- //}
- //output.println("};");
+ boolean first = true;
+ Enumeration tag_enum = fs.getTags();
+ output.println("int tags_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"[]={");
+ while(tag_enum.hasMoreElements()){
+ tagcounter++;
+ TagDescriptor tagd = (TagDescriptor)tag_enum.nextElement();
+ if(first==true)
+ first = false;
+ else
+ output.println(", ");
+ output.println("/*tagid*/"+state.getTagId(tagd));
+ }
+ output.println("};");
//Store the result in fsanalysiswrapper
- output.println("};\n");
+
output.println("struct fsanalysiswrapper fsanalysiswrapper_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"={");
- output.println("/* number of flags*/"+fs.numFlags()+",");
- output.println("flags_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+",");
+ output.println("/*flag*/"+flagid+",");
output.println("/* number of tags*/"+tagcounter+",");
output.println("tags_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+",");
output.println("/* number of optionaltaskdescriptors */"+availabletasks.size()+",");
//Build the classanalysiswrapper referring to the previous array
output.println("struct classanalysiswrapper classanalysiswrapper_"+cdtemp.getSafeSymbol()+"={");
output.println("/*type*/"+cdtemp.getId()+",");
+ output.println("/*numotd*/"+numotd+",");
+ output.println("otdarray"+cdtemp.getSafeSymbol()+",");
output.println("/* number of fsanalysiswrappers */"+fscounter+",");
output.println("fsanalysiswrapperarray_"+cdtemp.getSafeSymbol()+"};\n");
fscounter = 0;
processedcd.add(cdtemp);
}
-
+
//build an array containing every classes for which code has been build
output.println("struct classanalysiswrapper * classanalysiswrapperarray[]={");
+ boolean needcomma=false;
for(Iterator classit = processedcd.iterator(); classit.hasNext();){
ClassDescriptor cdtemp=(ClassDescriptor)classit.next();
- if(!classit.hasNext()) output.println("&classanalysiswrapper_"+cdtemp.getSafeSymbol()+"};\n");
- else output.println("&classanalysiswrapper_"+cdtemp.getSafeSymbol()+",");
+ if (needcomma)
+ output.println(", ");
+ needcomma=true;
+ output.println("&classanalysiswrapper_"+cdtemp.getSafeSymbol());
}
- output.println("int numclasses = "+processedcd.size()+";");
+ output.println("};");
+
+ output.println("int numclasses="+processedcd.size()+";");
+ headers.println("extern numclasses;");
+ output.println("int maxotd="+maxotd+";");
+ headers.println("extern maxotd;");
+ headers.println("#endif");
+
}
projects / IRC.git / blobdiff