more cases & fixes

src/main/java/analysis/IDELinearConstantAnalysisProblem.java

@@ -21,9 +21,9 @@ public class IDELinearConstantAnalysisProblem extends DefaultJimpleIDETabulation
 
     protected InterproceduralCFG<Unit, SootMethod> icfg;
 
-    protected final static Integer TOP = Integer.MIN_VALUE; // Unknown
+    public final static Integer TOP = Integer.MIN_VALUE; // Unknown
 
-    protected final static Integer BOTTOM = Integer.MAX_VALUE; // Not Constant
+    public final static Integer BOTTOM = Integer.MAX_VALUE; // Not Constant
 
 
     public IDELinearConstantAnalysisProblem(InterproceduralCFG<Unit, SootMethod> icfg) {

src/main/java/analysis/edgefunctions/CPANormalEdgeFunctionProvider.java

@@ -1,5 +1,6 @@
 package analysis.edgefunctions;
 
+import analysis.IDELinearConstantAnalysisProblem;
 import analysis.data.DFF;
 import analysis.edgefunctions.normal.IntegerAssign;
 import analysis.edgefunctions.normal.IntegerBinop;
@@ -14,7 +15,7 @@
 
 public class CPANormalEdgeFunctionProvider {
 
-    private final static EdgeFunction<Integer> ALL_BOTTOM = new AllBottom<>(Integer.MAX_VALUE);
+    private final static EdgeFunction<Integer> ALL_BOTTOM = new IntegerAllBottom(IDELinearConstantAnalysisProblem.BOTTOM);
 
     private EdgeFunction<Integer> edgeFunction;
 

src/main/java/analysis/edgefunctions/IntegerAllBottom.java

@@ -0,0 +1,16 @@
+package analysis.edgefunctions;
+
+import heros.EdgeFunction;
+import heros.edgefunc.AllBottom;
+
+public class IntegerAllBottom extends AllBottom<Integer> {
+
+    public IntegerAllBottom(Integer bottomElement) {
+        super(bottomElement);
+    }
+
+    @Override
+    public EdgeFunction<Integer> meetWith(EdgeFunction<Integer> otherFunction) {
+        return this; // this should override everything
+    }
+}

src/main/java/analysis/edgefunctions/normal/IntegerAssign.java

@@ -1,5 +1,7 @@
 package analysis.edgefunctions.normal;
 
+import analysis.IDELinearConstantAnalysisProblem;
+import analysis.edgefunctions.IntegerAllBottom;
 import heros.EdgeFunction;
 import heros.edgefunc.AllBottom;
 import heros.edgefunc.EdgeIdentity;
@@ -66,11 +68,11 @@ public EdgeFunction<Integer> meetWith(EdgeFunction<Integer> otherFunction) {
             if(valueFromOtherBranch==valueFromThisBranch){
                 return this;
             }else{
-                return new AllBottom<>(Integer.MAX_VALUE);
+                return new IntegerAllBottom(IDELinearConstantAnalysisProblem.BOTTOM);
             }
         }else if(otherFunction instanceof IntegerBinop){
-            return new AllBottom<>(Integer.MAX_VALUE);
-        }else if(otherFunction instanceof AllBottom){
+            return new IntegerAllBottom(IDELinearConstantAnalysisProblem.BOTTOM);
+        }else if(otherFunction instanceof IntegerAllBottom){
             return otherFunction;
         }
         throw new RuntimeException("can't meeet: " + this.toString() + " and " + otherFunction.toString());

src/main/java/analysis/edgefunctions/normal/IntegerBinop.java

@@ -1,6 +1,8 @@
 package analysis.edgefunctions.normal;
 
+import analysis.IDELinearConstantAnalysisProblem;
 import analysis.data.DFF;
+import analysis.edgefunctions.IntegerAllBottom;
 import heros.EdgeFunction;
 import heros.edgefunc.EdgeIdentity;
 import soot.Value;
@@ -65,8 +67,16 @@ public static int executeBinOperation(String op, int lhs, int rhs) {
 
     @Override
     public EdgeFunction<Integer> meetWith(EdgeFunction otherFunction) {
-        throw new UnsupportedOperationException("int i = j op const .meetWith()");
-//                                return this;
+        if(otherFunction instanceof EdgeIdentity){
+            return this;
+        }else if(otherFunction instanceof IntegerAssign){
+            return new IntegerAllBottom(IDELinearConstantAnalysisProblem.BOTTOM);
+        }else if(otherFunction instanceof IntegerBinop){
+            return new IntegerAllBottom(IDELinearConstantAnalysisProblem.BOTTOM);
+        }else if(otherFunction instanceof IntegerAllBottom){
+            return otherFunction;
+        }
+        throw new RuntimeException("can't meeet: " + this.toString() + " and " + otherFunction.toString());
     }
 
     @Override

src/main/java/analysis/edgefunctions/normal/IntegerTop.java

@@ -1,5 +1,6 @@
 package analysis.edgefunctions.normal;
 
+import analysis.IDELinearConstantAnalysisProblem;
 import heros.EdgeFunction;
 
 /**
@@ -9,7 +10,7 @@ public class IntegerTop implements EdgeFunction<Integer> {
 
     private static final IntegerTop instance = new IntegerTop();
 
-    Integer value = Integer.MIN_VALUE;
+    Integer value = IDELinearConstantAnalysisProblem.TOP;
 
     private IntegerTop(){
     }

src/test/java/target/constant/SimpleAssignment4.java → src/test/java/target/constant/Assignment.java

@@ -1,11 +1,13 @@
 package target.constant;
 
-public class SimpleAssignment4 {
+public class Assignment {
 
+    /**
+     * Simple assignment
+     */
     public void entryPoint() {
         int a = 100;
         int b = 200;
-        int c = a * 4 + 13;
     }
 
 }

src/test/java/target/constant/SimpleAssignment2.java → src/test/java/target/constant/Assignment2.java

@@ -1,7 +1,10 @@
 package target.constant;
 
-public class SimpleAssignment2 {
+public class Assignment2 {
 
+    /**
+     * Assignment with binop of constants
+     */
     public void entryPoint() {
         int a = 100;
         int b = 200;

src/test/java/target/constant/SimpleAssignment3.java → src/test/java/target/constant/Assignment3.java

@@ -1,7 +1,10 @@
 package target.constant;
 
-public class SimpleAssignment3 {
+public class Assignment3 {
 
+    /**
+     * Assignment with binop of linear value
+     */
     public void entryPoint() {
         int a = 100;
         int b = 200;

src/test/java/target/constant/Assignment4.java

@@ -0,0 +1,14 @@
+package target.constant;
+
+public class Assignment4 {
+
+    /**
+     * Assignment with linear value multi const
+     */
+    public void entryPoint() {
+        int a = 100;
+        int b = 200;
+        int c = a * 4 + 13;
+    }
+
+}

src/test/java/target/constant/SimpleAssignment5.java → src/test/java/target/constant/Assignment5.java

@@ -1,7 +1,10 @@
 package target.constant;
 
-public class SimpleAssignment5 {
+public class Assignment5 {
 
+    /**
+     * Assignment with overwrite
+     */
     public void entryPoint() {
         int a = 100;
         int b = 200;

src/test/java/target/constant/SimpleAssignment6.java → src/test/java/target/constant/Assignment6.java

@@ -1,7 +1,10 @@
 package target.constant;
 
-public class SimpleAssignment6 {
+public class Assignment6 {
 
+    /**
+     * Increment value
+     */
     public void entryPoint() {
         int a = 100;
         int b = 200;

src/test/java/target/constant/SimpleAssignment7.java → src/test/java/target/constant/Assignment7.java

@@ -1,7 +1,10 @@
 package target.constant;
 
-public class SimpleAssignment7 {
+public class Assignment7 {
 
+    /**
+     * various operators
+     */
     public void entryPoint() {
         int a = 100;
         int b = a + 10;

src/test/java/target/constant/SimpleAssignment8.java → src/test/java/target/constant/Assignment8.java

@@ -1,7 +1,10 @@
 package target.constant;
 
-public class SimpleAssignment8 {
+public class Assignment8 {
 
+    /**
+     * assignment chain
+     */
     public void entryPoint() {
         int a = 100;
         int b = a;

src/test/java/target/constant/Branching.java

@@ -2,6 +2,10 @@
 
 public class Branching {
 
+    /**
+     * Same value in different branches used in the end
+     * @param p unknown
+     */
     void entryPoint(boolean p) {
         int a = 0;
         int b = 1;

src/test/java/target/constant/Branching2.java

@@ -2,6 +2,10 @@
 
 public class Branching2 {
 
+    /**
+     * same value in different branches not used in the end
+     * @param p unknown
+     */
     void entryPoint(boolean p) {
         int a = 0;
         int b = 0;

src/test/java/target/constant/Branching3.java

@@ -0,0 +1,19 @@
+package target.constant;
+
+public class Branching3 {
+
+    /**
+     * different values in different branches used in the end
+     * @param p unknown
+     */
+    void entryPoint(boolean p) {
+        int a = 0;
+        if (p) {
+            a = 23;
+        } else {
+            a = 42;
+        }
+        int c = a;
+    }
+
+}

src/test/java/target/constant/Branching4.java

@@ -0,0 +1,20 @@
+package target.constant;
+
+public class Branching4 {
+
+    /**
+     * different values in different branches not used in the end
+     * @param p unknown
+     */
+    void entryPoint(boolean p) {
+        int a = 0;
+        int b = 10;
+        if (p) {
+            a = 23;
+        } else {
+            a = 42;
+        }
+        int c = b;
+    }
+
+}

src/test/java/target/constant/Branching5.java

@@ -0,0 +1,20 @@
+package target.constant;
+
+public class Branching5 {
+
+    /**
+     * different values in different branches meet with linear op
+     * @param p unknown
+     */
+    void entryPoint(boolean p) {
+        int a = 0;
+        int b = 10;
+        if (p) {
+            a = 23;
+        } else {
+            a = 42;
+        }
+        int c = a + 3;
+    }
+
+}

src/test/java/target/constant/Branching6.java

@@ -0,0 +1,20 @@
+package target.constant;
+
+public class Branching6 {
+
+    /**
+     * same values in different branches meet with linear op
+     * @param p unknown
+     */
+    void entryPoint(boolean p) {
+        int a = 0;
+        int b = 10;
+        if (p) {
+            a = 23;
+        } else {
+            a = 23;
+        }
+        int c = a + 3;
+    }
+
+}

src/test/java/target/constant/FunctionCall.java → src/test/java/target/constant/Context.java

@@ -1,6 +1,6 @@
 package target.constant;
 
-public class FunctionCall {
+public class Context {
 
     int id(int a) {
         return a;

src/test/java/target/constant/FunctionCall2.java → src/test/java/target/constant/Context2.java

@@ -1,6 +1,6 @@
 package target.constant;
 
-public class FunctionCall2 {
+public class Context2 {
 
     int increment(int a) {
         return a + 1;

src/test/java/target/constant/FunctionCall3.java → src/test/java/target/constant/Context3.java

@@ -1,6 +1,6 @@
 package target.constant;
 
-public class FunctionCall3 {
+public class Context3 {
 
     int add(int a, int b) {
         return a + 13;

src/test/java/target/constant/Context4.java

@@ -0,0 +1,28 @@
+package target.constant;
+
+
+public class Context4 {
+
+    int increment(int a) {
+        return a + 1;
+    }
+
+    int nestedCaller(int a){
+        return nestedCaller1(a);
+    }
+
+    int nestedCaller1(int a){
+        return increment(a);
+    }
+
+    /**
+     * nested calls
+     */
+    public void entryPoint() {
+        int a = 100;
+        int b = 200;
+        int c = increment(a);
+        int d = nestedCaller(b);
+    }
+
+}

src/test/java/target/constant/Field.java

@@ -5,6 +5,9 @@ public class Field {
     int x;
     int y;
 
+    /**
+     * Field loaded with constant
+     */
     public void entryPoint() {
         Field field = new Field();
         field.x = 100;

src/test/java/target/constant/Field2.java

@@ -5,6 +5,9 @@ public class Field2 {
     int x;
     int y;
 
+    /**
+     * field stored to local
+     */
     public void entryPoint() {
         Field2 field = new Field2();
         field.x = 100;