Fix SVFA implementation

.gitignore

@@ -16,4 +16,5 @@ project/plugins/project/
 # Scala-IDE specific
 .scala_dependencies
 .worksheet
-.idea
+.idea
+.gradle/

src/main/scala/br/unb/cic/soot/graph/Graph.scala

@@ -27,6 +27,7 @@ trait GraphNode {
   def unit(): soot.Unit
   def method(): soot.SootMethod
   def show(): String
+  def line(): Int
 }
 
 trait LambdaNode extends scala.AnyRef {
@@ -51,17 +52,14 @@ case class Statement(className: String, method: String, stmt: String, line: Int,
 case class StatementNode(value: Statement, nodeType: NodeType) extends GraphNode {
   type T = Statement
 
-  //  override def show(): String = "(" ++ value.method + ": " + value.stmt + " - " + value.line + " <" + nodeType.toString + ">)"
-  override def show(): String = value.stmt
+  override def show(): String = "(" ++ value.method + ": " + value.stmt + " - " + value.line + " <" + nodeType.toString + ">)"
 
   override def toString: String =
-    "Node(" + value.method + "," + value.stmt + "," + "," + nodeType.toString + ")"
+    "Node(" + value.method + "," + value.stmt + "," + value.line+ "," + nodeType.toString + ")"
 
   override def equals(o: Any): Boolean = {
     o match {
-      //      case stmt: StatementNode => stmt.value.toString == value.toString
-      //      case stmt: StatementNode => stmt.value == value && stmt.nodeType == nodeType
-      case stmt: StatementNode => stmt.value.className.equals(value.className) &&
+       case stmt: StatementNode => stmt.value.className.equals(value.className) &&
         stmt.value.method.equals(value.method) &&
         stmt.value.stmt.equals(value.stmt) &&
         stmt.value.line.equals(value.line) &&
@@ -75,6 +73,8 @@ case class StatementNode(value: Statement, nodeType: NodeType) extends GraphNode
   override def unit(): soot.Unit = value.sootUnit
 
   override def method(): SootMethod = value.sootMethod
+
+  override def line(): Int = value.line
 }
 
 /*

src/main/scala/br/unb/cic/soot/svfa/SootConfiguration.scala

@@ -50,6 +50,7 @@ abstract class SootConfiguration {
     Options.v().set_keep_line_number(true)
     Options.v().set_prepend_classpath(true)
     Options.v().setPhaseOption("jb", "use-original-names:true")
+    Options.v().set_ignore_resolution_errors(true);
     configureCallGraphPhase()
 
     Scene.v().loadNecessaryClasses()

src/main/scala/br/unb/cic/soot/svfa/jimple/AnalysisDepth.scala

@@ -0,0 +1,10 @@
+package br.unb.cic.soot.svfa.jimple
+
+trait AnalysisDepth {
+  def maxDepth(): Int = 0
+  def isLimited(): Boolean= maxDepth() > 0
+}
+
+trait StandardLimitedAnalysis	extends AnalysisDepth {
+  override def maxDepth(): Int = 10
+}

src/main/scala/br/unb/cic/soot/svfa/jimple/JSVFA.scala

@@ -2,34 +2,37 @@ package br.unb.cic.soot.svfa.jimple
 
 import java.util
 import br.unb.cic.soot.svfa.jimple.rules.RuleAction
-import br.unb.cic.soot.graph.{CallSiteCloseLabel, CallSiteLabel, CallSiteOpenLabel, ContextSensitiveRegion, GraphNode, SinkNode, SourceNode, StatementNode}
+import br.unb.cic.soot.graph.{CallSiteCloseLabel, CallSiteLabel, CallSiteOpenLabel, ContextSensitiveRegion, GraphNode, SimpleNode, SinkNode, SourceNode, StatementNode}
 import br.unb.cic.soot.svfa.jimple.dsl.{DSL, LanguageParser}
 import br.unb.cic.soot.svfa.{SVFA, SourceSinkDef}
 import com.typesafe.scalalogging.LazyLogging
 import soot.jimple._
-import soot.jimple.internal.{JArrayRef, JAssignStmt}
+import soot.jimple.internal.{JArrayRef, JAssignStmt, JInstanceFieldRef}
 import soot.jimple.spark.ondemand.DemandCSPointsTo
 import soot.jimple.spark.pag
 import soot.jimple.spark.pag.{AllocNode, PAG}
 import soot.jimple.spark.sets.{DoublePointsToSet, HybridPointsToSet, P2SetVisitor}
 import soot.toolkits.graph.ExceptionalUnitGraph
 import soot.toolkits.scalar.SimpleLocalDefs
-import soot.{ArrayType, Local, Scene, SceneTransformer, SootField, SootMethod, Transform, Value, jimple}
+import soot.{ArrayType, Local, PointsToSet, Scene, SceneTransformer, SootField, SootMethod, Transform, Value, jimple}
 
 import scala.collection.mutable.ListBuffer
 
 /**
  * A Jimple based implementation of
  * SVFA.
  */
-abstract class JSVFA extends SVFA with Analysis with FieldSensitiveness with ObjectPropagation with SourceSinkDef with LazyLogging  with DSL {
+abstract class JSVFA extends SVFA with Analysis with AnalysisDepth with FieldSensitiveness with ObjectPropagation with SourceSinkDef with LazyLogging  with DSL {
 
+  val visitedMethodsDepth = new ListBuffer[SootMethod]()
+  val visitedMethodsAllocationSites = scala.collection.mutable.Set.empty[SootMethod]
+  var numberVisitedMethods = 0
+  var printDepthVisitedMethods: Boolean = false
   var methods = 0
   val traversedMethods = scala.collection.mutable.Set.empty[SootMethod]
   val allocationSites = scala.collection.mutable.HashMap.empty[soot.Value, StatementNode]
   val arrayStores = scala.collection.mutable.HashMap.empty[Local, List[soot.Unit]]
   val languageParser = new LanguageParser(this)
-
   val methodRules = languageParser.evaluate(code())
 
   /*
@@ -55,9 +58,7 @@ abstract class JSVFA extends SVFA with Analysis with FieldSensitiveness with Obj
         expr = invokeStmt.getInvokeExpr
       }catch {
         case e: Exception=>
-          srcArg = invokeStmt.getInvokeExpr.getArg(from)
-          expr = invokeStmt.getInvokeExpr
-          println("Entrou com errro!")
+          println("An error occurred in getInvokeExpr with args: "+invokeStmt.getInvokeExpr+" -> "+e)
       }
       if(hasBaseObject(expr) && srcArg.isInstanceOf[Local]) {
         val local = srcArg.asInstanceOf[Local]
@@ -171,38 +172,62 @@ abstract class JSVFA extends SVFA with Analysis with FieldSensitiveness with Obj
     }
   }
 
-
   def createSceneTransform(): (String, Transform) = ("wjtp", new Transform("wjtp.svfa", new Transformer()))
 
   def initAllocationSites(): Unit = {
     val listener = Scene.v().getReachableMethods.listener()
 
     while(listener.hasNext) {
       val m = listener.next().method()
-      if (m.hasActiveBody) {
-        val body = m.getActiveBody
-        body.getUnits.forEach(unit => {
-          if (unit.isInstanceOf[soot.jimple.AssignStmt]) {
-            val right = unit.asInstanceOf[soot.jimple.AssignStmt].getRightOp
-            if (right.isInstanceOf[NewExpr] || right.isInstanceOf[NewArrayExpr] || right.isInstanceOf[StringConstant]) {
-              allocationSites += (right -> createNode(m, unit))
-            }
+
+      updateAllocationSites(m)
+
+    }
+  }
+
+  def updateAllocationSites(m: SootMethod): Unit = {
+
+    if(visitedMethodsAllocationSites.contains(m)) {
+      return
+    }
+
+    visitedMethodsAllocationSites.add(m)
+
+    if (m.hasActiveBody) {
+      val body = m.getActiveBody
+      body.getUnits.forEach(unit => {
+        if (unit.isInstanceOf[soot.jimple.AssignStmt]) {
+          val right = unit.asInstanceOf[soot.jimple.AssignStmt].getRightOp
+          if (right.isInstanceOf[soot.jimple.InstanceInvokeExpr]){
+            val method = right.asInstanceOf[soot.jimple.InstanceInvokeExpr]
+            updateAllocationSites(method.getMethod)
           }
-          else if(unit.isInstanceOf[soot.jimple.ReturnStmt]) {
-            val exp = unit.asInstanceOf[soot.jimple.ReturnStmt].getOp
-            if(exp.isInstanceOf[StringConstant]) {
-              allocationSites += (exp -> createNode(m, unit))
-            }
+          if (right.isInstanceOf[NewExpr] || right.isInstanceOf[NewArrayExpr] || right.isInstanceOf[StringConstant]) {
+            allocationSites += (right -> createNode(m, unit))
           }
-        })
-      }
+        }
+        else if(unit.isInstanceOf[soot.jimple.ReturnStmt]) {
+          val exp = unit.asInstanceOf[soot.jimple.ReturnStmt].getOp
+          if(exp.isInstanceOf[StringConstant]) {
+            allocationSites += (exp -> createNode(m, unit))
+          }
+        }
+
+        if (unit.isInstanceOf[soot.jimple.InvokeStmt]){
+          val method = unit.asInstanceOf[soot.jimple.InvokeStmt]
+          updateAllocationSites(method.getInvokeExpr.getMethod)
+        }
+
+      })
     }
   }
 
   class Transformer extends SceneTransformer {
     override def internalTransform(phaseName: String, options: util.Map[String, String]): Unit = {
       pointsToAnalysis = Scene.v().getPointsToAnalysis
+
       initAllocationSites()
+
       Scene.v().getEntryPoints.forEach(method => {
         traverse(method)
         methods = methods + 1
@@ -211,14 +236,22 @@ abstract class JSVFA extends SVFA with Analysis with FieldSensitiveness with Obj
   }
 
   def traverse(method: SootMethod, forceNewTraversal: Boolean = false) : Unit = {
+
     if((!forceNewTraversal) && (method.isPhantom || traversedMethods.contains(method))) {
       return
     }
 
+    if (isLimited() && visitedMethodsDepth.size >= maxDepth()){
+      return
+    }
+
+    if (printDepthVisitedMethods){
+      println(method.toString+", deep: "+ visitedMethodsDepth.size)
+    }
+
     traversedMethods.add(method)
 
     val body  = method.retrieveActiveBody()
-
     val graph = new ExceptionalUnitGraph(body)
     val defs  = new SimpleLocalDefs(graph)
 
@@ -232,8 +265,8 @@ abstract class JSVFA extends SVFA with Analysis with FieldSensitiveness with Obj
         case _ =>
       }
     })
-  }
 
+  }
 
   def traverse(assignStmt: AssignStmt, method: SootMethod, defs: SimpleLocalDefs) : Unit = {
     val left = assignStmt.stmt.getLeftOp
@@ -249,6 +282,7 @@ abstract class JSVFA extends SVFA with Analysis with FieldSensitiveness with Obj
       case (p: JArrayRef, _) => storeArrayRule(assignStmt)
       case _ =>
     }
+
   }
 
   def traverse(stmt: InvokeStmt, method: SootMethod, defs: SimpleLocalDefs) : Unit = {
@@ -275,16 +309,26 @@ abstract class JSVFA extends SVFA with Analysis with FieldSensitiveness with Obj
 
     if(analyze(callStmt.base) == SinkNode) {
       defsToCallOfSinkMethod(callStmt, exp, caller, defs)
-      return  // TODO: we are not exploring the body of a sink method.
-      //       For this reason, we only find one path in the
-      //       FieldSample test case, instead of two.
     }
 
-    if(analyze(callStmt.base) == SourceNode) {
+    if(analyze(callStmt.base) == SourceNode || analyze(callStmt.base) == SinkNode) {
       val source = createNode(caller, callStmt.base)
       svg.addNode(source)
     }
 
+    //Add edge from defs statements to invoke statement use
+    callStmt.base.getUseBoxes.forEach(stmt => {
+      if(stmt.getValue.isInstanceOf[Local]) {
+        val local = stmt.getValue.asInstanceOf[Local]
+
+        defs.getDefsOfAt(local, callStmt.base).forEach(sourceStmt => {
+          val sourceNode = createNode(caller, sourceStmt)
+          val targetNode = createNode(caller, callStmt.base)
+          updateGraph(sourceNode, targetNode)
+        })
+      }
+    })
+
     for(r <- methodRules) {
       if(r.check(callee)) {
         r.apply(caller, callStmt.base.asInstanceOf[jimple.Stmt], defs)
@@ -314,8 +358,14 @@ abstract class JSVFA extends SVFA with Analysis with FieldSensitiveness with Obj
         stringToCallSite(caller, callee, callStmt.base, s)
       }
     })
+    visitedMethodsDepth += callee.retrieveActiveBody().getMethod
+
+    numberVisitedMethods += 1
 
     traverse(callee)
+
+    visitedMethodsDepth -= callee.retrieveActiveBody().getMethod
+
   }
 
   private def applyPhantomMethodCallRule(callStmt: Statement, exp: InvokeExpr, caller: SootMethod, defs: SimpleLocalDefs) = {
@@ -456,6 +506,7 @@ abstract class JSVFA extends SVFA with Analysis with FieldSensitiveness with Obj
         })
       }
       else {
+
         //        val allocationNodes = findAllocationSites(base)
 
         //        val allocationNodes = findAllocationSites(base, true, fieldRef.getField)
@@ -468,8 +519,10 @@ abstract class JSVFA extends SVFA with Analysis with FieldSensitiveness with Obj
         })
         //          })
         //        }
+
       }
     }
+
   }
 
   def storeArrayRule(assignStmt: AssignStmt) {
@@ -487,7 +540,6 @@ abstract class JSVFA extends SVFA with Analysis with FieldSensitiveness with Obj
       val csCloseLabel = createCSCloseLabel(caller, callStmt, callee)
       svg.addEdge(source, target, csCloseLabel)
 
-
       if(local.getType.isInstanceOf[ArrayType]) {
         val stores = arrayStores.getOrElseUpdate(local, List())
         stores.foreach(sourceStmt => {
@@ -741,4 +793,12 @@ abstract class JSVFA extends SVFA with Analysis with FieldSensitiveness with Obj
     }
   }
 
+  def setPrintDepthVisitedMethods(printDepthVisitedMethods: Boolean) {
+    this.printDepthVisitedMethods = printDepthVisitedMethods
+  }
+
+  def getNumberVisitedMethods(): Int = {
+    return numberVisitedMethods
+  }
+
 }

src/main/scala/br/unb/cic/soot/svfa/jimple/Statement.scala

@@ -12,6 +12,7 @@ case class AssignStmt(b: Unit) extends Statement(b) {
 case class InvokeStmt(b: Unit) extends Statement(b) {
   val stmt = base.asInstanceOf[soot.jimple.InvokeStmt]
 }
+
 case class InvalidStmt(b: Unit) extends Statement(b)
 
 object Statement {

src/test/java/samples/AllocationFlowTest1.java

@@ -0,0 +1,12 @@
+package samples;
+
+public class AllocationFlowTest1 {
+    private Point p;
+
+    public void main() {
+        Integer x = new Integer(3); //Left
+        x = null;
+        Integer y;
+        y = x;
+    }
+}

src/test/java/samples/AllocationFlowTest2.java

@@ -0,0 +1,11 @@
+package samples;
+
+public class AllocationFlowTest2 {
+    private Point p;
+
+    public void main() {
+        Integer x = new Integer(3); //Left
+        Integer y;
+        y = x;
+    }
+}

src/test/java/samples/Field1.java

@@ -0,0 +1,10 @@
+package samples;
+
+public class Field1 {
+//    Integer p = new Integer(1);
+    public void main() {
+        Integer x, p;
+        p = new Integer(3); //Left
+        x = new Integer(p); //Right
+    }
+}

src/test/java/samples/Field2.java

@@ -0,0 +1,10 @@
+package samples;
+
+public class Field2 {
+    private Point p;
+
+    public void main() {
+        p.y = 3; //Left
+        p.y = p.x + 5; //Right
+    }
+}

src/test/java/samples/Field3.java

@@ -0,0 +1,10 @@
+package samples;
+
+public class Field3 {
+    private Point p;
+
+    public void main() {
+        p.y = 3; //Left
+        p.y = 5; //Right
+    }
+}