a bug fix...

[IRC.git] / Robust / src / Analysis / SSJava / LocationInference.java

diff --git a/Robust/src/Analysis/SSJava/LocationInference.java b/Robust/src/Analysis/SSJava/LocationInference.java
index 63514e3037ff54d2c41af1647e1764a6c579d31a..b15742f55874221a52703f4ddf5653a6cb7b39fa 100644 (file)
--- a/Robust/src/Analysis/SSJava/LocationInference.java
+++ b/Robust/src/Analysis/SSJava/LocationInference.java
@@ -77,6 +77,9 @@ public class LocationInference {
   // keep current descriptors to visit in fixed-point interprocedural analysis,
   private Stack<MethodDescriptor> methodDescriptorsToVisitStack;
 
+  // map a descriptor to a naive lattice
+  private Map<Descriptor, SSJavaLattice<String>> desc2naiveLattice;
+
   // map a class descriptor to a field lattice
   private Map<ClassDescriptor, SSJavaLattice<String>> cd2lattice;
 
@@ -194,6 +197,8 @@ public class LocationInference {
     this.mapMethodDescriptorToFlowGraph = new HashMap<MethodDescriptor, FlowGraph>();
     this.cd2lattice = new HashMap<ClassDescriptor, SSJavaLattice<String>>();
     this.md2lattice = new HashMap<MethodDescriptor, SSJavaLattice<String>>();
+    this.desc2naiveLattice = new HashMap<Descriptor, SSJavaLattice<String>>();
+
     this.methodDescriptorsToVisitStack = new Stack<MethodDescriptor>();
     this.mapMethodDescriptorToMethodInvokeNodeSet =
         new HashMap<MethodDescriptor, Set<MethodInvokeNode>>();
@@ -361,8 +366,10 @@ public class LocationInference {
       // + locOrder.getKeySet().size() + "\t" + hg.getNodeSet().size());
     }
 
-    System.out.println("The number of elements: Naive=" + numLocationsNaive + " SInfer="
-        + numLocationsSInfer);
+    if (state.SSJAVA_INFER_NAIVE_WRITEDOTS) {
+      System.out.println("The number of elements: Naive=" + numLocationsNaive);
+    }
+    System.out.println("The number of elements: SInfer=" + numLocationsSInfer);
 
     System.exit(0);
 
@@ -2549,12 +2556,10 @@ public class LocationInference {
       // HierarchyGraph simpleHierarchyGraph = getSimpleHierarchyGraph(key);
       HierarchyGraph scHierarchyGraph = getSkeletonCombinationHierarchyGraph(key);
       if (key instanceof ClassDescriptor) {
-        // writeInferredLatticeDotFile((ClassDescriptor) key, scHierarchyGraph, simpleLattice,
-        // "_SIMPLE");
+        writeInferredLatticeDotFile((ClassDescriptor) key, simpleLattice, "_SIMPLE");
       } else if (key instanceof MethodDescriptor) {
         MethodDescriptor md = (MethodDescriptor) key;
-        // writeInferredLatticeDotFile(md.getClassDesc(), md, scHierarchyGraph, simpleLattice,
-        // "_SIMPLE");
+        writeInferredLatticeDotFile(md.getClassDesc(), md, simpleLattice, "_SIMPLE");
       }
 
       LocationSummary ls = getLocationSummary(key);
@@ -2565,19 +2570,35 @@ public class LocationInference {
     for (Iterator iterator = cdKeySet.iterator(); iterator.hasNext();) {
       ClassDescriptor cd = (ClassDescriptor) iterator.next();
       // System.out.println("########cd=" + cd);
-      writeInferredLatticeDotFile((ClassDescriptor) cd, getSkeletonCombinationHierarchyGraph(cd),
-          cd2lattice.get(cd), "");
+      writeInferredLatticeDotFile((ClassDescriptor) cd, cd2lattice.get(cd), "");
       COUNT += cd2lattice.get(cd).getKeySet().size();
     }
 
     Set<MethodDescriptor> mdKeySet = md2lattice.keySet();
     for (Iterator iterator = mdKeySet.iterator(); iterator.hasNext();) {
       MethodDescriptor md = (MethodDescriptor) iterator.next();
-      writeInferredLatticeDotFile(md.getClassDesc(), md, getSkeletonCombinationHierarchyGraph(md),
-          md2lattice.get(md), "");
+      writeInferredLatticeDotFile(md.getClassDesc(), md, md2lattice.get(md), "");
       COUNT += md2lattice.get(md).getKeySet().size();
     }
     System.out.println("###COUNT=" + COUNT);
+
+    Set<Descriptor> descKeySet = desc2naiveLattice.keySet();
+    for (Iterator iterator = descKeySet.iterator(); iterator.hasNext();) {
+      Descriptor desc = (Descriptor) iterator.next();
+      // System.out.println("########cd=" + cd);
+
+      ClassDescriptor cd_naive;
+      MethodDescriptor md_naive;
+      if (desc instanceof ClassDescriptor) {
+        cd_naive = (ClassDescriptor) desc;
+        md_naive = null;
+      } else {
+        md_naive = (MethodDescriptor) desc;
+        cd_naive = md_naive.getClassDesc();
+      }
+
+      writeInferredLatticeDotFile(cd_naive, md_naive, desc2naiveLattice.get(desc), "_naive");
+    }
   }
 
   private void buildLattice(Descriptor desc) {
@@ -2586,13 +2607,27 @@ public class LocationInference {
 
     addMapDescToSimpleLattice(desc, simpleLattice);
 
+    if (desc instanceof ClassDescriptor) {
+      writeInferredLatticeDotFile((ClassDescriptor) desc, null, simpleLattice, "_SC");
+    } else {
+      MethodDescriptor md = (MethodDescriptor) desc;
+      writeInferredLatticeDotFile(md.getClassDesc(), md, simpleLattice, "_SC");
+    }
+
     HierarchyGraph simpleHierarchyGraph = getSimpleHierarchyGraph(desc);
+
     // System.out.println("\n## insertIntermediateNodesToStraightLine:"
     // + simpleHierarchyGraph.getName());
     SSJavaLattice<String> lattice =
         buildLattice.insertIntermediateNodesToStraightLine(desc, simpleLattice);
+
+    if (lattice == null) {
+      return;
+    }
     lattice.removeRedundantEdges();
 
+    LocationInference.numLocationsSInfer += lattice.getKeySet().size();
+
     if (desc instanceof ClassDescriptor) {
       // field lattice
       cd2lattice.put((ClassDescriptor) desc, lattice);
@@ -2607,6 +2642,7 @@ public class LocationInference {
 
   }
 
+  // deprecated: it builds method/class lattices without considering class inheritance
   private void buildLattice() {
 
     Set<Descriptor> keySet = mapDescriptorToCombineSkeletonHierarchyGraph.keySet();
@@ -6568,15 +6604,15 @@ public class LocationInference {
 
   }
 
-  public void writeInferredLatticeDotFile(ClassDescriptor cd, HierarchyGraph simpleHierarchyGraph,
-      SSJavaLattice<String> locOrder, String nameSuffix) {
+  public void writeInferredLatticeDotFile(ClassDescriptor cd, SSJavaLattice<String> locOrder,
+      String nameSuffix) {
     // System.out.println("@cd=" + cd);
     // System.out.println("@sharedLoc=" + locOrder.getSharedLocSet());
-    writeInferredLatticeDotFile(cd, null, simpleHierarchyGraph, locOrder, nameSuffix);
+    writeInferredLatticeDotFile(cd, null, locOrder, nameSuffix);
   }
 
   public void writeInferredLatticeDotFile(ClassDescriptor cd, MethodDescriptor md,
-      HierarchyGraph simpleHierarchyGraph, SSJavaLattice<String> locOrder, String nameSuffix) {
+      SSJavaLattice<String> locOrder, String nameSuffix) {
 
     String fileName = "lattice_";
     if (md != null) {
@@ -6608,12 +6644,12 @@ public class LocationInference {
           String lowLocId = pair.getSecond();
           if (!addedLocSet.contains(highLocId)) {
             addedLocSet.add(highLocId);
-            drawNode(bw, locOrder, simpleHierarchyGraph, highLocId);
+            drawNode(bw, locOrder, highLocId);
           }
 
           if (!addedLocSet.contains(lowLocId)) {
             addedLocSet.add(lowLocId);
-            drawNode(bw, locOrder, simpleHierarchyGraph, lowLocId);
+            drawNode(bw, locOrder, lowLocId);
           }
 
           bw.write(highLocId + " -> " + lowLocId + ";\n");
@@ -6642,8 +6678,12 @@ public class LocationInference {
     return str;
   }
 
-  private void drawNode(BufferedWriter bw, SSJavaLattice<String> lattice, HierarchyGraph graph,
-      String locName) throws IOException {
+  public void addNaiveLattice(Descriptor desc, SSJavaLattice<String> lattice) {
+    desc2naiveLattice.put(desc, lattice);
+  }
+
+  private void drawNode(BufferedWriter bw, SSJavaLattice<String> lattice, String locName)
+      throws IOException {
 
     String prettyStr;
     if (lattice.isSharedLoc(locName)) {