svf-lib 1.0.2451 → 1.0.2453

package/SVF-linux-x86_64/include/Graphs/BasicBlockG.h

@@ -74,6 +74,7 @@ class SVFBasicBlock : public GenericBasicBlockNodeTy
     friend class FunObjVar;
     friend class ICFGBuilder;
     friend class ICFG;
+    friend class GraphDBClient;
 
 public:
     typedef std::vector<const ICFGNode*>::const_iterator const_iterator;
@@ -98,6 +99,17 @@ protected:
 
     /// @}
 
+    // Getters of predecessor and successor basic blocks, used for writing bb to DB
+    const std::vector<const SVFBasicBlock*> getSuccBBs() const
+    {
+        return succBBs;
+    }
+
+    const std::vector<const SVFBasicBlock*> getPredBBs() const
+    {
+        return predBBs;
+    }
+
 public:
     /// Constructor without name
     SVFBasicBlock(NodeID id, const FunObjVar* f): GenericBasicBlockNodeTy(id, BasicBlockKd), fun(f)
@@ -289,24 +301,26 @@ public:
 typedef GenericGraph<SVFBasicBlock, BasicBlockEdge> GenericBasicBlockGraphTy;
 class BasicBlockGraph: public GenericBasicBlockGraphTy
 {
-private:
-    NodeID id{0};
 public:
+    NodeID id{0};
     /// Constructor
-    BasicBlockGraph()
+    BasicBlockGraph(): GenericBasicBlockGraphTy()
     {
 
     }
 
+
     SVFBasicBlock* addBasicBlock(const std::string& bbname)
     {
         id++;
         SVFBasicBlock* bb = new SVFBasicBlock(id, nullptr);
-        addGNode(id, bb);
         bb->setName(bbname);
+        addBasicBlock(bb);
         return bb;
     }
 
+    void addBasicBlock(SVFBasicBlock* bb);
+
 };
 }
 

package/SVF-linux-x86_64/include/Graphs/CHG.h

@@ -105,6 +105,7 @@ private:
 typedef GenericNode<CHNode, CHEdge> GenericCHNodeTy;
 class CHNode: public GenericCHNodeTy
 {
+    friend class GraphDBClient;
 
 public:
     typedef enum
@@ -222,6 +223,16 @@ private:
      * virtualFunctionVectors = {{Af1, Af2, ...}, {Bg1, Bg2, ...}}
      */
     std::vector<FuncVector> virtualFunctionVectors;
+
+protected:
+    inline size_t getFlags() const
+    {
+        return flags;
+    }
+    inline void setFlags(size_t f)
+    {
+        flags = f;
+    }
 };
 
 /// class hierarchy graph
@@ -229,6 +240,7 @@ typedef GenericGraph<CHNode, CHEdge> GenericCHGraphTy;
 class CHGraph: public CommonCHGraph, public GenericCHGraphTy
 {
     friend class CHGBuilder;
+    friend class GraphDBClient;
 
 public:
     typedef Set<const CHNode*> CHNodeSetTy;

package/SVF-linux-x86_64/include/Graphs/CallGraph.h

@@ -224,6 +224,7 @@ public:
     {
         return node->getNodeKind() == CallNodeKd;
     }
+
     //@}
 };
 
@@ -233,6 +234,8 @@ public:
 typedef GenericGraph<CallGraphNode, CallGraphEdge> GenericPTACallGraphTy;
 class CallGraph : public GenericPTACallGraphTy
 {
+    friend class GraphDBClient;
+
 
 public:
     typedef CallGraphEdge::CallGraphEdgeSet CallGraphEdgeSet;
@@ -281,13 +284,14 @@ protected:
         if(it == csToIdMap.end())
         {
             CallSiteID id = totalCallSiteNum++;
-            csToIdMap.insert(std::make_pair(newCS, id));
-            idToCSMap.insert(std::make_pair(id, newCS));
+            addCallSite(cs,callee,id, newCS);
             return id;
         }
         return it->second;
     }
 
+    CallSiteID addCallSite(const CallICFGNode* cs, const FunObjVar* callee, const CallSiteID csid, std::pair<const CallICFGNode*, const FunObjVar*> newCS);
+
     /// Add call graph edge
     inline void addEdge(CallGraphEdge* edge)
     {
@@ -295,6 +299,14 @@ protected:
         edge->getSrcNode()->addOutgoingEdge(edge);
     }
 
+    /// add direct call graph edge from database [only used this function when loading cgEdges from db results]
+    void addDirectCallGraphEdge(CallGraphEdge* cgEdge);
+
+    /// add call graph node from database [only used this function when loading cgNodes from db results]
+    void addCallGraphNode(CallGraphNode* cgNode);
+
+    /// Whether we have already created this call graph edge
+    CallGraphEdge* hasGraphEdge(CallGraphEdge* cgEdge) const;
 public:
     /// Constructor
     CallGraph(CGEK k = NormCallGraph);

package/SVF-linux-x86_64/include/Graphs/ICFG.h

@@ -34,6 +34,7 @@
 #include "Graphs/ICFGEdge.h"
 #include "Util/WorkList.h"
 #include "MemoryModel/SVFLoop.h"
+#include "SVFIR/SVFVariables.h"
 
 namespace SVF
 {
@@ -48,6 +49,7 @@ class ICFG : public GenericICFGTy
 {
     friend class ICFGBuilder;
     friend class ICFGSimplification;
+    friend class GraphDBClient;
 
 public:
 
@@ -198,23 +200,37 @@ protected:
     virtual inline FunEntryICFGNode* addFunEntryICFGNode(const FunObjVar* svfFunc)
     {
         FunEntryICFGNode* sNode = new FunEntryICFGNode(totalICFGNode++,svfFunc);
-        addICFGNode(sNode);
-        return FunToFunEntryNodeMap[svfFunc] = sNode;
+        return addFunEntryICFGNode(sNode);
     }
 
+    virtual inline FunEntryICFGNode* addFunEntryICFGNode(FunEntryICFGNode* funEntryICFGNode)
+    {
+        addICFGNode(funEntryICFGNode);
+        return FunToFunEntryNodeMap[funEntryICFGNode->getFun()] = funEntryICFGNode;
+    }
+
+    virtual void addGlobalICFGNode(GlobalICFGNode* globalICFGNode);
+
     virtual inline FunExitICFGNode* addFunExitICFGNode(const FunObjVar* svfFunc)
     {
-        FunExitICFGNode* sNode = new FunExitICFGNode(totalICFGNode++, svfFunc);
-        addICFGNode(sNode);
-        return FunToFunExitNodeMap[svfFunc] = sNode;
+        const SVFBasicBlock* bb = nullptr;
+        if (svfFunc->begin() != svfFunc->end())
+        {
+            bb = svfFunc->getExitBB();
+        }
+        FunExitICFGNode* sNode = new FunExitICFGNode(totalICFGNode++, svfFunc, bb);
+        return addFunExitICFGNode(sNode);
     }
 
-    /// Add a ICFG node
-    virtual inline void addICFGNode(ICFGNode* node)
+    virtual inline FunExitICFGNode* addFunExitICFGNode(FunExitICFGNode* funExitICFGNode)
     {
-        addGNode(node->getId(),node);
+        addICFGNode(funExitICFGNode);
+        return FunToFunExitNodeMap[funExitICFGNode->getFun()] = funExitICFGNode;
     }
 
+    /// Add a ICFG node
+    virtual void addICFGNode(ICFGNode* node);
+
 public:
     /// Get a basic block ICFGNode
     /// TODO:: need to fix the assertions

package/SVF-linux-x86_64/include/Graphs/ICFGEdge.h

@@ -112,6 +112,7 @@ class IntraCFGEdge : public ICFGEdge
 {
     friend class ICFG;
     friend class SVFIRBuilder;
+    friend class GraphDBClient;
 
 public:
     /// Constructor

package/SVF-linux-x86_64/include/Graphs/ICFGNode.h

@@ -140,8 +140,6 @@ public:
         return isICFGNodeKinds(node->getNodeKind());
     }
 
-
-
 protected:
     const FunObjVar* fun;
     const SVFBasicBlock* bb;
@@ -192,6 +190,8 @@ public:
  */
 class IntraICFGNode : public ICFGNode
 {
+    friend class GraphDBClient;
+
 private:
     bool isRet;
 
@@ -270,6 +270,7 @@ public:
  */
 class FunEntryICFGNode : public InterICFGNode
 {
+    friend class GraphDBClient;
 
 public:
     typedef std::vector<const SVFVar *> FormalParmNodeVec;
@@ -335,12 +336,18 @@ public:
  */
 class FunExitICFGNode : public InterICFGNode
 {
+    friend class GraphDBClient;
 
 private:
     const SVFVar *formalRet;
 
 public:
-    FunExitICFGNode(NodeID id, const FunObjVar* f);
+    FunExitICFGNode(NodeID id, const FunObjVar* f, const SVFBasicBlock* b)
+        : InterICFGNode(id, FunExitBlock), formalRet(nullptr)
+    {
+        this->fun = f;
+        this->bb = b;
+    }
 
     /// Return function
     inline const FunObjVar* getFun() const override
@@ -398,6 +405,7 @@ public:
  */
 class CallICFGNode : public InterICFGNode
 {
+    friend class GraphDBClient;
 
 public:
     typedef std::vector<const ValVar *> ActualParmNodeVec;
@@ -411,6 +419,8 @@ protected:
     SVFVar* vtabPtr;                /// virtual table pointer
     s32_t virtualFunIdx;            /// virtual function index of the virtual table(s) at a virtual call
     std::string funNameOfVcall;     /// the function name of this virtual call
+    const SVFVar* indFunPtr;
+
 
 public:
     CallICFGNode(NodeID id, const SVFBasicBlock* b, const SVFType* ty,
@@ -561,6 +571,18 @@ public:
     {
         return "CallICFGNode: " + ICFGNode::getSourceLoc();
     }
+
+    inline void setIndFunPtr(const SVFVar* indFun)
+    {
+        assert(isIndirectCall() && "not a indirect call?");
+        indFunPtr = indFun;
+    }
+
+    inline const SVFVar* getIndFunPtr() const
+    {
+        assert(isIndirectCall() && "not a indirect call?");
+        return indFunPtr;
+    }
 };
 
 
@@ -569,6 +591,14 @@ public:
  */
 class RetICFGNode : public InterICFGNode
 {
+    friend class GraphDBClient;
+
+protected:
+    /// Add call block node from database for the new RetICFGNode [only used this function when loading from db results]
+    inline void setCallBlockNode(const CallICFGNode* cb)
+    {
+        callBlockNode = cb;
+    }
 
 private:
     const SVFVar *actualRet;
@@ -578,9 +608,12 @@ public:
     RetICFGNode(NodeID id, CallICFGNode* cb) :
         InterICFGNode(id, FunRetBlock), actualRet(nullptr), callBlockNode(cb)
     {
-        fun = cb->getFun();
-        bb = cb->getBB();
-        type = cb->getType();
+        if (nullptr != cb)
+        {
+            fun = cb->getFun();
+            bb = cb->getBB();
+            type = cb->getType();
+        }
     }
 
     inline const CallICFGNode* getCallICFGNode() const

package/SVF-linux-x86_64/include/Graphs/IRGraph.h

@@ -52,6 +52,7 @@ class IRGraph : public GenericGraph<SVFVar, SVFStmt>
 {
     friend class SVFIRBuilder;
     friend class SymbolTableBuilder;
+    friend class GraphDBClient;
 
 public:
 
@@ -129,6 +130,7 @@ protected:
     /// blocks, thus flags are needed to distinguish them
     SVFStmt* hasLabeledEdge(SVFVar* src, SVFVar* dst, SVFStmt::PEDGEK kind,
                             const ICFGNode* cs);
+    SVFStmt* hasEdge(SVFStmt* edge, SVFStmt::PEDGEK kind);
     /// Return MultiOpndStmt since it has more than one operands (we use operand
     /// 2 here to make the flag)
     SVFStmt* hasLabeledEdge(SVFVar* src, SVFVar* op1, SVFStmt::PEDGEK kind,
@@ -270,6 +272,15 @@ public:
         return svfTypes;
     }
 
+    inline const SVFType* getSVFType(u32_t id) const
+    {
+        for(const SVFType* type : svfTypes)
+        {
+            if(type->getId() == id)
+                return type;
+        }
+        return nullptr;
+    }
     inline const Set<const StInfo*>& getStInfos() const
     {
         return stInfos;
@@ -360,6 +371,7 @@ public:
 
     inline void addStInfo(StInfo* stInfo)
     {
+        stInfo->setStinfoId(stInfos.size());
         stInfos.insert(stInfo);
     }
 

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

@@ -51,7 +51,7 @@ class SVFVar;
 */
 class AccessPath
 {
-
+    friend class GraphDBClient;
 public:
     enum LSRelation
     {
@@ -161,6 +161,12 @@ public:
     /// Dump location set
     std::string dump() const;
 
+protected:
+    inline void addIdxOperandPair(std::pair<const SVFVar*, const SVFType*> pair)
+    {
+        idxOperandPairs.push_back(pair);
+    }
+
 private:
 
     /// Check relations of two location sets

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

@@ -148,7 +148,7 @@ private:
     inline void addGlobalICFGNode()
     {
         icfg->globalBlockNode = new GlobalICFGNode(icfg->totalICFGNode++);
-        icfg->addICFGNode(icfg->globalBlockNode);
+        icfg->addGlobalICFGNode(icfg->globalBlockNode);
     }
 
 private:

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

@@ -46,6 +46,7 @@ namespace SVF
  */
 class SVFIRBuilder: public llvm::InstVisitor<SVFIRBuilder>
 {
+    friend class GraphDBSVFIRBuilder;
 
 private:
     SVFIR* pag;

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

@@ -42,6 +42,7 @@ namespace SVF
 class ObjTypeInfo
 {
     friend class SymbolTableBuilder;
+    friend class GraphDBClient;
 
 public:
     typedef enum
@@ -148,6 +149,10 @@ public:
     {
         flags |= mask;
     }
+    inline u32_t getFlag() const
+    {
+        return flags;
+    }
     inline bool hasFlag(MEMTYPE mask)
     {
         return (flags & mask) == mask;

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

@@ -46,6 +46,8 @@ class SVFIR : public IRGraph
     friend class PAGBuilderFromFile;
     friend class TypeBasedHeapCloning;
     friend class BVDataPTAImpl;
+    friend class GraphDBClient;
+    friend class GraphDBSVFIRBuilder;
 
 public:
     typedef Set<const CallICFGNode*> CallSiteSet;
@@ -181,6 +183,11 @@ public:
         return callGraph;
     }
 
+    inline void setCallGraph(CallGraph* cg)
+    {
+        callGraph = cg;
+    }
+
     const FunObjVar* getFunObjVar(const std::string& name);
 
     inline const std::string& getModuleIdentifier() const
@@ -500,6 +507,22 @@ public:
     /// Print SVFIR
     void print();
 
+protected:
+    inline NodeID addBaseObjNode(BaseObjVar* node)
+    {
+        memToFieldsMap[node->getId()].set(node->getId());
+        return addObjNode(node);
+    }
+
+    NodeID addDummyObjNode(DummyObjVar* node);
+
+    NodeID addGepObjNode(GepObjVar* gepObj, NodeID base, const APOffset& apOffset);
+
+    inline void addGepValObjFromDB(NodeID curInstID, const GepValVar* gepValvar)
+    {
+        GepValObjMap[curInstID][std::make_pair(gepValvar->getBaseNode()->getId(), gepValvar->getAccessPath())] = gepValvar->getId();
+    }
+
 private:
 
     /// Map a SVFStatement type to a set of corresponding SVF statements
@@ -521,6 +544,11 @@ private:
     inline void addFunArgs(const FunObjVar* fun, const SVFVar* arg)
     {
         FunEntryICFGNode* funEntryBlockNode = icfg->getFunEntryICFGNode(fun);
+        addFunArgs(funEntryBlockNode, fun, arg);
+    }
+
+    inline void addFunArgs(FunEntryICFGNode* funEntryBlockNode, const FunObjVar* fun, const SVFVar* arg)
+    {
         funEntryBlockNode->addFormalParms(arg);
         funArgsListMap[fun].push_back(arg);
     }
@@ -528,6 +556,11 @@ private:
     inline void addFunRet(const FunObjVar* fun, const SVFVar* ret)
     {
         FunExitICFGNode* funExitBlockNode = icfg->getFunExitICFGNode(fun);
+        addFunRet(funExitBlockNode, fun, ret);
+    }
+
+    inline void addFunRet(FunExitICFGNode* funExitBlockNode, const FunObjVar* fun, const SVFVar* ret)
+    {
         funExitBlockNode->addFormalRet(ret);
         funRetMap[fun] = ret;
     }
@@ -557,7 +590,7 @@ private:
     /// Add a value (pointer) node
     inline NodeID addValNode(NodeID i, const SVFType* type, const ICFGNode* icfgNode)
     {
-        SVFVar *node = new ValVar(i, type, icfgNode, ValVar::ValNode);
+        ValVar *node = new ValVar(i, type, icfgNode, ValVar::ValNode);
         return addValNode(node);
     }
 
@@ -624,9 +657,8 @@ private:
      */
     inline NodeID addHeapObjNode(NodeID i, ObjTypeInfo* ti, const ICFGNode* node)
     {
-        memToFieldsMap[i].set(i);
         HeapObjVar *heapObj = new HeapObjVar(i, ti, node);
-        return addObjNode(heapObj);
+        return addBaseObjNode(heapObj);
     }
 
     /**
@@ -634,60 +666,52 @@ private:
      */
     inline NodeID addStackObjNode(NodeID i, ObjTypeInfo* ti, const ICFGNode* node)
     {
-        memToFieldsMap[i].set(i);
         StackObjVar *stackObj = new StackObjVar(i, ti, node);
-        return addObjNode(stackObj);
+        return addBaseObjNode(stackObj);
     }
 
     NodeID addFunObjNode(NodeID id,  ObjTypeInfo* ti, const ICFGNode* node)
     {
-        memToFieldsMap[id].set(id);
         FunObjVar* funObj = new FunObjVar(id, ti, node);
-        return addObjNode(funObj);
+        return addBaseObjNode(funObj);
     }
 
 
     inline NodeID addConstantFPObjNode(NodeID i, ObjTypeInfo* ti, double dval, const ICFGNode* node)
     {
-        memToFieldsMap[i].set(i);
         ConstFPObjVar* conObj = new ConstFPObjVar(i, dval, ti, node);
-        return addObjNode(conObj);
+        return addBaseObjNode(conObj);
     }
 
 
     inline NodeID addConstantIntObjNode(NodeID i, ObjTypeInfo* ti, const std::pair<s64_t, u64_t>& intValue, const ICFGNode* node)
     {
-        memToFieldsMap[i].set(i);
         ConstIntObjVar* conObj =
             new ConstIntObjVar(i, intValue.first, intValue.second, ti, node);
-        return addObjNode(conObj);
+        return addBaseObjNode(conObj);
     }
 
 
     inline NodeID addConstantNullPtrObjNode(const NodeID i, ObjTypeInfo* ti, const ICFGNode* node)
     {
-        memToFieldsMap[i].set(i);
         ConstNullPtrObjVar* conObj = new ConstNullPtrObjVar(i, ti, node);
-        return addObjNode(conObj);
+        return addBaseObjNode(conObj);
     }
 
     inline NodeID addGlobalObjNode(const NodeID i, ObjTypeInfo* ti, const ICFGNode* node)
     {
-        memToFieldsMap[i].set(i);
         GlobalObjVar* gObj = new GlobalObjVar(i, ti, node);
-        return addObjNode(gObj);
+        return addBaseObjNode(gObj);
     }
     inline NodeID addConstantAggObjNode(const NodeID i, ObjTypeInfo* ti, const ICFGNode* node)
     {
-        memToFieldsMap[i].set(i);
         ConstAggObjVar* conObj = new ConstAggObjVar(i, ti, node);
-        return addObjNode(conObj);
+        return addBaseObjNode(conObj);
     }
     inline NodeID addConstantDataObjNode(const NodeID i, ObjTypeInfo* ti, const ICFGNode* node)
     {
-        memToFieldsMap[i].set(i);
         ConstDataObjVar* conObj = new ConstDataObjVar(i, ti, node);
-        return addObjNode(conObj);
+        return addBaseObjNode(conObj);
     }
 
     /// Add a unique return node for a procedure
@@ -710,9 +734,8 @@ private:
     /// Add a field-insensitive node, this method can only invoked by getFIGepObjNode
     NodeID addFIObjNode(NodeID i, ObjTypeInfo* ti, const ICFGNode* node)
     {
-        memToFieldsMap[i].set(i);
         BaseObjVar* baseObj = new BaseObjVar(i, ti, node);
-        return addObjNode(baseObj);
+        return addBaseObjNode(baseObj);
     }
 
 
@@ -730,11 +753,11 @@ private:
         {
             ObjTypeInfo* ti = createObjTypeInfo(type);
             idToObjTypeInfoMap()[i] = ti;
-            return addObjNode(new DummyObjVar(i, ti, nullptr));
+            return addDummyObjNode(new DummyObjVar(i, ti, nullptr));
         }
         else
         {
-            return addObjNode(new DummyObjVar(i, getObjTypeInfo(i), nullptr));
+            return addDummyObjNode(new DummyObjVar(i, getObjTypeInfo(i), nullptr));
         }
     }
 
@@ -753,23 +776,9 @@ private:
     //@}
 
     /// Add a value (pointer) node
-    inline NodeID addValNode(SVFVar *node)
-    {
-        assert(node && "node cannot be nullptr.");
-        assert(hasGNode(node->getId()) == false &&
-               "This NodeID clashes here. Please check NodeIDAllocator. Switch "
-               "Strategy::DBUG to SEQ or DENSE");
-        return addNode(node);
-    }
+    NodeID addValNode(ValVar* node);
     /// Add a memory obj node
-    inline NodeID addObjNode(SVFVar *node)
-    {
-        assert(node && "node cannot be nullptr.");
-        assert(hasGNode(node->getId()) == false &&
-               "This NodeID clashes here. Please check NodeIDAllocator. Switch "
-               "Strategy::DBUG to SEQ or DENSE");
-        return addNode(node);
-    }
+    NodeID addObjNode(ObjVar *node);
     /// Add a unique return node for a procedure
     inline NodeID addRetNode(const FunObjVar*, SVFVar *node)
     {
@@ -795,36 +804,49 @@ private:
     //@{
     /// Add Address edge
     AddrStmt* addAddrStmt(NodeID src, NodeID dst);
+    void addAddrStmt(AddrStmt* edge);
     /// Add Copy edge
     CopyStmt* addCopyStmt(NodeID src, NodeID dst, CopyStmt::CopyKind type);
+    void addCopyStmt(CopyStmt* edge);
 
     /// Add phi node information
     PhiStmt*  addPhiStmt(NodeID res, NodeID opnd, const ICFGNode* pred);
+    void addPhiStmt(PhiStmt* edge, SVFVar* src, SVFVar* dst);
     /// Add SelectStmt
     SelectStmt*  addSelectStmt(NodeID res, NodeID op1, NodeID op2, NodeID cond);
+    void addSelectStmt(SelectStmt* edge, SVFVar* src, SVFVar* dst);
     /// Add Copy edge
     CmpStmt* addCmpStmt(NodeID op1, NodeID op2, NodeID dst, u32_t predict);
+    void addCmpStmt(CmpStmt* edge, SVFVar* src, SVFVar* dst);
     /// Add Copy edge
     BinaryOPStmt* addBinaryOPStmt(NodeID op1, NodeID op2, NodeID dst,
                                   u32_t opcode);
+    void addBinaryOPStmt(BinaryOPStmt* edge, SVFVar* src, SVFVar* dst);
     /// Add Unary edge
     UnaryOPStmt* addUnaryOPStmt(NodeID src, NodeID dst, u32_t opcode);
+    void addUnaryOPStmt(UnaryOPStmt* edge, SVFVar* src, SVFVar* dst);
     /// Add BranchStmt
     BranchStmt* addBranchStmt(NodeID br, NodeID cond,
                               const BranchStmt::SuccAndCondPairVec& succs);
+    void addBranchStmt(BranchStmt* edge, SVFVar* src, SVFVar* dst);
     /// Add Load edge
     LoadStmt* addLoadStmt(NodeID src, NodeID dst);
+    void addLoadStmt(LoadStmt* edge);
     /// Add Store edge
     StoreStmt* addStoreStmt(NodeID src, NodeID dst, const ICFGNode* val);
+    void addStoreStmt(StoreStmt* edge, SVFVar* src, SVFVar* dst);
     /// Add Call edge
     CallPE* addCallPE(NodeID src, NodeID dst, const CallICFGNode* cs,
                       const FunEntryICFGNode* entry);
+    void addCallPE(CallPE* edge, SVFVar* src, SVFVar* dst);
     /// Add Return edge
     RetPE* addRetPE(NodeID src, NodeID dst, const CallICFGNode* cs,
                     const FunExitICFGNode* exit);
+    void addRetPE(RetPE* edge, SVFVar* src, SVFVar* dst);
     /// Add Gep edge
     GepStmt* addGepStmt(NodeID src, NodeID dst, const AccessPath& ap,
                         bool constGep);
+    void addGepStmt(GepStmt* edge);
     /// Add Offset(Gep) edge
     GepStmt* addNormalGepStmt(NodeID src, NodeID dst, const AccessPath& ap);
     /// Add Variant(Gep) edge