X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=Robust%2Fsrc%2FIR%2FFlat%2FBuildFlat.java;h=98070b7fcd52425aa229eefcec5faacf5b061c57;hb=7d9444125d973802b28173ac2533e8930e64c675;hp=6c58090e6c740c4dc6c5488a6cc07a069017363d;hpb=3b16dfab9b7b6606bf87cbc5a3e77261bd545dd7;p=IRC.git

diff --git a/Robust/src/IR/Flat/BuildFlat.java b/Robust/src/IR/Flat/BuildFlat.java
index 6c58090e..98070b7f 100644
--- a/Robust/src/IR/Flat/BuildFlat.java
+++ b/Robust/src/IR/Flat/BuildFlat.java
@@ -6,10 +6,13 @@ import java.util.*;
 public class BuildFlat {
     State state;
     Hashtable temptovar;
+    MethodDescriptor currmd;
+    TypeUtil typeutil;
 
-    public BuildFlat(State st) {
+    public BuildFlat(State st, TypeUtil typeutil) {
 	state=st;
 	temptovar=new Hashtable();
+	this.typeutil=typeutil;
     }
 
     public Hashtable getMap() {
@@ -22,22 +25,132 @@ public class BuildFlat {
 	    ClassDescriptor cn=(ClassDescriptor)it.next();
 	    flattenClass(cn);
 	}
+	
+	Iterator task_it=state.getTaskSymbolTable().getDescriptorsIterator();
+	while(task_it.hasNext()) {
+	    TaskDescriptor td=(TaskDescriptor)task_it.next();
+	    flattenTask(td);
+	}
     }
     
+    private void flattenTask(TaskDescriptor td) {
+	BlockNode bn=state.getMethodBody(td);
+	NodePair np=flattenBlockNode(bn);
+	FlatNode fn=np.getBegin();
+	if (np.getEnd().kind()!=FKind.FlatReturnNode) {
+	    FlatReturnNode rnflat=new FlatReturnNode(null);
+	    np.getEnd().addNext(rnflat);
+	}
+
+	FlatFlagActionNode ffan=new FlatFlagActionNode(FlatFlagActionNode.PRE);
+	ffan.addNext(fn);
+
+	FlatMethod fm=new FlatMethod(td);
+	fm.addNext(ffan);
+
+	Hashtable visitedset=new Hashtable();
+
+	for(int i=0;i<td.numParameters();i++) {
+	    VarDescriptor paramvd=td.getParameter(i);
+	    fm.addParameterTemp(getTempforVar(paramvd));
+	    TagExpressionList tel=td.getTag(paramvd);
+	    //BUG added next line to fix...to test feed in any task program
+	    if (tel!=null)
+		for(int j=0;j<tel.numTags();j++) {
+		    TagVarDescriptor tvd=(TagVarDescriptor) td.getParameterTable().getFromSameScope(tel.getName(j));
+		    TempDescriptor tagtmp=getTempforVar(tvd);
+		    if (!visitedset.containsKey(tvd.getName())) {
+			visitedset.put(tvd.getName(),tvd.getTag());
+			fm.addTagTemp(tagtmp);
+		    } else {
+			TagDescriptor tmptd=(TagDescriptor) visitedset.get(tvd.getName());
+			if (!tmptd.equals(tvd.getTag()))
+			    throw new Error("Two different tag types with same name as parameters to:"+td);
+		    }
+		    tel.setTemp(j, tagtmp);
+		}
+	}
+
+	/* Flatten Vector of Flag Effects */
+	Vector flags=td.getFlagEffects();
+	updateFlagActionNode(ffan,flags);
+
+	state.addFlatCode(td,fm);
+    }
+
+
+    /* This method transforms a vector of FlagEffects into the FlatFlagActionNode */
+    private void updateFlagActionNode(FlatFlagActionNode ffan, Vector flags) {
+	if (flags==null) // Do nothing if the flag effects vector is empty
+	    return;
+
+	for(int i=0;i<flags.size();i++) {
+	    FlagEffects fes=(FlagEffects)flags.get(i);
+	    TempDescriptor flagtemp=getTempforVar(fes.getVar());
+	    // Process the flags
+	    for(int j=0;j<fes.numEffects();j++) {
+		FlagEffect fe=fes.getEffect(j);
+		ffan.addFlagAction(flagtemp, fe.getFlag(), fe.getStatus());
+	    }
+	    // Process the tags
+	    for(int j=0;j<fes.numTagEffects();j++) {
+		TagEffect te=fes.getTagEffect(j);
+		TempDescriptor tagtemp=getTempforVar(te.getTag());
+		
+		ffan.addTagAction(flagtemp, te.getTag().getTag(), tagtemp, te.getStatus());
+	    }
+	}
+    }
+
+    FlatAtomicEnterNode curran=null;
+
     private void flattenClass(ClassDescriptor cn) {
 	Iterator methodit=cn.getMethods();
 	while(methodit.hasNext()) {
-	    MethodDescriptor md=(MethodDescriptor)methodit.next();
-	    BlockNode bn=state.getMethodBody(md);
-	    FlatNode fn=flattenBlockNode(bn).getBegin();
-	    FlatMethod fm=new FlatMethod(md, fn);
-	    if (!md.isStatic())
-		fm.addParameterTemp(getTempforVar(md.getThis()));
-	    for(int i=0;i<md.numParameters();i++) {
-		fm.addParameterTemp(getTempforVar(md.getParameter(i)));
+	    currmd=(MethodDescriptor)methodit.next();
+	    BlockNode bn=state.getMethodBody(currmd);
+
+	    if (state.DSM&&currmd.getModifiers().isAtomic()) {
+		curran=new FlatAtomicEnterNode();
+	    } else
+		curran=null;
+	    NodePair np=flattenBlockNode(bn);
+	    FlatNode fn=np.getBegin();
+	    if (state.THREAD&&currmd.getModifiers().isSynchronized()) {
+		MethodDescriptor memd=(MethodDescriptor)typeutil.getClass("Object").getMethodTable().get("MonitorEnter");
+		TempDescriptor thistd=getTempforVar(currmd.getThis());
+		FlatCall fc=new FlatCall(memd, null, thistd, new TempDescriptor[0]);
+		fc.addNext(fn);
+		fn=fc;
+		if (np.getEnd().kind()!=FKind.FlatReturnNode) {
+		    MethodDescriptor memdex=(MethodDescriptor)typeutil.getClass("Object").getMethodTable().get("MonitorExit");
+		    FlatCall fcunlock=new FlatCall(memdex, null, thistd, new TempDescriptor[0]);
+		    np.getEnd().addNext(fcunlock);
+		    FlatReturnNode rnflat=new FlatReturnNode(null);
+		    fcunlock.addNext(rnflat);
+		}
+	    } else if (state.DSM&&currmd.getModifiers().isAtomic()) {
+		curran.addNext(fn);
+		fn=curran;
+		if (np.getEnd().kind()!=FKind.FlatReturnNode) {
+		    FlatAtomicExitNode aen=new FlatAtomicExitNode(curran);
+		    np.getEnd().addNext(aen);
+		    FlatReturnNode rnflat=new FlatReturnNode(null);
+		    aen.addNext(rnflat);
+		}
+	    } else if (np.getEnd().kind()!=FKind.FlatReturnNode) {
+		FlatReturnNode rnflat=new FlatReturnNode(null);
+		np.getEnd().addNext(rnflat);
+	    }
+
+	    FlatMethod fm=new FlatMethod(currmd);
+	    fm.addNext(fn);
+	    if (!currmd.isStatic())
+		fm.addParameterTemp(getTempforParam(currmd.getThis()));
+	    for(int i=0;i<currmd.numParameters();i++) {
+		fm.addParameterTemp(getTempforParam(currmd.getParameter(i)));
 	    }
-	    System.out.println(fm.printMethod());
-	    state.addFlatCode(md,fm);
+	    state.addFlatCode(currmd,fm);
 	}
     }
 
@@ -84,23 +197,116 @@ public class BuildFlat {
 
     private NodePair flattenCreateObjectNode(CreateObjectNode con,TempDescriptor out_temp) {
 	TypeDescriptor td=con.getType();
-	FlatNew fn=new FlatNew(td, out_temp);
-	TempDescriptor[] temps=new TempDescriptor[con.numArgs()];
-	FlatNode last=fn;
-	//Build arguments
-	for(int i=0;i<con.numArgs();i++) {
-	    ExpressionNode en=con.getArg(i);
-	    TempDescriptor tmp=TempDescriptor.tempFactory("arg",en.getType());
-	    temps[i]=tmp;
-	    NodePair np=flattenExpressionNode(en, tmp);
-	    last.addNext(np.getBegin());
-	    last=np.getEnd();
+	if (!td.isArray()) {
+	    FlatNew fn=new FlatNew(td, out_temp, con.isGlobal());
+	    TempDescriptor[] temps=new TempDescriptor[con.numArgs()];
+	    FlatNode last=fn;
+	    if (td.getClassDesc().hasFlags()) {
+		//	    if (con.getFlagEffects()!=null) {
+		FlatFlagActionNode ffan=new FlatFlagActionNode(FlatFlagActionNode.NEWOBJECT);
+		FlagEffects fes=con.getFlagEffects();
+		TempDescriptor flagtemp=out_temp;
+		if (fes!=null) {
+		    for(int j=0;j<fes.numEffects();j++) {
+			FlagEffect fe=fes.getEffect(j);
+			ffan.addFlagAction(flagtemp, fe.getFlag(), fe.getStatus());
+		    } 
+		    for(int j=0;j<fes.numTagEffects();j++) {
+			TagEffect te=fes.getTagEffect(j);
+			TempDescriptor tagtemp=getTempforVar(te.getTag());
+		
+			ffan.addTagAction(flagtemp, te.getTag().getTag(), tagtemp, te.getStatus());
+		    }
+		} else {
+		    ffan.addFlagAction(flagtemp, null, false);
+		}
+		last.addNext(ffan);
+		last=ffan;
+	    }
+	    //Build arguments
+	    for(int i=0;i<con.numArgs();i++) {
+		ExpressionNode en=con.getArg(i);
+		TempDescriptor tmp=TempDescriptor.tempFactory("arg",en.getType());
+		temps[i]=tmp;
+		NodePair np=flattenExpressionNode(en, tmp);
+		last.addNext(np.getBegin());
+		last=np.getEnd();
+	    }
+	    MethodDescriptor md=con.getConstructor();
+	    //Call to constructor
+	    FlatCall fc=new FlatCall(md, null, out_temp, temps);
+	    last.addNext(fc);
+	    last=fc;
+	    return new NodePair(fn,last); 
+	} else {
+	    FlatNode first=null;
+	    FlatNode last=null;
+	    TempDescriptor[] temps=new TempDescriptor[con.numArgs()];
+	    for (int i=0;i<con.numArgs();i++) {
+		ExpressionNode en=con.getArg(i);
+		TempDescriptor tmp=TempDescriptor.tempFactory("arg",en.getType());
+		temps[i]=tmp;		
+		NodePair np=flattenExpressionNode(en, tmp);
+		if (first==null)
+		    first=np.getBegin();
+		else
+		    last.addNext(np.getBegin());
+		last=np.getEnd();
+		
+		TempDescriptor tmp2=(i==0)?
+		    out_temp:
+		TempDescriptor.tempFactory("arg",en.getType());
+	    }
+	    FlatNew fn=new FlatNew(td, out_temp, temps[0], con.isGlobal());
+	    last.addNext(fn);
+	    if (temps.length>1) {
+		NodePair np=generateNewArrayLoop(temps, td.dereference(), out_temp, 0, con.isGlobal());
+		fn.addNext(np.getBegin());
+		return new NodePair(first,np.getEnd()); 
+	    } else
+		return new NodePair(first, fn);
 	}
-	MethodDescriptor md=con.getConstructor();
-	//Call to constructor
-	FlatCall fc=new FlatCall(md, null, out_temp, temps);
-	last.addNext(fc);
-	return new NodePair(fn,fc);
+    }
+
+    private NodePair generateNewArrayLoop(TempDescriptor[] temparray, TypeDescriptor td, TempDescriptor tmp, int i, boolean isglobal) {
+	TempDescriptor index=TempDescriptor.tempFactory("index",new TypeDescriptor(TypeDescriptor.INT));
+	TempDescriptor tmpone=TempDescriptor.tempFactory("index",new TypeDescriptor(TypeDescriptor.INT));
+	FlatNop fnop=new FlatNop();//last node
+
+	//index=0
+	FlatLiteralNode fln=new FlatLiteralNode(index.getType(),new Integer(0),index);
+	//tmpone=1
+	FlatLiteralNode fln2=new FlatLiteralNode(tmpone.getType(),new Integer(1),tmpone);
+
+	TempDescriptor tmpbool=TempDescriptor.tempFactory("comp",new TypeDescriptor(TypeDescriptor.BOOLEAN));
+
+	FlatOpNode fcomp=new FlatOpNode(tmpbool,index,temparray[i],new Operation(Operation.LT));
+	FlatCondBranch fcb=new FlatCondBranch(tmpbool);
+	fcb.setTrueProb(State.TRUEPROB);
+	fcb.setLoop();
+	//is index<temp[i]
+	TempDescriptor new_tmp=TempDescriptor.tempFactory("tmp",td);
+	FlatNew fn=new FlatNew(td, new_tmp, temparray[i+1], isglobal);
+	FlatSetElementNode fsen=new FlatSetElementNode(tmp,index,new_tmp);
+	// index=index+1
+	FlatOpNode fon=new FlatOpNode(index,index,tmpone,new Operation(Operation.ADD));
+	//jump out
+	fln.addNext(fln2);
+	fln2.addNext(fcomp);
+	fcomp.addNext(fcb);
+	fcb.addTrueNext(fn);
+	fcb.addFalseNext(fnop);
+	fn.addNext(fsen);
+	//Recursive call here
+	if ((i+2)<temparray.length) {
+	    NodePair np2=generateNewArrayLoop(temparray, td.dereference(), new_tmp, i+1, isglobal);
+	    fsen.addNext(np2.getBegin());
+	    np2.getEnd().addNext(fon);
+	} else {
+	    fsen.addNext(fon);
+	}
+	fon.addNext(fcomp);
+	return new NodePair(fln, fnop);
     }
 
     private NodePair flattenMethodInvokeNode(MethodInvokeNode min,TempDescriptor out_temp) {
@@ -153,55 +359,293 @@ public class BuildFlat {
 	return new NodePair(npe.getBegin(),fn);
     }
 
+    private NodePair flattenArrayAccessNode(ArrayAccessNode aan,TempDescriptor out_temp) {
+	TempDescriptor tmp=TempDescriptor.tempFactory("temp",aan.getExpression().getType());
+	TempDescriptor tmpindex=TempDescriptor.tempFactory("temp",aan.getIndex().getType());
+	NodePair npe=flattenExpressionNode(aan.getExpression(),tmp);
+	NodePair npi=flattenExpressionNode(aan.getIndex(),tmpindex);
+	FlatElementNode fn=new FlatElementNode(tmp,tmpindex,out_temp);
+	npe.getEnd().addNext(npi.getBegin());
+	npi.getEnd().addNext(fn);
+	return new NodePair(npe.getBegin(),fn);
+    }
+
     private NodePair flattenAssignmentNode(AssignmentNode an,TempDescriptor out_temp) {
-	// Two cases:
+	// Three cases:
 	// left side is variable
 	// left side is field
+	// left side is array
 	
 	Operation base=an.getOperation().getBaseOp();
-	TempDescriptor src_tmp=TempDescriptor.tempFactory("src",an.getSrc().getType());
-	NodePair np_src=flattenExpressionNode(an.getSrc(),src_tmp);
-	FlatNode last=np_src.getEnd();
-	if (base!=null) {
-	    TempDescriptor src_tmp2=TempDescriptor.tempFactory("tmp", an.getDest().getType());
-	    NodePair np_dst_init=flattenExpressionNode(an.getDest(),src_tmp2);
-	    last.addNext(np_dst_init.getBegin());
-	    TempDescriptor dst_tmp=TempDescriptor.tempFactory("dst_tmp",an.getDest().getType());
-	    FlatOpNode fon=new FlatOpNode(dst_tmp, src_tmp,src_tmp2, base);
-	    np_dst_init.getEnd().addNext(fon);
-	    last=fon;
-	    src_tmp=dst_tmp;
+	boolean pre=base==null||(base.getOp()!=Operation.POSTINC&&base.getOp()!=Operation.POSTDEC);
+	
+	if (!pre) {
+	    //rewrite the base operation
+	    base=base.getOp()==Operation.POSTINC?new Operation(Operation.ADD):new Operation(Operation.SUB);
+	}
+	FlatNode first=null;
+	FlatNode last=null;
+	TempDescriptor src_tmp=an.getSrc()==null?TempDescriptor.tempFactory("srctmp",an.getDest().getType()):TempDescriptor.tempFactory("srctmp",an.getSrc().getType());
+
+	//Get src value
+	if (an.getSrc()!=null) {
+	    NodePair np_src=flattenExpressionNode(an.getSrc(),src_tmp);
+	    first=np_src.getBegin();
+	    last=np_src.getEnd();
+	} else if (!pre) {
+	    FlatLiteralNode fln=new FlatLiteralNode(new TypeDescriptor(TypeDescriptor.INT) ,new Integer(1),src_tmp);
+	    first=fln;
+	    last=fln;
 	}
 	
 	if (an.getDest().kind()==Kind.FieldAccessNode) {
+	    //We are assigning an object field
+
 	    FieldAccessNode fan=(FieldAccessNode)an.getDest();
 	    ExpressionNode en=fan.getExpression();
 	    TempDescriptor dst_tmp=TempDescriptor.tempFactory("dst",en.getType());
 	    NodePair np_baseexp=flattenExpressionNode(en, dst_tmp);
-	    last.addNext(np_baseexp.getBegin());
+	    if (first==null)
+		first=np_baseexp.getBegin();
+	    else
+		last.addNext(np_baseexp.getBegin());
+	    last=np_baseexp.getEnd();
+
+	    //See if we need to perform an operation
+	    if (base!=null) {
+		//If it is a preinc we need to store the initial value
+		TempDescriptor src_tmp2=pre?TempDescriptor.tempFactory("src",an.getDest().getType()):out_temp;
+		TempDescriptor tmp=TempDescriptor.tempFactory("srctmp3",an.getDest().getType());
+		FlatFieldNode ffn=new FlatFieldNode(fan.getField(), dst_tmp, src_tmp2);
+		last.addNext(ffn);
+		last=ffn;
+
+		if (base.getOp()==Operation.ADD&&an.getDest().getType().isString()) {
+		    ClassDescriptor stringcd=typeutil.getClass(TypeUtil.StringClass);
+		    MethodDescriptor concatmd=typeutil.getMethod(stringcd, "concat2", new TypeDescriptor[] {new TypeDescriptor(stringcd), new TypeDescriptor(stringcd)});
+		    FlatCall fc=new FlatCall(concatmd, tmp, null, new TempDescriptor[] {src_tmp2, src_tmp});
+		    src_tmp=tmp;
+		    last.addNext(fc);
+		    last=fc;
+		} else {
+		    FlatOpNode fon=new FlatOpNode(tmp, src_tmp2, src_tmp, base);
+		    src_tmp=tmp;
+		    last.addNext(fon);
+		    last=fon;
+		}
+	    }
+
 	    FlatSetFieldNode fsfn=new FlatSetFieldNode(dst_tmp, fan.getField(), src_tmp);
-	    np_baseexp.getEnd().addNext(fsfn);
-	    return new NodePair(np_src.getBegin(), fsfn);
+	    last.addNext(fsfn);
+	    last=fsfn;
+	    if (pre) {
+		FlatOpNode fon2=new FlatOpNode(out_temp, src_tmp, null, new Operation(Operation.ASSIGN));
+		fsfn.addNext(fon2);
+		last=fon2;
+	    }
+	    return new NodePair(first, last);
+	} else if (an.getDest().kind()==Kind.ArrayAccessNode) {
+	    //We are assigning an array element
+
+
+	    ArrayAccessNode aan=(ArrayAccessNode)an.getDest();
+	    ExpressionNode en=aan.getExpression();
+	    ExpressionNode enindex=aan.getIndex();
+	    TempDescriptor dst_tmp=TempDescriptor.tempFactory("dst",en.getType());
+	    TempDescriptor index_tmp=TempDescriptor.tempFactory("index",enindex.getType());
+	    NodePair np_baseexp=flattenExpressionNode(en, dst_tmp);
+	    NodePair np_indexexp=flattenExpressionNode(enindex, index_tmp);
+	    if (first==null)
+		first=np_baseexp.getBegin();
+	    else
+		last.addNext(np_baseexp.getBegin());
+	    np_baseexp.getEnd().addNext(np_indexexp.getBegin());
+	    last=np_indexexp.getEnd();
+
+	    //See if we need to perform an operation
+	    if (base!=null) {
+		//If it is a preinc we need to store the initial value
+		TempDescriptor src_tmp2=pre?TempDescriptor.tempFactory("src",an.getDest().getType()):out_temp;
+		TempDescriptor tmp=TempDescriptor.tempFactory("srctmp3",an.getDest().getType());
+
+		FlatElementNode fen=new FlatElementNode(dst_tmp, index_tmp, src_tmp2);
+		last.addNext(fen);
+		last=fen;
+
+		if (base.getOp()==Operation.ADD&&an.getDest().getType().isString()) {
+		    ClassDescriptor stringcd=typeutil.getClass(TypeUtil.StringClass);
+		    MethodDescriptor concatmd=typeutil.getMethod(stringcd, "concat2", new TypeDescriptor[] {new TypeDescriptor(stringcd), new TypeDescriptor(stringcd)});
+		    FlatCall fc=new FlatCall(concatmd, tmp, null, new TempDescriptor[] {src_tmp2, src_tmp});
+		    src_tmp=tmp;
+		    last.addNext(fc);
+		    last=fc;
+		} else {
+
+
+		    FlatOpNode fon=new FlatOpNode(tmp, src_tmp2, src_tmp, base);
+		    src_tmp=tmp;
+		    last.addNext(fon);
+		    last=fon;
+		}
+	    }
+
+
+	    FlatSetElementNode fsen=new FlatSetElementNode(dst_tmp, index_tmp, src_tmp);
+	    last.addNext(fsen);
+	    last=fsen;
+	    if (pre) {
+		FlatOpNode fon2=new FlatOpNode(out_temp, src_tmp, null, new Operation(Operation.ASSIGN));
+		fsen.addNext(fon2);
+		last=fon2;
+	    }
+	    return new NodePair(first, last);
 	} else if (an.getDest().kind()==Kind.NameNode) {
+	    //We could be assigning a field or variable
 	    NameNode nn=(NameNode)an.getDest();
 	    if (nn.getExpression()!=null) {
+		//It is a field
 		FieldAccessNode fan=(FieldAccessNode)nn.getExpression();
 		ExpressionNode en=fan.getExpression();
 		TempDescriptor dst_tmp=TempDescriptor.tempFactory("dst",en.getType());
 		NodePair np_baseexp=flattenExpressionNode(en, dst_tmp);
-		last.addNext(np_baseexp.getBegin());
+		if (first==null)
+		    first=np_baseexp.getBegin();
+		else
+		    last.addNext(np_baseexp.getBegin());
+		last=np_baseexp.getEnd();
+
+		//See if we need to perform an operation
+		if (base!=null) {
+		    //If it is a preinc we need to store the initial value
+		    TempDescriptor src_tmp2=pre?TempDescriptor.tempFactory("src",an.getDest().getType()):out_temp;
+		    TempDescriptor tmp=TempDescriptor.tempFactory("srctmp3",an.getDest().getType());
+		    
+		    FlatFieldNode ffn=new FlatFieldNode(fan.getField(), dst_tmp, src_tmp2);
+		    last.addNext(ffn);
+		    last=ffn;
+
+		    
+		    if (base.getOp()==Operation.ADD&&an.getDest().getType().isString()) {
+			ClassDescriptor stringcd=typeutil.getClass(TypeUtil.StringClass);
+			MethodDescriptor concatmd=typeutil.getMethod(stringcd, "concat2", new TypeDescriptor[] {new TypeDescriptor(stringcd), new TypeDescriptor(stringcd)});
+			FlatCall fc=new FlatCall(concatmd, tmp, null, new TempDescriptor[] {src_tmp2, src_tmp});
+			src_tmp=tmp;
+			last.addNext(fc);
+			last=fc;
+		    } else {
+			FlatOpNode fon=new FlatOpNode(tmp, src_tmp2, src_tmp, base);
+			src_tmp=tmp;
+			last.addNext(fon);
+			last=fon;
+		    }
+		}
+
+
 		FlatSetFieldNode fsfn=new FlatSetFieldNode(dst_tmp, fan.getField(), src_tmp);
-		np_baseexp.getEnd().addNext(fsfn);
-		return new NodePair(np_src.getBegin(), fsfn);
+		last.addNext(fsfn);
+		last=fsfn;
+		if (pre) {
+		    FlatOpNode fon2=new FlatOpNode(out_temp, src_tmp, null, new Operation(Operation.ASSIGN));
+		    fsfn.addNext(fon2);
+		    last=fon2;
+		}
+		return new NodePair(first, last);
 	    } else {
 		if (nn.getField()!=null) {
+		    //It is a field
+		    //Get src value
+
+		    //See if we need to perform an operation
+		    if (base!=null) {
+			//If it is a preinc we need to store the initial value
+			TempDescriptor src_tmp2=pre?TempDescriptor.tempFactory("src",an.getDest().getType()):out_temp;
+			TempDescriptor tmp=TempDescriptor.tempFactory("srctmp3",an.getDest().getType());
+			
+			FlatFieldNode ffn=new FlatFieldNode(nn.getField(), getTempforVar(nn.getVar()), src_tmp2);
+			if (first==null)
+			    first=ffn;
+			else {
+			    last.addNext(ffn);
+			}
+			last=ffn;
+
+			
+			if (base.getOp()==Operation.ADD&&an.getDest().getType().isString()) {
+			    ClassDescriptor stringcd=typeutil.getClass(TypeUtil.StringClass);
+			    MethodDescriptor concatmd=typeutil.getMethod(stringcd, "concat2", new TypeDescriptor[] {new TypeDescriptor(stringcd), new TypeDescriptor(stringcd)});
+			    FlatCall fc=new FlatCall(concatmd, tmp, null, new TempDescriptor[] {src_tmp2, src_tmp});
+			    src_tmp=tmp;
+			    last.addNext(fc);
+			    last=fc;
+			} else {
+			    FlatOpNode fon=new FlatOpNode(tmp, src_tmp2, src_tmp, base);
+			    src_tmp=tmp;
+			    last.addNext(fon);
+			    last=fon;
+			}
+		    }		    
+
 		    FlatSetFieldNode fsfn=new FlatSetFieldNode(getTempforVar(nn.getVar()), nn.getField(), src_tmp);
-		    last.addNext(fsfn);
-		    return new NodePair(np_src.getBegin(), fsfn);
+		    if (first==null) {
+			first=fsfn;
+		    } else {
+			last.addNext(fsfn);
+		    }
+		    last=fsfn;
+		    if (pre) {
+			FlatOpNode fon2=new FlatOpNode(out_temp, src_tmp, null, new Operation(Operation.ASSIGN));
+			fsfn.addNext(fon2);
+			last=fon2;
+		    }
+		    return new NodePair(first, last);
 		} else {
+		    //It is a variable
+		    //See if we need to perform an operation
+
+		    if (base!=null) {
+			//If it is a preinc we need to store the initial value
+			TempDescriptor src_tmp2=getTempforVar(nn.getVar());
+			TempDescriptor tmp=TempDescriptor.tempFactory("srctmp3",an.getDest().getType());
+			if (!pre) {
+			    FlatOpNode fon=new FlatOpNode(out_temp, src_tmp2, null, new Operation(Operation.ASSIGN));
+			    if (first==null)
+				first=fon;
+			    else
+				last.addNext(fon);
+			    last=fon;
+			}
+
+			
+			if (base.getOp()==Operation.ADD&&an.getDest().getType().isString()) {
+			    ClassDescriptor stringcd=typeutil.getClass(TypeUtil.StringClass);
+			    MethodDescriptor concatmd=typeutil.getMethod(stringcd, "concat2", new TypeDescriptor[] {new TypeDescriptor(stringcd), new TypeDescriptor(stringcd)});
+			    FlatCall fc=new FlatCall(concatmd, tmp, null, new TempDescriptor[] {src_tmp2, src_tmp});
+			    if (first==null)
+				first=fc;
+			    else
+				last.addNext(fc);
+			    src_tmp=tmp;
+			    last=fc;
+			} else {
+			    FlatOpNode fon=new FlatOpNode(tmp, src_tmp2, src_tmp, base);
+			    if (first==null) 
+				first=fon;
+			    else 
+				last.addNext(fon);
+			    src_tmp=tmp;
+			    last=fon;
+			}
+		    }
+
 		    FlatOpNode fon=new FlatOpNode(getTempforVar(nn.getVar()), src_tmp, null, new Operation(Operation.ASSIGN));
 		    last.addNext(fon);
-		    return new NodePair(np_src.getBegin(),fon);
+		    last=fon;
+		    if (pre) {
+			FlatOpNode fon2=new FlatOpNode(out_temp, src_tmp, null, new Operation(Operation.ASSIGN));
+			fon.addNext(fon2);
+			last=fon2;
+		    }
+		    return new NodePair(first, last);
 		}
 	    }
 	} 
@@ -217,7 +661,11 @@ public class BuildFlat {
 	    FlatFieldNode ffn=new FlatFieldNode(nn.getField(), tmp, out_temp); 
 	    return new NodePair(ffn,ffn);
 	} else {
-	    TempDescriptor tmp=getTempforVar(nn.getVar());
+	    TempDescriptor tmp=getTempforVar(nn.isTag()?nn.getTagVar():nn.getVar());
+	    if (nn.isTag()) {
+		//propagate tag
+		out_temp.setTag(tmp.getTag());
+	    }
 	    FlatOpNode fon=new FlatOpNode(out_temp, tmp, null, new Operation(Operation.ASSIGN));
 	    return new NodePair(fon,fon);
 	}
@@ -228,26 +676,7 @@ public class BuildFlat {
 	TempDescriptor temp_right=null;
 
 	Operation op=on.getOp();
-	if (op.getOp()==Operation.POSTINC||
-	    op.getOp()==Operation.POSTDEC||
-	    op.getOp()==Operation.PREINC||
-	    op.getOp()==Operation.PREDEC) {
-	    LiteralNode ln=new LiteralNode("int",new Integer(1));
-	    ln.setType(new TypeDescriptor(TypeDescriptor.INT));
-	    AssignmentNode an=new AssignmentNode(on.getLeft(),ln,
-			       new AssignOperation((op.getOp()==Operation.POSTINC||op.getOp()==Operation.PREINC)?AssignOperation.PLUSEQ:AssignOperation.MINUSEQ));
-	    if (op.getOp()==Operation.POSTINC||
-		op.getOp()==Operation.POSTDEC) {
-		NodePair left=flattenExpressionNode(on.getLeft(),out_temp);
-		NodePair assign=flattenAssignmentNode(an,temp_left);
-		left.getEnd().addNext(assign.getBegin());
-		return new NodePair(left.getBegin(),assign.getEnd());
-	    } else {
-		NodePair assign=flattenAssignmentNode(an,out_temp);
-		return assign;
-	    }
- 	} 
-	
+
 	NodePair left=flattenExpressionNode(on.getLeft(),temp_left);
 	NodePair right;
 	if (on.getRight()!=null) {
@@ -284,6 +713,14 @@ public class BuildFlat {
 	    fcb.addFalseNext(fon1);
 	    fon1.addNext(fnop);
  	    return new NodePair(left.getBegin(), fnop);
+	} else if (op.getOp()==Operation.ADD&&on.getLeft().getType().isString()) {
+	    //We have a string concatenate
+	    ClassDescriptor stringcd=typeutil.getClass(TypeUtil.StringClass);
+	    MethodDescriptor concatmd=typeutil.getMethod(stringcd, "concat", new TypeDescriptor[] {new TypeDescriptor(stringcd)});
+	    FlatCall fc=new FlatCall(concatmd, out_temp, temp_left, new TempDescriptor[] {temp_right});
+	    left.getEnd().addNext(right.getBegin());
+	    right.getEnd().addNext(fc);
+	    return new NodePair(left.getBegin(), fc);
 	}
 
 	FlatOpNode fon=new FlatOpNode(out_temp,temp_left,temp_right,op);
@@ -302,6 +739,8 @@ public class BuildFlat {
 	    return flattenCreateObjectNode((CreateObjectNode)en,out_temp);
 	case Kind.FieldAccessNode:
 	    return flattenFieldAccessNode((FieldAccessNode)en,out_temp);
+	case Kind.ArrayAccessNode:
+	    return flattenArrayAccessNode((ArrayAccessNode)en,out_temp);
 	case Kind.LiteralNode:
 	    return flattenLiteralNode((LiteralNode)en,out_temp);
 	case Kind.MethodInvokeNode:
@@ -324,14 +763,54 @@ public class BuildFlat {
 	    return new NodePair(fn,fn);
 	}
     }
-        
-    private TempDescriptor getTempforVar(VarDescriptor vd) {
-	if (temptovar.containsKey(vd))
-	    return (TempDescriptor)temptovar.get(vd);
+
+    private NodePair flattenTagDeclarationNode(TagDeclarationNode dn) {
+	TagVarDescriptor tvd=dn.getTagVarDescriptor();
+	TagDescriptor tag=tvd.getTag();
+	TempDescriptor tmp=getTempforVar(tvd);
+	FlatTagDeclaration ftd=new FlatTagDeclaration(tag, tmp);
+	return new NodePair(ftd,ftd);
+    }
+
+    private TempDescriptor getTempforParam(Descriptor d) {
+	if (temptovar.containsKey(d))
+	    return (TempDescriptor)temptovar.get(d);
+	else {
+	    if (d instanceof VarDescriptor) {
+		VarDescriptor vd=(VarDescriptor)d;
+		TempDescriptor td=TempDescriptor.paramtempFactory(vd.getName(),vd.getType());
+		temptovar.put(vd,td);
+		return td;
+	    } else if (d instanceof TagVarDescriptor) {
+		TagVarDescriptor tvd=(TagVarDescriptor)d;
+		TypeDescriptor tagtype=new TypeDescriptor(typeutil.getClass(TypeUtil.TagClass));
+		TempDescriptor td=TempDescriptor.paramtempFactory(tvd.getName(), tagtype, tvd.getTag());
+		temptovar.put(tvd,td);
+		return td;
+	    } else throw new Error("Unreconized Descriptor");
+	}
+    }
+    
+    private TempDescriptor getTempforVar(Descriptor d) {
+	if (temptovar.containsKey(d))
+	    return (TempDescriptor)temptovar.get(d);
 	else {
-	    TempDescriptor td=TempDescriptor.tempFactory(vd.getName(),vd.getType());
-	    temptovar.put(vd,td);
-	    return td;
+	    if (d instanceof VarDescriptor) {
+		VarDescriptor vd=(VarDescriptor)d;
+		TempDescriptor td=TempDescriptor.tempFactory(vd.getName(), vd.getType());
+		temptovar.put(vd,td);
+		return td;
+	    } else if (d instanceof TagVarDescriptor) {
+		TagVarDescriptor tvd=(TagVarDescriptor)d;
+		//BUGFIX TAGTYPE - add next line, modify following
+		//line to tag this new type descriptor, modify
+		//TempDescriptor constructor & factory to set type
+		//using this Type To test, use any program with tags
+		TypeDescriptor tagtype=new TypeDescriptor(typeutil.getClass(TypeUtil.TagClass));
+		TempDescriptor td=TempDescriptor.tempFactory(tvd.getName(),tagtype, tvd.getTag());
+		temptovar.put(tvd,td);
+		return td;
+	    } else throw new Error("Unrecognized Descriptor");
 	}
     }
 
@@ -367,11 +846,17 @@ public class BuildFlat {
 	    NodePair body=flattenBlockNode(ln.getBody());
 	    FlatNode begin=initializer.getBegin();
 	    FlatCondBranch fcb=new FlatCondBranch(cond_temp);
+	    fcb.setTrueProb(State.TRUEPROB);
+	    fcb.setLoop();
 	    FlatNop nopend=new FlatNop();
+	    FlatBackEdge backedge=new FlatBackEdge();
 
-	    initializer.getEnd().addNext(condition.getBegin());
+	    FlatNop nop2=new FlatNop();
+	    initializer.getEnd().addNext(nop2);
+	    nop2.addNext(condition.getBegin());
 	    body.getEnd().addNext(update.getBegin());
-	    update.getEnd().addNext(condition.getBegin());
+	    update.getEnd().addNext(backedge);
+	    backedge.addNext(condition.getBegin());
 	    condition.getEnd().addNext(fcb);
 	    fcb.addFalseNext(nopend);
 	    fcb.addTrueNext(body.getBegin());
@@ -382,9 +867,14 @@ public class BuildFlat {
 	    NodePair body=flattenBlockNode(ln.getBody());
 	    FlatNode begin=condition.getBegin();
 	    FlatCondBranch fcb=new FlatCondBranch(cond_temp);
+	    fcb.setTrueProb(State.TRUEPROB);
+	    fcb.setLoop();
 	    FlatNop nopend=new FlatNop();
+	    FlatBackEdge backedge=new FlatBackEdge();
+
+	    body.getEnd().addNext(backedge);
+	    backedge.addNext(condition.getBegin());
 
-	    body.getEnd().addNext(condition.getBegin());
 	    condition.getEnd().addNext(fcb);
 	    fcb.addFalseNext(nopend);
 	    fcb.addTrueNext(body.getBegin());
@@ -395,28 +885,100 @@ public class BuildFlat {
 	    NodePair body=flattenBlockNode(ln.getBody());
 	    FlatNode begin=body.getBegin();
 	    FlatCondBranch fcb=new FlatCondBranch(cond_temp);
+	    fcb.setTrueProb(State.TRUEPROB);
+	    fcb.setLoop();
 	    FlatNop nopend=new FlatNop();
+	    FlatBackEdge backedge=new FlatBackEdge();
 
 	    body.getEnd().addNext(condition.getBegin());
 	    condition.getEnd().addNext(fcb);
 	    fcb.addFalseNext(nopend);
-	    fcb.addTrueNext(body.getBegin());
+	    fcb.addTrueNext(backedge);
+	    backedge.addNext(body.getBegin());
 	    return new NodePair(begin,nopend);
 	} else throw new Error();
     }
 	    
     private NodePair flattenReturnNode(ReturnNode rntree) {
-	TempDescriptor retval=TempDescriptor.tempFactory("ret_value", rntree.getReturnExpression().getType());
-	NodePair cond=flattenExpressionNode(rntree.getReturnExpression(),retval);
+	TempDescriptor retval=null;
+	NodePair cond=null;
+	if (rntree.getReturnExpression()!=null) {
+	    retval=TempDescriptor.tempFactory("ret_value", rntree.getReturnExpression().getType());
+	    cond=flattenExpressionNode(rntree.getReturnExpression(),retval);
+	}
+
 	FlatReturnNode rnflat=new FlatReturnNode(retval);
-	cond.getEnd().addNext(rnflat);
-	return new NodePair(cond.getBegin(),rnflat);
+	FlatNode ln=rnflat;
+	if (state.THREAD&&currmd.getModifiers().isSynchronized()) {
+	    MethodDescriptor memd=(MethodDescriptor)typeutil.getClass("Object").getMethodTable().get("MonitorExit");
+	    TempDescriptor thistd=getTempforVar(currmd.getThis());
+	    FlatCall fc=new FlatCall(memd, null, thistd, new TempDescriptor[0]);
+	    fc.addNext(ln);
+	    ln=fc;
+	}
+	if (state.DSM&&currmd.getModifiers().isAtomic()) {
+	    FlatAtomicExitNode faen=new FlatAtomicExitNode(curran);
+	    faen.addNext(ln);
+	    ln=faen;
+	}
+
+	if (cond!=null) {
+	    cond.getEnd().addNext(ln);
+	    return new NodePair(cond.getBegin(),rnflat);
+	} else
+	    return new NodePair(ln,rnflat);
+    }
+
+    private NodePair flattenTaskExitNode(TaskExitNode ten) {
+	FlatFlagActionNode ffan=new FlatFlagActionNode(FlatFlagActionNode.TASKEXIT);
+	updateFlagActionNode(ffan, ten.getFlagEffects());
+	NodePair fcn=flattenConstraintCheck(ten.getChecks());
+	ffan.addNext(fcn.getBegin());
+	FlatReturnNode rnflat=new FlatReturnNode(null);
+	fcn.getEnd().addNext(rnflat);
+	return new NodePair(ffan, rnflat);
     }
+
+    private NodePair flattenConstraintCheck(Vector ccs) {
+	FlatNode begin=new FlatNop();
+	if (ccs==null)
+	    return new NodePair(begin,begin);
+	FlatNode last=begin;
+	for(int i=0;i<ccs.size();i++) {
+	    ConstraintCheck cc=(ConstraintCheck) ccs.get(i);
+	    /* Flatten the arguments */
+	    TempDescriptor[] temps=new TempDescriptor[cc.numArgs()];
+	    String[] vars=new String[cc.numArgs()];
+	    for(int j=0;j<cc.numArgs();j++) {
+		ExpressionNode en=cc.getArg(j);
+		TempDescriptor td=TempDescriptor.tempFactory("arg",en.getType());
+		temps[j]=td;
+		vars[j]=cc.getVar(j);
+		NodePair np=flattenExpressionNode(en, td);
+		last.addNext(np.getBegin());
+		last=np.getEnd();
+	    }
 	    
+	    FlatCheckNode fcn=new FlatCheckNode(cc.getSpec(), vars, temps);
+	    last.addNext(fcn);
+	    last=fcn;
+	}
+	return new NodePair(begin,last);
+    }
+
     private NodePair flattenSubBlockNode(SubBlockNode sbn) {
 	return flattenBlockNode(sbn.getBlockNode());
     }
 
+    private NodePair flattenAtomicNode(AtomicNode sbn) {
+	NodePair np=flattenBlockNode(sbn.getBlockNode());
+	FlatAtomicEnterNode faen=new FlatAtomicEnterNode();
+	FlatAtomicExitNode faexn=new FlatAtomicExitNode(faen);
+	faen.addNext(np.getBegin());
+	np.getEnd().addNext(faexn);
+	return new NodePair(faen, faexn);
+    }
+
     private NodePair flattenBlockStatementNode(BlockStatementNode bsn) {
 	switch(bsn.kind()) {
 	case Kind.BlockExpressionNode:
@@ -424,6 +986,9 @@ public class BuildFlat {
 	    
 	case Kind.DeclarationNode:
 	    return flattenDeclarationNode((DeclarationNode)bsn);
+
+	case Kind.TagDeclarationNode:
+	    return flattenTagDeclarationNode((TagDeclarationNode)bsn);
 	    
 	case Kind.IfStatementNode:
 	    return flattenIfStatementNode((IfStatementNode)bsn);
@@ -433,9 +998,15 @@ public class BuildFlat {
 	    
 	case Kind.ReturnNode:
 	    return flattenReturnNode((IR.Tree.ReturnNode)bsn);
+
+	case Kind.TaskExitNode:
+	    return flattenTaskExitNode((IR.Tree.TaskExitNode)bsn);
 	    
 	case Kind.SubBlockNode:
 	    return flattenSubBlockNode((SubBlockNode)bsn);
+
+	case Kind.AtomicNode:
+	    return flattenAtomicNode((AtomicNode)bsn);
 	    
 	}
     	throw new Error();