svf-tools 1.0.932 → 1.0.934

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.932",
+  "version": "1.0.934",
   "description": "* <b>[TypeClone](https://github.com/SVF-tools/SVF/wiki/TypeClone) published in our [ECOOP paper](https://yuleisui.github.io/publications/ecoop20.pdf) is now available in SVF </b> * <b>SVF now uses a single script for its build. Just type [`source ./build.sh`](https://github.com/SVF-tools/SVF/blob/master/build.sh) in your terminal, that's it!</b> * <b>SVF now supports LLVM-10.0.0! </b> * <b>We thank [bsauce](https://github.com/bsauce) for writing a user manual of SVF ([link1](https://www.jianshu.com/p/068a08ec749c) and [link2](https://www.jianshu.com/p/777c30d4240e)) in Chinese </b> * <b>SVF now supports LLVM-9.0.0 (Thank [Byoungyoung Lee](https://github.com/SVF-tools/SVF/issues/142) for his help!). </b> * <b>SVF now supports a set of [field-sensitive pointer analyses](https://yuleisui.github.io/publications/sas2019a.pdf). </b> * <b>[Use SVF as an external lib](https://github.com/SVF-tools/SVF/wiki/Using-SVF-as-a-lib-in-your-own-tool) for your own project (Contributed by [Hongxu Chen](https://github.com/HongxuChen)). </b> * <b>SVF now supports LLVM-7.0.0. </b> * <b>SVF now supports Docker. [Try SVF in Docker](https://github.com/SVF-tools/SVF/wiki/Try-SVF-in-Docker)! </b> * <b>SVF now supports [LLVM-6.0.0](https://github.com/svf-tools/SVF/pull/38) (Contributed by [Jack Anthony](https://github.com/jackanth)). </b> * <b>SVF now supports [LLVM-4.0.0](https://github.com/svf-tools/SVF/pull/23) (Contributed by Jared Carlson. Thank [Jared](https://github.com/jcarlson23) and [Will](https://github.com/dtzWill) for their in-depth [discussions](https://github.com/svf-tools/SVF/pull/18) about updating SVF!) </b> * <b>SVF now supports analysis for C++ programs.</b> <br />",
   "main": "index.js",
   "scripts": {

package/svf/include/AE/Core/AbstractValue.h

@@ -26,8 +26,11 @@
 namespace SVF
 {
 
-struct AbstractValue
+class AbstractValue
 {
+
+public:
+
     enum DataType
     {
         IntervalType,
@@ -122,6 +125,21 @@ struct AbstractValue
         }
         return *this;
     }
+
+    AbstractValue& operator=(const IntervalValue& other)
+    {
+        type = IntervalType;
+        interval = other;
+        return *this;
+    }
+
+    AbstractValue& operator=(const AddressValue& other)
+    {
+        type = AddressType;
+        addr = other;
+        return *this;
+    }
+
     AbstractValue operator==(const AbstractValue& other) const
     {
         assert(isInterval() && other.isInterval());

package/svf/include/AE/Svfexe/AbstractInterpretation.h

@@ -364,10 +364,10 @@ private:
 
 protected:
     // helper functions in handleCycle
-    bool widenFixpointPass(const ICFGNode* cycle_head,
-                           AbstractState& pre_es);
-    bool narrowFixpointPass(const ICFGNode* cycle_head,
-                            AbstractState& pre_es);
+    bool isFixPointAfterWidening(const ICFGNode* cycle_head,
+                                 AbstractState& pre_as);
+    bool isFixPointAfterNarrowing(const SVF::ICFGNode* cycle_head,
+                                  SVF::AbstractState& pre_as);
 
     AbstractState& getAbsState(const ICFGNode* node)
     {

package/svf/include/AE/Svfexe/SVFIR2AbsState.h

@@ -84,7 +84,7 @@ public:
     AbstractValue getByteOffset(const AbstractState& es, const GepStmt *gep);
 
     /// Return the offset expression of a GepStmt
-    AbstractValue getItvOfFlattenedElemIndex(const AbstractState& es, const GepStmt *gep);
+    AbstractValue getElementIndex(const AbstractState& es, const GepStmt *gep);
 
 
     static z3::context &getContext()

package/svf/lib/AE/Svfexe/AbstractInterpretation.cpp

@@ -720,7 +720,8 @@ void AbstractInterpretation::handleCycle(const ICFGWTOCycle *cycle)
             {
                 if (incresing)
                 {
-                    bool is_fixpoint = widenFixpointPass(cycle_head, pre_es);
+                    bool is_fixpoint =
+                        isFixPointAfterWidening(cycle_head, pre_es);
                     if (is_fixpoint)
                     {
                         incresing = false;
@@ -729,7 +730,8 @@ void AbstractInterpretation::handleCycle(const ICFGWTOCycle *cycle)
                 }
                 else if (!incresing)
                 {
-                    bool is_fixpoint = narrowFixpointPass(cycle_head, pre_es);
+                    bool is_fixpoint =
+                        isFixPointAfterNarrowing(cycle_head, pre_es);
                     if (is_fixpoint)
                         break;
                 }
@@ -754,46 +756,47 @@ void AbstractInterpretation::handleCycle(const ICFGWTOCycle *cycle)
     }
 }
 
-bool AbstractInterpretation::widenFixpointPass(const ICFGNode* cycle_head,
-        AbstractState& pre_es)
+bool AbstractInterpretation::isFixPointAfterWidening(const ICFGNode* cycle_head,
+        AbstractState& pre_as)
 {
     // increasing iterations
-    AbstractState new_pre_es = pre_es.widening(_postAbsTrace[cycle_head]);
-    AbstractState new_pre_vaddr_es = new_pre_es;
+    AbstractState new_pre_as = pre_as.widening(_postAbsTrace[cycle_head]);
+    AbstractState new_pre_vaddr_as = new_pre_as;
     //_svfir2AbsState->widenAddrs(getCurState(), new_pre_es, _postAbsTrace[cycle_head]);
 
-    if (pre_es >= new_pre_es)
+    if (pre_as >= new_pre_as)
     {
         // increasing iterations - fixpoint reached
-        pre_es = new_pre_es;
-        _postAbsTrace[cycle_head] = pre_es;
+        pre_as = new_pre_as;
+        _postAbsTrace[cycle_head] = pre_as;
         return true;
     }
     else
     {
-        pre_es = new_pre_es;
-        _postAbsTrace[cycle_head] = pre_es;
+        pre_as = new_pre_as;
+        _postAbsTrace[cycle_head] = pre_as;
         return false;
     }
 }
 
-bool AbstractInterpretation::narrowFixpointPass(const SVF::ICFGNode *cycle_head, SVF::AbstractState&pre_es)
+bool AbstractInterpretation::isFixPointAfterNarrowing(
+    const SVF::ICFGNode* cycle_head, SVF::AbstractState& pre_as)
 {
     // decreasing iterations
-    AbstractState new_pre_es = pre_es.narrowing(_postAbsTrace[cycle_head]);
-    AbstractState new_pre_vaddr_es = new_pre_es;
+    AbstractState new_pre_as = pre_as.narrowing(_postAbsTrace[cycle_head]);
+    AbstractState new_pre_vaddr_as = new_pre_as;
     //_svfir2AbsState->narrowAddrs(getCurState(), new_pre_es, _postAbsTrace[cycle_head]);
-    if (new_pre_es >= pre_es)
+    if (new_pre_as >= pre_as)
     {
         // decreasing iterations - fixpoint reached
-        pre_es = new_pre_es;
-        _postAbsTrace[cycle_head] = pre_es;
+        pre_as = new_pre_as;
+        _postAbsTrace[cycle_head] = pre_as;
         return true;
     }
     else
     {
-        pre_es = new_pre_es;
-        _postAbsTrace[cycle_head] = pre_es;
+        pre_as = new_pre_as;
+        _postAbsTrace[cycle_head] = pre_as;
         return false;
     }
 }

package/svf/lib/AE/Svfexe/SVFIR2AbsState.cpp

@@ -463,14 +463,14 @@ AbstractValue SVFIR2AbsState::getByteOffset(const AbstractState& es, const GepSt
 }
 
 /**
- * This function, getItvOfFlattenedElemIndex, calculates the offset range as a pair
+ * This function, getElementIndex, calculates the offset range as a pair
  * of APOffset values for a given GepStmt.
  *
  * @param gep   The GepStmt representing the GetElementPtr instruction.
  *
  * @return      A pair of APOffset values representing the offset range.
  */
-AbstractValue SVFIR2AbsState::getItvOfFlattenedElemIndex(const AbstractState& es, const GepStmt *gep)
+AbstractValue SVFIR2AbsState::getElementIndex(const AbstractState& es, const GepStmt *gep)
 {
     if (gep->isConstantOffset())
         return IntervalValue((s64_t)gep->accumulateConstantOffset());
@@ -1010,7 +1010,7 @@ void SVFIR2AbsState::handleGep(AbstractState& es, const GepStmt *gep)
     if (!inVarToAddrsTable(es, rhs)) return;
     AbstractValue &rhsVal = es[rhs];
     assert(!rhsVal.getAddrs().empty());
-    AbstractValue offsetPair = getItvOfFlattenedElemIndex(es, gep);
+    AbstractValue offsetPair = getElementIndex(es, gep);
     if (!isVirtualMemAddress(*rhsVal.getAddrs().begin()))
         return;
     else