Merge branch 'develop' into ci/snapshotrelease

Author: swissiety

SynchronizedPDS/src/main/java/sync/pds/solver/SyncPDSSolver.java

@@ -27,6 +27,7 @@
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
+import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import sync.pds.solver.nodes.ExclusionNode;
 import sync.pds.solver.nodes.GeneratedState;
@@ -58,9 +59,7 @@ public enum PDSSystem {
     CALLS
   }
 
-  private static final org.slf4j.Logger logger = LoggerFactory.getLogger(SyncPDSSolver.class);
-  private static final boolean FieldSensitive = true;
-  private static final boolean ContextSensitive = true;
+  private static final Logger logger = LoggerFactory.getLogger(SyncPDSSolver.class);
   protected final WeightedPushdownSystem<Stmt, INode<Fact>, W> callingPDS =
       new WeightedPushdownSystem<Stmt, INode<Fact>, W>() {
         public String toString() {
@@ -81,6 +80,8 @@ public String toString() {
       reachedStateUpdateListeners = HashMultimap.create();
   protected final WeightedPAutomaton<Field, INode<Node<Stmt, Fact>>, W> fieldAutomaton;
   protected final WeightedPAutomaton<Stmt, INode<Fact>, W> callAutomaton;
+  private final boolean fieldSensitive;
+  private final boolean contextSensitive;
 
   protected boolean preventFieldTransitionAdd(
       Transition<Field, INode<Node<Stmt, Fact>>> trans, W weight) {
@@ -99,8 +100,33 @@ public SyncPDSSolver(
       int maxCallDepth,
       int maxFieldDepth,
       int maxUnbalancedCallDepth) {
+    this(
+        useCallSummaries,
+        callSummaries,
+        useFieldSummaries,
+        fieldSummaries,
+        maxCallDepth,
+        maxFieldDepth,
+        maxUnbalancedCallDepth,
+        true,
+        true);
+  }
+
+  public SyncPDSSolver(
+      final boolean useCallSummaries,
+      NestedWeightedPAutomatons<Stmt, INode<Fact>, W> callSummaries,
+      final boolean useFieldSummaries,
+      NestedWeightedPAutomatons<Field, INode<Node<Stmt, Fact>>, W> fieldSummaries,
+      int maxCallDepth,
+      int maxFieldDepth,
+      int maxUnbalancedCallDepth,
+      boolean fieldSensitive,
+      boolean contextSensitive) {
+    this.fieldSensitive = fieldSensitive;
+    this.contextSensitive = contextSensitive;
+
     fieldAutomaton =
-        new WeightedPAutomaton<Field, INode<Node<Stmt, Fact>>, W>() {
+        new WeightedPAutomaton<>() {
           @Override
           public INode<Node<Stmt, Fact>> createState(INode<Node<Stmt, Fact>> d, Field loc) {
             if (loc.equals(emptyField())) return d;
@@ -141,7 +167,7 @@ public boolean isGeneratedState(INode<Node<Stmt, Fact>> d) {
         };
 
     callAutomaton =
-        new WeightedPAutomaton<Stmt, INode<Fact>, W>() {
+        new WeightedPAutomaton<>() {
           @Override
           public INode<Fact> createState(INode<Fact> d, Stmt loc) {
             return generateCallState(d, loc);
@@ -556,7 +582,7 @@ public void processPop(Node<Stmt, Fact> curr, PopNode popNode) {
     Object location = popNode.location();
     if (system.equals(PDSSystem.FIELDS)) {
       NodeWithLocation<Stmt, Fact, Field> node = (NodeWithLocation) location;
-      if (FieldSensitive) {
+      if (fieldSensitive) {
         addFieldRule(
             new PopRule<>(
                 asFieldFact(curr),
@@ -568,7 +594,7 @@ public void processPop(Node<Stmt, Fact> curr, PopNode popNode) {
       }
       addNormalCallFlow(curr, node.fact());
     } else if (system.equals(PDSSystem.CALLS)) {
-      if (ContextSensitive) {
+      if (contextSensitive) {
         addCallRule(
             new PopRule<>(
                 wrap(curr.fact()), curr.stmt(), wrap((Fact) location), getCallWeights().pop(curr)));
@@ -657,7 +683,7 @@ public void processPush(
       Node<Stmt, Fact> curr, Location location, PushNode<Stmt, Fact, ?> succ, PDSSystem system) {
     if (system.equals(PDSSystem.FIELDS)) {
 
-      if (FieldSensitive) {
+      if (fieldSensitive) {
         addFieldRule(
             new PushRule<>(
                 asFieldFact(curr),
@@ -673,7 +699,7 @@ public void processPush(
 
     } else if (system.equals(PDSSystem.CALLS)) {
       addNormalFieldFlow(curr, succ);
-      if (ContextSensitive) {
+      if (contextSensitive) {
         addCallRule(
             new PushRule<>(
                 wrap(curr.fact()),

boomerangPDS/src/main/java/boomerang/WeightedBoomerang.java

@@ -137,13 +137,10 @@ protected BackwardBoomerangSolver<W> createItem(BackwardQuery key) {
                   cfg(),
                   genField,
                   key,
-                  WeightedBoomerang.this.options,
                   createCallSummaries(null, backwardCallSummaries),
                   createFieldSummaries(null, backwardFieldSummaries),
-                  WeightedBoomerang.this.dataFlowscope,
-                  options.getBackwardFlowFunction(),
-                  callGraph.getFieldLoadStatements(),
-                  callGraph.getFieldStoreStatements(),
+                  frameworkScope,
+                  options,
                   null) {
 
                 @Override
@@ -435,6 +432,10 @@ protected FieldWritePOI createItem(FieldWritePOI key) {
   private final CallGraph callGraph;
   private INode<Val> rootQuery;
 
+  public WeightedBoomerang(FrameworkScope frameworkScope) {
+    this(frameworkScope, BoomerangOptions.DEFAULT());
+  }
+
   public WeightedBoomerang(FrameworkScope frameworkScope, BoomerangOptions options) {
     this.frameworkScope = frameworkScope;
     this.options = options;
@@ -461,10 +462,6 @@ public WeightedBoomerang(FrameworkScope frameworkScope, BoomerangOptions options
     this.queryGraph = new QueryGraph<>(this);
   }
 
-  public WeightedBoomerang(FrameworkScope frameworkScope) {
-    this(frameworkScope, BoomerangOptions.DEFAULT());
-  }
-
   protected void addVisitedMethod(Method method) {
     if (!dataFlowscope.isExcluded(method) && visitedMethods.add(method)) {
       LOGGER.trace("Reach Method: {}", method);
@@ -482,13 +479,10 @@ protected ForwardBoomerangSolver<W> createForwardSolver(final ForwardQuery sourc
             cfg(),
             sourceQuery,
             genField,
-            options,
             createCallSummaries(sourceQuery, forwardCallSummaries),
             createFieldSummaries(sourceQuery, forwardFieldSummaries),
-            dataFlowscope,
-            options.getForwardFlowFunction(),
-            callGraph.getFieldLoadStatements(),
-            callGraph.getFieldStoreStatements(),
+            frameworkScope,
+            options,
             sourceQuery.getType()) {
 
           @Override
@@ -990,10 +984,7 @@ public ForwardBoomerangResults<W> solve(ForwardQuery query) {
         this.queryToSolvers,
         getStats(),
         analysisWatch,
-        visitedMethods,
-        options.trackDataFlowPath(),
-        options.prunePathConditions(),
-        options.trackImplicitFlows());
+        visitedMethods);
   }
 
   public BackwardBoomerangResults<W> solve(BackwardQuery query) {
@@ -1103,10 +1094,7 @@ public ForwardBoomerangResults<W> solveUnderScope(
         this.queryToSolvers,
         getStats(),
         analysisWatch,
-        visitedMethods,
-        options.trackDataFlowPath(),
-        options.prunePathConditions(),
-        options.trackImplicitFlows());
+        visitedMethods);
   }
 
   public void debugOutput() {

boomerangPDS/src/main/java/boomerang/flowfunction/DefaultBackwardFlowFunction.java

@@ -14,6 +14,7 @@
  */
 package boomerang.flowfunction;
 
+import boomerang.options.IAllocationSite;
 import boomerang.scope.ControlFlowGraph.Edge;
 import boomerang.scope.Field;
 import boomerang.scope.IArrayRef;
@@ -25,9 +26,7 @@
 import boomerang.scope.StaticFieldVal;
 import boomerang.scope.Val;
 import boomerang.scope.fields.ArrayField;
-import boomerang.solver.BackwardBoomerangSolver;
 import boomerang.solver.Strategies;
-import com.google.common.collect.Multimap;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.LinkedHashSet;
@@ -43,10 +42,18 @@
 
 public class DefaultBackwardFlowFunction implements IBackwardFlowFunction {
 
-  private final DefaultBackwardFlowFunctionOptions options;
-  private Strategies strategies;
+  private final IAllocationSite allocationSite;
+  private final Strategies strategies;
+  private final FlowFunctionOptions options;
 
-  public DefaultBackwardFlowFunction(DefaultBackwardFlowFunctionOptions options) {
+  public DefaultBackwardFlowFunction(IAllocationSite allocationSite, Strategies strategies) {
+    this(allocationSite, strategies, FlowFunctionOptions.DEFAULT());
+  }
+
+  public DefaultBackwardFlowFunction(
+      IAllocationSite allocationSite, Strategies strategies, FlowFunctionOptions options) {
+    this.allocationSite = allocationSite;
+    this.strategies = strategies;
     this.options = options;
   }
 
@@ -105,10 +112,7 @@ public Collection<Val> callFlow(Statement callSite, Val fact, Method callee, Sta
   @Override
   public Collection<State> normalFlow(Edge currEdge, Edge nextEdge, Val fact) {
     Statement nextStmt = nextEdge.getTarget();
-    if (options
-        .allocationSite()
-        .getAllocationSite(nextStmt.getMethod(), nextStmt, fact)
-        .isPresent()) {
+    if (allocationSite.getAllocationSite(nextStmt.getMethod(), nextStmt, fact).isPresent()) {
       return Collections.emptySet();
     }
     if (nextStmt.isThrowStmt()) {
@@ -193,20 +197,6 @@ public Collection<State> callToReturnFlow(Edge currEdge, Edge nextEdge, Val fact
     return normalFlow(currEdge, nextEdge, fact);
   }
 
-  @Override
-  public void setSolver(
-      BackwardBoomerangSolver<?> solver,
-      Multimap<Field, Statement> fieldLoadStatements,
-      Multimap<Field, Statement> fieldStoreStatements) {
-    this.strategies =
-        new Strategies(
-            options.staticFieldStrategy(),
-            options.arrayStrategy(),
-            solver,
-            fieldLoadStatements,
-            fieldStoreStatements);
-  }
-
   protected Collection<State> systemArrayCopyFlow(Edge edge, Val fact) {
     Statement callSite = edge.getTarget();
     if (fact.equals(callSite.getInvokeExpr().getArg(2))) {