svf-tools 1.0.1027 → 1.0.1029

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.1027",
+  "version": "1.0.1029",
   "description": "* <b>[TypeClone](https://github.com/SVF-tools/SVF/wiki/TypeClone) published in our [ECOOP paper](https://yuleisui.github.io/publications/ecoop20.pdf) is now available in SVF </b> * <b>SVF now uses a single script for its build. Just type [`source ./build.sh`](https://github.com/SVF-tools/SVF/blob/master/build.sh) in your terminal, that's it!</b> * <b>SVF now supports LLVM-10.0.0! </b> * <b>We thank [bsauce](https://github.com/bsauce) for writing a user manual of SVF ([link1](https://www.jianshu.com/p/068a08ec749c) and [link2](https://www.jianshu.com/p/777c30d4240e)) in Chinese </b> * <b>SVF now supports LLVM-9.0.0 (Thank [Byoungyoung Lee](https://github.com/SVF-tools/SVF/issues/142) for his help!). </b> * <b>SVF now supports a set of [field-sensitive pointer analyses](https://yuleisui.github.io/publications/sas2019a.pdf). </b> * <b>[Use SVF as an external lib](https://github.com/SVF-tools/SVF/wiki/Using-SVF-as-a-lib-in-your-own-tool) for your own project (Contributed by [Hongxu Chen](https://github.com/HongxuChen)). </b> * <b>SVF now supports LLVM-7.0.0. </b> * <b>SVF now supports Docker. [Try SVF in Docker](https://github.com/SVF-tools/SVF/wiki/Try-SVF-in-Docker)! </b> * <b>SVF now supports [LLVM-6.0.0](https://github.com/svf-tools/SVF/pull/38) (Contributed by [Jack Anthony](https://github.com/jackanth)). </b> * <b>SVF now supports [LLVM-4.0.0](https://github.com/svf-tools/SVF/pull/23) (Contributed by Jared Carlson. Thank [Jared](https://github.com/jcarlson23) and [Will](https://github.com/dtzWill) for their in-depth [discussions](https://github.com/svf-tools/SVF/pull/18) about updating SVF!) </b> * <b>SVF now supports analysis for C++ programs.</b> <br />",
   "main": "index.js",
   "scripts": {

package/svf/include/DDA/DDAVFSolver.h

@@ -473,8 +473,6 @@ protected:
         NodeID id = getPtrNodeID(var);
         const BaseObjVar* baseObj = _pag->getBaseObject(id);
         assert(baseObj && "base object is null??");
-        const MemObj* obj = _pag->getObject(id);
-        assert(obj && "object not found!!");
         if(SVFUtil::isa<StackObjVar>(baseObj))
         {
             if(const SVFFunction* svffun = _pag->getGNode(id)->getFunction())
@@ -645,14 +643,14 @@ protected:
 
     inline bool isArrayCondMemObj(const CVar& var) const
     {
-        const MemObj* mem = _pag->getObject(getPtrNodeID(var));
-        assert(mem && "memory object is null??");
-        return mem->isArray();
+        const BaseObjVar* obj = _pag->getBaseObject(getPtrNodeID(var));
+        assert(obj && "base object is null??");
+        return obj->isArray();
     }
     inline bool isFieldInsenCondMemObj(const CVar& var) const
     {
-        const MemObj* mem =  _pag->getBaseObj(getPtrNodeID(var));
-        return mem->isFieldInsensitive();
+        const BaseObjVar* baseObj = _pag->getBaseObject(getPtrNodeID(var));
+        return baseObj->isFieldInsensitive();
     }
     //@}
 private:

package/svf/include/Graphs/ConsG.h

@@ -323,8 +323,8 @@ public:
     }
     inline bool isSingleFieldObj(NodeID id) const
     {
-        const MemObj* mem = pag->getBaseObj(id);
-        return (mem->getMaxFieldOffsetLimit() == 1);
+        const BaseObjVar* baseObj = pag->getBaseObject(id);
+        return (baseObj->getMaxFieldOffsetLimit() == 1);
     }
     /// Get a field of a memory object
     inline NodeID getGepObjVar(NodeID id, const APOffset& apOffset)

package/svf/include/Graphs/IRGraph.h

@@ -65,10 +65,11 @@ protected:
     SymbolTableInfo* symInfo;
 
     /// Add a node into the graph
-    inline NodeID addNode(SVFVar* node, NodeID i)
+    inline NodeID addNode(SVFVar* node)
     {
-        addGNode(i,node);
-        return i;
+        assert(node && "cannot add a null node");
+        addGNode(node->getId(),node);
+        return node->getId();
     }
     /// Add an edge into the graph
     bool addEdge(SVFVar* src, SVFVar* dst, SVFStmt* edge);
@@ -94,12 +95,6 @@ protected:
             inserted.first->second.emplace(edge);
         }
     }
-    /// get MemObj according to LLVM value
-    inline const MemObj* getMemObj(const SVFValue* val) const
-    {
-        return symInfo->getObj(symInfo->getObjSym(val));
-    }
-
 public:
     IRGraph(bool buildFromFile)
         : fromFile(buildFromFile), nodeNumAfterPAGBuild(0), totalPTAPAGEdge(0)
@@ -174,14 +169,6 @@ public:
     {
         return symInfo->nullPtrSymID();
     }
-    inline const MemObj* getBlackHoleObj() const
-    {
-        return symInfo->getBlkObj();
-    }
-    inline const MemObj* getConstantObj() const
-    {
-        return symInfo->getConstantObj();
-    }
 
     inline u32_t getValueNodeNum() const
     {
@@ -189,7 +176,7 @@ public:
     }
     inline u32_t getObjectNodeNum() const
     {
-        return symInfo->idToObjMap().size();
+        return symInfo->idToObjTypeInfoMap().size();
     }
     inline u32_t getNodeNumAfterPAGBuild() const
     {

package/svf/include/MemoryModel/PointerAnalysis.h

@@ -309,9 +309,9 @@ public:
 
     inline bool isArrayMemObj(NodeID id) const
     {
-        const MemObj* mem = pag->getObject(id);
-        assert(mem && "memory object is null??");
-        return mem->isArray();
+        const BaseObjVar* obj = pag->getBaseObject(id);
+        assert(obj && "base object is null??");
+        return obj->isArray();
     }
     //@}
 
@@ -339,13 +339,13 @@ public:
     }
     inline void setObjFieldInsensitive(NodeID id)
     {
-        MemObj* mem =  const_cast<MemObj*>(pag->getBaseObj(id));
-        mem->setFieldInsensitive();
+        BaseObjVar* baseObj = const_cast<BaseObjVar*>(pag->getBaseObject(id));
+        baseObj->setFieldInsensitive();
     }
     inline bool isFieldInsensitive(NodeID id) const
     {
-        const MemObj* mem =  pag->getBaseObj(id);
-        return mem->isFieldInsensitive();
+        const BaseObjVar* baseObj = pag->getBaseObject(id);
+        return baseObj->isFieldInsensitive();
     }
     ///@}
 

package/svf/include/SVFIR/SVFFileSystem.h

@@ -129,8 +129,6 @@ class SVFMetadataAsValue;
 
 class SVFLoopAndDomInfo; // Part of SVFFunction
 
-// Classes created upon buildSymbolTableInfo
-class MemObj;
 
 // Classes created upon ICFG construction
 class ICFGNode;
@@ -422,7 +420,6 @@ private:
 
     cJSON* toJson(const AccessPath& ap);
     cJSON* toJson(const SVFLoop* loop);
-    cJSON* toJson(const MemObj* memObj);
     cJSON* toJson(const ObjTypeInfo* objTypeInfo);  // Only owned by MemObj
     cJSON* toJson(const SVFLoopAndDomInfo* ldInfo); // Only owned by SVFFunction
     cJSON* toJson(const StInfo* stInfo);
@@ -528,7 +525,6 @@ private:
 
     // Other classes
     cJSON* contentToJson(const SVFLoop* loop);
-    cJSON* contentToJson(const MemObj* memObj); // Owned by SymbolTable->objMap
     cJSON* contentToJson(const StInfo* stInfo);
     ///@}
 
@@ -899,13 +895,8 @@ class SymbolTableInfoReader
 
 private:
     const cJSON* symTabFieldJson = nullptr;
-    ReaderIDToObjMap<MemObj> memObjMap;
 
 public:
-    inline MemObj* getMemObjPtr(unsigned id) const
-    {
-        return memObjMap.getPtr(id);
-    }
 
     template <typename MemObjCreator>
     void createObjs(const cJSON* symTabJson, MemObjCreator memObjCreator)
@@ -915,7 +906,6 @@ public:
 
         const cJSON* const allMemObj = symTabJson->child;
         CHECK_JSON_KEY(allMemObj);
-        memObjMap.createObjs(allMemObj, memObjCreator);
 
         symTabFieldJson = allMemObj->next;
     }
@@ -1104,7 +1094,6 @@ private:
 
     void readJson(const cJSON* obj, AccessPath& ap);
     void readJson(const cJSON* obj, SVFLoop*& loop);
-    void readJson(const cJSON* obj, MemObj*& memObj);
     void readJson(const cJSON* obj,
                   ObjTypeInfo*& objTypeInfo); // Only owned by MemObj
     void readJson(const cJSON* obj,
@@ -1257,7 +1246,6 @@ private:
     void fill(const cJSON*& fieldJson, TDForkPE* stmt);
     void fill(const cJSON*& fieldJson, TDJoinPE* stmt);
 
-    void fill(const cJSON*& fieldJson, MemObj* memObj);
     void fill(const cJSON*& fieldJson, StInfo* stInfo);
     // ICFG
     void virtFill(const cJSON*& fieldJson, ICFGNode* node);

package/svf/include/SVFIR/SVFIR.h

@@ -393,15 +393,6 @@ public:
     /// return whole allocated memory object if this node is a gep obj node
     /// return nullptr is this node is not a ObjVar type
     //@{
-    inline const MemObj* getObject(NodeID id) const
-    {
-        const SVFVar* node = getGNode(id);
-        if (const ObjVar* objPN = SVFUtil::dyn_cast<ObjVar>(node))
-            return getObject(objPN);
-        else
-            return nullptr;
-    }
-
     inline const BaseObjVar* getBaseObject(NodeID id) const
     {
         const SVFVar* node = getGNode(id);
@@ -421,20 +412,15 @@ public:
         else
             return SVFUtil::dyn_cast<ValVar>(node);
     }
-
-    inline const MemObj*getObject(const ObjVar* node) const
-    {
-        return node->getMemObj();
-    }
     //@}
 
     /// Get a field SVFIR Object node according to base mem obj and offset
-    NodeID getGepObjVar(const MemObj* obj, const APOffset& ap);
+    NodeID getGepObjVar(const BaseObjVar* baseObj, const APOffset& ap);
     /// Get a field obj SVFIR node according to a mem obj and a given offset
     NodeID getGepObjVar(NodeID id, const APOffset& ap) ;
     /// Get a field-insensitive obj SVFIR node according to a mem obj
     //@{
-    inline NodeID getFIObjVar(const MemObj* obj) const
+    inline NodeID getFIObjVar(const BaseObjVar* obj) const
     {
         return obj->getId();
     }
@@ -464,7 +450,7 @@ public:
     }
     inline bool isConstantObj(NodeID id) const
     {
-        const MemObj* obj = getObject(id);
+        const BaseObjVar* obj = getBaseObject(id);
         assert(obj && "not an object node?");
         return SymbolTableInfo::isConstantObj(id) ||
                obj->isConstDataOrConstGlobal();
@@ -476,20 +462,13 @@ public:
     /// Get a base pointer node given a field pointer
     inline NodeID getBaseObjVar(NodeID id) const
     {
-        return getBaseObj(id)->getId();
-    }
-    inline const MemObj* getBaseObj(NodeID id) const
-    {
-        const SVFVar* node = pag->getGNode(id);
-        assert(SVFUtil::isa<ObjVar>(node) && "need an object node");
-        const ObjVar* obj = SVFUtil::cast<ObjVar>(node);
-        return obj->getMemObj();
+        return getBaseObject(id)->getId();
     }
     //@}
 
     /// Get all fields of an object
     //@{
-    NodeBS& getAllFieldsObjVars(const MemObj* obj);
+    NodeBS& getAllFieldsObjVars(const BaseObjVar* obj);
     NodeBS& getAllFieldsObjVars(NodeID id);
     NodeBS getFieldsAfterCollapse(NodeID id);
     //@}
@@ -569,157 +548,152 @@ private:
     inline NodeID addValNode(const SVFValue* val, NodeID i, const ICFGNode* icfgNode)
     {
         SVFVar *node = new ValVar(val,i, ValVar::ValNode, icfgNode);
-        return addValNode(val, node, i);
+        return addValNode(val, node);
     }
 
-    NodeID addFunValNode(const CallGraphNode* callGraphNode, NodeID i, const ICFGNode* icfgNode)
+    NodeID addFunValNode(NodeID i, const ICFGNode* icfgNode, const CallGraphNode* callGraphNode)
     {
-        FunValVar* node = new FunValVar(callGraphNode, i, icfgNode);
-        return addValNode(nullptr, node, i);
+        FunValVar* node = new FunValVar(i, icfgNode, callGraphNode);
+        return addValNode(nullptr, node);
     }
 
     NodeID addArgValNode(NodeID i, u32_t argNo, const ICFGNode* icfgNode, const CallGraphNode* callGraphNode, bool isUncalled = false)
     {
         ArgValVar* node =
             new ArgValVar(i, argNo, icfgNode, callGraphNode, isUncalled);
-        return addValNode(nullptr, node, i);
+        return addValNode(nullptr, node);
     }
 
-    inline NodeID addConstantFPValNode(const SVFValue* curInst, double dval, const NodeID i,
+    inline NodeID addConstantFPValNode(const SVFValue* curInst, const NodeID i, double dval,
                                        const ICFGNode* icfgNode)
     {
-        SVFVar* node = new ConstantFPValVar(curInst,  dval, i, icfgNode);
-        return addNode(node, i);
+        SVFVar* node = new ConstantFPValVar(curInst,  i, dval, icfgNode);
+        return addNode(node);
     }
 
-    inline NodeID addConstantIntValNode(const SVFValue* curInst, const std::pair<s64_t, u64_t>& intValue, const NodeID i,
+    inline NodeID addConstantIntValNode(const SVFValue* curInst, NodeID i, const std::pair<s64_t, u64_t>& intValue,
                                         const ICFGNode* icfgNode)
     {
-        SVFVar* node = new ConstantIntValVar(curInst, intValue.first, intValue.second, i, icfgNode);
-        return addNode(node, i);
+        SVFVar* node = new ConstantIntValVar(curInst, i, intValue.first, intValue.second, icfgNode);
+        return addNode(node);
     }
 
     inline NodeID addConstantNullPtrValNode(const SVFValue* curInst, const NodeID i, const ICFGNode* icfgNode)
     {
         SVFVar* node = new ConstantNullPtrValVar(curInst, i, icfgNode);
-        return addNode(node, i);
+        return addNode(node);
     }
 
     inline NodeID addGlobalValueValNode(const SVFValue* curInst, const NodeID i, const ICFGNode* icfgNode)
     {
         SVFVar* node = new GlobalValVar(curInst, i, icfgNode);
-        return addNode(node, i);
+        return addNode(node);
     }
 
     inline NodeID addConstantDataValNode(const SVFValue* curInst, const NodeID i, const ICFGNode* icfgNode)
     {
         SVFVar* node = new ConstantDataValVar(curInst, i, icfgNode);
-        return addNode(node, i);
+        return addNode(node);
     }
 
 
     /// Add a memory obj node
-    inline NodeID addObjNode(const SVFValue* val, NodeID i)
+    inline NodeID addObjNode(const SVFValue* val, NodeID i, ObjTypeInfo* ti)
     {
-        const MemObj* mem = getMemObj(val);
-        assert(mem->getId() == i && "not same object id?");
-        return addFIObjNode(mem);
+        return addFIObjNode(val, i, ti);
     }
 
     /**
      * Creates and adds a heap object node to the SVFIR
      */
-    inline NodeID addHeapObjNode(const SVFValue* val, const SVFFunction* f, NodeID i)
+    inline NodeID addHeapObjNode(const SVFValue* val, NodeID i, ObjTypeInfo* ti, const SVFFunction* f)
     {
-        const MemObj* mem = getMemObj(val);
-        assert(mem->getId() == i && "not same object id?");
         memToFieldsMap[i].set(i);
-        HeapObjVar *node = new HeapObjVar(f, val->getType(), i, mem);
-        return addObjNode(val, node, i);
+        HeapObjVar *heapObj = new HeapObjVar(val, i, ti, f);
+        return addObjNode(val, heapObj);
     }
 
     /**
      * Creates and adds a stack object node to the SVFIR
      */
-    inline NodeID addStackObjNode(const SVFValue* val, const SVFFunction* f, NodeID i)
+    inline NodeID addStackObjNode(const SVFValue* val, NodeID i, ObjTypeInfo* ti, const SVFFunction* f)
     {
-        const MemObj* mem = getMemObj(val);
-        assert(mem->getId() == i && "not same object id?");
         memToFieldsMap[i].set(i);
-        StackObjVar *node = new  StackObjVar(f, val->getType(), i, mem);
-        return addObjNode(val, node, i);
+        StackObjVar *stackObj = new StackObjVar(val, i, ti, f);
+        return addObjNode(val, stackObj);
     }
 
-    NodeID addFunObjNode(const CallGraphNode* callGraphNode, NodeID id);
+    NodeID addFunObjNode(const SVFValue* val, NodeID id,  ObjTypeInfo* ti, const CallGraphNode* callGraphNode)
+    {
+        memToFieldsMap[id].set(id);
+        FunObjVar* funObj = new FunObjVar(val, id, ti, callGraphNode);
+        return addObjNode(val, funObj);
+    }
 
 
-    inline NodeID addConstantFPObjNode(const SVFValue* curInst, double dval, const NodeID i)
+    inline NodeID addConstantFPObjNode(const SVFValue* curInst, NodeID i, ObjTypeInfo* ti, double dval)
     {
-        const MemObj* mem = getMemObj(curInst);
-        NodeID base = mem->getId();
-        memToFieldsMap[base].set(mem->getId());
-        ConstantFPObjVar* node = new ConstantFPObjVar(curInst, dval, mem->getId(), mem);
-        return addObjNode(curInst, node, mem->getId());
+        memToFieldsMap[i].set(i);
+        ConstantFPObjVar* conObj = new ConstantFPObjVar(curInst, i, dval, ti);
+        return addObjNode(curInst, conObj);
     }
 
 
-    inline NodeID addConstantIntObjNode(const SVFValue* curInst, const std::pair<s64_t, u64_t>& intValue, const NodeID i)
+    inline NodeID addConstantIntObjNode(const SVFValue* curInst, NodeID i, ObjTypeInfo* ti, const std::pair<s64_t, u64_t>& intValue)
     {
-        const MemObj* mem = getMemObj(curInst);
-        NodeID base = mem->getId();
-        memToFieldsMap[base].set(mem->getId());
-        ConstantIntObjVar* node =
-            new ConstantIntObjVar(curInst, intValue.first, intValue.second, mem->getId(), mem);
-        return addObjNode(curInst, node, mem->getId());
+        memToFieldsMap[i].set(i);
+        ConstantIntObjVar* conObj =
+            new ConstantIntObjVar(curInst, i, intValue.first, intValue.second, ti);
+        return addObjNode(curInst, conObj);
     }
 
 
-    inline NodeID addConstantNullPtrObjNode(const SVFValue* curInst, const NodeID i)
+    inline NodeID addConstantNullPtrObjNode(const SVFValue* curInst, const NodeID i, ObjTypeInfo* ti)
     {
-        const MemObj* mem = getMemObj(curInst);
-        NodeID base = mem->getId();
-        memToFieldsMap[base].set(mem->getId());
-        ConstantNullPtrObjVar* node = new ConstantNullPtrObjVar(curInst, mem->getId(), mem);
-        return addObjNode(mem->getValue(), node, mem->getId());
+        memToFieldsMap[i].set(i);
+        ConstantNullPtrObjVar* conObj = new ConstantNullPtrObjVar(curInst, i, ti);
+        return addObjNode(curInst, conObj);
     }
 
-    inline NodeID addGlobalValueObjNode(const SVFValue* curInst, const NodeID i)
+    inline NodeID addGlobalValueObjNode(const SVFValue* curInst, const NodeID i, ObjTypeInfo* ti)
     {
-        const MemObj* mem = getMemObj(curInst);
-        NodeID base = mem->getId();
-        memToFieldsMap[base].set(mem->getId());
-        GlobalObjVar* node = new GlobalObjVar(curInst, mem->getId(), mem);
-        return addObjNode(mem->getValue(), node, mem->getId());
+        memToFieldsMap[i].set(i);
+        GlobalObjVar* gObj = new GlobalObjVar(curInst, i, ti);
+        return addObjNode(curInst, gObj);
     }
 
-    inline NodeID addConstantDataObjNode(const SVFValue* curInst, const NodeID i)
+    inline NodeID addConstantDataObjNode(const SVFValue* curInst, const NodeID i, ObjTypeInfo* ti)
     {
-        const MemObj* mem = getMemObj(curInst);
-        NodeID base = mem->getId();
-        memToFieldsMap[base].set(mem->getId());
-        ConstantDataObjVar* node = new ConstantDataObjVar(curInst, mem->getId(), mem);
-        return addObjNode(mem->getValue(), node, mem->getId());
+        memToFieldsMap[i].set(i);
+        ConstantDataObjVar* conObj = new ConstantDataObjVar(curInst, i, ti);
+        return addObjNode(curInst, conObj);
     }
 
     /// Add a unique return node for a procedure
-    inline NodeID addRetNode(const CallGraphNode* callGraphNode, NodeID i)
+    inline NodeID addRetNode(NodeID i, const CallGraphNode* callGraphNode)
     {
-        SVFVar *node = new RetPN(callGraphNode,i);
-        return addRetNode(callGraphNode, node, i);
+        SVFVar *node = new RetPN(i, callGraphNode);
+        return addRetNode(callGraphNode, node);
     }
     /// Add a unique vararg node for a procedure
-    inline NodeID addVarargNode(const CallGraphNode* val, NodeID i)
+    inline NodeID addVarargNode(NodeID i, const CallGraphNode* val)
     {
-        SVFVar *node = new VarArgPN(val,i);
-        return addNode(node,i);
+        SVFVar *node = new VarArgPN(i, val);
+        return addNode(node);
     }
 
     /// Add a temp field value node, this method can only invoked by getGepValVar
     NodeID addGepValNode(const SVFValue* curInst,const SVFValue* val, const AccessPath& ap, NodeID i, const SVFType* type);
     /// Add a field obj node, this method can only invoked by getGepObjVar
-    NodeID addGepObjNode(const MemObj* obj, const APOffset& apOffset, const NodeID gepId);
+    NodeID addGepObjNode(const BaseObjVar* baseObj, const APOffset& apOffset, const NodeID gepId);
     /// Add a field-insensitive node, this method can only invoked by getFIGepObjNode
-    NodeID addFIObjNode(const MemObj* obj);
+    NodeID addFIObjNode(const SVFValue* val, NodeID i, ObjTypeInfo* ti)
+    {
+        memToFieldsMap[i].set(i);
+        BaseObjVar* baseObj = new BaseObjVar(val, i, ti);
+        return addObjNode(val, baseObj);
+    }
+
 
     //@}
 
@@ -727,28 +701,30 @@ private:
     //@{
     inline NodeID addDummyValNode(NodeID i)
     {
-        return addValNode(nullptr, new DummyValVar(i), i);
+        return addValNode(nullptr, new DummyValVar(i));
     }
     inline NodeID addDummyObjNode(NodeID i, const SVFType* type)
     {
-        const MemObj* mem = addDummyMemObj(i, type);
-        return addObjNode(nullptr, new DummyObjVar(i,mem), i);
-    }
-    inline const MemObj* addDummyMemObj(NodeID i, const SVFType* type)
-    {
-        return getSymbolInfo()->createDummyObj(i,type);
+        if (symInfo->idToObjTypeInfoMap().find(i) == symInfo->idToObjTypeInfoMap().end())
+        {
+            ObjTypeInfo* ti = symInfo->createObjTypeInfo(type);
+            symInfo->idToObjTypeInfoMap()[i] = ti;
+            return addObjNode(nullptr, new DummyObjVar(i, ti));
+        }
+        else
+        {
+            return addObjNode(nullptr, new DummyObjVar(i, symInfo->getObjTypeInfo(i)));
+        }
     }
+
     inline NodeID addBlackholeObjNode()
     {
         return addObjNode(
-                   nullptr, new DummyObjVar(getBlackHoleNode(), getBlackHoleObj()),
-                   getBlackHoleNode());
+                   nullptr, new DummyObjVar(getBlackHoleNode(), symInfo->getObjTypeInfo(getBlackHoleNode())));
     }
     inline NodeID addConstantObjNode()
     {
-        return addObjNode(nullptr,
-                          new DummyObjVar(getConstantNode(), getConstantObj()),
-                          getConstantNode());
+        return addObjNode(nullptr, new DummyObjVar(getConstantNode(), symInfo->getObjTypeInfo(getConstantNode())));
     }
     inline NodeID addBlackholePtrNode()
     {
@@ -757,30 +733,32 @@ private:
     //@}
 
     /// Add a value (pointer) node
-    inline NodeID addValNode(const SVFValue*, SVFVar *node, NodeID i)
+    inline NodeID addValNode(const SVFValue*, SVFVar *node)
     {
-        assert(hasGNode(i) == false &&
+        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, i);
+        return addNode(node);
     }
     /// Add a memory obj node
-    inline NodeID addObjNode(const SVFValue*, SVFVar *node, NodeID i)
+    inline NodeID addObjNode(const SVFValue*, SVFVar *node)
     {
-        assert(hasGNode(i) == false &&
+        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, i);
+        return addNode(node);
     }
     /// Add a unique return node for a procedure
-    inline NodeID addRetNode(const CallGraphNode*, SVFVar *node, NodeID i)
+    inline NodeID addRetNode(const CallGraphNode*, SVFVar *node)
     {
-        return addNode(node,i);
+        return addNode(node);
     }
     /// Add a unique vararg node for a procedure
-    inline NodeID addVarargNode(const SVFFunction*, SVFVar *node, NodeID i)
+    inline NodeID addVarargNode(const SVFFunction*, SVFVar *node)
     {
-        return addNode(node,i);
+        return addNode(node);
     }
 
     /// Add global PAGEdges (not in a procedure)