svf-lib 1.0.2113 → 1.0.2114

package/SVF-osx/Release-build/include/SVF-LLVM/ICFGBuilder.h

@@ -33,6 +33,7 @@
 #include "Graphs/ICFG.h"
 #include "Util/WorkList.h"
 #include "BasicTypes.h"
+#include "LLVMModule.h"
 
 namespace SVF
 {
@@ -44,6 +45,12 @@ public:
 
     typedef std::vector<const Instruction*> InstVec;
     typedef Set<const Instruction*> BBSet;
+    typedef Map<const Instruction*, CallICFGNode *> CSToCallNodeMapTy;
+    typedef Map<const Instruction*, RetICFGNode *> CSToRetNodeMapTy;
+    typedef Map<const Instruction*, IntraICFGNode *> InstToBlockNodeMapTy;
+    typedef Map<const Function*, FunEntryICFGNode *> FunToFunEntryNodeMapTy;
+    typedef Map<const Function*, FunExitICFGNode *> FunToFunExitNodeMapTy;
+
 
 private:
     ICFG* icfg;
@@ -55,9 +62,42 @@ public:
     {
 
     }
-    void build(SVFModule* svfModule);
+    void build();
 
 private:
+
+    LLVMModuleSet* llvmModuleSet()
+    {
+        return LLVMModuleSet::getLLVMModuleSet();
+    }
+
+    CSToRetNodeMapTy& csToRetNodeMap()
+    {
+        return llvmModuleSet()->CSToRetNodeMap;
+    }
+
+    CSToCallNodeMapTy& csToCallNodeMap()
+    {
+        return llvmModuleSet()->CSToCallNodeMap;
+    }
+
+    InstToBlockNodeMapTy& instToBlockNodeMap()
+    {
+        return llvmModuleSet()->InstToBlockNodeMap;
+    }
+
+    FunToFunEntryNodeMapTy& funToFunEntryNodeMap()
+    {
+        return llvmModuleSet()->FunToFunEntryNodeMap;
+    }
+
+    FunToFunExitNodeMapTy& funToFunExitNodeMap()
+    {
+        return llvmModuleSet()->FunToFunExitNodeMap;
+    }
+
+private:
+
     /// Create edges between ICFG nodes within a function
     ///@{
     void processFunEntry(const Function*  fun, WorkList& worklist);
@@ -71,41 +111,71 @@ private:
 
     void checkICFGNodesVisited(const Function* fun);
 
-    void connectGlobalToProgEntry(SVFModule* svfModule);
+    void connectGlobalToProgEntry();
 
-    /// Add/Get an inter block ICFGNode
-    InterICFGNode* addInterBlockICFGNode(const SVFInstruction* inst);
 
-    /// Add/Get a basic block ICFGNode
-    inline ICFGNode* addBlockICFGNode(const SVFInstruction* inst)
+    /// Create edges between ICFG nodes across functions
+    void addICFGInterEdges(const Instruction*  cs, const Function*  callee);
+
+    inline ICFGNode* getICFGNode(const Instruction* inst)
     {
-        ICFGNode* node;
-        if(SVFUtil::isNonInstricCallSite(inst))
-            node = addInterBlockICFGNode(inst);
-        else
-            node = addIntraBlockICFGNode(inst);
-        const_cast<SVFBasicBlock*>(inst->getParent())->addICFGNode(node);
-        return node;
+        return llvmModuleSet()->getICFGNode(inst);
     }
 
-    /// Create edges between ICFG nodes across functions
-    void addICFGInterEdges(const SVFInstruction*  cs, const SVFFunction*  callee);
+    inline bool hasICFGNode(const Instruction* inst)
+    {
+        return llvmModuleSet()->hasICFGNode(inst);
+    }
 
-    /// Add a call node
-    inline CallICFGNode* getCallICFGNode(const SVFInstruction*  cs)
+    /// get a call node
+    inline CallICFGNode* getCallICFGNode(const Instruction*  cs)
     {
-        return icfg->getCallICFGNode(cs);
+        return llvmModuleSet()->getCallICFGNode(cs);
     }
-    /// Add a return node
-    inline RetICFGNode* getRetICFGNode(const SVFInstruction*  cs)
+    /// get a return node
+    inline RetICFGNode* getRetICFGNode(const Instruction*  cs)
     {
-        return icfg->getRetICFGNode(cs);
+        return llvmModuleSet()->getRetICFGNode(cs);
+    }
+    /// get a intra node
+    inline IntraICFGNode* getIntraICFGNode(const Instruction* inst)
+    {
+        return llvmModuleSet()->getIntraICFGNode(inst);
     }
 
+    /// get a function entry node
+    inline FunEntryICFGNode* getFunEntryICFGNode(const Function*  fun)
+    {
+        return llvmModuleSet()->getFunEntryICFGNode(fun);
+    }
+    /// get a function exit node
+    inline FunExitICFGNode* getFunExitICFGNode(const Function*  fun)
+    {
+        return llvmModuleSet()->getFunExitICFGNode(fun);
+    }
+
+    inline GlobalICFGNode* getGlobalICFGNode() const
+    {
+        return icfg->getGlobalICFGNode();
+    }
+
+    /// Add/Get an inter block ICFGNode
+    InterICFGNode* addInterBlockICFGNode(const Instruction* inst);
+
+    /// Add/Get a basic block ICFGNode
+    inline ICFGNode* addBlockICFGNode(const Instruction* inst);
+
     /// Add and get IntraBlock ICFGNode
-    IntraICFGNode* addIntraBlockICFGNode(const SVFInstruction* inst)
+    IntraICFGNode* addIntraBlockICFGNode(const Instruction* inst);
+
+    FunEntryICFGNode* addFunEntryBlock(const Function* fun);
+
+    FunExitICFGNode* addFunExitBlock(const Function* fun);
+
+    inline void addGlobalICFGNode()
     {
-        return icfg->addIntraICFGNode(inst);
+        icfg->globalBlockNode = new GlobalICFGNode(icfg->totalICFGNode++);
+        icfg->addICFGNode(icfg->globalBlockNode);
     }
 
 private:

package/SVF-osx/Release-build/include/SVF-LLVM/LLVMModule.h

@@ -44,6 +44,7 @@ class ObjTypeInference;
 class LLVMModuleSet
 {
     friend class SVFIRBuilder;
+    friend class ICFGBuilder;
 
 public:
 
@@ -63,6 +64,12 @@ public:
     typedef Map<const Type*, StInfo*> Type2TypeInfoMap;
     typedef Map<std::string, std::vector<std::string>> Fun2AnnoMap;
 
+    typedef Map<const Instruction*, CallICFGNode *> CSToCallNodeMapTy;
+    typedef Map<const Instruction*, RetICFGNode *> CSToRetNodeMapTy;
+    typedef Map<const Instruction*, IntraICFGNode *> InstToBlockNodeMapTy;
+    typedef Map<const Function*, FunEntryICFGNode *> FunToFunEntryNodeMapTy;
+    typedef Map<const Function*, FunExitICFGNode *> FunToFunExitNodeMapTy;
+
 private:
     static LLVMModuleSet* llvmModuleSet;
     static bool preProcessed;
@@ -90,6 +97,12 @@ private:
     Type2TypeInfoMap Type2TypeInfo;
     ObjTypeInference* typeInference;
 
+    CSToCallNodeMapTy CSToCallNodeMap; ///< map a callsite to its CallICFGNode
+    CSToRetNodeMapTy CSToRetNodeMap; ///< map a callsite to its RetICFGNode
+    InstToBlockNodeMapTy InstToBlockNodeMap; ///< map a basic block to its ICFGNode
+    FunToFunEntryNodeMapTy FunToFunEntryNodeMap; ///< map a function to its FunExitICFGNode
+    FunToFunExitNodeMapTy FunToFunExitNodeMap; ///< map a function to its FunEntryICFGNode
+
     /// Constructor
     LLVMModuleSet();
 
@@ -266,6 +279,33 @@ public:
         return nullptr;
     }
 
+    ICFGNode* getICFGNode(const Instruction* inst);
+
+    bool hasICFGNode(const Instruction* inst);
+
+    /// get a call node
+    CallICFGNode* getCallICFGNode(const Instruction*  cs);
+    /// get a return node
+    RetICFGNode* getRetICFGNode(const Instruction*  cs);
+    /// get a intra node
+    IntraICFGNode* getIntraICFGNode(const Instruction* inst);
+
+    /// Add a function entry node
+    inline FunEntryICFGNode* getFunEntryICFGNode(const Function*  fun)
+    {
+        FunEntryICFGNode* b = getFunEntryBlock(fun);
+        assert(b && "Function entry not created?");
+        return b;
+    }
+    /// Add a function exit node
+    inline FunExitICFGNode* getFunExitICFGNode(const Function*  fun)
+    {
+        FunExitICFGNode* b = getFunExitBlock(fun);
+        assert(b && "Function exit not created?");
+        return b;
+    }
+
+
     /// Global to rep
     bool hasGlobalRep(const GlobalVariable* val) const
     {
@@ -344,6 +384,50 @@ private:
     void prePassSchedule();
     void buildSymbolTable() const;
     void collectExtFunAnnotations(const Module* mod);
+
+    /// Get/Add a call node
+    inline CallICFGNode* getCallBlock(const Instruction* cs)
+    {
+        CSToCallNodeMapTy::const_iterator it = CSToCallNodeMap.find(cs);
+        if (it == CSToCallNodeMap.end())
+            return nullptr;
+        return it->second;
+    }
+
+    /// Get/Add a return node
+    inline RetICFGNode* getRetBlock(const Instruction* cs)
+    {
+        CSToRetNodeMapTy::const_iterator it = CSToRetNodeMap.find(cs);
+        if (it == CSToRetNodeMap.end())
+            return nullptr;
+        return it->second;
+    }
+
+    inline IntraICFGNode* getIntraBlock(const Instruction* inst)
+    {
+        InstToBlockNodeMapTy::const_iterator it = InstToBlockNodeMap.find(inst);
+        if (it == InstToBlockNodeMap.end())
+            return nullptr;
+        return it->second;
+    }
+
+    /// Get/Add a function entry node
+    inline FunEntryICFGNode* getFunEntryBlock(const Function* fun)
+    {
+        FunToFunEntryNodeMapTy::const_iterator it = FunToFunEntryNodeMap.find(fun);
+        if (it == FunToFunEntryNodeMap.end())
+            return nullptr;
+        return it->second;
+    }
+
+    /// Get/Add a function exit node
+    inline FunExitICFGNode* getFunExitBlock(const Function* fun)
+    {
+        FunToFunExitNodeMapTy::const_iterator it = FunToFunExitNodeMap.find(fun);
+        if (it == FunToFunExitNodeMap.end())
+            return nullptr;
+        return it->second;
+    }
 };
 
 } // End namespace SVF

package/SVF-osx/Release-build/include/SVF-LLVM/LLVMUtil.h

@@ -360,6 +360,21 @@ inline bool isHeapAllocExtCall(const Instruction *inst)
     return isHeapAllocExtCallViaRet(inst) || isHeapAllocExtCallViaArg(inst);
 }
 
+/// Whether an instruction is a callsite in the application code, excluding llvm intrinsic calls
+bool isNonInstricCallSite(const Instruction* inst);
+
+/// Get program entry function from module.
+inline const Function* getProgEntryFunction(Module& module)
+{
+    for (auto it = module.begin(), eit = module.end(); it != eit; ++it)
+    {
+        const Function *fun = &(*it);
+        if (isProgEntryFunction(fun))
+            return (fun);
+    }
+    return nullptr;
+}
+
 } // End namespace LLVMUtil
 
 } // End namespace SVF

package/SVF-osx/Release-build/include/SVF-LLVM/SVFIRBuilder.h

@@ -90,14 +90,14 @@ public:
         processCE(V);
 
         // strip off the constant cast and return the value node
-        SVFValue* svfVal = LLVMModuleSet::getLLVMModuleSet()->getSVFValue(V);
+        SVFValue* svfVal = llvmModuleSet()->getSVFValue(V);
         return pag->getValueNode(svfVal);
     }
 
     /// GetObject - Return the object node (stack/global/heap/function) according to a LLVM Value
     inline NodeID getObjectNode(const Value* V)
     {
-        SVFValue* svfVal = LLVMModuleSet::getLLVMModuleSet()->getSVFValue(V);
+        SVFValue* svfVal = llvmModuleSet()->getSVFValue(V);
         return pag->getObjectNode(svfVal);
     }
 
@@ -240,8 +240,8 @@ protected:
     /// Set current basic block in order to keep track of control flow information
     inline void setCurrentLocation(const Value* val, const BasicBlock* bb)
     {
-        curBB = (bb == nullptr? nullptr : LLVMModuleSet::getLLVMModuleSet()->getSVFBasicBlock(bb));
-        curVal = (val == nullptr ? nullptr: LLVMModuleSet::getLLVMModuleSet()->getSVFValue(val));
+        curBB = (bb == nullptr? nullptr : llvmModuleSet()->getSVFBasicBlock(bb));
+        curVal = (val == nullptr ? nullptr: llvmModuleSet()->getSVFValue(val));
     }
     inline void setCurrentLocation(const SVFValue* val, const SVFBasicBlock* bb)
     {
@@ -270,9 +270,9 @@ protected:
     /// Add NullPtr PAGNode
     inline NodeID addNullPtrNode()
     {
-        LLVMContext& cxt = LLVMModuleSet::getLLVMModuleSet()->getContext();
+        LLVMContext& cxt = llvmModuleSet()->getContext();
         ConstantPointerNull* constNull = ConstantPointerNull::get(PointerType::getUnqual(cxt));
-        NodeID nullPtr = pag->addValNode(LLVMModuleSet::getLLVMModuleSet()->getSVFValue(constNull),pag->getNullPtr());
+        NodeID nullPtr = pag->addValNode(llvmModuleSet()->getSVFValue(constNull),pag->getNullPtr(), nullptr);
         setCurrentLocation(constNull, nullptr);
         addBlackHoleAddrEdge(pag->getBlkPtr());
         return nullPtr;
@@ -305,7 +305,7 @@ protected:
         AddrStmt* edge = addAddrEdge(src, dst);
         if (inst.getArraySize())
         {
-            SVFValue* arrSz = LLVMModuleSet::getLLVMModuleSet()->getSVFValue(inst.getArraySize());
+            SVFValue* arrSz = llvmModuleSet()->getSVFValue(inst.getArraySize());
             edge->addArrSize(arrSz);
         }
         return edge;
@@ -332,7 +332,7 @@ protected:
             if (cs->arg_size() > 0)
             {
                 const llvm::Value* val = cs->getArgOperand(0);
-                SVFValue* svfval = LLVMModuleSet::getLLVMModuleSet()->getSVFValue(val);
+                SVFValue* svfval = llvmModuleSet()->getSVFValue(val);
                 edge->addArrSize(svfval);
             }
         }
@@ -342,8 +342,8 @@ protected:
         {
             if (cs->arg_size() > 1)
             {
-                edge->addArrSize(LLVMModuleSet::getLLVMModuleSet()->getSVFValue(cs->getArgOperand(0)));
-                edge->addArrSize(LLVMModuleSet::getLLVMModuleSet()->getSVFValue(cs->getArgOperand(1)));
+                edge->addArrSize(llvmModuleSet()->getSVFValue(cs->getArgOperand(0)));
+                edge->addArrSize(llvmModuleSet()->getSVFValue(cs->getArgOperand(1)));
             }
         }
         else
@@ -351,7 +351,7 @@ protected:
             if (cs->arg_size() > 0)
             {
                 const llvm::Value* val = cs->getArgOperand(0);
-                SVFValue* svfval = LLVMModuleSet::getLLVMModuleSet()->getSVFValue(val);
+                SVFValue* svfval = llvmModuleSet()->getSVFValue(val);
                 edge->addArrSize(svfval);
             }
         }
@@ -452,7 +452,8 @@ protected:
     {
         ICFGNode* node;
         if (const SVFInstruction* inst = SVFUtil::dyn_cast<SVFInstruction>(curVal))
-            node = pag->getICFG()->getICFGNode(inst);
+            node = llvmModuleSet()->getICFGNode(
+                       SVFUtil::cast<Instruction>(llvmModuleSet()->getLLVMValue(inst)));
         else
             node = nullptr;
         if (StoreStmt* edge = pag->addStoreStmt(src, dst, node))
@@ -503,6 +504,12 @@ protected:
     //@}
 
     AccessPath getAccessPathFromBaseNode(NodeID nodeId);
+
+private:
+    LLVMModuleSet* llvmModuleSet()
+    {
+        return LLVMModuleSet::getLLVMModuleSet();
+    }
 };
 
 } // End namespace SVF

package/SVF-osx/Release-build/include/SVFIR/SVFFileSystem.h

@@ -1064,7 +1064,7 @@ public:
     }
 
 private:
-    using GNodeK = GenericNode<int, GenericEdge<void>>::GNodeK;
+    using GNodeK = s32_t;
     using GEdgeFlag = GenericEdge<void>::GEdgeFlag;
     using GEdgeKind = GenericEdge<void>::GEdgeKind;
     static ICFGNode* createICFGNode(NodeID id, GNodeK type);

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

@@ -531,9 +531,9 @@ private:
     /// add node into SVFIR
     //@{
     /// Add a value (pointer) node
-    inline NodeID addValNode(const SVFValue* val, NodeID i)
+    inline NodeID addValNode(const SVFValue* val, NodeID i, const SVFBaseNode* gNode)
     {
-        SVFVar *node = new ValVar(val,i);
+        SVFVar *node = new ValVar(val,i, ValVar::ValNode, gNode);
         return addValNode(val, node, i);
     }
     /// Add a memory obj node

package/SVF-osx/Release-build/include/SVFIR/SVFVariables.h

@@ -60,19 +60,8 @@ public:
     /// GepValNode: temporary gep obj node for field sensitivity
     /// FIObjNode: for field insensitive analysis
     /// DummyValNode and DummyObjNode: for non-llvm-value node
-    enum PNODEK
-    {
-        ValNode,
-        ObjNode,
-        RetNode,
-        VarargNode,
-        GepValNode,
-        GepObjNode,
-        FIObjNode,
-        DummyValNode,
-        DummyObjNode,
-    };
-
+    typedef GNodeK PNODEK;
+    typedef s64_t GEdgeKind;
 
 protected:
     const SVFValue* value; ///< value of this SVFIR node
@@ -206,19 +195,34 @@ public:
     }
     //@}
 
+    static inline bool classof(const SVFVar *)
+    {
+        return true;
+    }
+
+    static inline bool classof(const GenericPAGNodeTy * node)
+    {
+        return isSVFVarKind(node->getNodeKind());
+    }
+
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return isSVFVarKind(node->getNodeKind());
+    }
+
 private:
     ///  add methods of the components
     //@{
     inline void addInEdge(SVFStmt* inEdge)
     {
-        GNodeK kind = inEdge->getEdgeKind();
+        GEdgeKind kind = inEdge->getEdgeKind();
         InEdgeKindToSetMap[kind].insert(inEdge);
         addIncomingEdge(inEdge);
     }
 
     inline void addOutEdge(SVFStmt* outEdge)
     {
-        GNodeK kind = outEdge->getEdgeKind();
+        GEdgeKind kind = outEdge->getEdgeKind();
         OutEdgeKindToSetMap[kind].insert(outEdge);
         addOutgoingEdge(outEdge);
     }
@@ -264,9 +268,11 @@ class ValVar: public SVFVar
     friend class SVFIRWriter;
     friend class SVFIRReader;
 
+private:
+    const SVFBaseNode* gNode; // constant, gepValvar, retPN, dummy could be null
 protected:
     /// Constructor to create an empty ValVar (for SVFIRReader/deserialization)
-    ValVar(NodeID i, PNODEK ty = ValNode) : SVFVar(i, ty) {}
+    ValVar(NodeID i, PNODEK ty = ValNode) : SVFVar(i, ty), gNode(nullptr) {}
 
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -277,25 +283,21 @@ public:
     }
     static inline bool classof(const SVFVar* node)
     {
-        return node->getNodeKind() == SVFVar::ValNode ||
-               node->getNodeKind() == SVFVar::GepValNode ||
-               node->getNodeKind() == SVFVar::RetNode ||
-               node->getNodeKind() == SVFVar::VarargNode ||
-               node->getNodeKind() == SVFVar::DummyValNode;
+        return isValVarKinds(node->getNodeKind());
     }
     static inline bool classof(const GenericPAGNodeTy* node)
     {
-        return node->getNodeKind() == SVFVar::ValNode ||
-               node->getNodeKind() == SVFVar::GepValNode ||
-               node->getNodeKind() == SVFVar::RetNode ||
-               node->getNodeKind() == SVFVar::VarargNode ||
-               node->getNodeKind() == SVFVar::DummyValNode;
+        return isValVarKinds(node->getNodeKind());
+    }
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return isValVarKinds(node->getNodeKind());
     }
     //@}
 
     /// Constructor
-    ValVar(const SVFValue* val, NodeID i, PNODEK ty = ValNode)
-        : SVFVar(val, i, ty)
+    ValVar(const SVFValue* val, NodeID i, PNODEK ty = ValNode, const SVFBaseNode* node = nullptr)
+        : SVFVar(val, i, ty), gNode(node)
     {
     }
     /// Return name of a LLVM value
@@ -306,6 +308,11 @@ public:
         return "";
     }
 
+    const SVFBaseNode* getGNode() const
+    {
+        return gNode;
+    }
+
     virtual const std::string toString() const;
 };
 
@@ -335,17 +342,15 @@ public:
     }
     static inline bool classof(const SVFVar* node)
     {
-        return node->getNodeKind() == SVFVar::ObjNode ||
-               node->getNodeKind() == SVFVar::GepObjNode ||
-               node->getNodeKind() == SVFVar::FIObjNode ||
-               node->getNodeKind() == SVFVar::DummyObjNode;
+        return isObjVarKinds(node->getNodeKind());
     }
     static inline bool classof(const GenericPAGNodeTy* node)
     {
-        return node->getNodeKind() == SVFVar::ObjNode ||
-               node->getNodeKind() == SVFVar::GepObjNode ||
-               node->getNodeKind() == SVFVar::FIObjNode ||
-               node->getNodeKind() == SVFVar::DummyObjNode;
+        return isObjVarKinds(node->getNodeKind());
+    }
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return isObjVarKinds(node->getNodeKind());
     }
     //@}
 
@@ -477,6 +482,10 @@ public:
     {
         return node->getNodeKind() == SVFVar::GepObjNode;
     }
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return node->getNodeKind() == SVFVar::GepObjNode;
+    }
     //@}
 
     /// Constructor
@@ -494,9 +503,9 @@ public:
     }
 
     /// Set the base object from which this GEP node came from.
-    inline void setBaseNode(NodeID base)
+    inline void setBaseNode(NodeID bs)
     {
-        this->base = base;
+        this->base = bs;
     }
 
     /// Return the base object from which this GEP node came from.
@@ -554,6 +563,10 @@ public:
     {
         return node->getNodeKind() == SVFVar::FIObjNode;
     }
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return node->getNodeKind() == SVFVar::FIObjNode;
+    }
     //@}
 
     /// Constructor
@@ -604,6 +617,10 @@ public:
     {
         return node->getNodeKind() == SVFVar::RetNode;
     }
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return node->getNodeKind() == SVFVar::RetNode;
+    }
     //@}
 
     /// Constructor
@@ -648,6 +665,10 @@ public:
     {
         return node->getNodeKind() == SVFVar::VarargNode;
     }
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return node->getNodeKind() == SVFVar::VarargNode;
+    }
     //@}
 
     /// Constructor
@@ -688,6 +709,10 @@ public:
     {
         return node->getNodeKind() == SVFVar::DummyValNode;
     }
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return node->getNodeKind() == SVFVar::DummyValNode;
+    }
     //@}
 
     /// Constructor
@@ -732,6 +757,11 @@ public:
     {
         return node->getNodeKind() == SVFVar::DummyObjNode;
     }
+
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return node->getNodeKind() == SVFVar::DummyObjNode;
+    }
     //@}
 
     /// Constructor

package/SVF-osx/Release-build/include/SVFIR/SymbolTableInfo.h

@@ -373,6 +373,7 @@ protected:
     Set<const StInfo*> stInfos;
 };
 
+class SVFBaseNode;
 
 /*!
  * Memory object symbols or MemObj (address-taken variables in LLVM-based languages)
@@ -381,6 +382,7 @@ class MemObj
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
+    friend class SVFIRBuilder;
 
 private:
     /// Type information of this object
@@ -390,9 +392,11 @@ private:
     /// The unique id to represent this symbol
     SymID symId;
 
+    const SVFBaseNode* gNode;
+
 public:
     /// Constructor
-    MemObj(SymID id, ObjTypeInfo* ti, const SVFValue* val = nullptr);
+    MemObj(SymID id, ObjTypeInfo* ti, const SVFValue* val = nullptr, const SVFBaseNode* node = nullptr);
 
     /// Destructor
     virtual ~MemObj()
@@ -408,6 +412,12 @@ public:
         return refVal;
     }
 
+    /// Get the reference value to this object
+    inline const SVFBaseNode* getGNode() const
+    {
+        return gNode;
+    }
+
     /// Get the memory object id
     inline SymID getId() const
     {

package/SVF-osx/Release-build/include/WPA/Andersen.h

@@ -137,7 +137,7 @@ public:
     //@}
 
     /// Add copy edge on constraint graph
-    virtual inline bool addCopyEdge(NodeID src, NodeID dst) = 0;
+    virtual bool addCopyEdge(NodeID src, NodeID dst) = 0;
 
     /// dump statistics
     inline void printStat()