svf-tools 1.0.853 → 1.0.855

package/svf/lib/Util/PTAStat.cpp

@@ -36,8 +36,17 @@
 using namespace SVF;
 using namespace std;
 
-PTAStat::PTAStat(PointerAnalysis* p) : SVFStat(), pta(p)
+PTAStat::PTAStat(PointerAnalysis* p) : SVFStat(),
+    pta(p),
+    _vmrssUsageBefore(0),
+    _vmrssUsageAfter(0),
+    _vmsizeUsageBefore(0),
+    _vmsizeUsageAfter(0)
 {
+    u32_t vmrss = 0;
+    u32_t vmsize = 0;
+    SVFUtil::getMemoryUsageKB(&vmrss, &vmsize);
+    setMemUsageBefore(vmrss, vmsize);
 }
 
 void PTAStat::performStat()
@@ -59,6 +68,13 @@ void PTAStat::performStat()
         }
     }
     PTNumStatMap["LocalVarInRecur"] = localVarInRecursion.count();
+
+    u32_t vmrss = 0;
+    u32_t vmsize = 0;
+    SVFUtil::getMemoryUsageKB(&vmrss, &vmsize);
+    setMemUsageAfter(vmrss, vmsize);
+    PTNumStatMap["MemoryUsageVmrss"] = _vmrssUsageAfter - _vmrssUsageBefore;
+    PTNumStatMap["MemoryUsageVmsize"] = _vmsizeUsageAfter - _vmsizeUsageBefore;
 }
 
 void PTAStat::callgraphStat()

package/svf/lib/WPA/Andersen.cpp

@@ -74,11 +74,11 @@ void AndersenBase::initialize()
 {
     /// Build SVFIR
     PointerAnalysis::initialize();
+    /// Create statistic class
+    stat = new AndersenStat(this);
     /// Build Constraint Graph
     consCG = new ConstraintGraph(pag);
     setGraph(consCG);
-    /// Create statistic class
-    stat = new AndersenStat(this);
     if (Options::ConsCGDotGraph())
         consCG->dump("consCG_initial");
 }

package/svf/lib/WPA/AndersenStat.cpp

@@ -352,6 +352,9 @@ void AndersenStat::performStat()
     PTNumStatMap["PointsToConstPtr"] = _NumOfConstantPtr;
     PTNumStatMap["PointsToBlkPtr"] = _NumOfBlackholePtr;
 
+    PTNumStatMap["MemoryUsageVmrss"] = _vmrssUsageAfter - _vmrssUsageBefore;
+    PTNumStatMap["MemoryUsageVmsize"] = _vmsizeUsageAfter - _vmsizeUsageBefore;
+
     PTAStat::printStat("Andersen Pointer Analysis Stats");
 }
 

package/svf-llvm/tools/AE/CMakeLists.txt

@@ -0,0 +1,2 @@
+add_llvm_executable(ae ae.cpp)
+target_link_libraries(ae PUBLIC ${llvm_libs} SvfLLVM)

package/svf-llvm/tools/AE/ae.cpp

@@ -0,0 +1,607 @@
+//
+// Created by Jiawei Ren on 11/28/23.
+//
+#include "AbstractExecution/IntervalExeState.h"
+#include "AbstractExecution/RelExeState.h"
+#include "AbstractExecution/RelationSolver.h"
+#include "SVF-LLVM/LLVMUtil.h"
+#include "Util/Z3Expr.h"
+#include "Util/Options.h"
+#include <chrono>
+
+using namespace SVF;
+using namespace SVFUtil;
+
+static Option<bool> SYMABS(
+    "symabs",
+    "symbolic abstraction test",
+    false
+);
+
+class SymblicAbstractionTest
+{
+public:
+    SymblicAbstractionTest() = default;
+
+    ~SymblicAbstractionTest() = default;
+
+    static z3::context& getContext()
+    {
+        return Z3Expr::getContext();
+    }
+
+    void test_print()
+    {
+        SVFUtil::outs() << "hello print\n";
+    }
+
+    IntervalESBase RSY_time(IntervalESBase& inv, const Z3Expr& phi,
+                            RelationSolver& rs)
+    {
+        auto start_time = std::chrono::high_resolution_clock::now();
+        IntervalESBase resRSY = rs.RSY(inv, phi);
+        auto end_time = std::chrono::high_resolution_clock::now();
+        auto duration = std::chrono::duration_cast<std::chrono::microseconds>(
+                            end_time - start_time);
+        outs() << "running time of RSY      : " << duration.count()
+               << " microseconds\n";
+        return resRSY;
+    }
+    IntervalESBase Bilateral_time(IntervalESBase& inv, const Z3Expr& phi,
+                                  RelationSolver& rs)
+    {
+        auto start_time = std::chrono::high_resolution_clock::now();
+        IntervalESBase resBilateral = rs.bilateral(inv, phi);
+        auto end_time = std::chrono::high_resolution_clock::now();
+        auto duration = std::chrono::duration_cast<std::chrono::microseconds>(
+                            end_time - start_time);
+        outs() << "running time of Bilateral: " << duration.count()
+               << " microseconds\n";
+        return resBilateral;
+    }
+    IntervalESBase BS_time(IntervalESBase& inv, const Z3Expr& phi,
+                           RelationSolver& rs)
+    {
+        auto start_time = std::chrono::high_resolution_clock::now();
+        IntervalESBase resBS = rs.BS(inv, phi);
+        auto end_time = std::chrono::high_resolution_clock::now();
+        auto duration = std::chrono::duration_cast<std::chrono::microseconds>(
+                            end_time - start_time);
+        outs() << "running time of BS       : " << duration.count()
+               << " microseconds\n";
+        return resBS;
+    }
+
+    void testRelExeState1_1()
+    {
+        SVFUtil::outs() << sucMsg("\t SUCCESS :") << "test1_1 start\n";
+        IntervalESBase itv;
+        RelExeState relation;
+        // var0 := [0, 1];
+        itv[0] = IntervalValue(0, 1);
+        relation[0] = getContext().int_const("0");
+        // var1 := var0 + 1;
+        relation[1] =
+            getContext().int_const("1") == getContext().int_const("0") + 1;
+        itv[1] = itv[0] + IntervalValue(1);
+        // Test extract sub vars
+        Set<u32_t> res;
+        relation.extractSubVars(relation[1], res);
+        assert(res == Set<u32_t>({0, 1}) && "inconsistency occurs");
+        IntervalESBase inv = itv.sliceState(res);
+        RelationSolver rs;
+        const Z3Expr& relExpr = relation[1];
+        const Z3Expr& initExpr = rs.gamma_hat(inv);
+        const Z3Expr& phi = (relExpr && initExpr).simplify();
+        IntervalESBase resRSY = rs.RSY(inv, phi);
+        IntervalESBase resBilateral = rs.bilateral(inv, phi);
+        IntervalESBase resBS = rs.BS(inv, phi);
+        // 0:[0,1] 1:[1,2]
+        assert(resRSY == resBS && resBS == resBilateral && "inconsistency occurs");
+        for (auto r : resRSY.getVarToVal())
+        {
+            outs() << r.first << " " << r.second << "\n";
+        }
+        IntervalESBase::VarToValMap intendedRes = {{0, IntervalValue(0, 1)}, {1, IntervalValue(1, 2)}};
+        assert(IntervalESBase::eqVarToValMap(resBS.getVarToVal(), intendedRes) && "inconsistency occurs");
+    }
+
+    void testRelExeState1_2()
+    {
+        SVFUtil::outs() << "test1_2 start\n";
+        IntervalESBase itv;
+        RelExeState relation;
+        // var0 := [0, 1];
+        relation[0] = getContext().int_const("0");
+        itv[0] = IntervalValue(0, 1);
+        // var1 := var0 + 1;
+        relation[1] =
+            getContext().int_const("1") == getContext().int_const("0") * 2;
+        itv[1] = itv[0] * IntervalValue(2);
+
+        // Test extract sub vars
+        Set<u32_t> res;
+        relation.extractSubVars(relation[1], res);
+        assert(res == Set<u32_t>({0, 1}) && "inconsistency occurs");
+        IntervalESBase inv = itv.sliceState(res);
+        RelationSolver rs;
+        const Z3Expr& relExpr = relation[1];
+        const Z3Expr& initExpr = rs.gamma_hat(inv);
+        const Z3Expr& phi = (relExpr && initExpr).simplify();
+        IntervalESBase resRSY = rs.RSY(inv, phi);
+        IntervalESBase resBilateral = rs.bilateral(inv, phi);
+        IntervalESBase resBS = rs.BS(inv, phi);
+        // 0:[0,1] 1:[0,2]
+        assert(resRSY == resBS && resBS == resBilateral && "inconsistency occurs");
+        for (auto r : resRSY.getVarToVal())
+        {
+            outs() << r.first << " " << r.second << "\n";
+        }
+        IntervalESBase::VarToValMap intendedRes = {{0, IntervalValue(0, 1)}, {1, IntervalValue(0, 2)}};
+        assert(IntervalESBase::eqVarToValMap(resBS.getVarToVal(), intendedRes) && "inconsistency occurs");
+    }
+
+    void testRelExeState2_1()
+    {
+        SVFUtil::outs() << "test2_1 start\n";
+        IntervalESBase itv;
+        RelExeState relation;
+        // var0 := [0, 10];
+        relation[0] = getContext().int_const("0");
+        itv[0] = IntervalValue(0, 10);
+        // var1 := var0;
+        relation[1] =
+            getContext().int_const("1") == getContext().int_const("0");
+        itv[1] = itv[0];
+        // var2 := var1 - var0;
+        relation[2] = getContext().int_const("2") ==
+                      getContext().int_const("1") - getContext().int_const("0");
+        itv[2] = itv[1] - itv[0];
+        // Test extract sub vars
+        Set<u32_t> res;
+        relation.extractSubVars(relation[2], res);
+        assert(res == Set<u32_t>({0, 1, 2}) && "inconsistency occurs");
+        IntervalESBase inv = itv.sliceState(res);
+        RelationSolver rs;
+        const Z3Expr& relExpr = relation[2] && relation[1];
+        const Z3Expr& initExpr = rs.gamma_hat(inv);
+        const Z3Expr& phi = (relExpr && initExpr).simplify();
+        IntervalESBase resRSY = rs.RSY(inv, phi);
+        IntervalESBase resBilateral = rs.bilateral(inv, phi);
+        IntervalESBase resBS = rs.BS(inv, phi);
+        // 0:[0,10] 1:[0,10] 2:[0,0]
+        assert(resRSY == resBS && resBS == resBilateral && "inconsistency occurs");
+        for (auto r : resRSY.getVarToVal())
+        {
+            outs() << r.first << " " << r.second << "\n";
+        }
+        // ground truth
+        IntervalESBase::VarToValMap intendedRes = {{0, IntervalValue(0, 10)},
+            {1, IntervalValue(0, 10)},
+            {2, IntervalValue(0, 0)}
+        };
+        assert(IntervalESBase::eqVarToValMap(resBS.getVarToVal(), intendedRes) && "inconsistency occurs");
+    }
+
+    void testRelExeState2_2()
+    {
+        SVFUtil::outs() << "test2_2 start\n";
+        IntervalESBase itv;
+        RelExeState relation;
+        // var0 := [0, 100];
+        relation[0] = getContext().int_const("0");
+        itv[0] = IntervalValue(0, 100);
+        // var1 := var0;
+        relation[1] =
+            getContext().int_const("1") == getContext().int_const("0");
+        itv[1] = itv[0];
+        // var2 := var1 - var0;
+        relation[2] = getContext().int_const("2") ==
+                      getContext().int_const("1") - getContext().int_const("0");
+        itv[2] = itv[1] - itv[0];
+
+        // Test extract sub vars
+        Set<u32_t> res;
+        relation.extractSubVars(relation[2], res);
+        assert(res == Set<u32_t>({0, 1, 2}) && "inconsistency occurs");
+        IntervalESBase inv = itv.sliceState(res);
+        RelationSolver rs;
+        const Z3Expr& relExpr = relation[2] && relation[1];
+        const Z3Expr& initExpr = rs.gamma_hat(inv);
+        const Z3Expr& phi = (relExpr && initExpr).simplify();
+        IntervalESBase resRSY = rs.RSY(inv, phi);
+        IntervalESBase resBilateral = rs.bilateral(inv, phi);
+        IntervalESBase resBS = rs.BS(inv, phi);
+        // 0:[0,100] 1:[0,100] 2:[0,0]
+        assert(resRSY == resBS && resBS == resBilateral && "inconsistency occurs");
+        for (auto r : resRSY.getVarToVal())
+        {
+            outs() << r.first << " " << r.second << "\n";
+        }
+        // ground truth
+        IntervalESBase::VarToValMap intendedRes = {{0, IntervalValue(0, 100)},
+            {1, IntervalValue(0, 100)},
+            {2, IntervalValue(0, 0)}
+        };
+        assert(IntervalESBase::eqVarToValMap(resBS.getVarToVal(), intendedRes) && "inconsistency occurs");
+    }
+
+    void testRelExeState2_3()
+    {
+        SVFUtil::outs() << "test2_3 start\n";
+        IntervalESBase itv;
+        RelExeState relation;
+        // var0 := [0, 1000];
+        relation[0] = getContext().int_const("0");
+        itv[0] = IntervalValue(0, 1000);
+        // var1 := var0;
+        relation[1] =
+            getContext().int_const("1") == getContext().int_const("0");
+        itv[1] = itv[0];
+        // var2 := var1 - var0;
+        relation[2] = getContext().int_const("2") ==
+                      getContext().int_const("1") - getContext().int_const("0");
+        itv[2] = itv[1] - itv[0];
+
+        // Test extract sub vars
+        Set<u32_t> res;
+        relation.extractSubVars(relation[2], res);
+        assert(res == Set<u32_t>({0, 1, 2}) && "inconsistency occurs");
+        IntervalESBase inv = itv.sliceState(res);
+        RelationSolver rs;
+        const Z3Expr& relExpr = relation[2] && relation[1];
+        const Z3Expr& initExpr = rs.gamma_hat(inv);
+        const Z3Expr& phi = (relExpr && initExpr).simplify();
+        IntervalESBase resRSY = rs.RSY(inv, phi);
+        IntervalESBase resBilateral = rs.bilateral(inv, phi);
+        IntervalESBase resBS = rs.BS(inv, phi);
+        // 0:[0,1000] 1:[0,1000] 2:[0,0]
+        assert(resRSY == resBS && resBS == resBilateral && "inconsistency occurs");
+        for (auto r : resRSY.getVarToVal())
+        {
+            outs() << r.first << " " << r.second << "\n";
+        }
+        // ground truth
+        // ground truth
+        IntervalESBase::VarToValMap intendedRes = {{0, IntervalValue(0, 1000)},
+            {1, IntervalValue(0, 1000)},
+            {2, IntervalValue(0, 0)}
+        };
+        assert(IntervalESBase::eqVarToValMap(resBS.getVarToVal(), intendedRes) && "inconsistency occurs");
+    }
+
+    void testRelExeState2_4()
+    {
+        SVFUtil::outs() << "test2_4 start\n";
+        IntervalESBase itv;
+        RelExeState relation;
+        // var0 := [0, 10000];
+        relation[0] = getContext().int_const("0");
+        itv[0] = IntervalValue(0, 10000);
+        // var1 := var0;
+        relation[1] =
+            getContext().int_const("1") == getContext().int_const("0");
+        itv[1] = itv[0];
+        // var2 := var1 - var0;
+        relation[2] = getContext().int_const("2") ==
+                      getContext().int_const("1") - getContext().int_const("0");
+        itv[2] = itv[1] - itv[0];
+
+        // Test extract sub vars
+        Set<u32_t> res;
+        relation.extractSubVars(relation[2], res);
+        assert(res == Set<u32_t>({0, 1, 2}) && "inconsistency occurs");
+        IntervalESBase inv = itv.sliceState(res);
+        RelationSolver rs;
+        const Z3Expr& relExpr = relation[2] && relation[1];
+        const Z3Expr& initExpr = rs.gamma_hat(inv);
+        const Z3Expr& phi = (relExpr && initExpr).simplify();
+        IntervalESBase resRSY = RSY_time(inv, phi, rs);
+        IntervalESBase resBilateral = Bilateral_time(inv, phi, rs);
+        IntervalESBase resBS = BS_time(inv, phi, rs);
+        // 0:[0,10000] 1:[0,10000] 2:[0,0]
+        assert(resRSY == resBS && resBS == resBilateral && "inconsistency occurs");
+        for (auto r : resRSY.getVarToVal())
+        {
+            outs() << r.first << " " << r.second << "\n";
+        }
+        // ground truth
+        // ground truth
+        IntervalESBase::VarToValMap intendedRes = {{0, IntervalValue(0, 10000)},
+            {1, IntervalValue(0, 10000)},
+            {2, IntervalValue(0, 0)}
+        };
+        assert(IntervalESBase::eqVarToValMap(resBS.getVarToVal(), intendedRes) && "inconsistency occurs");
+    }
+
+    void testRelExeState2_5()
+    {
+        SVFUtil::outs() << "test2_5 start\n";
+        IntervalESBase itv;
+        RelExeState relation;
+        // var0 := [0, 100000];
+        relation[0] = getContext().int_const("0");
+        itv[0] = IntervalValue(0, 100000);
+        // var1 := var0;
+        relation[1] =
+            getContext().int_const("1") == getContext().int_const("0");
+        itv[1] = itv[0];
+        // var2 := var1 - var0;
+        relation[2] = getContext().int_const("2") ==
+                      getContext().int_const("1") - getContext().int_const("0");
+        itv[2] = itv[1] - itv[0];
+
+        // Test extract sub vars
+        Set<u32_t> res;
+        relation.extractSubVars(relation[2], res);
+        assert(res == Set<u32_t>({0, 1, 2}) && "inconsistency occurs");
+        IntervalESBase inv = itv.sliceState(res);
+        RelationSolver rs;
+        const Z3Expr& relExpr = relation[2] && relation[1];
+        const Z3Expr& initExpr = rs.gamma_hat(inv);
+        const Z3Expr& phi = (relExpr && initExpr).simplify();
+        IntervalESBase resRSY = RSY_time(inv, phi, rs);
+        IntervalESBase resBilateral = Bilateral_time(inv, phi, rs);
+        IntervalESBase resBS = BS_time(inv, phi, rs);
+        // 0:[0,100000] 1:[0,100000] 2:[0,0]
+        assert(resRSY == resBS && resBS == resBilateral && "inconsistency occurs");
+        for (auto r : resRSY.getVarToVal())
+        {
+            outs() << r.first << " " << r.second << "\n";
+        }
+        // ground truth
+        // ground truth
+        IntervalESBase::VarToValMap intendedRes = {{0, IntervalValue(0, 100000)},
+            {1, IntervalValue(0, 100000)},
+            {2, IntervalValue(0, 0)}
+        };
+        assert(IntervalESBase::eqVarToValMap(resBS.getVarToVal(), intendedRes) && "inconsistency occurs");
+    }
+
+    void testRelExeState3_1()
+    {
+        SVFUtil::outs() << "test3_1 start\n";
+        IntervalESBase itv;
+        RelExeState relation;
+        // var0 := [1, 10];
+        relation[0] = getContext().int_const("0");
+        itv[0] = IntervalValue(1, 10);
+        // var1 := var0;
+        relation[1] =
+            getContext().int_const("1") == getContext().int_const("0");
+        itv[1] = itv[0];
+        // var2 := var1 / var0;
+        relation[2] = getContext().int_const("2") ==
+                      getContext().int_const("1") / getContext().int_const("0");
+        itv[2] = itv[1] / itv[0];
+        // Test extract sub vars
+        Set<u32_t> res;
+        relation.extractSubVars(relation[2], res);
+        assert(res == Set<u32_t>({0, 1, 2}) && "inconsistency occurs");
+        IntervalESBase inv = itv.sliceState(res);
+        RelationSolver rs;
+        const Z3Expr& relExpr = relation[2] && relation[1];
+        const Z3Expr& initExpr = rs.gamma_hat(inv);
+        const Z3Expr& phi = (relExpr && initExpr).simplify();
+        IntervalESBase resRSY = rs.RSY(inv, phi);
+        IntervalESBase resBilateral = rs.bilateral(inv, phi);
+        IntervalESBase resBS = rs.BS(inv, phi);
+        // 0:[1,10] 1:[1,10] 2:[1,1]
+        assert(resRSY == resBS && resBS == resBilateral && "inconsistency occurs");
+        for (auto r : resRSY.getVarToVal())
+        {
+            outs() << r.first << " " << r.second << "\n";
+        }
+        // ground truth
+        IntervalESBase::VarToValMap intendedRes = {{0, IntervalValue(1, 10)},
+            {1, IntervalValue(1, 10)},
+            {2, IntervalValue(1, 1)}
+        };
+        assert(IntervalESBase::eqVarToValMap(resBS.getVarToVal(), intendedRes) && "inconsistency occurs");
+    }
+
+    void testRelExeState3_2()
+    {
+        SVFUtil::outs() << "test3_2 start\n";
+        IntervalESBase itv;
+        RelExeState relation;
+        // var0 := [1, 1000];
+        relation[0] = getContext().int_const("0");
+        itv[0] = IntervalValue(1, 1000);
+        // var1 := var0;
+        relation[1] =
+            getContext().int_const("1") == getContext().int_const("0");
+        itv[1] = itv[0];
+        // var2 := var1 / var0;
+        relation[2] = getContext().int_const("2") ==
+                      getContext().int_const("1") / getContext().int_const("0");
+        itv[2] = itv[1] / itv[0];
+        // Test extract sub vars
+        Set<u32_t> res;
+        relation.extractSubVars(relation[2], res);
+        assert(res == Set<u32_t>({0, 1, 2}) && "inconsistency occurs");
+        IntervalESBase inv = itv.sliceState(res);
+        RelationSolver rs;
+        const Z3Expr& relExpr = relation[2] && relation[1];
+        const Z3Expr& initExpr = rs.gamma_hat(inv);
+        const Z3Expr& phi = (relExpr && initExpr).simplify();
+        IntervalESBase resRSY = rs.RSY(inv, phi);
+        IntervalESBase resBilateral = rs.bilateral(inv, phi);
+        IntervalESBase resBS = rs.BS(inv, phi);
+        // 0:[1,1000] 1:[1,1000] 2:[1,1]
+        assert(resRSY == resBS && resBS == resBilateral && "inconsistency occurs");
+        for (auto r : resRSY.getVarToVal())
+        {
+            outs() << r.first << " " << r.second << "\n";
+        }
+        // ground truth
+        IntervalESBase::VarToValMap intendedRes = {{0, IntervalValue(1, 1000)},
+            {1, IntervalValue(1, 1000)},
+            {2, IntervalValue(1, 1)}
+        };
+        assert(IntervalESBase::eqVarToValMap(resBS.getVarToVal(), intendedRes) && "inconsistency occurs");
+    }
+
+    void testRelExeState3_3()
+    {
+        SVFUtil::outs() << "test3_3 start\n";
+        IntervalESBase itv;
+        RelExeState relation;
+        // var0 := [1, 10000];
+        relation[0] = getContext().int_const("0");
+        itv[0] = IntervalValue(1, 10000);
+        // var1 := var0;
+        relation[1] =
+            getContext().int_const("1") == getContext().int_const("0");
+        itv[1] = itv[0];
+        // var2 := var1 / var0;
+        relation[2] = getContext().int_const("2") ==
+                      getContext().int_const("1") / getContext().int_const("0");
+        itv[2] = itv[1] / itv[0];
+        // Test extract sub vars
+        Set<u32_t> res;
+        relation.extractSubVars(relation[2], res);
+        assert(res == Set<u32_t>({0, 1, 2}) && "inconsistency occurs");
+        IntervalESBase inv = itv.sliceState(res);
+        RelationSolver rs;
+        const Z3Expr& relExpr = relation[2] && relation[1];
+        const Z3Expr& initExpr = rs.gamma_hat(inv);
+        const Z3Expr& phi = (relExpr && initExpr).simplify();
+        IntervalESBase resRSY = RSY_time(inv, phi, rs);
+        IntervalESBase resBilateral = Bilateral_time(inv, phi, rs);
+        IntervalESBase resBS = BS_time(inv, phi, rs);
+        // 0:[1,10000] 1:[1,10000] 2:[1,1]
+        assert(resRSY == resBS && resBS == resBilateral && "inconsistency occurs");
+        for (auto r : resRSY.getVarToVal())
+        {
+            outs() << r.first << " " << r.second << "\n";
+        }
+        // ground truth
+        IntervalESBase::VarToValMap intendedRes =
+        Map<u32_t, IntervalValue>({{0, IntervalValue(1, 10000)},
+            {1, IntervalValue(1, 10000)},
+            {2, IntervalValue(1, 1)}});
+    }
+
+    void testRelExeState3_4()
+    {
+        SVFUtil::outs() << "test3_4 start\n";
+        IntervalESBase itv;
+        RelExeState relation;
+        // var0 := [1, 100000];
+        relation[0] = getContext().int_const("0");
+        itv[0] = IntervalValue(1, 100000);
+        // var1 := var0;
+        relation[1] =
+            getContext().int_const("1") == getContext().int_const("0");
+        itv[1] = itv[0];
+        // var2 := var1 / var0;
+        relation[2] = getContext().int_const("2") ==
+                      getContext().int_const("1") / getContext().int_const("0");
+        itv[2] = itv[1] / itv[0];
+        // Test extract sub vars
+        Set<u32_t> res;
+        relation.extractSubVars(relation[2], res);
+        assert(res == Set<u32_t>({0, 1, 2}) && "inconsistency occurs");
+        IntervalESBase inv = itv.sliceState(res);
+        RelationSolver rs;
+        const Z3Expr& relExpr = relation[2] && relation[1];
+        const Z3Expr& initExpr = rs.gamma_hat(inv);
+        const Z3Expr& phi = (relExpr && initExpr).simplify();
+        IntervalESBase resRSY = RSY_time(inv, phi, rs);
+        IntervalESBase resBilateral = Bilateral_time(inv, phi, rs);
+        IntervalESBase resBS = BS_time(inv, phi, rs);
+        // 0:[1,100000] 1:[1,100000] 2:[1,1]
+        assert(resRSY == resBS && resBS == resBilateral && "inconsistency occurs");
+        for (auto r : resRSY.getVarToVal())
+        {
+            outs() << r.first << " " << r.second << "\n";
+        }
+        // ground truth
+        IntervalESBase::VarToValMap intendedRes = {{0, IntervalValue(1, 100000)},
+            {1, IntervalValue(1, 100000)},
+            {2, IntervalValue(1, 1)}
+        };
+        assert(IntervalESBase::eqVarToValMap(resBS.getVarToVal(), intendedRes) && "inconsistency occurs");
+    }
+
+    void testRelExeState4_1()
+    {
+        SVFUtil::outs() << "test4_1 start\n";
+        IntervalESBase itv;
+        RelExeState relation;
+        // var0 := [0, 10];
+        relation[0] = getContext().int_const("0");
+        itv[0] = IntervalValue(0, 10);
+        // var1 := var0;
+        relation[1] =
+            getContext().int_const("1") == getContext().int_const("0");
+        itv[1] = itv[0];
+        // var2 := var1 / var0;
+        relation[2] = getContext().int_const("2") ==
+                      getContext().int_const("1") / getContext().int_const("0");
+        itv[2] = itv[1] / itv[0];
+        // Test extract sub vars
+        Set<u32_t> res;
+        relation.extractSubVars(relation[2], res);
+        assert(res == Set<u32_t>({0, 1, 2}) && "inconsistency occurs");
+        IntervalESBase inv = itv.sliceState(res);
+        RelationSolver rs;
+        const Z3Expr& relExpr = relation[2] && relation[1];
+        const Z3Expr& initExpr = rs.gamma_hat(inv);
+        const Z3Expr& phi = (relExpr && initExpr).simplify();
+        // IntervalExeState resRSY = rs.RSY(inv, phi);
+        outs() << "rsy done\n";
+        // IntervalExeState resBilateral = rs.bilateral(inv, phi);
+        outs() << "bilateral done\n";
+        IntervalESBase resBS = rs.BS(inv, phi);
+        outs() << "bs done\n";
+        // 0:[0,10] 1:[0,10] 2:[-00,+00]
+        // assert(resRSY == resBS && resBS == resBilateral);
+        for (auto r : resBS.getVarToVal())
+        {
+            outs() << r.first << " " << r.second << "\n";
+        }
+        // ground truth
+        IntervalESBase::VarToValMap intendedRes = {{0, IntervalValue(0, 10)},
+            {1, IntervalValue(0, 10)},
+            {2, IntervalValue(IntervalValue::minus_infinity(), IntervalValue::plus_infinity())}
+        };
+        assert(IntervalESBase::eqVarToValMap(resBS.getVarToVal(), intendedRes) && "inconsistency occurs");
+    }
+
+    void testsValidation()
+    {
+        SymblicAbstractionTest saTest;
+        saTest.testRelExeState1_1();
+        saTest.testRelExeState1_2();
+
+        saTest.testRelExeState2_1();
+        saTest.testRelExeState2_2();
+        saTest.testRelExeState2_3();
+//        saTest.testRelExeState2_4(); /// 10000
+//        saTest.testRelExeState2_5(); /// 100000
+
+        saTest.testRelExeState3_1();
+        saTest.testRelExeState3_2();
+//        saTest.testRelExeState3_3(); /// 10000
+//        saTest.testRelExeState3_4(); /// 100000
+
+        outs() << "start top\n";
+        saTest.testRelExeState4_1(); /// top
+    }
+};
+
+int main(int argc, char** argv)
+{
+    std::vector<std::string> moduleNameVec;
+    moduleNameVec = OptionBase::parseOptions(
+                        argc, argv, "Source-Sink Bug Detector", "[options] <input-bitcode...>"
+                    );
+    if (SYMABS())
+    {
+        SymblicAbstractionTest saTest;
+        saTest.testsValidation();
+    }
+    return 0;
+}

package/svf-llvm/tools/CMakeLists.txt

@@ -5,15 +5,16 @@ add_subdirectory(DDA)
 add_subdirectory(MTA)
 add_subdirectory(CFL)
 add_subdirectory(LLVM2SVF)
+add_subdirectory(AE)
 
 set_target_properties(
-    cfl dvf svf-ex llvm2svf mta saber wpa
+    cfl dvf svf-ex llvm2svf mta saber wpa ae
     PROPERTIES
         RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
 )
 
 install(
-    TARGETS cfl dvf svf-ex llvm2svf mta saber wpa
+    TARGETS cfl dvf svf-ex llvm2svf mta saber wpa ae
     EXPORT SVFTargets
     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}