svf-lib 1.0.2694 → 1.0.2696

package/SVF-linux-x86_64/include/MemoryModel/AbstractPointsToDS.h

@@ -101,6 +101,12 @@ public:
         return ptdTy;
     }
 
+    /// Whether we maintain reverse points-to sets.
+    inline bool hasReversePts() const
+    {
+        return rev;
+    }
+
     /// Clears all points-to sets as if nothing is stored.
     virtual void clear() = 0;
 

package/SVF-linux-x86_64/include/MemoryModel/PointerAnalysis.h

@@ -189,6 +189,10 @@ public:
     /// Interface exposed to users of our pointer analysis, given PAGNodeID
     virtual AliasResult alias(NodeID node1, NodeID node2) = 0;
 
+    /// Collect the nodes that may alias the given node.
+    /// Subclasses must implement this query; the default reports unsupported and aborts.
+    virtual NodeBS getMayAliases(NodeID node);
+
     /// Get points-to targets of a pointer. It needs to be implemented in child class
     virtual const PointsTo& getPts(NodeID ptr) = 0;
 

package/SVF-linux-x86_64/include/MemoryModel/PointerAnalysisImpl.h

@@ -225,6 +225,10 @@ public:
     /// Interface expose to users of our pointer analysis, given two pts
     virtual AliasResult alias(const PointsTo& pts1, const PointsTo& pts2);
 
+    /// Declaring the PointsTo overload below would otherwise hide the base class's
+    /// mayAlias(NodeID, NodeID) and mayAlias(const SVFVar*, const SVFVar*).
+    using PointerAnalysis::mayAlias;
+
     /// Convenience bool wrappers: return true if the two operands may/must/partial alias
     inline bool mayAlias(const PointsTo& pts1, const PointsTo& pts2)
     {

package/SVF-linux-x86_64/include/WPA/Andersen.h

@@ -252,6 +252,9 @@ public:
         return getPTDataTy()->unionPts(id,ptd);
     }
 
+    /// Collect exactly the SVFIR nodes q for which mayAlias(node, q) holds
+    virtual NodeBS getMayAliases(NodeID node);
+
 
     void dumpTopLevelPtsTo();
 
@@ -354,6 +357,13 @@ protected:
     /// SCC detection
     virtual NodeStack& SCCDetect();
 
+    /// Collect may-alias candidates. Attempts to do so from reverse points-to sets (cheaper),
+    /// and if not possible, falls back to trying every node (costlier).
+    NodeBS getMayAliasCandidates(NodeID node);
+
+    /// Also check getMayAliases on the pointers that the alias tests use
+    virtual void validateSuccessTests(std::string fun);
+
 
 
     /// Sanitize pts for field insensitive objects

package/SVF-osx/include/AE/Core/AbstractState.h

@@ -327,7 +327,7 @@ public:
     bool operator==(const AbstractState&rhs) const
     {
         return  eqVarToValMap(_varToAbsVal, rhs.getVarToVal()) &&
-        eqVarToValMap(_addrToAbsVal, rhs.getLocToVal());
+                eqVarToValMap(_addrToAbsVal, rhs.getLocToVal());
     }
 
     bool operator!=(const AbstractState&rhs) const

package/SVF-osx/include/AE/Core/AddressValue.h

@@ -176,9 +176,9 @@ public:
 
     bool hasIntersect(const AddressValue &other) const
     {
-for (const auto& addr : _addrs)
-    {
-        if (other._addrs.count(addr))
+        for (const auto& addr : _addrs)
+        {
+            if (other._addrs.count(addr))
                 return true;
         }
         return false;

package/SVF-osx/include/AE/Core/IntervalValue.h

@@ -150,12 +150,12 @@ public:
     IntervalValue operator==(const IntervalValue &other) const
     {
         if (this->isBottom() || other.isBottom())
-    {
-        return bottom();
+        {
+            return bottom();
         }
         else if (this->isTop() || other.isTop())
-    {
-        return top();
+        {
+            return top();
         }
         else
         {
@@ -184,12 +184,12 @@ public:
     IntervalValue operator!=(const IntervalValue &other) const
     {
         if (this->isBottom() || other.isBottom())
-    {
-        return bottom();
+        {
+            return bottom();
         }
         else if (this->isTop() || other.isTop())
-    {
-        return top();
+        {
+            return top();
         }
         else
         {
@@ -300,16 +300,16 @@ public:
     bool containedWithin(const IntervalValue &other) const
     {
         if (this->isBottom())
-    {
-        return true;
-    }
-    else if (other.isBottom())
-    {
-        return false;
-    }
-    else
-    {
-        return other._lb.leq(this->_lb) && this->_ub.leq(other._ub);
+        {
+            return true;
+        }
+        else if (other.isBottom())
+        {
+            return false;
+        }
+        else
+        {
+            return other._lb.leq(this->_lb) && this->_ub.leq(other._ub);
         }
 
     }
@@ -321,16 +321,16 @@ public:
     bool contain(const IntervalValue &other) const
     {
         if (this->isBottom())
-    {
-        return true;
-    }
-    else if (other.isBottom())
-    {
-        return false;
-    }
-    else
-    {
-        return other._lb.geq(this->_lb) && this->_ub.geq(other._ub);
+        {
+            return true;
+        }
+        else if (other.isBottom())
+        {
+            return false;
+        }
+        else
+        {
+            return other._lb.geq(this->_lb) && this->_ub.geq(other._ub);
         }
     }
 
@@ -339,16 +339,16 @@ public:
     bool leq(const IntervalValue &other) const
     {
         if (this->isBottom())
-    {
-        return true;
-    }
-    else if (other.isBottom())
-    {
-        return false;
-    }
-    else
-    {
-        return this->_ub.leq(other._lb);
+        {
+            return true;
+        }
+        else if (other.isBottom())
+        {
+            return false;
+        }
+        else
+        {
+            return this->_ub.leq(other._lb);
         }
     }
 
@@ -357,16 +357,16 @@ public:
     bool geq(const IntervalValue &other) const
     {
         if (this->isBottom())
-    {
-        return true;
-    }
-    else if (other.isBottom())
-    {
-        return false;
-    }
-    else
-    {
-        return this->_lb.geq(other._ub);
+        {
+            return true;
+        }
+        else if (other.isBottom())
+        {
+            return false;
+        }
+        else
+        {
+            return this->_lb.geq(other._ub);
         }
     }
 
@@ -375,16 +375,16 @@ public:
     bool equals(const IntervalValue &other) const
     {
         if (this->isBottom())
-    {
-        return other.isBottom();
+        {
+            return other.isBottom();
         }
         else if (other.isBottom())
-    {
-        return false;
-    }
-    else
-    {
-        if (this->is_real() && other.is_real())
+        {
+            return false;
+        }
+        else
+        {
+            if (this->is_real() && other.is_real())
             {
                 return this->_lb.equal(other._lb) && this->_ub.equal(other._ub);
             }
@@ -500,16 +500,16 @@ public:
     void dump(std::ostream &o) const
     {
         if (this->isBottom())
-    {
-        o << "⊥";
-    }
-    else
-    {
-        o << "[" << this->_lb << ", " << this->_ub << "]";
+        {
+            o << "⊥";
+        }
+        else
+        {
+            o << "[" << this->_lb << ", " << this->_ub << "]";
+        }
     }
-}
 
-const std::string toString() const
+    const std::string toString() const
     {
         std::string str;
         std::stringstream rawStr(str);

package/SVF-osx/include/AE/Core/NumericValue.h

@@ -163,8 +163,8 @@ public:
     {
         // If only one of the two BoundedInts is infinite.
         if (is_infinity() ^ rhs.is_infinity())
-    {
-        if (is_infinity())
+        {
+            if (is_infinity())
             {
                 return is_minus_infinity();
             }
@@ -175,8 +175,8 @@ public:
         }
         // If both BoundedInts are infinite.
         if (is_infinity() && rhs.is_infinity())
-    {
-        if (is_minus_infinity())
+        {
+            if (is_minus_infinity())
                 return true;
             else
                 return rhs.is_plus_infinity();
@@ -184,15 +184,15 @@ public:
         // If neither BoundedInt is infinite.
         else
             return _iVal <= rhs._iVal;
-        }
+    }
 
     // Checks if the BoundedInt is greater than or equal to another BoundedInt.
     bool geq(const BoundedInt& rhs) const
     {
         // If only one of the two BoundedInts is infinite.
         if (is_infinity() ^ rhs.is_infinity())
-    {
-        if (is_infinity())
+        {
+            if (is_infinity())
             {
                 return is_plus_infinity();
             }
@@ -203,8 +203,8 @@ public:
         }
         // If both BoundedInts are infinite.
         if (is_infinity() && rhs.is_infinity())
-    {
-        if (is_plus_infinity())
+        {
+            if (is_plus_infinity())
                 return true;
             else
                 return rhs.is_minus_infinity();
@@ -212,7 +212,7 @@ public:
         // If neither BoundedInt is infinite.
         else
             return _iVal >= rhs._iVal;
-        }
+    }
 
     /// Reload operator
     //{%
@@ -667,14 +667,14 @@ public:
         // If the object represents negative infinity, return the minimum
         // representable 64-bit integer.
         if (is_minus_infinity())
-    {
-        return std::numeric_limits<s64_t>::min();
+        {
+            return std::numeric_limits<s64_t>::min();
         }
         // If the object represents positive infinity, return the maximum
         // representable 64-bit integer.
         else if (is_plus_infinity())
-    {
-        return std::numeric_limits<s64_t>::max();
+        {
+            return std::numeric_limits<s64_t>::max();
         }
         // Otherwise, return the actual 64-bit integer value of the object.
         else
@@ -686,20 +686,20 @@ public:
     inline virtual const std::string to_string() const
     {
         if (is_minus_infinity())
-    {
-        return "-oo";
-    }
-    if (is_plus_infinity())
-    {
-        return "+oo";
-    }
-    else
-        return std::to_string(_iVal);
+        {
+            return "-oo";
+        }
+        if (is_plus_infinity())
+        {
+            return "+oo";
+        }
+        else
+            return std::to_string(_iVal);
     }
 
 //%}
 
-bool is_real() const
+    bool is_real() const
     {
         return false;
     }
@@ -817,8 +817,8 @@ public:
     bool leq(const BoundedDouble& rhs) const
     {
         if (is_infinity() ^ rhs.is_infinity())
-    {
-        if (is_infinity())
+        {
+            if (is_infinity())
             {
                 return is_minus_infinity();
             }
@@ -828,21 +828,21 @@ public:
             }
         }
         if (is_infinity() && rhs.is_infinity())
-    {
-        if (is_minus_infinity())
+        {
+            if (is_minus_infinity())
                 return true;
             else
                 return rhs.is_plus_infinity();
         }
         else
             return _fVal <= rhs._fVal;
-        }
+    }
 
     bool geq(const BoundedDouble& rhs) const
     {
         if (is_infinity() ^ rhs.is_infinity())
-    {
-        if (is_infinity())
+        {
+            if (is_infinity())
             {
                 return is_plus_infinity();
             }
@@ -852,15 +852,15 @@ public:
             }
         }
         if (is_infinity() && rhs.is_infinity())
-    {
-        if (is_plus_infinity())
+        {
+            if (is_plus_infinity())
                 return true;
             else
                 return rhs.is_minus_infinity();
         }
         else
             return _fVal >= rhs._fVal;
-        }
+    }
 
     /// Reload operator
     //{%
@@ -1260,16 +1260,16 @@ public:
     inline s64_t getNumeral() const
     {
         if (is_minus_infinity())
-    {
-        return INT64_MIN;
-    }
-    else if (is_plus_infinity())
-    {
-        return INT64_MAX;
-    }
-    else
-    {
-        return std::round(_fVal);
+        {
+            return INT64_MIN;
+        }
+        else if (is_plus_infinity())
+        {
+            return INT64_MAX;
+        }
+        else
+        {
+            return std::round(_fVal);
         }
     }
 

package/SVF-osx/include/AE/Svfexe/AEDetector.h

@@ -217,12 +217,12 @@ public:
     IntervalValue getGepObjOffsetFromBase(const GepObjVar* obj) const
     {
         if (hasGepObjOffsetFromBase(obj))
-        return gepObjOffsetFromBase.at(obj);
+            return gepObjOffsetFromBase.at(obj);
         else
         {
             assert(false && "GepObjVar not found in gepObjOffsetFromBase");
-                abort();
-            }
+            abort();
+        }
     }
 
     /**
@@ -274,8 +274,8 @@ public:
     void reportBug() override
     {
         if (!nodeToBugInfo.empty())
-    {
-        std::cerr << "######################Buffer Overflow (" + std::to_string(nodeToBugInfo.size())
+        {
+            std::cerr << "######################Buffer Overflow (" + std::to_string(nodeToBugInfo.size())
                       + " found)######################\n";
             std::cerr << "---------------------------------------------\n";
             for (const auto& it : nodeToBugInfo)
@@ -405,8 +405,8 @@ public:
     void reportBug() override
     {
         if (!nodeToBugInfo.empty())
-    {
-        std::cerr << "###################### Nullptr Dereference (" + std::to_string(nodeToBugInfo.size())
+        {
+            std::cerr << "###################### Nullptr Dereference (" + std::to_string(nodeToBugInfo.size())
                       + " found)######################\n";
             std::cerr << "---------------------------------------------\n";
             for (const auto& it : nodeToBugInfo)

package/SVF-osx/include/DDA/FlowDDA.h

@@ -163,9 +163,9 @@ public:
     {
         if (isTopLevelPtrStmt(dpm.getLoc())) return unionPts(dpm.getCurNodeID(), targetPts);
         else return dpmToADCPtSetMap[dpm] |= targetPts;
-        }
+    }
 
-virtual const std::string PTAName() const override
+    virtual const std::string PTAName() const override
     {
         return "FlowSensitive DDA";
     }

package/SVF-osx/include/Graphs/CDG.h

@@ -193,12 +193,12 @@ public:
     inline CDGNode *getCDGNode(NodeID id) const
     {
         if (!hasCDGNode(id))
-        return nullptr;
+            return nullptr;
         return getGNode(id);
     }
 
 /// Whether has the CDGNode
-inline bool hasCDGNode(NodeID id) const
+    inline bool hasCDGNode(NodeID id) const
     {
         return hasGNode(id);
     }

package/SVF-osx/include/Graphs/CHG.h

@@ -278,9 +278,9 @@ public:
             virtualFunctionToIDMap.find(vfn);
         if (it != virtualFunctionToIDMap.end())
             return it->second;
-            else
-                return -1;
-            }
+        else
+            return -1;
+    }
     inline const FunObjVar* getVirtualFunctionBasedonID(u32_t id) const
     {
         Map<const FunObjVar*, u32_t>::const_iterator it, eit;

package/SVF-osx/include/Graphs/IRGraph.h

@@ -272,9 +272,9 @@ public:
 
     inline const SVFType* getSVFType(u32_t id) const
     {
-for(const SVFType* type : svfTypes)
-    {
-        if(type->getId() == id)
+        for(const SVFType* type : svfTypes)
+        {
+            if(type->getId() == id)
                 return type;
         }
         return nullptr;

package/SVF-osx/include/Graphs/VFG.h

@@ -327,8 +327,8 @@ public:
     inline bool hasBlackHoleConstObjAddrAsDef(const ValVar* valVar) const
     {
         if (hasDef(valVar))
-    {
-        const VFGNode* defNode = getVFGNode(getDef(valVar));
+        {
+            const VFGNode* defNode = getVFGNode(getDef(valVar));
             if (const AddrVFGNode* addr = SVFUtil::dyn_cast<AddrVFGNode>(defNode))
             {
                 if (SVFIR::getPAG()->isBlkObjOrConstantObj(addr->getSVFStmt()->getSrcID()))
@@ -506,13 +506,13 @@ protected:
     virtual inline bool isInterestedSVFVar(const SVFVar* node) const
     {
         if (isPtrOnlySVFG())
-        return node->isPointer();
+            return node->isPointer();
         else
             return true;
-        }
+    }
 
 /// Create edges between VFG nodes within a function
-void connectDirectVFGEdges();
+    void connectDirectVFGEdges();
 
     /// Create edges between VFG nodes across functions
     void addVFGInterEdges(const CallICFGNode* cs, const FunObjVar* callee);

package/SVF-osx/include/Graphs/WTO.h

@@ -712,7 +712,7 @@ protected:
         void visit(const WTONodeT& node) override
         {
             _nodeToWTOCycleDepth.insert(
-            std::make_pair(node.getICFGNode(), _wtoCycleDepth));
+                std::make_pair(node.getICFGNode(), _wtoCycleDepth));
         }
 
     }; // end class WTOCycleDepthBuilder

package/SVF-osx/include/MTA/LockAnalysis.h

@@ -321,30 +321,30 @@ public:
     inline bool hasOneCxtInLockSpan(const ICFGNode *I, LockSpan lspan) const
     {
         if(!hasCxtStmtFromInst(I))
-        return false;
+            return false;
         const LockSpan ctsset = getCxtStmtsFromInst(I);
         for (LockSpan::const_iterator cts = ctsset.begin(), ects = ctsset.end(); cts != ects; cts++)
         {
             if(lspan.find(*cts) != lspan.end())
-                {
-                    return true;
-                }
+            {
+                return true;
             }
+        }
         return false;
     }
 
     inline bool hasAllCxtInLockSpan(const ICFGNode *I, LockSpan lspan) const
     {
         if(!hasCxtStmtFromInst(I))
-        return false;
+            return false;
         const LockSpan ctsset = getCxtStmtsFromInst(I);
         for (LockSpan::const_iterator cts = ctsset.begin(), ects = ctsset.end(); cts != ects; cts++)
         {
             if (lspan.find(*cts) == lspan.end())
-                {
-                    return false;
-                }
+            {
+                return false;
             }
+        }
         return true;
     }