more implementation for the inference: propagating relations of callee parameters...
authoryeom <yeom>
Mon, 7 May 2012 00:09:43 +0000 (00:09 +0000)
committeryeom <yeom>
Mon, 7 May 2012 00:09:43 +0000 (00:09 +0000)
Robust/src/Analysis/SSJava/FlowGraph.java
Robust/src/Analysis/SSJava/FlowNode.java
Robust/src/Analysis/SSJava/LocationInference.java
Robust/src/Analysis/SSJava/SSJavaAnalysis.java

index da480be..c1181a5 100644 (file)
@@ -31,18 +31,22 @@ public class FlowGraph {
   // maps an infer node to the set of neighbors which is pointed by the node
   Map<NTuple<Descriptor>, Set<FlowNode>> mapNodeToNeighborSet;
 
+  // maps a paramter descriptor to its index
+  Map<Descriptor, Integer> mapParamDescToIdx;
   boolean debug = true;
 
-  public FlowGraph(MethodDescriptor md) {
+  public FlowGraph(MethodDescriptor md, Map<Descriptor, Integer> mapParamDescToIdx) {
     this.md = md;
     nodeSet = new HashSet<FlowNode>();
     mapDescTupleToInferNode = new HashMap<NTuple<Descriptor>, FlowNode>();
     mapNodeToNeighborSet = new HashMap<NTuple<Descriptor>, Set<FlowNode>>();
+    this.mapParamDescToIdx = new HashMap<Descriptor, Integer>();
+    this.mapParamDescToIdx.putAll(mapParamDescToIdx);
 
     // create a node for 'this' varialbe
     NTuple<Descriptor> thisDescTuple = new NTuple<Descriptor>();
     thisDescTuple.add(md.getThis());
-    FlowNode thisNode = new FlowNode(thisDescTuple);
+    FlowNode thisNode = new FlowNode(thisDescTuple, true);
     NTuple<Descriptor> thisVarTuple = new NTuple<Descriptor>();
     thisVarTuple.add(md.getThis());
     createNewFlowNode(thisVarTuple);
@@ -115,7 +119,8 @@ public class FlowGraph {
   public FlowNode createNewFlowNode(NTuple<Descriptor> tuple) {
 
     if (!mapDescTupleToInferNode.containsKey(tuple)) {
-      FlowNode node = new FlowNode(tuple);
+
+      FlowNode node = new FlowNode(tuple, isParamter(tuple));
       mapDescTupleToInferNode.put(tuple, node);
       nodeSet.add(node);
 
@@ -132,6 +137,17 @@ public class FlowGraph {
 
   }
 
+  public boolean isParamter(NTuple<Descriptor> tuple) {
+    // return true if a descriptor tuple is started with a parameter descriptor
+    Descriptor firstIdxDesc = tuple.get(0);
+    return mapParamDescToIdx.containsKey(firstIdxDesc);
+  }
+
+  public int getParamIdx(NTuple<Descriptor> tuple) {
+    Descriptor firstDesc = tuple.get(0);
+    return mapParamDescToIdx.get(firstDesc).intValue();
+  }
+
   private void drawEdges(FlowNode node, BufferedWriter bw, Set<FlowNode> addedNodeSet,
       Set<FlowEdge> addedEdgeSet) throws IOException {
 
index 86edb08..21a2e08 100644 (file)
@@ -15,13 +15,18 @@ public class FlowNode {
   // this set contains fields of the base type
   private Set<FlowNode> fieldNodeSet;
 
+  // set true if this node is driven from a paramter
+  private boolean isParameter;
+
   public Set<FlowNode> getFieldNodeSet() {
     return fieldNodeSet;
   }
 
   private Set<FlowEdge> outEdgeSet;
 
-  public FlowNode(NTuple<Descriptor> tuple) {
+  public FlowNode(NTuple<Descriptor> tuple, boolean isParam) {
+
+    this.isParameter = isParam;
 
     NTuple<Descriptor> base = null;
     Descriptor desc = null;
@@ -46,6 +51,10 @@ public class FlowNode {
     fieldNodeSet.add(node);
   }
 
+  public boolean isParameter() {
+    return isParameter;
+  }
+
   public NTuple<Descriptor> getDescTuple() {
     return descTuple;
   }
@@ -55,7 +64,12 @@ public class FlowNode {
   }
 
   public String toString() {
-    return "[FlowNode]::" + descTuple;
+    String rtr = "[FlowNode]:";
+    if (isParameter()) {
+      rtr += "param:";
+    }
+    rtr += ":" + descTuple;
+    return rtr;
   }
 
   public Iterator<FlowEdge> iteratorOfOutEdges() {
index 21aec9e..66dadfa 100644 (file)
@@ -6,7 +6,6 @@ import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
-import java.util.Hashtable;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
@@ -58,6 +57,9 @@ public class LocationInference {
   List<MethodDescriptor> toanalyzeMethodList;
   Map<MethodDescriptor, FlowGraph> mapMethodDescriptorToFlowGraph;
 
+  // map a method descriptor to its set of parameter descriptors
+  Map<MethodDescriptor, Set<Descriptor>> mapMethodDescriptorToParamDescSet;
+
   // keep current descriptors to visit in fixed-point interprocedural analysis,
   private Stack<MethodDescriptor> methodDescriptorsToVisitStack;
 
@@ -73,6 +75,16 @@ public class LocationInference {
   // map a method descriptor to a lattice mapping
   private Map<MethodDescriptor, Map<FieldDescriptor, String>> cd2LatticeMapping;
 
+  // map a method descriptor to the set of hierarchy relations that are
+  // contributed from the callee
+  private Map<MethodDescriptor, Set<ParamIndexRelation>> mapMethodDescriptorToCalleeParamRelationSet;
+
+  // map a method descriptor to the set of method invocation nodes which are
+  // invoked by the method descriptor
+  private Map<MethodDescriptor, Set<MethodInvokeNode>> mapMethodDescriptorToMethodInvokeNodeSet;
+
+  private Map<MethodInvokeNode, Map<Integer, NTuple<Descriptor>>> mapMethodInvokeNodeToArgIdxMap;
+
   boolean debug = true;
 
   public LocationInference(SSJavaAnalysis ssjava, State state) {
@@ -86,6 +98,13 @@ public class LocationInference {
     this.methodDescriptorsToVisitStack = new Stack<MethodDescriptor>();
     this.md2LatticeMapping = new HashMap<MethodDescriptor, Map<VarDescriptor, String>>();
     this.cd2LatticeMapping = new HashMap<MethodDescriptor, Map<FieldDescriptor, String>>();
+    this.mapMethodDescriptorToCalleeParamRelationSet =
+        new HashMap<MethodDescriptor, Set<ParamIndexRelation>>();
+    this.mapMethodDescriptorToMethodInvokeNodeSet =
+        new HashMap<MethodDescriptor, Set<MethodInvokeNode>>();
+    this.mapMethodInvokeNodeToArgIdxMap =
+        new HashMap<MethodInvokeNode, Map<Integer, NTuple<Descriptor>>>();
+
   }
 
   public void setupToAnalyze() {
@@ -198,6 +217,8 @@ public class LocationInference {
       SSJavaLattice<String> methodLattice =
           new SSJavaLattice<String>(SSJavaLattice.TOP, SSJavaLattice.BOTTOM);
 
+      System.out.println("SSJAVA: Inferencing the lattice from " + md);
+
       analyzeMethodLattice(md, methodLattice);
 
       SSJavaLattice<String> prevMethodLattice = md2lattice.get(md);
@@ -237,8 +258,6 @@ public class LocationInference {
 
   private void analyzeMethodLattice(MethodDescriptor md, SSJavaLattice<String> methodLattice) {
 
-    System.out.println("# Create the method lattice for " + md);
-
     // visit each node of method flow graph
 
     FlowGraph fg = getFlowGraph(md);
@@ -250,31 +269,116 @@ public class LocationInference {
     for (Iterator iterator = nodeSet.iterator(); iterator.hasNext();) {
       FlowNode srcNode = (FlowNode) iterator.next();
 
+      // first, take a look at directly connected nodes
       Set<FlowEdge> outEdgeSet = srcNode.getOutEdgeSet();
       for (Iterator iterator2 = outEdgeSet.iterator(); iterator2.hasNext();) {
         FlowEdge outEdge = (FlowEdge) iterator2.next();
-
         FlowNode dstNode = outEdge.getDst();
 
-        if ((srcNode.getDescTuple().size() > 1 && dstNode.getDescTuple().size() > 1)
-            && srcNode.getDescTuple().get(0).equals(dstNode.getDescTuple().get(0))) {
-          // value flow between fields: we don't need to add a binary relation
-          // for this case
+        addRelationToLattice(md, methodLattice, srcNode, dstNode);
+
+        // second, take a look at all nodes that are reachable from the source
+        // node
+        recursiveVisitNodes(md, srcNode, dstNode);
+
+      }
+
+    }
+
+  }
+
+  private void addRelationToLattice(MethodDescriptor md, SSJavaLattice<String> methodLattice,
+      FlowNode srcNode, FlowNode dstNode) {
+    if ((srcNode.getDescTuple().size() > 1 && dstNode.getDescTuple().size() > 1)
+        && srcNode.getDescTuple().get(0).equals(dstNode.getDescTuple().get(0))) {
+      // value flow between fields: we don't need to add a binary relation
+      // for this case
+
+      VarDescriptor varDesc = (VarDescriptor) srcNode.getDescTuple().get(0);
+      ClassDescriptor varClassDesc = varDesc.getType().getClassDesc();
+
+      extractRelationFromFieldFlows(varClassDesc, srcNode, dstNode, 1);
+      return;
+    }
+
+    // add a new binary relation of dstNode < srcNode
+
+    String srcSymbol = getSymbol(0, srcNode);
+    String dstSymbol = getSymbol(0, dstNode);
+
+    methodLattice.addRelationHigherToLower(srcSymbol, dstSymbol);
+
+    if (srcNode.isParameter() && dstNode.isParameter()) {
+      propagateRelationToCaller(md, srcNode, dstNode);
+    }
+  }
+
+  private SSJavaLattice<String> getMethodLattice(MethodDescriptor md) {
+
+    if (!md2lattice.containsKey(md)) {
+      md2lattice.put(md, new SSJavaLattice<String>(SSJavaLattice.TOP, SSJavaLattice.BOTTOM));
+    }
+    return md2lattice.get(md);
+  }
+
+  private void propagateRelationToCaller(MethodDescriptor calleeMethodDesc, FlowNode srcNode,
+      FlowNode newVisitNode) {
+
+    FlowGraph calleeFlowGraph = getFlowGraph(calleeMethodDesc);
+
+    int higherLocIdxCallee = calleeFlowGraph.getParamIdx(srcNode.getDescTuple());
+    int lowerLocIdxCallee = calleeFlowGraph.getParamIdx(newVisitNode.getDescTuple());
+
+    System.out.println(" ssjava.getDependents(md)=" + ssjava.getDependents(calleeMethodDesc));
+    Iterator<MethodDescriptor> depsItr = ssjava.getDependents(calleeMethodDesc).iterator();
+    while (depsItr.hasNext()) {
+      MethodDescriptor callerMethodDesc = depsItr.next();
+
+      SSJavaLattice<String> callerMethodLattice = md2lattice.get(callerMethodDesc);
 
-          VarDescriptor varDesc = (VarDescriptor) srcNode.getDescTuple().get(0);
-          ClassDescriptor varClassDesc = varDesc.getType().getClassDesc();
+      Set<MethodInvokeNode> minSet = mapMethodDescriptorToMethodInvokeNodeSet.get(callerMethodDesc);
+      for (Iterator iterator = minSet.iterator(); iterator.hasNext();) {
+        MethodInvokeNode methodInvokeNode = (MethodInvokeNode) iterator.next();
+        if (methodInvokeNode.getMethod().equals(calleeMethodDesc)) {
+          // need to propagate a relation from the callee to the caller
+          // TODO
+
+          System.out.println("higherLocIdxCallee=" + higherLocIdxCallee);
+          System.out.println("lowerLocIdxCallee=" + lowerLocIdxCallee);
+
+          NTuple<Descriptor> higherArg = getArgTupleByArgIdx(methodInvokeNode, higherLocIdxCallee);
+          NTuple<Descriptor> lowerArg = getArgTupleByArgIdx(methodInvokeNode, lowerLocIdxCallee);
+
+          FlowNode callerHigherFlowNode = getFlowGraph(callerMethodDesc).getFlowNode(higherArg);
+          FlowNode calleeHigherFlowNode = getFlowGraph(callerMethodDesc).getFlowNode(lowerArg);
+
+          addRelationToLattice(callerMethodDesc, getMethodLattice(callerMethodDesc),
+              callerHigherFlowNode, calleeHigherFlowNode);
 
-          extractRelationFromFieldFlows(varClassDesc, srcNode, dstNode, 1);
-          continue;
         }
+      }
+
+    }
+  }
+
+  private void recursiveVisitNodes(MethodDescriptor md, FlowNode srcNode, FlowNode currentVisitNode) {
+
+    NTuple<Descriptor> srcTuple = srcNode.getDescTuple();
 
-        // add a new binary relation of dstNode < srcNode
+    for (Iterator<FlowEdge> outEdgeIter = currentVisitNode.getOutEdgeSet().iterator(); outEdgeIter
+        .hasNext();) {
 
-        String srcSymbol = getSymbol(0, srcNode);
-        String dstSymbol = getSymbol(0, dstNode);
+      FlowEdge outEdge = outEdgeIter.next();
+      FlowNode newVisitNode = outEdge.getDst();
 
-        methodLattice.addRelationHigherToLower(srcSymbol, dstSymbol);
+      NTuple<Descriptor> newVisitTuple = newVisitNode.getDescTuple();
 
+      // if both the source node and the newly visit node are parameters,
+      // need to keep this relation, then later add a new relation between
+      // corresponding arguments in the caller's lattice.
+      if (srcNode.isParameter() && newVisitNode.isParameter()) {
+        System.out.println("src=" + srcNode + "            newVisitNode=" + newVisitNode);
+        propagateRelationToCaller(md, srcNode, newVisitNode);
       }
 
     }
@@ -325,8 +429,19 @@ public class LocationInference {
           if (state.SSJAVADEBUG) {
             System.out.println("SSJAVA: Constructing a flow graph: " + md);
           }
-          FlowGraph fg = new FlowGraph(md);
+
+          // creates a mapping from a parameter descriptor to its index
+
+          Map<Descriptor, Integer> mapParamDescToIdx = new HashMap<Descriptor, Integer>();
+          int offset = md.isStatic() ? 0 : 1;
+          for (int i = 0; i < md.numParameters(); i++) {
+            Descriptor paramDesc = (Descriptor) md.getParameter(i);
+            mapParamDescToIdx.put(paramDesc, new Integer(i + offset));
+          }
+
+          FlowGraph fg = new FlowGraph(md, mapParamDescToIdx);
           mapMethodDescriptorToFlowGraph.put(md, fg);
+
           analyzeMethodBody(cd, md);
         }
       }
@@ -600,9 +715,21 @@ public class LocationInference {
 
   }
 
+  private void addMapCallerMethodDescToMethodInvokeNodeSet(MethodDescriptor caller,
+      MethodInvokeNode min) {
+    Set<MethodInvokeNode> set = mapMethodDescriptorToMethodInvokeNodeSet.get(caller);
+    if (set == null) {
+      set = new HashSet<MethodInvokeNode>();
+      mapMethodDescriptorToMethodInvokeNodeSet.put(caller, set);
+    }
+    set.add(min);
+  }
+
   private void analyzeFlowMethodInvokeNode(MethodDescriptor md, SymbolTable nametable,
       MethodInvokeNode min, NodeTupleSet implicitFlowTupleSet) {
 
+    addMapCallerMethodDescToMethodInvokeNodeSet(md, min);
+
     MethodDescriptor calleeMD = min.getMethod();
 
     NameDescriptor baseName = min.getBaseName();
@@ -656,6 +783,8 @@ public class LocationInference {
       // }
       // }
 
+      analyzeFlowMethodParameters(md, nametable, min);
+
       // checkCalleeConstraints(md, nametable, min, baseLocation, constraint);
 
       // checkCallerArgumentLocationConstraints(md, nametable, min,
@@ -675,6 +804,38 @@ public class LocationInference {
 
   }
 
+  private NTuple<Descriptor> getArgTupleByArgIdx(MethodInvokeNode min, int idx) {
+    return mapMethodInvokeNodeToArgIdxMap.get(min).get(new Integer(idx));
+  }
+
+  private void addArgIdxMap(MethodInvokeNode min, int idx, NTuple<Descriptor> argTuple) {
+    Map<Integer, NTuple<Descriptor>> mapIdxToArgTuple = mapMethodInvokeNodeToArgIdxMap.get(min);
+    if (mapIdxToArgTuple == null) {
+      mapIdxToArgTuple = new HashMap<Integer, NTuple<Descriptor>>();
+      mapMethodInvokeNodeToArgIdxMap.put(min, mapIdxToArgTuple);
+    }
+    mapIdxToArgTuple.put(new Integer(idx), argTuple);
+  }
+
+  private void analyzeFlowMethodParameters(MethodDescriptor callermd, SymbolTable nametable,
+      MethodInvokeNode min) {
+
+    if (min.numArgs() > 0) {
+
+      int offset = min.getMethod().isStatic() ? 0 : 1;
+
+      for (int i = 0; i < min.numArgs(); i++) {
+        ExpressionNode en = min.getArg(i);
+        NTuple<Descriptor> argTuple =
+            analyzeFlowExpressionNode(callermd, nametable, en, new NodeTupleSet(), false);
+
+        addArgIdxMap(min, i + offset, argTuple);
+      }
+
+    }
+
+  }
+
   private void analyzeLiteralNode(MethodDescriptor md, SymbolTable nametable, LiteralNode en) {
     // TODO Auto-generated method stub
 
@@ -984,3 +1145,8 @@ public class LocationInference {
   }
 
 }
+
+class ParamIndexRelation {
+  private Integer higherIdx;
+  private Integer lowerIdx;
+}
index 7f11924..344dd83 100644 (file)
@@ -631,6 +631,12 @@ public class SSJavaAnalysis {
 
     discovered.add(md);
 
+    Iterator itr2 = callgraph.getCalleeSet(md).iterator();
+    while (itr2.hasNext()) {
+      MethodDescriptor dCallee = (MethodDescriptor) itr2.next();
+      addDependent(dCallee, md);
+    }
+
     Iterator itr = callgraph.getCallerSet(md).iterator();
     while (itr.hasNext()) {
       MethodDescriptor dCaller = (MethodDescriptor) itr.next();