added support for array element nodes

diff --git a/Robust/src/Analysis/OwnershipAnalysis/OwnershipAnalysis.java b/Robust/src/Analysis/OwnershipAnalysis/OwnershipAnalysis.java
index 630ca3d325b4b83be167403e5bec7ffecfad9d3e..f669dc4a421f6e7afa4cf16497a4c6124f899e31 100644 (file)
--- a/Robust/src/Analysis/OwnershipAnalysis/OwnershipAnalysis.java
+++ b/Robust/src/Analysis/OwnershipAnalysis/OwnershipAnalysis.java
@@ -3,6 +3,7 @@ package Analysis.OwnershipAnalysis;
 import Analysis.CallGraph.*;
 import IR.*;
 import IR.Flat.*;
+import IR.Tree.Modifiers;
 import java.util.*;
 import java.io.*;
 
@@ -196,6 +197,12 @@ public class OwnershipAnalysis {
   // should be re-added to this set
   private HashSet<Descriptor> descriptorsToVisit;
 
+  // a special field descriptor for all array elements
+  private static FieldDescriptor fdElement = new FieldDescriptor(new Modifiers(Modifiers.PUBLIC),
+                                                                new TypeDescriptor( "Array[]" ),
+                                                                "elements",
+                                                                null,
+                                                                false);
 
 
   // this analysis generates an ownership graph for every task
@@ -487,6 +494,24 @@ public class OwnershipAnalysis {
       rhs = fsfn.getSrc();
       og.assignTempXFieldFEqualToTempY(lhs, fld, rhs);
       break;
+     
+    case FKind.FlatElementNode:
+      FlatElementNode fen = (FlatElementNode) fn;
+      lhs = fen.getDst();
+      rhs = fen.getSrc();
+      if( !lhs.getType().isPrimitive() ) {
+       og.assignTempXEqualToTempYFieldF(lhs, rhs, fdElement);
+      }
+      break;
+
+    case FKind.FlatSetElementNode:
+      FlatSetElementNode fsen = (FlatSetElementNode) fn;
+      lhs = fsen.getDst();
+      rhs = fsen.getSrc();
+      if( !rhs.getType().isPrimitive() ) {
+       og.assignTempXFieldFEqualToTempY(lhs, fdElement, rhs);
+      }
+      break;
 
     case FKind.FlatNew:
       FlatNew fnn = (FlatNew) fn;
@@ -576,9 +601,6 @@ public class OwnershipAnalysis {
 
 
 
-
-
-
   // return just the allocation site associated with one FlatNew node
   private AllocationSite getAllocationSiteFromFlatNewPRIVATE(FlatNew fn) {
 

diff --git a/Robust/src/Analysis/OwnershipAnalysis/OwnershipGraph.java b/Robust/src/Analysis/OwnershipAnalysis/OwnershipGraph.java
index fd018948a931e95ea3a96acb28c0fa9c30ad3279..ff8e20c92131ad9faa75be2df9493016d8682e46 100644 (file)
--- a/Robust/src/Analysis/OwnershipAnalysis/OwnershipGraph.java
+++ b/Robust/src/Analysis/OwnershipAnalysis/OwnershipGraph.java
@@ -16,6 +16,8 @@ public class OwnershipGraph {
   // actions to take during the traversal
   protected static final int VISIT_HRN_WRITE_FULL = 0;
 
+  protected static TempDescriptor tdReturn = new TempDescriptor("_Return___");
+
 
   public Hashtable<Integer,        HeapRegionNode> id2hrn;
   public Hashtable<TempDescriptor, LabelNode     > td2ln;
@@ -26,7 +28,6 @@ public class OwnershipGraph {
   public HashSet<AllocationSite> allocationSites;
 
 
-  protected static TempDescriptor tdReturn = new TempDescriptor("_Return___");
 
 
   public OwnershipGraph(int allocationDepth) {
@@ -364,7 +365,6 @@ public class OwnershipGraph {
   public void assignTempXEqualToTempYFieldF(TempDescriptor x,
                                             TempDescriptor y,
                                             FieldDescriptor f) {
-
     LabelNode lnX = getLabelNodeFromTemp(x);
     LabelNode lnY = getLabelNodeFromTemp(y);
 
@@ -401,7 +401,6 @@ public class OwnershipGraph {
   public void assignTempXFieldFEqualToTempY(TempDescriptor x,
                                             FieldDescriptor f,
                                             TempDescriptor y) {
-
     LabelNode lnX = getLabelNodeFromTemp(x);
     LabelNode lnY = getLabelNodeFromTemp(y);
 
@@ -1329,37 +1328,56 @@ public class OwnershipGraph {
     // return value may need to be assigned in caller
     if( fc.getReturnTemp() != null ) {
 
-      HashSet<HeapRegionNode> assignCallerRhs = new HashSet<HeapRegionNode>();
+      LabelNode lnLhsCaller = getLabelNodeFromTemp(fc.getReturnTemp() );
+      clearReferenceEdgesFrom(lnLhsCaller, null, true);
 
       LabelNode lnReturnCallee = ogCallee.getLabelNodeFromTemp(tdReturn);
       Iterator<ReferenceEdge> edgeCalleeItr = lnReturnCallee.iteratorToReferencees();
       while( edgeCalleeItr.hasNext() ) {
        ReferenceEdge edgeCallee = edgeCalleeItr.next();
 
-       HashSet<HeapRegionNode> possibleCallerHRNs =
+       ReferenceEdge edgeNewInCallerTemplate = new ReferenceEdge(null,
+                                                                 null,
+                                                                 edgeCallee.getFieldDesc(),
+                                                                 false,
+                                                                 toShadowTokens(ogCallee, edgeCallee.getBeta() )
+                                                                 );
+       rewriteCallerEdgeBeta(fm.numParameters(),
+                             bogusIndex,
+                             edgeNewInCallerTemplate,
+                             paramIndex2rewriteJ,
+                             paramIndex2rewriteD,
+                             paramIndex2paramToken,
+                             paramIndex2paramTokenStar,
+                             false,
+                             null);
+       
+       edgeNewInCallerTemplate.applyBetaNew();
+
+
+       HashSet<HeapRegionNode> assignCallerRhs =
          getHRNSetThatPossiblyMapToCalleeHRN(ogCallee,
                                              edgeCallee.getDst(),
                                              false,
                                              paramIndex2reachableCallerNodes);
 
-       assignCallerRhs.addAll(possibleCallerHRNs);
-      }
-
-      LabelNode lnLhsCaller = getLabelNodeFromTemp(fc.getReturnTemp() );
-      clearReferenceEdgesFrom(lnLhsCaller, null, true);
-
-      Iterator<HeapRegionNode> itrHrn = assignCallerRhs.iterator();
-      while( itrHrn.hasNext() ) {
-       HeapRegionNode hrnCaller = itrHrn.next();
-
-       ReferenceEdge edgeNew = new ReferenceEdge(lnLhsCaller,
-                                                 hrnCaller,
-                                                 null,
-                                                 false,
-                                                 new ReachabilitySet().makeCanonical()
-                                                 );
-
-       addReferenceEdge(lnLhsCaller, hrnCaller, edgeNew);
+       Iterator<HeapRegionNode> itrHrn = assignCallerRhs.iterator();
+       while( itrHrn.hasNext() ) {
+         HeapRegionNode hrnCaller = itrHrn.next();
+        
+         ReferenceEdge edgeNewInCaller = edgeNewInCallerTemplate.copy();
+         edgeNewInCaller.setSrc(lnLhsCaller);
+         edgeNewInCaller.setDst(hrnCaller);
+
+         ReferenceEdge edgeExisting = lnLhsCaller.getReferenceTo(hrnCaller, edgeNewInCaller.getFieldDesc() );
+         if( edgeExisting == null ) {
+           // if this edge doesn't exist in the caller, create it
+           addReferenceEdge(lnLhsCaller, hrnCaller, edgeNewInCaller);
+         } else {
+           // if it already exists, merge with it
+           edgeExisting.setBeta(edgeExisting.getBeta().union(edgeNewInCaller.getBeta() ) );
+         }      
+       }
       }
     }
 
@@ -1384,6 +1402,11 @@ public class OwnershipGraph {
 
       mergeIntoSummary(hrnSummaryShadow, hrnSummary);
 
+      // then clear off after merge
+      clearReferenceEdgesFrom(hrnSummaryShadow, null, true);
+      clearReferenceEdgesTo(hrnSummaryShadow, null, true);
+      hrnSummaryShadow.setAlpha(new ReachabilitySet().makeCanonical() );
+
       // then transplant shadow nodes onto the now clean normal nodes
       for( int i = 0; i < as.getAllocationDepth(); ++i ) {
 

diff --git a/Robust/src/Analysis/OwnershipAnalysis/ReferenceEdge.java b/Robust/src/Analysis/OwnershipAnalysis/ReferenceEdge.java
index 7e625b157eb87b2fad991cc631dfcc2fc482584e..09c6ae3a5a8e04c9b92a7fd48a8b417a22b15f37 100644 (file)
--- a/Robust/src/Analysis/OwnershipAnalysis/ReferenceEdge.java
+++ b/Robust/src/Analysis/OwnershipAnalysis/ReferenceEdge.java
@@ -86,7 +86,7 @@ public class ReferenceEdge {
     int hash = 0;
 
     if( fieldDesc != null ) {
-      hash += fieldDesc.getType().hashCode();
+      hash += fieldDesc.hashCode();
     }
 
     hash += src.hashCode()*11;
@@ -173,4 +173,8 @@ public class ReferenceEdge {
 
     return edgeLabel;
   }
+
+  public String toString() {
+    return new String( "("+src+" "+fieldDesc+" "+dst+")" );
+  }
 }

diff --git a/Robust/src/Tests/OwnershipAnalysisTest/test01/test01.java b/Robust/src/Tests/OwnershipAnalysisTest/test01/test01.java
index d77854626f42173119b560ba01147de305db0d1e..a432b9147bcb363e5a22b87a60759614ecab3d8c 100644 (file)
--- a/Robust/src/Tests/OwnershipAnalysisTest/test01/test01.java
+++ b/Robust/src/Tests/OwnershipAnalysisTest/test01/test01.java
@@ -339,8 +339,24 @@ task strongUpdates( Foo p0{ f } ) {
     
     taskexit( p0{ !f } );
 }
+*/
+
+task arrayAssignments( Foo a{ f } ) {
+
+  Foo f[] = new Foo[3];
+
+  Foo g = new Foo();
+  Foo h = new Foo();
+
+  f[1] = g;
+  f[2] = h;
 
+  Foo i = f[0];
 
+  taskexit( a{ !f } );
+}
+
+/*
 task methodTest( Foo p0{ f } ) {
 
     Foo up0 = new Foo();

diff --git a/Robust/src/Tests/OwnershipAnalysisTest/test03/test03.java b/Robust/src/Tests/OwnershipAnalysisTest/test03/test03.java
index 99f3c754e594b45d8543b9be97aef7accf462d56..b59d683a418404a3224170fd47054cbfed54e9c2 100644 (file)
--- a/Robust/src/Tests/OwnershipAnalysisTest/test03/test03.java
+++ b/Robust/src/Tests/OwnershipAnalysisTest/test03/test03.java
@@ -1,46 +1,49 @@
 
 public class Parameter {
-    flag w;
-    Node root;
-    public Parameter() {}
+  flag w;
+  Node root;
+  public Parameter() {}
 }
 
 public class Node {
-    HashSet neighbors;
-
-    public Node() {
-       neighbors = new HashSet();
-    }
-
-    public static Node makeNode() {
-       return new Node();
-    }
-
-    public addNeighbor( Node n ) {
-       neighbors.add( n );
-    }
+  HashSet neighbors;
+  
+  public Node() {
+    neighbors = new HashSet();
+  }
+  
+  public static Node makeNode() {
+    return new Node();
+  }
+  
+  public addNeighbor( Node n ) {
+    neighbors.add( n );
+  }
 }
 
 task Startup( StartupObject s{ initialstate } ) {
-
-    Parameter p1 = new Parameter();
-
-    taskexit( s{ !initialstate } );
+  
+  Parameter p1 = new Parameter();
+  
+  taskexit( s{ !initialstate } );
 }
 
 
 task MakeGraph( Parameter p1{ !w } ) {
 
+  while( false ) {
+    Parameter p2 = new Parameter();
+    
     Node n1 = Node.makeNode();
     Node n2 = Node.makeNode();
     Node n3 = Node.makeNode();
-
+    
     n1.addNeighbor( n2 );
     n2.addNeighbor( n3 );
     n3.addNeighbor( n1 );
+    
+    p2.root = n1;
+  }
 
-    p1.root = n1;
-
-
-    taskexit( p1{ w } );
+  taskexit( p1{ w } );
 }