svf-lib 1.0.2584 → 1.0.2586

package/SVF-linux-aarch64/include/AE/Svfexe/AbsExtAPI.h

@@ -48,12 +48,19 @@ public:
      */
     enum ExtAPIType { UNCLASSIFIED, MEMCPY, MEMSET, STRCPY, STRCAT };
 
+    // Only AbstractInterpretation may construct the single owned AbsExtAPI
+    // instance (reachable through its private getUtils()). Keeping the
+    // constructor private prevents external callers from creating their own
+    // AbsExtAPI and invoking handleExtAPI()/handleMemcpy()/... directly.
+    friend class AbstractInterpretation;
+private:
     /**
      * @brief Constructor for AbsExtAPI.
      * @param ae Reference to the AbstractInterpretation instance.
      */
     AbsExtAPI(AbstractInterpretation* ae);
 
+public:
     /**
      * @brief Initializes the external function map.
      */

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,13 +176,13 @@ public:
 
     bool hasIntersect(const AddressValue &other) const
     {
-        for (const auto& addr : _addrs)
-            if (other._addrs.count(addr))
-                return true;
-        return false;
-    }
+for (const auto& addr : _addrs)
+        if (other._addrs.count(addr))
+            return true;
+            return false;
+        }
 
-    inline bool isBottom() const
+inline bool isBottom() const
     {
         return empty();
     }

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

@@ -162,8 +162,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();
             }
@@ -174,8 +174,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();
@@ -183,15 +183,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();
             }
@@ -202,8 +202,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();
@@ -211,7 +211,7 @@ public:
         // If neither BoundedInt is infinite.
         else
             return _iVal >= rhs._iVal;
-    }
+        }
 
     /// Reload operator
     //{%
@@ -666,14 +666,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
@@ -685,20 +685,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;
     }
@@ -816,8 +816,8 @@ public:
     bool leq(const BoundedDouble& rhs) const
     {
         if (is_infinity() ^ rhs.is_infinity())
-        {
-            if (is_infinity())
+    {
+        if (is_infinity())
             {
                 return is_minus_infinity();
             }
@@ -827,21 +827,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();
             }
@@ -851,15 +851,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
     //{%
@@ -1259,16 +1259,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

@@ -162,9 +162,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

@@ -187,12 +187,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
+/// Whether has the CDGNode
+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

@@ -273,9 +273,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();
+/// Create edges between VFG nodes within a function
+void connectDirectVFGEdges();
 
     /// Create edges between VFG nodes across functions
     void addVFGInterEdges(const CallICFGNode* cs, const FunObjVar* callee);

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

@@ -713,7 +713,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

@@ -270,30 +270,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;
     }