svf-lib 1.0.2535 → 1.0.2537

package/SVF-linux-x86_64/include/SVF-LLVM/BasicTypes.h

@@ -42,6 +42,8 @@
 #include <llvm/IR/DerivedTypes.h>
 #include <llvm/IR/Statepoint.h>
 #include <llvm/IR/Intrinsics.h>
+#include <llvm/IR/InlineAsm.h>
+#include <llvm/IR/Constants.h>
 
 #include <llvm/Analysis/MemoryLocation.h>
 #include <llvm/Analysis/DominanceFrontier.h>
@@ -127,6 +129,9 @@ typedef llvm::Constant Constant;
 typedef llvm::ConstantInt ConstantInt;
 typedef llvm::ConstantFP ConstantFP;
 typedef llvm::ConstantPointerNull ConstantPointerNull;
+typedef llvm::InlineAsm InlineAsm;
+typedef llvm::DSOLocalEquivalent DSOLocalEquivalent;
+typedef llvm::NoCFIValue NoCFIValue;
 typedef llvm::GlobalAlias GlobalAlias;
 typedef llvm::GlobalIFunc GlobalIFunc;
 typedef llvm::GlobalVariable GlobalVariable;

package/SVF-linux-x86_64/include/SVFIR/SVFIR.h

@@ -837,6 +837,18 @@ private:
     {
         return addDummyValNode(getBlkPtr(), nullptr);
     }
+    inline NodeID addIntrinsicValNode(NodeID i, const SVFType* type)
+    {
+        return addValNode(new IntrinsicValVar(i, type));
+    }
+    inline NodeID addBasicBlockValNode(NodeID i, const SVFType* type)
+    {
+        return addValNode(new BasicBlockValVar(i, type));
+    }
+    inline NodeID addAsmPCValNode(NodeID i, const SVFType* type)
+    {
+        return addValNode(new AsmPCValVar(i, type));
+    }
     //@}
 
     /// Add a value (pointer) node

package/SVF-linux-x86_64/include/SVFIR/SVFValue.h

@@ -80,6 +80,9 @@ public:
         ConstNullptrValNode,     // │   └── Represents a constant nullptr value node
         // │   └─ Subclass: DummyValVar
         DummyValNode,            // │   └── Dummy node for uninitialized values
+        IntrinsicValNode,        // │   └── LLVM intrinsic call instruction (e.g. llvm.dbg.declare)
+        BasicBlockValNode,       // │   └── LLVM BasicBlock (label operand of br/switch)
+        AsmPCValNode,            // │   └── InlineAsm, DSOLocalEquivalent, NoCFIValue
 
         // └─ Subclass: ObjVar (Object variable nodes)
         ObjNode,                 // ├── Represents an object variable
@@ -230,7 +233,7 @@ protected:
 
     static inline bool isSVFVarKind(GNodeK n)
     {
-        static_assert(DummyObjNode - ValNode == 26,
+        static_assert(DummyObjNode - ValNode == 29,
                       "The number of SVFVarKinds has changed, make sure the "
                       "range is correct");
 
@@ -239,10 +242,10 @@ protected:
 
     static inline bool isValVarKinds(GNodeK n)
     {
-        static_assert(DummyValNode - ValNode == 13,
+        static_assert(AsmPCValNode - ValNode == 16,
                       "The number of ValVarKinds has changed, make sure the "
                       "range is correct");
-        return n <= DummyValNode && n >= ValNode;
+        return n <= AsmPCValNode && n >= ValNode;
     }
 
 

package/SVF-linux-x86_64/include/SVFIR/SVFVariables.h

@@ -283,10 +283,7 @@ public:
     //@}
 
     /// Constructor
-    ValVar(NodeID i, const SVFType* svfType, const ICFGNode* node, PNODEK ty = ValNode)
-        : SVFVar(i, svfType, ty), icfgNode(node)
-    {
-    }
+    ValVar(NodeID i, const SVFType* svfType, const ICFGNode* node, PNODEK ty = ValNode);
     /// Return name of a LLVM value
     inline const std::string getValueName() const
     {
@@ -2111,6 +2108,8 @@ public:
     VarArgValPN(NodeID i, const FunObjVar* node, const SVFType* svfType, const ICFGNode* icn)
         : ValVar(i, svfType, icn, VarargValNode), callGraphNode(node)
     {
+        assert((node->isDeclaration() || icn) &&
+               "VarArgValPN of a defined function must have a valid ICFGNode");
     }
 
     virtual const FunObjVar* getFunction() const;
@@ -2176,6 +2175,133 @@ public:
     virtual const std::string toString() const;
 };
 
+/*
+ * Represents an LLVM intrinsic call instruction (e.g. llvm.dbg.declare).
+ * These are collected into valSyms but have no corresponding ICFGNode.
+ */
+class IntrinsicValVar: public ValVar
+{
+    friend class GraphDBClient;
+
+public:
+    //@{ Methods for support type inquiry through isa, cast, and dyn_cast:
+    static inline bool classof(const IntrinsicValVar*)
+    {
+        return true;
+    }
+    static inline bool classof(const SVFVar* node)
+    {
+        return node->getNodeKind() == SVFVar::IntrinsicValNode;
+    }
+    static inline bool classof(const ValVar* node)
+    {
+        return node->getNodeKind() == SVFVar::IntrinsicValNode;
+    }
+    static inline bool classof(const GenericPAGNodeTy* node)
+    {
+        return node->getNodeKind() == SVFVar::IntrinsicValNode;
+    }
+    static inline bool classof(const SVFValue* node)
+    {
+        return node->getNodeKind() == SVFVar::IntrinsicValNode;
+    }
+    //@}
+
+    IntrinsicValVar(NodeID i, const SVFType* svfType)
+        : ValVar(i, svfType, nullptr, IntrinsicValNode)
+    {
+    }
+
+    inline const std::string getValueName() const
+    {
+        return "intrinsicVal";
+    }
+
+    virtual const std::string toString() const;
+};
+
+/*
+ * Represents an LLVM BasicBlock (label operand of br/switch).
+ * Collected into valSyms as a branch operand but has no ICFGNode.
+ */
+class BasicBlockValVar: public ValVar
+{
+    friend class GraphDBClient;
+
+public:
+    static inline bool classof(const BasicBlockValVar*)
+    {
+        return true;
+    }
+    static inline bool classof(const SVFVar* node)
+    {
+        return node->getNodeKind() == SVFVar::BasicBlockValNode;
+    }
+    static inline bool classof(const ValVar* node)
+    {
+        return node->getNodeKind() == SVFVar::BasicBlockValNode;
+    }
+    static inline bool classof(const GenericPAGNodeTy* node)
+    {
+        return node->getNodeKind() == SVFVar::BasicBlockValNode;
+    }
+    static inline bool classof(const SVFValue* node)
+    {
+        return node->getNodeKind() == SVFVar::BasicBlockValNode;
+    }
+
+    BasicBlockValVar(NodeID i, const SVFType* svfType)
+        : ValVar(i, svfType, nullptr, BasicBlockValNode) {}
+
+    inline const std::string getValueName() const
+    {
+        return "basicBlockVal";
+    }
+    virtual const std::string toString() const;
+};
+
+/*
+ * Represents InlineAsm, DSOLocalEquivalent, and NoCFIValue.
+ * These are non-instruction values related to inline assembly,
+ * position-independent code (PIC), or control-flow integrity (CFI).
+ * They have no corresponding ICFGNode.
+ */
+class AsmPCValVar: public ValVar
+{
+    friend class GraphDBClient;
+
+public:
+    static inline bool classof(const AsmPCValVar*)
+    {
+        return true;
+    }
+    static inline bool classof(const SVFVar* node)
+    {
+        return node->getNodeKind() == SVFVar::AsmPCValNode;
+    }
+    static inline bool classof(const ValVar* node)
+    {
+        return node->getNodeKind() == SVFVar::AsmPCValNode;
+    }
+    static inline bool classof(const GenericPAGNodeTy* node)
+    {
+        return node->getNodeKind() == SVFVar::AsmPCValNode;
+    }
+    static inline bool classof(const SVFValue* node)
+    {
+        return node->getNodeKind() == SVFVar::AsmPCValNode;
+    }
+
+    AsmPCValVar(NodeID i, const SVFType* svfType)
+        : ValVar(i, svfType, nullptr, AsmPCValNode) {}
+
+    inline const std::string getValueName() const
+    {
+        return "asmPCVal";
+    }
+    virtual const std::string toString() const;
+};
+
 /*
  * Dummy object variable
  */

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

@@ -597,13 +597,11 @@ protected:
         /// do not set def here, this node is not a variable definition
     }
     /// Add a formal parameter VFG node
-    inline void addFormalParmVFGNode(const ValVar* fparm, const FunObjVar* fun, CallPESet& callPEs)
+    inline void addFormalParmVFGNode(const ValVar* fparm, const FunObjVar* fun, const CallPE* callPE)
     {
         FormalParmVFGNode* sNode = new FormalParmVFGNode(totalVFGNode++,fparm,fun);
         addVFGNode(sNode, pag->getICFG()->getFunEntryICFGNode(fun));
-        for(CallPESet::const_iterator it = callPEs.begin(), eit=callPEs.end();
-                it!=eit; ++it)
-            sNode->addCallPE(*it);
+        sNode->setCallPE(callPE);
 
         setDef(fparm,sNode);
         SVFVarToFormalParmMap[fparm] = sNode;

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

@@ -1028,12 +1028,12 @@ class FormalParmVFGNode : public ArgumentVFGNode
 {
 private:
     const FunObjVar* fun;
-    CallPESet callPEs;
+    const CallPE* callPE;
 
 public:
     /// Constructor
     FormalParmVFGNode(NodeID id, const ValVar* n, const FunObjVar* f):
-        ArgumentVFGNode(id, n, FParm),  fun(f)
+        ArgumentVFGNode(id, n, FParm),  fun(f), callPE(nullptr)
     {
     }
 
@@ -1048,20 +1048,15 @@ public:
     {
         return fun;
     }
-    /// Return call edge
-    inline void addCallPE(const CallPE* call)
+    /// Set the (single, phi-like) CallPE for this formal parameter
+    inline void setCallPE(const CallPE* call)
     {
-        callPEs.insert(call);
+        callPE = call;
     }
-    /// Call edge iterator
-    ///@{
-    inline CallPESet::const_iterator callPEBegin() const
-    {
-        return callPEs.begin();
-    }
-    inline CallPESet::const_iterator callPEEnd() const
+    /// Return the CallPE (phi-like, merges all actual params)
+    inline const CallPE* getCallPE() const
     {
-        return callPEs.end();
+        return callPE;
     }
     //@}
 

package/SVF-osx/include/SVFIR/SVFIR.h

@@ -57,6 +57,7 @@ public:
     typedef std::vector<const SVFStmt*> SVFStmtList;
     typedef std::vector<const ValVar*> ValVarList;
     typedef Map<const SVFVar*,PhiStmt*> PHINodeMap;
+    typedef Map<const SVFVar*,CallPE*> FParmToCallPEMap;
     typedef Map<const FunObjVar*,ValVarList> FunToArgsListMap;
     typedef Map<const CallICFGNode*,ValVarList> CSToArgsListMap;
     typedef Map<const RetICFGNode*,const ValVar*> CSToRetMap;
@@ -84,6 +85,7 @@ private:
     MemObjToFieldsMap memToFieldsMap;	///< Map a mem object id to all its fields
     SVFStmtSet globSVFStmtSet;	///< Global PAGEdges without control flow information
     PHINodeMap phiNodeMap;	///< A set of phi copy edges
+    FParmToCallPEMap fParmToCallPEMap; ///< Map a formal param to its CallPE
     FunToArgsListMap funArgsListMap;	///< Map a function to a list of all its formal parameters
     CSToArgsListMap callSiteArgsListMap;	///< Map a callsite to a list of all its actual parameters
     CSToRetMap callSiteRetMap;	///< Map a callsite to its callsite returns PAGNodes
@@ -353,6 +355,12 @@ public:
     {
         return phiNodeMap.find(node) != phiNodeMap.end();
     }
+    /// Get the CallPE for a formal parameter (phi-like, nullptr if not found)
+    inline CallPE* getCallPEForFormalParm(const SVFVar* param) const
+    {
+        auto it = fParmToCallPEMap.find(param);
+        return it != fParmToCallPEMap.end() ? it->second : nullptr;
+    }
 
     /// Function has arguments list
     inline bool hasFunArgsList(const FunObjVar* func) const
@@ -911,7 +919,7 @@ private:
     /// Add Store edge
     StoreStmt* addStoreStmt(NodeID src, NodeID dst, const ICFGNode* val);
     void addStoreStmt(StoreStmt* edge, SVFVar* src, SVFVar* dst);
-    /// Add Call edge
+    /// Add Call edge (phi-like: merges actual params from all call sites into formal param)
     CallPE* addCallPE(NodeID src, NodeID dst, const CallICFGNode* cs,
                       const FunEntryICFGNode* entry);
     void addCallPE(CallPE* edge, SVFVar* src, SVFVar* dst);

package/SVF-osx/include/SVFIR/SVFStatements.h

@@ -335,10 +335,8 @@ public:
                edge->getEdgeKind() == SVFStmt::Copy ||
                edge->getEdgeKind() == SVFStmt::Store ||
                edge->getEdgeKind() == SVFStmt::Load ||
-               edge->getEdgeKind() == SVFStmt::Call ||
                edge->getEdgeKind() == SVFStmt::Ret ||
                edge->getEdgeKind() == SVFStmt::Gep ||
-               edge->getEdgeKind() == SVFStmt::ThreadFork ||
                edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
     static inline bool classof(const GenericPAGEdgeTy* edge)
@@ -347,10 +345,8 @@ public:
                edge->getEdgeKind() == SVFStmt::Copy ||
                edge->getEdgeKind() == SVFStmt::Store ||
                edge->getEdgeKind() == SVFStmt::Load ||
-               edge->getEdgeKind() == SVFStmt::Call ||
                edge->getEdgeKind() == SVFStmt::Ret ||
                edge->getEdgeKind() == SVFStmt::Gep ||
-               edge->getEdgeKind() == SVFStmt::ThreadFork ||
                edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
     //@}
@@ -693,67 +689,6 @@ public:
 };
 
 
-/*!
- * Call
- */
-class CallPE: public AssignStmt
-{
-    friend class GraphDBClient;
-
-private:
-    CallPE(const CallPE&);         ///< place holder
-    void operator=(const CallPE&); ///< place holder
-
-    const CallICFGNode* call;      /// the callsite statement calling from
-    const FunEntryICFGNode* entry; /// the function exit statement calling to
-
-public:
-    /// Methods for support type inquiry through isa, cast, and dyn_cast:
-    //@{
-    static inline bool classof(const CallPE*)
-    {
-        return true;
-    }
-    static inline bool classof(const SVFStmt* edge)
-    {
-        return edge->getEdgeKind() == SVFStmt::Call ||
-               edge->getEdgeKind() == SVFStmt::ThreadFork;
-    }
-    static inline bool classof(const GenericPAGEdgeTy* edge)
-    {
-        return edge->getEdgeKind() == SVFStmt::Call ||
-               edge->getEdgeKind() == SVFStmt::ThreadFork;
-    }
-    //@}
-
-    /// constructor
-    CallPE(SVFVar* s, SVFVar* d, const CallICFGNode* i,
-           const FunEntryICFGNode* e, GEdgeKind k = SVFStmt::Call);
-
-    /// Get method for the call instruction
-    //@{
-    inline const CallICFGNode* getCallInst() const
-    {
-        return call;
-    }
-    inline const CallICFGNode* getCallSite() const
-    {
-        return call;
-    }
-    inline const FunEntryICFGNode* getFunEntryICFGNode() const
-    {
-        return entry;
-    }
-    //@}
-
-    const ValVar* getRHSVar() const;
-    const ValVar* getLHSVar() const;
-    const ValVar* getSrcNode() const;
-    const ValVar* getDstNode() const;
-
-    virtual const std::string toString() const override;
-};
-
 /*!
  * Return
  */
@@ -850,12 +785,14 @@ public:
     static inline bool classof(const SVFStmt* node)
     {
         return node->getEdgeKind() == Phi || node->getEdgeKind() == Select ||
-               node->getEdgeKind() == BinaryOp || node->getEdgeKind() == Cmp;
+               node->getEdgeKind() == BinaryOp || node->getEdgeKind() == Cmp ||
+               node->getEdgeKind() == Call || node->getEdgeKind() == ThreadFork;
     }
     static inline bool classof(const GenericPAGEdgeTy* node)
     {
         return node->getEdgeKind() == Phi || node->getEdgeKind() == Select ||
-               node->getEdgeKind() == BinaryOp || node->getEdgeKind() == Cmp;
+               node->getEdgeKind() == BinaryOp || node->getEdgeKind() == Cmp ||
+               node->getEdgeKind() == Call || node->getEdgeKind() == ThreadFork;
     }
     //@}
     /// Operands and result at a BinaryNode e.g., p = q + r, `p` is resVar and
@@ -891,6 +828,81 @@ public:
     //@}
 };
 
+/*!
+ * Call
+ * CallPE is a phi-like statement at function entry that merges actual parameters
+ * from all call sites into the formal parameter.
+ * e.g., formal_param = CallPE(actual1@callsite1, actual2@callsite2, ...)
+ */
+class CallPE: public MultiOpndStmt
+{
+    friend class GraphDBClient;
+
+public:
+    typedef std::vector<const CallICFGNode*> CallICFGNodeVec;
+
+private:
+    CallPE(const CallPE&);         ///< place holder
+    void operator=(const CallPE&); ///< place holder
+
+    CallICFGNodeVec opCallICFGNodes; /// each operand's call site
+    const FunEntryICFGNode* entry;   /// the function entry node
+
+public:
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const CallPE*)
+    {
+        return true;
+    }
+    static inline bool classof(const SVFStmt* edge)
+    {
+        return edge->getEdgeKind() == SVFStmt::Call ||
+               edge->getEdgeKind() == SVFStmt::ThreadFork;
+    }
+    static inline bool classof(const GenericPAGEdgeTy* edge)
+    {
+        return edge->getEdgeKind() == SVFStmt::Call ||
+               edge->getEdgeKind() == SVFStmt::ThreadFork;
+    }
+    //@}
+
+    /// constructor
+    CallPE(ValVar* res, const OPVars& opnds,
+           const CallICFGNodeVec& icfgNodes,
+           const FunEntryICFGNode* e,
+           GEdgeKind k = SVFStmt::Call);
+
+    /// Add an operand (actual param) from a call site
+    void addOpVar(ValVar* op, const CallICFGNode* call)
+    {
+        opVars.push_back(op);
+        opCallICFGNodes.push_back(call);
+        assert(opVars.size() == opCallICFGNodes.size() &&
+               "Numbers of operands and their CallICFGNodes are not consistent?");
+    }
+
+    /// Return the CallICFGNode of the i-th operand
+    inline const CallICFGNode* getOpCallICFGNode(u32_t op_idx) const
+    {
+        return opCallICFGNodes.at(op_idx);
+    }
+
+    /// Return all call site ICFGNodes
+    inline const CallICFGNodeVec& getOpCallICFGNodes() const
+    {
+        return opCallICFGNodes;
+    }
+
+    /// Return the function entry node
+    inline const FunEntryICFGNode* getFunEntryICFGNode() const
+    {
+        return entry;
+    }
+
+    virtual const std::string toString() const override;
+};
+
 /*!
  * Phi statement (e.g., p = phi(q,r) which receives values from variables q and r from different paths)
  * it is typically at a joint point of the control-flow graph
@@ -1340,17 +1352,13 @@ public:
     //@}
 
     /// constructor
-    TDForkPE(SVFVar* s, SVFVar* d, const CallICFGNode* i,
-             const FunEntryICFGNode* entry)
-        : CallPE(s, d, i, entry, SVFStmt::ThreadFork)
+    TDForkPE(ValVar* res, const OPVars& opnds,
+             const CallICFGNodeVec& icfgNodes,
+             const FunEntryICFGNode* e)
+        : CallPE(res, opnds, icfgNodes, e, SVFStmt::ThreadFork)
     {
     }
 
-    const ValVar* getRHSVar() const;
-    const ValVar* getLHSVar() const;
-    const ValVar* getSrcNode() const;
-    const ValVar* getDstNode() const;
-
     virtual const std::string toString() const;
 
 };

package/SVF-osx/lib/cmake/SVF/SVFTargets.cmake

@@ -7,7 +7,7 @@ if(CMAKE_VERSION VERSION_LESS "3.0.0")
    message(FATAL_ERROR "CMake >= 3.0.0 required")
 endif()
 cmake_policy(PUSH)
-cmake_policy(VERSION 3.0.0...4.0)
+cmake_policy(VERSION 3.0.0...4.1)
 #----------------------------------------------------------------
 # Generated CMake target import file.
 #----------------------------------------------------------------
@@ -65,7 +65,7 @@ set_target_properties(SVF::SvfFlags PROPERTIES
   INTERFACE_LINK_DIRECTORIES "${_IMPORT_PREFIX}/lib"
   INTERFACE_LINK_LIBRARIES "z3::libz3"
   INTERFACE_LINK_OPTIONS "\$<\$<NOT:\$<BOOL:ON>>:-fno-rtti>"
-  INTERFACE_SYSTEM_INCLUDE_DIRECTORIES "include;include"
+  INTERFACE_SYSTEM_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include;${_IMPORT_PREFIX}/include"
 )
 
 # Create imported target SVF::SvfCore

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-lib",
-  "version": "1.0.2535",
+  "version": "1.0.2537",
   "description": "SVF's npm support",
   "main": "index.js",
   "scripts": {