From 2476e4b18ed88f17e423734749518a32e11ce679 Mon Sep 17 00:00:00 2001
From: bdemsky <bdemsky>
Date: Mon, 15 Jun 2009 23:09:28 +0000
Subject: [PATCH] changes: (1) Add support for synchronized blocks (2) Fix
 analysis bug (3) Start support for delaying operations until commit

---
 .../Analysis/Locality/DelayComputation.java   | 228 ++++++++++++++++++
 .../Analysis/Locality/DiscoverConflicts.java  |  12 +-
 Robust/src/Analysis/Loops/CSE.java            |   6 +-
 .../src/Analysis/Loops/GlobalFieldType.java   |  88 +++++++
 Robust/src/Analysis/Loops/LoopInvariant.java  |   6 +-
 Robust/src/Analysis/Loops/localCSE.java       |   6 +-
 Robust/src/IR/Flat/BuildFlat.java             |  20 ++
 Robust/src/IR/Tree/BuildIR.java               |   4 +
 Robust/src/IR/Tree/Kind.java                  |   1 +
 Robust/src/IR/Tree/SemanticCheck.java         |  11 +
 Robust/src/IR/TypeDescriptor.java             |   2 +-
 Robust/src/Parse/java14.cup                   |  16 +-
 12 files changed, 383 insertions(+), 17 deletions(-)
 create mode 100644 Robust/src/Analysis/Locality/DelayComputation.java

diff --git a/Robust/src/Analysis/Locality/DelayComputation.java b/Robust/src/Analysis/Locality/DelayComputation.java
new file mode 100644
index 00000000..5a8fe1ae
--- /dev/null
+++ b/Robust/src/Analysis/Locality/DelayComputation.java
@@ -0,0 +1,228 @@
+package Analysis.Locality;
+import IR.State;
+import IR.MethodDescriptor;
+import IR.TypeDescriptor;
+import IR.FieldDescriptor;
+import IR.Flat.*;
+import Analysis.Loops.GlobalFieldType;
+import java.util.HashSet;
+import java.util.Hashtable;
+import java.util.Set;
+import java.util.Iterator;
+
+public class DelayComputation {
+  State state;
+  LocalityAnalysis locality;
+  TypeAnalysis typeanalysis;
+  GlobalFieldType gft;
+
+  public DelayComputation(LocalityAnalysis locality, State state, TypeAnalysis typeanalysis, GlobalFieldType gft) {
+    this.locality=locality;
+    this.state=state;
+    this.typeanalysis=typeanalysis;
+    this.gft=gft;
+  }
+
+  public void doAnalysis() {
+    Set<LocalityBinding> localityset=locality.getLocalityBindings();
+    for(Iterator<LocalityBinding> lb=localityset.iterator();lb.hasNext();) {
+      analyzeMethod(lb.next());
+    }
+  }
+
+  public void analyzeMethod(LocalityBinding lb) {
+    MethodDescriptor md=lb.getMethod();
+    FlatMethod fm=state.getMethodFlat(md);
+    HashSet<FlatNode> cannotdelay=new HashSet<FlatNode>();
+    Hashtable<FlatNode, Integer> atomictable=locality.getAtomic(lb);
+    if (lb.isAtomic()) {
+      //We are in a transaction already...
+      //skip past this method or something
+      return;
+    }
+
+    HashSet<FlatNode> toanalyze=new HashSet<FlatNode>();
+    toanalyze.addAll(fm.getNodeSet());
+
+    //Build the hashtables
+    Hashtable<FlatNode, HashSet<TempDescriptor>> nodelaytemps=new Hashtable<FlatNode, HashSet<TempDescriptor>>();
+    Hashtable<FlatNode, HashSet<FieldDescriptor>> nodelayfieldswr=new Hashtable<FlatNode, HashSet<FieldDescriptor>>();
+    Hashtable<FlatNode, HashSet<TypeDescriptor>> nodelayarrayswr=new Hashtable<FlatNode, HashSet<TypeDescriptor>>();
+    Hashtable<FlatNode, HashSet<FieldDescriptor>> nodelayfieldsrd=new Hashtable<FlatNode, HashSet<FieldDescriptor>>();
+    Hashtable<FlatNode, HashSet<TypeDescriptor>> nodelayarraysrd=new Hashtable<FlatNode, HashSet<TypeDescriptor>>();
+    
+    //Effect of adding something to nodelay set is to move it up past everything in delay set
+    //Have to make sure we can do this commute
+
+    while(!toanalyze.isEmpty()) {
+      FlatNode fn=toanalyze.iterator().next();
+      toanalyze.remove(fn);
+      
+      boolean isatomic=atomictable.get(fn).intValue()>0;
+
+      if (!isatomic)
+	continue;
+      boolean isnodelay=false;
+
+      /* Compute incoming nodelay sets */
+      HashSet<TempDescriptor> nodelaytempset=new HashSet<TempDescriptor>();
+      HashSet<FieldDescriptor> nodelayfieldwrset=new HashSet<FieldDescriptor>();
+      HashSet<TypeDescriptor> nodelayarraywrset=new HashSet<TypeDescriptor>();
+      HashSet<FieldDescriptor> nodelayfieldrdset=new HashSet<FieldDescriptor>();
+      HashSet<TypeDescriptor> nodelayarrayrdset=new HashSet<TypeDescriptor>();
+      for(int i=0;i<fn.numNext();i++) {
+	if (nodelaytemps.containsKey(fn.getNext(i)))
+	  nodelaytempset.addAll(nodelaytemps.get(fn.getNext(i)));
+	//do field/array write sets
+	if (nodelayfieldswr.containsKey(fn.getNext(i)))
+	  nodelayfieldwrset.addAll(nodelayfieldswr.get(fn.getNext(i)));	  
+	if (nodelayarrayswr.containsKey(fn.getNext(i)))
+	  nodelayarraywrset.addAll(nodelayarrayswr.get(fn.getNext(i)));	  
+	//do read sets
+	if (nodelayfieldsrd.containsKey(fn.getNext(i)))
+	  nodelayfieldrdset.addAll(nodelayfieldsrd.get(fn.getNext(i)));	  
+	if (nodelayarrayswr.containsKey(fn.getNext(i)))
+	  nodelayarraywrset.addAll(nodelayarrayswr.get(fn.getNext(i)));	  
+      }
+      
+      /* Check our temp write set */
+
+      TempDescriptor writeset[]=fn.writesTemps();
+      for(int i=0;i<writeset.length;i++) {
+	TempDescriptor tmp=writeset[i];
+	if (nodelaytempset.contains(tmp)) {
+	  //We are writing to a nodelay temp
+	  //Therefore we are nodelay
+	  isnodelay=true;
+	  //Kill temp we wrote to
+	  nodelaytempset.remove(tmp);
+	}
+      }
+      
+      //See if flatnode is definitely no delay
+      if (fn.kind()==FKind.FlatCall) {
+	isnodelay=true;
+	//Have to deal with fields/arrays
+	FlatCall fcall=(FlatCall)fn;
+	MethodDescriptor mdcall=fcall.getMethod();
+	nodelayfieldwrset.addAll(gft.getFieldsAll(mdcall));
+	nodelayarraywrset.addAll(typeanalysis.expandSet(gft.getArraysAll(mdcall)));
+	//Have to deal with field/array reads
+	nodelayfieldrdset.addAll(gft.getFieldsRdAll(mdcall));
+	nodelayarrayrdset.addAll(typeanalysis.expandSet(gft.getArraysRdAll(mdcall)));
+      }
+      
+      // Can't delay branches
+      if (fn.kind()==FKind.FlatCondBranch) {
+	isnodelay=true;
+      }
+
+      //Check for field conflicts
+      if (fn.kind()==FKind.FlatSetFieldNode) {
+	FieldDescriptor fd=((FlatSetFieldNode)fn).getField();
+	//write conflicts
+	if (nodelayfieldwrset.contains(fd))
+	  isnodelay=true;
+	//read 
+	if (nodelayfieldrdset.contains(fd))
+	  isnodelay=true;
+      }
+
+      if (fn.kind()==FKind.FlatFieldNode) {
+	FieldDescriptor fd=((FlatFieldNode)fn).getField();
+	//write conflicts
+	if (nodelayfieldwrset.contains(fd))
+	  isnodelay=true;
+      }
+
+      //Check for array conflicts
+      if (fn.kind()==FKind.FlatSetElementNode) {
+	TypeDescriptor td=((FlatSetElementNode)fn).getDst().getType();
+	//check for write conflicts
+	if (nodelayarraywrset.contains(td))
+	  isnodelay=true;
+	//check for read conflicts
+	if (nodelayarrayrdset.contains(td))
+	  isnodelay=true;
+      }
+      if (fn.kind()==FKind.FlatElementNode) {
+	TypeDescriptor td=((FlatElementNode)fn).getSrc().getType();
+	//check for write conflicts
+	if (nodelayarraywrset.contains(td))
+	  isnodelay=true;
+      }
+      
+      //If we are no delay, then the temps we read are no delay
+      if (isnodelay) {
+	/* Add our read set */
+	TempDescriptor readset[]=fn.readsTemps();
+	for(int i=0;i<readset.length;i++) {
+	  TempDescriptor tmp=readset[i];
+	  nodelaytempset.add(tmp);
+	}
+	cannotdelay.add(fn);
+
+	/* Do we write to fields */
+	if (fn.kind()==FKind.FlatSetFieldNode) {
+	  nodelayfieldwrset.add(((FlatSetFieldNode)fn).getField());
+	}
+	/* Do we read from fields */
+	if (fn.kind()==FKind.FlatFieldNode) {
+	  nodelayfieldrdset.add(((FlatFieldNode)fn).getField());
+	}
+
+	/* Do we write to arrays */
+	if (fn.kind()==FKind.FlatSetElementNode) {
+	  //have to do expansion
+	  nodelayarraywrset.addAll(typeanalysis.expand(((FlatSetElementNode)fn).getDst().getType()));	  
+	}
+	/* Do we read from arrays */
+	if (fn.kind()==FKind.FlatElementNode) {
+	  //have to do expansion
+	  nodelayarrayrdset.addAll(typeanalysis.expand(((FlatSetElementNode)fn).getSrc().getType()));	  
+	}
+      }
+      
+      boolean changed=false;
+      //See if we need to propagate changes
+      if (!nodelaytemps.containsKey(fn)||
+	  !nodelaytemps.get(fn).equals(nodelaytempset)) {
+	nodelaytemps.put(fn, nodelaytempset);
+	changed=true;
+      }
+
+      //See if we need to propagate changes
+      if (!nodelayfieldswr.containsKey(fn)||
+	  !nodelayfieldswr.get(fn).equals(nodelayfieldwrset)) {
+	nodelayfieldswr.put(fn, nodelayfieldwrset);
+	changed=true;
+      }
+
+      //See if we need to propagate changes
+      if (!nodelayfieldsrd.containsKey(fn)||
+	  !nodelayfieldsrd.get(fn).equals(nodelayfieldrdset)) {
+	nodelayfieldsrd.put(fn, nodelayfieldrdset);
+	changed=true;
+      }
+
+      //See if we need to propagate changes
+      if (!nodelayarrayswr.containsKey(fn)||
+	  !nodelayarrayswr.get(fn).equals(nodelayarraywrset)) {
+	nodelayarrayswr.put(fn, nodelayarraywrset);
+	changed=true;
+      }
+
+      //See if we need to propagate changes
+      if (!nodelayarraysrd.containsKey(fn)||
+	  !nodelayarraysrd.get(fn).equals(nodelayarrayrdset)) {
+	nodelayarraysrd.put(fn, nodelayarrayrdset);
+	changed=true;
+      }
+
+      if (changed)
+	for(int i=0;i<fn.numPrev();i++)
+	  toanalyze.add(fn.getPrev(i));
+    } //end of while loop
+
+  } //end of method
+} //end of class
\ No newline at end of file
diff --git a/Robust/src/Analysis/Locality/DiscoverConflicts.java b/Robust/src/Analysis/Locality/DiscoverConflicts.java
index 928733c4..87930f3a 100644
--- a/Robust/src/Analysis/Locality/DiscoverConflicts.java
+++ b/Robust/src/Analysis/Locality/DiscoverConflicts.java
@@ -38,7 +38,9 @@ public class DiscoverConflicts {
   }
   
   public void doAnalysis() {
-    //Compute fields and arrays for all transactions
+    //Compute fields and arrays for all transactions.  Note that we
+    //only look at changes to old objects
+
     Set<LocalityBinding> localityset=locality.getLocalityBindings();
     for(Iterator<LocalityBinding> lb=localityset.iterator();lb.hasNext();) {
       computeModified(lb.next());
@@ -383,7 +385,8 @@ public class DiscoverConflicts {
     return tmptofnset;
   }
   
-  /* See what fields and arrays transactions might modify. */
+  /* See what fields and arrays transactions might modify.  We only
+   * look at changes to old objects. */
 
   public void computeModified(LocalityBinding lb) {
     MethodDescriptor md=lb.getMethod();
@@ -408,6 +411,11 @@ public class DiscoverConflicts {
     }
   }
     
+
+  //Returns a table that maps a flatnode to a set of temporaries
+  //This set of temporaries is old (meaning they may point to object
+  //allocated before the beginning of the current transaction
+
   Hashtable<FlatNode, Set<TempDescriptor>> computeOldTemps(LocalityBinding lb) {
     Hashtable<FlatNode, Set<TempDescriptor>> fntooldtmp=new Hashtable<FlatNode, Set<TempDescriptor>>();
     HashSet<FlatNode> discovered=new HashSet<FlatNode>();
diff --git a/Robust/src/Analysis/Loops/CSE.java b/Robust/src/Analysis/Loops/CSE.java
index c1776848..e3ce5828 100644
--- a/Robust/src/Analysis/Loops/CSE.java
+++ b/Robust/src/Analysis/Loops/CSE.java
@@ -55,9 +55,9 @@ public class CSE {
 	{
 	  FlatCall fc=(FlatCall) fn;
 	  MethodDescriptor md=fc.getMethod();
-	  Set<FieldDescriptor> fields=gft.getFields(md);
-	  Set<TypeDescriptor> arrays=gft.getArrays(md);
-	  killexpressions(tab, fields, arrays, gft.containsAtomic(md)||gft.containsBarrier(md));
+	  Set<FieldDescriptor> fields=gft.getFieldsAll(md);
+	  Set<TypeDescriptor> arrays=gft.getArraysAll(md);
+	  killexpressions(tab, fields, arrays, gft.containsAtomicAll(md)||gft.containsBarrierAll(md));
 	  break;
 	}
       case FKind.FlatOpNode:
diff --git a/Robust/src/Analysis/Loops/GlobalFieldType.java b/Robust/src/Analysis/Loops/GlobalFieldType.java
index c81fdab5..3aa5ef89 100644
--- a/Robust/src/Analysis/Loops/GlobalFieldType.java
+++ b/Robust/src/Analysis/Loops/GlobalFieldType.java
@@ -18,6 +18,8 @@ public class GlobalFieldType {
   MethodDescriptor root;
   Hashtable<MethodDescriptor, Set<FieldDescriptor>> fields;
   Hashtable<MethodDescriptor, Set<TypeDescriptor>> arrays;
+  Hashtable<MethodDescriptor, Set<FieldDescriptor>> fieldsrd;
+  Hashtable<MethodDescriptor, Set<TypeDescriptor>> arraysrd;
   HashSet<MethodDescriptor> containsAtomic;
   HashSet<MethodDescriptor> containsBarrier;
   
@@ -27,6 +29,8 @@ public class GlobalFieldType {
     this.root=root;
     this.fields=new Hashtable<MethodDescriptor, Set<FieldDescriptor>>();
     this.arrays=new Hashtable<MethodDescriptor, Set<TypeDescriptor>>();
+    this.fieldsrd=new Hashtable<MethodDescriptor, Set<FieldDescriptor>>();
+    this.arraysrd=new Hashtable<MethodDescriptor, Set<TypeDescriptor>>();
     this.containsAtomic=new HashSet<MethodDescriptor>();
     this.containsBarrier=new HashSet<MethodDescriptor>();
     doAnalysis();
@@ -84,6 +88,10 @@ public class GlobalFieldType {
 	    changed=true;
 	  if (arrays.get(md).addAll(arrays.get(md2)))
 	    changed=true;
+	  if (fieldsrd.get(md).addAll(fieldsrd.get(md2)))
+	    changed=true;
+	  if (arraysrd.get(md).addAll(arraysrd.get(md2)))
+	    changed=true;
 	  if (containsAtomic.contains(md2)) {
 	    if (containsAtomic.add(md))
 	      changed=true;
@@ -113,9 +121,83 @@ public class GlobalFieldType {
     return arrays.get(md);
   }
 
+  public Set<FieldDescriptor> getFieldsRd(MethodDescriptor md) {
+    return fieldsrd.get(md);
+  }
+
+  public Set<TypeDescriptor> getArraysRd(MethodDescriptor md) {
+    return arraysrd.get(md);
+  }
+
+  public boolean containsAtomicAll(MethodDescriptor md) {
+    Set methodset=cg.getMethods(md);
+    for(Iterator it=methodset.iterator();it.hasNext();) {
+      MethodDescriptor md2=(MethodDescriptor)it.next();
+      if (containsAtomic.contains(md2))
+	return true;
+    }
+    return false;
+  }
+
+  public boolean containsBarrierAll(MethodDescriptor md) {
+    Set methodset=cg.getMethods(md);
+    for(Iterator it=methodset.iterator();it.hasNext();) {
+      MethodDescriptor md2=(MethodDescriptor)it.next();
+      if (containsBarrier.contains(md2))
+	return true;
+    }
+    return false;
+  }
+  
+  public Set<FieldDescriptor> getFieldsAll(MethodDescriptor md) {
+    HashSet<FieldDescriptor> s=new HashSet<FieldDescriptor>();
+    Set methodset=cg.getMethods(md);
+    for(Iterator it=methodset.iterator();it.hasNext();) {
+      MethodDescriptor md2=(MethodDescriptor)it.next();
+      if (fields.containsKey(md2))
+	s.addAll(fields.get(md2));
+    }
+    return s;
+  }
+
+  public Set<TypeDescriptor> getArraysAll(MethodDescriptor md) {
+    HashSet<TypeDescriptor> s=new HashSet<TypeDescriptor>();
+    Set methodset=cg.getMethods(md);
+    for(Iterator it=methodset.iterator();it.hasNext();) {
+      MethodDescriptor md2=(MethodDescriptor)it.next();
+      if (arrays.containsKey(md2))
+	s.addAll(arrays.get(md2));
+    }
+    return s;
+  }
+
+  public Set<FieldDescriptor> getFieldsRdAll(MethodDescriptor md) {
+    HashSet<FieldDescriptor> s=new HashSet<FieldDescriptor>();
+    Set methodset=cg.getMethods(md);
+    for(Iterator it=methodset.iterator();it.hasNext();) {
+      MethodDescriptor md2=(MethodDescriptor)it.next();
+      if (fieldsrd.containsKey(md2))
+	s.addAll(fieldsrd.get(md2));
+    }
+    return s;
+  }
+
+  public Set<TypeDescriptor> getArraysRdAll(MethodDescriptor md) {
+    HashSet<TypeDescriptor> s=new HashSet<TypeDescriptor>();
+    Set methodset=cg.getMethods(md);
+    for(Iterator it=methodset.iterator();it.hasNext();) {
+      MethodDescriptor md2=(MethodDescriptor)it.next();
+      if (arraysrd.containsKey(md2))
+	s.addAll(arraysrd.get(md2));
+    }
+    return s;
+  }
+
   public void analyzeMethod(MethodDescriptor md) {
     fields.put(md, new HashSet<FieldDescriptor>());
     arrays.put(md, new HashSet<TypeDescriptor>());
+    fieldsrd.put(md, new HashSet<FieldDescriptor>());
+    arraysrd.put(md, new HashSet<TypeDescriptor>());
     
     FlatMethod fm=st.getMethodFlat(md);
     for(Iterator it=fm.getNodeSet().iterator();it.hasNext();) {
@@ -123,9 +205,15 @@ public class GlobalFieldType {
       if (fn.kind()==FKind.FlatSetElementNode) {
 	FlatSetElementNode fsen=(FlatSetElementNode)fn;
 	arrays.get(md).add(fsen.getDst().getType());
+      } else if (fn.kind()==FKind.FlatElementNode) {
+	FlatElementNode fen=(FlatElementNode)fn;
+	arraysrd.get(md).add(fen.getSrc().getType());
       } else if (fn.kind()==FKind.FlatSetFieldNode) {
 	FlatSetFieldNode fsfn=(FlatSetFieldNode)fn;
 	fields.get(md).add(fsfn.getField());
+      } else if (fn.kind()==FKind.FlatFieldNode) {
+	FlatFieldNode ffn=(FlatFieldNode)fn;
+	fieldsrd.get(md).add(ffn.getField());
       } else if (fn.kind()==FKind.FlatAtomicEnterNode) {
 	containsAtomic.add(md);
       } else if (fn.kind()==FKind.FlatCall) {
diff --git a/Robust/src/Analysis/Loops/LoopInvariant.java b/Robust/src/Analysis/Loops/LoopInvariant.java
index 9fbc9990..60bdc5a9 100644
--- a/Robust/src/Analysis/Loops/LoopInvariant.java
+++ b/Robust/src/Analysis/Loops/LoopInvariant.java
@@ -72,13 +72,13 @@ public class LoopInvariant {
 	} else if (fn.kind()==FKind.FlatCall) {
 	  FlatCall fcall=(FlatCall)fn;
 	  MethodDescriptor md=fcall.getMethod();
-	  Set<FieldDescriptor> f=gft.getFields(md);
-	  Set<TypeDescriptor> t=gft.getArrays(md);
+	  Set<FieldDescriptor> f=gft.getFieldsAll(md);
+	  Set<TypeDescriptor> t=gft.getArraysAll(md);
 	  if (f!=null)
 	    fields.addAll(f);
 	  if (t!=null)
 	    types.addAll(t);
-	  if (gft.containsAtomic(md)||gft.containsBarrier(md)) {
+	  if (gft.containsAtomicAll(md)||gft.containsBarrierAll(md)) {
 	    unsafe=true;
 	  }
 	} else if (fn.kind()==FKind.FlatSetFieldNode) {
diff --git a/Robust/src/Analysis/Loops/localCSE.java b/Robust/src/Analysis/Loops/localCSE.java
index 108d992e..b42c9955 100644
--- a/Robust/src/Analysis/Loops/localCSE.java
+++ b/Robust/src/Analysis/Loops/localCSE.java
@@ -154,9 +154,9 @@ public class localCSE {
 	  //do side effects
 	  FlatCall fc=(FlatCall)fn;
 	  MethodDescriptor md=fc.getMethod();
-	  Set<FieldDescriptor> fields=gft.getFields(md);
-	  Set<TypeDescriptor> arrays=gft.getArrays(md);
-	  kill(table, fields, arrays, gft.containsAtomic(md), gft.containsBarrier(md));
+	  Set<FieldDescriptor> fields=gft.getFieldsAll(md);
+	  Set<TypeDescriptor> arrays=gft.getArraysAll(md);
+	  kill(table, fields, arrays, gft.containsAtomicAll(md), gft.containsBarrierAll(md));
 	}
 	default: {
 	  TempDescriptor[] writes=fn.writesTemps();
diff --git a/Robust/src/IR/Flat/BuildFlat.java b/Robust/src/IR/Flat/BuildFlat.java
index d2f4727a..3e683db3 100644
--- a/Robust/src/IR/Flat/BuildFlat.java
+++ b/Robust/src/IR/Flat/BuildFlat.java
@@ -1136,6 +1136,23 @@ public class BuildFlat {
     return flattenBlockNode(sbn.getBlockNode());
   }
 
+  private NodePair flattenSynchronizedNode(SynchronizedNode sbn) {
+    TempDescriptor montmp=TempDescriptor.tempFactory("monitor",sbn.getExpr().getType());
+    NodePair npexp=flattenExpressionNode(sbn.getExpr(), montmp);
+    NodePair npblock=flattenBlockNode(sbn.getBlockNode());
+
+    MethodDescriptor menmd=(MethodDescriptor)typeutil.getClass("Object").getMethodTable().get("MonitorEnter");
+    FlatCall fcen=new FlatCall(menmd, null, montmp, new TempDescriptor[0]);
+
+    MethodDescriptor mexmd=(MethodDescriptor)typeutil.getClass("Object").getMethodTable().get("MonitorExit");
+    FlatCall fcex=new FlatCall(mexmd, null, montmp, new TempDescriptor[0]);
+
+    npexp.getEnd().addNext(fcen);
+    fcen.addNext(npblock.getBegin());
+    npblock.getEnd().addNext(fcex);
+    return new NodePair(npexp.getBegin(), fcex);
+  }
+
   private NodePair flattenAtomicNode(AtomicNode sbn) {
     NodePair np=flattenBlockNode(sbn.getBlockNode());
     FlatAtomicEnterNode faen=new FlatAtomicEnterNode();
@@ -1276,6 +1293,9 @@ public class BuildFlat {
     case Kind.AtomicNode:
       return flattenAtomicNode((AtomicNode)bsn);
 
+    case Kind.SynchronizedNode:
+      return flattenSynchronizedNode((SynchronizedNode)bsn);
+
     case Kind.SESENode:
       return flattenSESENode((SESENode)bsn);
 
diff --git a/Robust/src/IR/Tree/BuildIR.java b/Robust/src/IR/Tree/BuildIR.java
index f57330cf..2e2fc524 100644
--- a/Robust/src/IR/Tree/BuildIR.java
+++ b/Robust/src/IR/Tree/BuildIR.java
@@ -701,6 +701,10 @@ public class BuildIR {
     } else if (isNode(pn,"atomic")) {
       BlockNode bn=parseBlockHelper(pn);
       blockstatements.add(new AtomicNode(bn));
+    } else if (isNode(pn,"synchronized")) {
+      BlockNode bn=parseBlockHelper(pn.getChild("block"));
+      ExpressionNode en=parseExpression(pn.getChild("expr").getFirstChild());
+      blockstatements.add(new SynchronizedNode(en, bn));
     } else if (isNode(pn,"return")) {
       if (isEmpty(pn.getTerminal()))
 	blockstatements.add(new ReturnNode());
diff --git a/Robust/src/IR/Tree/Kind.java b/Robust/src/IR/Tree/Kind.java
index a50a67f6..40375f46 100644
--- a/Robust/src/IR/Tree/Kind.java
+++ b/Robust/src/IR/Tree/Kind.java
@@ -28,4 +28,5 @@ public class Kind {
   public final static int TertiaryNode=25;
   public final static int InstanceOfNode=26;
   public final static int ArrayInitializerNode=27;
+  public final static int SynchronizedNode=28;
 }
diff --git a/Robust/src/IR/Tree/SemanticCheck.java b/Robust/src/IR/Tree/SemanticCheck.java
index 0f731f91..389fc208 100644
--- a/Robust/src/IR/Tree/SemanticCheck.java
+++ b/Robust/src/IR/Tree/SemanticCheck.java
@@ -296,6 +296,10 @@ public class SemanticCheck {
       checkAtomicNode(md, nametable, (AtomicNode)bsn);
       return;
 
+    case Kind.SynchronizedNode:
+      checkSynchronizedNode(md, nametable, (SynchronizedNode)bsn);
+      return;
+
     case Kind.ContinueBreakNode:
 	checkContinueBreakNode(md, nametable, (ContinueBreakNode) bsn);
 	return;
@@ -343,6 +347,12 @@ public class SemanticCheck {
     checkBlockNode(md, nametable, sbn.getBlockNode());
   }
 
+  void checkSynchronizedNode(Descriptor md, SymbolTable nametable, SynchronizedNode sbn) {
+    checkBlockNode(md, nametable, sbn.getBlockNode());
+    //todo this could be Object
+    checkExpressionNode(md, nametable, sbn.getExpr(), null);
+  }
+
   void checkContinueBreakNode(Descriptor md, SymbolTable nametable, ContinueBreakNode cbn) {
       if (loopstack.empty())
 	  throw new Error("continue/break outside of loop");
@@ -485,6 +495,7 @@ public class SemanticCheck {
       fd=(FieldDescriptor) ltd.getClassDesc().getFieldTable().get(fieldname);
     if (fd==null)
       throw new Error("Unknown field "+fieldname + " in "+fan.printNode(0)+" in "+md);
+
     if (fd.getType().iswrapper()) {
       FieldAccessNode fan2=new FieldAccessNode(left, fieldname);
       fan2.setField(fd);
diff --git a/Robust/src/IR/TypeDescriptor.java b/Robust/src/IR/TypeDescriptor.java
index 7725f610..4ee68570 100644
--- a/Robust/src/IR/TypeDescriptor.java
+++ b/Robust/src/IR/TypeDescriptor.java
@@ -58,7 +58,7 @@ public class TypeDescriptor extends Descriptor {
   }
 
   public boolean iswrapper() {
-    if (arraycount!=0||!isClass())
+    if (arraycount!=0||isClass())
       return false;
     return (name.equals("bytewrapper")||
 	    name.equals("booleanwrapper")||
diff --git a/Robust/src/Parse/java14.cup b/Robust/src/Parse/java14.cup
index edc61cb7..01f07d0d 100644
--- a/Robust/src/Parse/java14.cup
+++ b/Robust/src/Parse/java14.cup
@@ -188,7 +188,8 @@ non terminal ParseNode statement_expression_list;
 non terminal ParseNode break_statement, continue_statement;
 non terminal ParseNode return_statement;
 //non terminal ParseNode throw_statement;
-//non terminal ParseNode synchronized_statement, try_statement;
+non terminal ParseNode synchronized_statement;
+//non terminal ParseNode try_statement;
 //non terminal ParseNode catches_opt;
 //non terminal ParseNode catches, catch_clause;
 //non terminal ParseNode finally;
@@ -1188,7 +1189,7 @@ statement_without_trailing_substatement ::=
 	|	task_exitstatement:st {: RESULT=st; :}
 	|	atomic_statement:st {: RESULT=st; :}
 	|	sese_statement:st {: RESULT=st; :}
-//	|	synchronized_statement
+	|	synchronized_statement:st {: RESULT=st; :}
 //	|	throw_statement
 //	|	try_statement
 //	|	assert_statement
@@ -1362,9 +1363,14 @@ return_statement ::=
 //throw_statement ::=
 //		THROW expression SEMICOLON
 //	;
-//synchronized_statement ::=
-//		SYNCHRONIZED LPAREN expression RPAREN block
-//	;
+synchronized_statement ::=
+		SYNCHRONIZED LPAREN expression:e RPAREN block:b {: 
+		ParseNode pn=new ParseNode("synchronized");
+		pn.addChild("expr").addChild(e);
+		pn.addChild("block").addChild(b);
+		RESULT=pn;
+		:}
+	;
 atomic_statement ::=
 		ATOMIC block:blk {: 
 	RESULT=(new ParseNode("atomic")).addChild(blk).getRoot();
-- 
2.34.1