svf-lib 1.0.1820 → 1.0.1822

package/SVF-linux/svf/include/SVFIR/SVFType.h

@@ -243,6 +243,7 @@ class SVFType
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
+    friend class LLVMModuleSet;
 
 public:
     typedef s64_t GNodeK;
@@ -258,6 +259,25 @@ public:
         SVFOtherTy,
     };
 
+public:
+
+    inline static SVFType* getPtrTy()
+    {
+        assert(ptrTy && "ptr type not set?");
+        return ptrTy;
+    }
+
+    inline static SVFType* getI8Ty()
+    {
+        assert(i8Ty && "int8 type not set?");
+        return i8Ty;
+    }
+
+private:
+
+    static SVFType* ptrTy; ///< ptr type
+    static SVFType* i8Ty; ///< 8-bit int type
+
 private:
     GNodeK kind; ///< used for classof
     const SVFPointerType*
@@ -268,7 +288,7 @@ private:
     ///< array
 
 protected:
-    SVFType(bool svt, SVFTyKind k, u32_t Sz)
+    SVFType(bool svt, SVFTyKind k, u32_t Sz = 1)
         : kind(k), getPointerToTy(nullptr), typeinfo(nullptr),
           isSingleValTy(svt), byteSize(Sz)
     {
@@ -357,7 +377,7 @@ private:
     const SVFType* ptrElementType;
 
 public:
-    SVFPointerType(u32_t byteSize)
+    SVFPointerType(u32_t byteSize = 1)
         : SVFType(true, SVFPointerTy, byteSize), ptrElementType(nullptr)
     {
     }
@@ -389,7 +409,7 @@ private:
     short signAndWidth; ///< For printing
 
 public:
-    SVFIntegerType(u32_t byteSize) : SVFType(true, SVFIntegerTy, byteSize) {}
+    SVFIntegerType(u32_t byteSize = 1) : SVFType(true, SVFIntegerTy, byteSize) {}
     static inline bool classof(const SVFType* node)
     {
         return node->getKind() == SVFIntegerTy;
@@ -418,7 +438,7 @@ private:
 
 public:
     SVFFunctionType(const SVFType* rt)
-        : SVFType(false, SVFFunctionTy, 0), retTy(rt)
+        : SVFType(false, SVFFunctionTy, 1), retTy(rt)
     {
     }
     static inline bool classof(const SVFType* node)
@@ -443,7 +463,7 @@ private:
     std::string name;
 
 public:
-    SVFStructType(u32_t byteSize) : SVFType(false, SVFStructTy, byteSize) {}
+    SVFStructType(u32_t byteSize = 1) : SVFType(false, SVFStructTy, byteSize) {}
 
     static inline bool classof(const SVFType* node)
     {
@@ -476,7 +496,7 @@ private:
     const SVFType* typeOfElement; /// For printing & debugging
 
 public:
-    SVFArrayType(u32_t byteSize)
+    SVFArrayType(u32_t byteSize = 1)
         : SVFType(false, SVFArrayTy, byteSize), numOfElement(0), typeOfElement(nullptr)
     {
     }
@@ -515,7 +535,7 @@ private:
     std::string repr; /// Field representation for printing
 
 public:
-    SVFOtherType(u32_t byteSize, bool isSingleValueTy) : SVFType(isSingleValueTy, SVFOtherTy, byteSize) {}
+    SVFOtherType(bool isSingleValueTy, u32_t byteSize = 1) : SVFType(isSingleValueTy, SVFOtherTy, byteSize) {}
 
     static inline bool classof(const SVFType* node)
     {

package/SVF-osx/svf/include/AbstractExecution/BoundedZ3Expr.h

@@ -63,6 +63,7 @@ public:
 
     BoundedZ3Expr(BoundedZ3Expr &&z3Expr) : Z3Expr(z3Expr) {}
 
+
     inline BoundedZ3Expr &operator=(BoundedZ3Expr &&rhs)
     {
         Z3Expr::operator=(rhs);
@@ -387,3 +388,4 @@ struct std::hash<SVF::BoundedZ3Expr>
     }
 };
 #endif //SVF_BOUNDEDZ3EXPR_H
+

package/SVF-osx/svf/include/AbstractExecution/CFBasicBlockGWTO.h

@@ -0,0 +1,83 @@
+//===- CFBasicBlockGWTO.h -- WTO for CFBasicBlockGraph----------------------//
+//
+//                     SVF: Static Value-Flow Analysis
+//
+// Copyright (C) <2013->  <Yulei Sui>
+//
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * CFBasicBlockGWTO.h
+ *
+ * The implementation is based on F. Bourdoncle's paper:
+ * "Efficient chaotic iteration strategies with widenings", Formal
+ * Methods in Programming and Their Applications, 1993, pages 128-141.
+ *
+ *  Created on: Jan 22, 2024
+ *      Author: Xiao Cheng
+ *
+ */
+#ifndef SVF_CFBASICBLOCKGWTO_H
+#define SVF_CFBASICBLOCKGWTO_H
+#include "Graphs/CFBasicBlockG.h"
+#include "Graphs/WTO.h"
+
+namespace SVF
+{
+typedef WTOComponent<CFBasicBlockGraph> CFBasicBlockGWTOComp;
+typedef WTONode<CFBasicBlockGraph> CFBasicBlockGWTONode;
+typedef WTOCycle<CFBasicBlockGraph> CFBasicBlockGWTOCycle;
+
+class CFBasicBlockGWTO : public WTO<CFBasicBlockGraph>
+{
+public:
+    typedef WTO<CFBasicBlockGraph> Base;
+    typedef WTOComponentVisitor<CFBasicBlockGraph>::WTONodeT
+    CFBasicBlockGWTONode;
+
+    explicit CFBasicBlockGWTO(CFBasicBlockGraph* graph,
+                              const CFBasicBlockNode* node)
+        : Base(graph, node)
+    {
+    }
+
+    inline void forEachSuccessor(
+        const CFBasicBlockNode* node,
+        std::function<void(const CFBasicBlockNode*)> func) const override
+    {
+        if (const auto* callNode =
+                    SVFUtil::dyn_cast<CallICFGNode>(node->getICFGNodes().front()))
+        {
+            const CFBasicBlockNode* succ = _graph->getCFBasicBlockNode(
+                                               callNode->getRetICFGNode()->getId());
+            func(succ);
+        }
+        else
+        {
+            for (const auto& e : node->getOutEdges())
+            {
+                if (e->getICFGEdge() &&
+                        (!e->getICFGEdge()->isIntraCFGEdge() ||
+                         node->getFunction() != e->getDstNode()->getFunction()))
+                    continue;
+                func(e->getDstNode());
+            }
+        }
+    }
+};
+} // namespace SVF
+#endif // SVF_CFBASICBLOCKGWTO_H

package/SVF-osx/svf/include/AbstractExecution/ConsExeState.h

@@ -57,6 +57,7 @@ public:
 public:
     ConsExeState(): ExeState(ExeState::SingleValueK) {}
 
+
     /// Constructor
     ConsExeState(VarToValMap varToValMap, LocToValMap locToValMap) : ExeState(ExeState::SingleValueK), _varToVal(
             SVFUtil::move(varToValMap)), _locToVal(SVFUtil::move(locToValMap))  {}
@@ -360,6 +361,8 @@ public:
 
 public:
 
+
+
     s64_t getNumber(u32_t lhs);
 
     static inline SingleAbsValue getIntOneZ3Expr()
@@ -406,11 +409,14 @@ public:
     /// Whether two var to value map is equivalent
     static bool eqVarToValMap(const VarToValMap &pre, const VarToValMap &nxt);
 
+
     /// Whether lhs is less than rhs
     static bool lessThanVarToValMap(const VarToValMap &lhs, const VarToValMap &rhs);
 
+
 private:
 
+
     static bool assign(SingleAbsValue &lhs, const SingleAbsValue &rhs);
 
     inline bool store(u32_t objId, const SingleAbsValue &z3Expr)
@@ -440,4 +446,6 @@ struct std::hash<SVF::ConsExeState>
     }
 };
 
+
+
 #endif // SVF_CONSEXESTATE_H

package/SVF-osx/svf/include/AbstractExecution/ExeState.h

@@ -27,6 +27,7 @@
  *
  */
 
+
 #ifndef Z3_EXAMPLE_EXESTATE_H
 #define Z3_EXAMPLE_EXESTATE_H
 
@@ -89,6 +90,7 @@ public:
         return *this;
     }
 
+
 protected:
     VarToAddrs _varToAddrs{{0, getVirtualMemAddress(0)}}; ///< Map a variable (symbol) to its memory addresses
     VarToAddrs _locToAddrs;                               ///< Map a memory address to its stored memory addresses
@@ -113,6 +115,7 @@ public:
         return _locToAddrs.find(id) != _locToAddrs.end();
     }
 
+
     inline virtual const VarToAddrs &getVarToAddrs() const
     {
         return _varToAddrs;
@@ -145,6 +148,8 @@ public:
         return _kind;
     }
 
+
+
 public:
     inline virtual void storeAddrs(u32_t addr, const Addrs &vaddrs)
     {
@@ -280,8 +285,11 @@ public:
         return AddressValue::getInternalID(idx);
     }
 
+
 }; // end class ExeState
 
+
+
 } // end namespace SVF
 
 template<>

package/SVF-osx/svf/include/AbstractExecution/ICFGWTO.h

@@ -0,0 +1,78 @@
+//===--------------- ICFGWTO.h -- WTO for ICFG----------------------//
+//
+//                     SVF: Static Value-Flow Analysis
+//
+// Copyright (C) <2013->  <Yulei Sui>
+//
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * ICFGWTO.h
+ *
+ * The implementation is based on F. Bourdoncle's paper:
+ * "Efficient chaotic iteration strategies with widenings", Formal
+ * Methods in Programming and Their Applications, 1993, pages 128-141.
+ *
+ *  Created on: Jan 22, 2024
+ *      Author: Xiao Cheng
+ *
+ */
+#ifndef SVF_ICFGWTO_H
+#define SVF_ICFGWTO_H
+
+#include "Graphs/ICFG.h"
+#include "Graphs/WTO.h"
+
+namespace SVF
+{
+
+typedef WTOComponent<ICFG> ICFGWTOComp;
+typedef WTONode<ICFG> ICFGWTONode;
+typedef WTOCycle<ICFG> ICFGWTOCycle;
+
+class ICFGWTO : public WTO<ICFG>
+{
+public:
+    typedef WTO<ICFG> Base;
+    typedef WTOComponentVisitor<ICFG>::WTONodeT ICFGWTONode;
+
+    explicit ICFGWTO(ICFG* graph, const ICFGNode* node) : Base(graph, node) {}
+
+    inline void forEachSuccessor(
+        const ICFGNode* node,
+        std::function<void(const ICFGNode*)> func) const override
+    {
+        if (const auto* callNode = SVFUtil::dyn_cast<CallICFGNode>(node))
+        {
+            const ICFGNode* succ = callNode->getRetICFGNode();
+            func(succ);
+        }
+        else
+        {
+            for (const auto& e : node->getOutEdges())
+            {
+                if (!e->isIntraCFGEdge() ||
+                        node->getFun() != e->getDstNode()->getFun())
+                    continue;
+                func(e->getDstNode());
+            }
+        }
+    }
+};
+} // namespace SVF
+
+#endif // SVF_ICFGWTO_H

package/SVF-osx/svf/include/AbstractExecution/IntervalExeState.h

@@ -77,6 +77,7 @@ public:
 
     virtual ~IntervalESBase() = default;
 
+
     IntervalESBase &operator=(const IntervalESBase &rhs)
     {
         if (rhs != *this)
@@ -216,6 +217,7 @@ public:
     /// domain meet with other, important! other widen this.
     void meetWith(const IntervalESBase &other);
 
+
     /// Return int value from an expression if it is a numeral, otherwise return an approximate value
     inline s32_t Interval2NumValue(const IntervalValue &e) const
     {
@@ -335,6 +337,7 @@ public:
         return true;
     }
 
+
     static bool lessThanVarToValMap(const VarToValMap &lhs, const VarToValMap &rhs)
     {
         if (lhs.empty()) return !rhs.empty();
@@ -380,6 +383,7 @@ public:
         return !(*this >= rhs);
     }
 
+
     bool operator>=(const IntervalESBase &rhs) const
     {
         return geqVarToValMap(_varToItvVal, rhs.getVarToVal()) && geqVarToValMap(_locToItvVal, rhs.getLocToVal());
@@ -393,6 +397,7 @@ public:
         _varToAddrs.clear();
     }
 
+
 protected:
     void printTable(const VarToValMap &table, std::ostream &oss) const;
 
@@ -421,6 +426,7 @@ public:
 
     virtual ~IntervalExeState() = default;
 
+
     IntervalExeState &operator=(const IntervalExeState &rhs)
     {
         IntervalESBase::operator=(rhs);
@@ -622,6 +628,7 @@ public:
         return !(*this >= rhs);
     }
 
+
     bool operator>=(const IntervalExeState &rhs) const
     {
         return geqVarToValMap(_varToItvVal, rhs.getVarToVal()) && geqVarToValMap(_locToItvVal, rhs._locToItvVal);

package/SVF-osx/svf/include/AbstractExecution/IntervalValue.h

@@ -27,6 +27,7 @@
  *
  */
 
+
 #ifndef Z3_EXAMPLE_IntervalValue_H
 #define Z3_EXAMPLE_IntervalValue_H
 
@@ -320,6 +321,7 @@ public:
         }
     }
 
+
     /// Equality comparison
     bool equals(const IntervalValue &other) const
     {
@@ -677,6 +679,7 @@ inline IntervalValue operator<(const IntervalValue &lhs, const IntervalValue &rh
     }
 }
 
+
 // Compare two IntervalValues for greater than or equal to
 inline IntervalValue operator>=(const IntervalValue &lhs, const IntervalValue &rhs)
 {

package/SVF-osx/svf/include/AbstractExecution/NumericLiteral.h

@@ -174,6 +174,7 @@ public:
             return _n.geq(rhs._n).simplify().is_true();
     }
 
+
     /// Reload operator
     //{%
     friend NumericLiteral operator==(const NumericLiteral &lhs, const NumericLiteral &rhs)
@@ -433,6 +434,7 @@ public:
 
     //%}
 
+
 }; // end class NumericLiteral
 } // end namespace SVF
 

package/SVF-osx/svf/include/AbstractExecution/RelExeState.h

@@ -91,6 +91,7 @@ public:
     /// Overloading Operator==
     bool operator<(const RelExeState &rhs) const;
 
+
     static z3::context &getContext()
     {
         return Z3Expr::getContext();

package/SVF-osx/svf/include/AbstractExecution/RelationSolver.h

@@ -56,6 +56,7 @@ public:
 
     IntervalESBase beta(const Map<u32_t, double> &sigma, const IntervalESBase &exeState) const;
 
+
     /// Return Z3 expression lazily based on SVFVar ID
     virtual inline Z3Expr toZ3Expr(u32_t varId) const
     {

package/SVF-osx/svf/include/AbstractExecution/SVFIR2ConsExeState.h

@@ -97,6 +97,7 @@ public:
     /// Init ConZ3Expr for ObjVar
     void initObjVar(const ObjVar *objVar, u32_t varId);
 
+
     void initSVFVar(u32_t varId);
 
     void moveToGlobal();

package/SVF-osx/svf/include/AbstractExecution/SVFIR2ItvExeState.h

@@ -86,6 +86,7 @@ public:
     /// Return the offset expression of a GepStmt
     IntervalValue getItvOfFlattenedElemIndex(const GepStmt *gep);
 
+
     static z3::context &getContext()
     {
         return Z3Expr::getContext();
@@ -93,6 +94,7 @@ public:
 
     void applySummary(IntervalExeState &es);
 
+
     /// Init ObjVar
     void initObjVar(const ObjVar *objVar, u32_t varId);
 
@@ -107,6 +109,7 @@ public:
             return globalNulladdrs;
     }
 
+
     /// whether the variable is in varToVal table
     inline bool inVarToValTable(u32_t id) const
     {
@@ -119,6 +122,7 @@ public:
         return _es.inVarToAddrsTable(id);
     }
 
+
     /// whether the memory address stores a interval value
     inline bool inLocToValTable(u32_t id) const
     {

package/SVF-osx/svf/include/AbstractExecution/SingleAbsValue.h

@@ -135,6 +135,7 @@ public:
         return (getExpr() >= rhs.getExpr()).simplify().is_true();
     }
 
+
     /// Reload operator
     //{%
     friend SingleAbsValue operator==(const SingleAbsValue &lhs, const SingleAbsValue &rhs)
@@ -472,4 +473,5 @@ struct std::hash<SVF::SingleAbsValue>
     }
 };
 
+
 #endif //SVF_SINGLEABSVALUE_H

package/SVF-osx/svf/include/AbstractExecution/SymState.h

@@ -83,6 +83,7 @@ public:
         return *this;
     }
 
+
     /// Move Constructor
     SymState(SymState &&rhs) noexcept: _exeState(SVFUtil::move(rhs._exeState)),
         _typeState(SVFUtil::move(rhs._typeState)),
@@ -110,6 +111,7 @@ public:
         return _keyNodesSet;
     }
 
+
     void insertKeyNode(NodeID id)
     {
         if (_keyNodesSet.empty())
@@ -201,6 +203,8 @@ public:
 
 } // end namespace SVF
 
+
+
 /// Specialise hash for SymState
 template<>
 struct std::hash<SVF::SymState>

package/SVF-osx/svf/include/CFL/CFGrammar.h

@@ -127,6 +127,7 @@ public:
         }
     };
 
+
     struct SymbolVectorHash
     {
         size_t operator()(const std::vector<Symbol> &v) const
@@ -155,6 +156,7 @@ public:
              typedef std::vector<Symbol> Production;
              typedef SymbolSet<Production> Productions;
 
+
              inline Map<std::string, Kind>& getNonterminals()
     {
         return this->nonterminals;
@@ -362,6 +364,7 @@ public:
         return it->second;
     }
 
+
     const Symbol& getLHSSymbol(const Production& prod) const
     {
         return prod.at(0);
@@ -381,6 +384,7 @@ public:
 
     void dump(std::string fileName) const;
 
+
     const inline u32_t num_generator()
     {
         return newTerminalSubscript++;

package/SVF-osx/svf/include/CFL/CFLAlias.h

@@ -54,6 +54,7 @@ public:
     /// Initialize Solver
     virtual void initializeSolver();
 
+
     /// Print grammar and graph
     virtual void finalize();
 

package/SVF-osx/svf/include/CFL/CFLGraphBuilder.h

@@ -160,6 +160,7 @@ private:
     void addBiGepCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFGrammar::Attribute attri);
 };
 
+
 }// SVF
 
 #endif /* INCLUDE_CFL_CFLGRAPHBUILDER_H_*/

package/SVF-osx/svf/include/CFL/CFLStat.h

@@ -20,6 +20,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+
 /*
  * CFLStat.h
  *

package/SVF-osx/svf/include/CFL/CFLVF.h

@@ -30,6 +30,7 @@
 #ifndef INCLUDE_CFL_CFLVF_H_
 #define INCLUDE_CFL_CFLVF_H_
 
+
 #include "CFL/CFLBase.h"
 #include "CFL/CFLStat.h"
 #include "CFL/CFLSVFGBuilder.h"

package/SVF-osx/svf/include/DDA/ContextDDA.h

@@ -118,6 +118,7 @@ public:
     /// get callsite id from return, return 0 if it is a spurious return edge
     CallSiteID getCSIDAtRet(CxtLocDPItem& dpm, const SVFGEdge* edge);
 
+
     /// Pop recursive callsites
     inline virtual void popRecursiveCallSites(CxtLocDPItem& dpm)
     {

package/SVF-osx/svf/include/DDA/DDAClient.h

@@ -20,6 +20,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+
 /*
  * @file: DDAClient.h
  * @author: yesen
@@ -29,6 +30,7 @@
  *
  */
 
+
 #ifndef DDACLIENT_H_
 #define DDACLIENT_H_
 
@@ -116,6 +118,7 @@ private:
     bool solveAll;				///< TRUE if all top level pointers are being queried
 };
 
+
 /**
  * DDA client with function pointers as query candidates.
  */
@@ -133,6 +136,8 @@ public:
     virtual void performStat(PointerAnalysis* pta);
 };
 
+
+
 /**
  * DDA client with function pointers as query candidates.
  */

package/SVF-osx/svf/include/DDA/DDAPass.h

@@ -28,12 +28,13 @@
  *
  */
 
+
 #ifndef DDAPASS_H_
 #define DDAPASS_H_
 
-#include "MemoryModel/PointerAnalysisImpl.h"
 #include "DDA/DDAClient.h"
-#include "Util/SCC.h"
+#include "Graphs/SCC.h"
+#include "MemoryModel/PointerAnalysisImpl.h"
 
 namespace SVF
 {