svf-lib 1.0.1276 → 1.0.1278

package/SVF-linux/include/Graphs/ConsGNode.h

@@ -259,56 +259,68 @@ public:
         storeInEdges.insert(inEdge);
         addIncomingEdge(inEdge);
     }
-    inline void addIncomingDirectEdge(ConstraintEdge* inEdge)
+    inline bool addIncomingDirectEdge(ConstraintEdge* inEdge)
     {
         assert(inEdge->getDstID() == this->getId());
         bool added1 = directInEdges.insert(inEdge).second;
         bool added2 = addIncomingEdge(inEdge);
-        assert(added1 && added2 && "edge not added, duplicated adding!!");
+        bool both_added = added1 & added2;
+        assert(both_added && "edge not added, duplicated adding!!");
+        return both_added;
     }
     inline void addOutgoingAddrEdge(AddrCGEdge* outEdge)
     {
         addressOutEdges.insert(outEdge);
         addOutgoingEdge(outEdge);
     }
-    inline void addOutgoingLoadEdge(LoadCGEdge* outEdge)
+    inline bool addOutgoingLoadEdge(LoadCGEdge* outEdge)
     {
         bool added1 = loadOutEdges.insert(outEdge).second;
         bool added2 = addOutgoingEdge(outEdge);
-        assert(added1 && added2 && "edge not added, duplicated adding!!");
+        bool both_added = added1 & added2;
+        assert(both_added && "edge not added, duplicated adding!!");
+        return both_added;
     }
-    inline void addOutgoingStoreEdge(StoreCGEdge* outEdge)
+    inline bool addOutgoingStoreEdge(StoreCGEdge* outEdge)
     {
         bool added1 = storeOutEdges.insert(outEdge).second;
         bool added2 = addOutgoingEdge(outEdge);
-        assert(added1 && added2 && "edge not added, duplicated adding!!");
+        bool both_added = added1 & added2;
+        assert(both_added && "edge not added, duplicated adding!!");
+        return both_added;
     }
-    inline void addOutgoingDirectEdge(ConstraintEdge* outEdge)
+    inline bool addOutgoingDirectEdge(ConstraintEdge* outEdge)
     {
         assert(outEdge->getSrcID() == this->getId());
         bool added1 = directOutEdges.insert(outEdge).second;
         bool added2 = addOutgoingEdge(outEdge);
-        assert(added1 && added2 && "edge not added, duplicated adding!!");
+        bool both_added = added1 & added2;
+        assert(both_added && "edge not added, duplicated adding!!");
+        return both_added;
     }
     //@}
 
     /// Remove constraint graph edges
     //{@
-    inline void removeOutgoingAddrEdge(AddrCGEdge* outEdge)
+    inline bool removeOutgoingAddrEdge(AddrCGEdge* outEdge)
     {
         u32_t num1 = addressOutEdges.erase(outEdge);
         u32_t num2 = removeOutgoingEdge(outEdge);
-        assert((num1 && num2) && "edge not in the set, can not remove!!!");
+        bool removed = (num1 > 0) & (num2 > 0);
+        assert(removed && "edge not in the set, can not remove!!!");
+        return removed;
     }
 
-    inline void removeIncomingAddrEdge(AddrCGEdge* inEdge)
+    inline bool removeIncomingAddrEdge(AddrCGEdge* inEdge)
     {
         u32_t num1 = addressInEdges.erase(inEdge);
         u32_t num2 = removeIncomingEdge(inEdge);
-        assert((num1 && num2) && "edge not in the set, can not remove!!!");
+        bool removed = (num1 > 0) & (num2 > 0);
+        assert(removed && "edge not in the set, can not remove!!!");
+        return removed;
     }
 
-    inline void removeOutgoingDirectEdge(ConstraintEdge* outEdge)
+    inline bool removeOutgoingDirectEdge(ConstraintEdge* outEdge)
     {
         if (SVFUtil::isa<GepCGEdge>(outEdge))
             gepOutEdges.erase(outEdge);
@@ -316,10 +328,12 @@ public:
             copyOutEdges.erase(outEdge);
         u32_t num1 = directOutEdges.erase(outEdge);
         u32_t num2 = removeOutgoingEdge(outEdge);
-        assert((num1 && num2) && "edge not in the set, can not remove!!!");
+        bool removed = (num1 > 0) & (num2 > 0);
+        assert(removed && "edge not in the set, can not remove!!!");
+        return removed;
     }
 
-    inline void removeIncomingDirectEdge(ConstraintEdge* inEdge)
+    inline bool removeIncomingDirectEdge(ConstraintEdge* inEdge)
     {
         if (SVFUtil::isa<GepCGEdge>(inEdge))
             gepInEdges.erase(inEdge);
@@ -327,35 +341,45 @@ public:
             copyInEdges.erase(inEdge);
         u32_t num1 = directInEdges.erase(inEdge);
         u32_t num2 = removeIncomingEdge(inEdge);
-        assert((num1 && num2) && "edge not in the set, can not remove!!!");
+        bool removed = (num1 > 0) & (num2 > 0);
+        assert(removed && "edge not in the set, can not remove!!!");
+        return removed;
     }
 
-    inline void removeOutgoingLoadEdge(LoadCGEdge* outEdge)
+    inline bool removeOutgoingLoadEdge(LoadCGEdge* outEdge)
     {
         u32_t num1 = loadOutEdges.erase(outEdge);
         u32_t num2 = removeOutgoingEdge(outEdge);
-        assert((num1 && num2) && "edge not in the set, can not remove!!!");
+        bool removed = (num1 > 0) & (num2 > 0);
+        assert(removed && "edge not in the set, can not remove!!!");
+        return removed;
     }
 
-    inline void removeIncomingLoadEdge(LoadCGEdge* inEdge)
+    inline bool removeIncomingLoadEdge(LoadCGEdge* inEdge)
     {
         u32_t num1 = loadInEdges.erase(inEdge);
         u32_t num2 = removeIncomingEdge(inEdge);
-        assert((num1 && num2) && "edge not in the set, can not remove!!!");
+        bool removed = (num1 > 0) & (num2 > 0);
+        assert(removed && "edge not in the set, can not remove!!!");
+        return removed;
     }
 
-    inline void removeOutgoingStoreEdge(StoreCGEdge* outEdge)
+    inline bool removeOutgoingStoreEdge(StoreCGEdge* outEdge)
     {
         u32_t num1 = storeOutEdges.erase(outEdge);
         u32_t num2 = removeOutgoingEdge(outEdge);
-        assert((num1 && num2) && "edge not in the set, can not remove!!!");
+        bool removed = (num1 > 0) & (num2 > 0);
+        assert(removed && "edge not in the set, can not remove!!!");
+        return removed;
     }
 
-    inline void removeIncomingStoreEdge(StoreCGEdge* inEdge)
+    inline bool removeIncomingStoreEdge(StoreCGEdge* inEdge)
     {
         u32_t num1 = storeInEdges.erase(inEdge);
         u32_t num2 = removeIncomingEdge(inEdge);
-        assert((num1 && num2) && "edge not in the set, can not remove!!!");
+        bool removed = (num1 > 0) & (num2 > 0);
+        assert(removed && "edge not in the set, can not remove!!!");
+        return removed;
     }
     //@}
 

package/SVF-linux/include/Graphs/GenericGraph.h

@@ -292,13 +292,15 @@ public:
     {
         iterator it = InEdges.find(edge);
         assert(it != InEdges.end() && "can not find in edge in SVFG node");
-        return InEdges.erase(edge);
+        InEdges.erase(it);
+        return 1;
     }
     inline u32_t removeOutgoingEdge(EdgeType* edge)
     {
         iterator it = OutEdges.find(edge);
         assert(it != OutEdges.end() && "can not find out edge in SVFG node");
-        return OutEdges.erase(edge);
+        OutEdges.erase(it);
+        return 1;
     }
     ///@}
 

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

@@ -179,8 +179,9 @@ protected:
     {
         bool added1 = edge->getDstNode()->addIncomingEdge(edge);
         bool added2 = edge->getSrcNode()->addOutgoingEdge(edge);
-        assert(added1 && added2 && "edge not added??");
-        return true;
+        bool all_added = added1 && added2;
+        assert(all_added && "ICFGEdge not added?");
+        return all_added;
     }
 
     /// Add a ICFG node

package/SVF-linux/include/Graphs/SVFGOPT.h

@@ -261,23 +261,23 @@ private:
     {
         PAGNodeToDefMapTy::iterator it = PAGNodeToDefMap.find(pagNode);
         assert(it != PAGNodeToDefMap.end() && "a SVFIR node doesn't have definition before");
-        PAGNodeToDefMap[pagNode] = node->getId();
+        it->second = node->getId();
     }
 
     /// Set def-site of actual-in/formal-out.
     ///@{
     inline void setActualINDef(NodeID ai, NodeID def)
     {
-        NodeIDToNodeIDMap::const_iterator it = actualInToDefMap.find(ai);
-        assert(it == actualInToDefMap.end() && "can not set actual-in's def twice");
-        actualInToDefMap[ai] = def;
+        bool inserted = actualInToDefMap.emplace(ai, def).second;
+        (void)inserted; // Suppress warning of unused variable under release build
+        assert(inserted && "can not set actual-in's def twice");
         defNodes.set(def);
     }
     inline void setFormalOUTDef(NodeID fo, NodeID def)
     {
-        NodeIDToNodeIDMap::const_iterator it = formalOutToDefMap.find(fo);
-        assert(it == formalOutToDefMap.end() && "can not set formal-out's def twice");
-        formalOutToDefMap[fo] = def;
+        bool inserted = formalOutToDefMap.emplace(fo, def).second;
+        (void) inserted;
+        assert(inserted && "can not set formal-out's def twice");
         defNodes.set(def);
     }
     ///@}

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

@@ -340,8 +340,9 @@ public:
     {
         bool added1 = edge->getDstNode()->addIncomingEdge(edge);
         bool added2 = edge->getSrcNode()->addOutgoingEdge(edge);
-        assert(added1 && added2 && "edge not added??");
-        return true;
+        bool both_added = added1 & added2;
+        assert(both_added && "VFGEdge not added??");
+        return both_added;
     }
 
 protected:

package/SVF-linux/include/MSSA/MemSSA.h

@@ -324,9 +324,9 @@ public:
     {
         if (const LoadStmt* load = SVFUtil::dyn_cast<LoadStmt>(inst))
         {
-            assert(0 != load2MuSetMap.count(load)
-                   && "not associated with mem region!");
-            return true;
+            bool hasMu = load2MuSetMap.count(load) != 0;
+            assert(hasMu && "not associated with mem region!");
+            return hasMu;
         }
         else
             return false;
@@ -336,9 +336,9 @@ public:
         if (const StoreStmt* store = SVFUtil::dyn_cast<StoreStmt>(
                                          inst))
         {
-            assert(0 != store2ChiSetMap.count(store)
-                   && "not associated with mem region!");
-            return true;
+            bool has_store = store2ChiSetMap.count(store) != 0;
+            assert(has_store && "not associated with mem region!");
+            return has_store;
         }
         else
             return false;

package/SVF-linux/include/MemoryModel/PersistentPointsToDS.h

@@ -363,7 +363,7 @@ public:
     virtual inline const KeySet& getRevPts(const Data&) override
     {
         assert(false && "PersistentDFPTData::getRevPts: not supported yet!");
-        return *(KeySet*)nullptr; // suppress -Werror=return-type
+        abort();
     }
 
     virtual inline bool unionPts(const Key& dstKey, const Key& srcKey) override

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

@@ -456,6 +456,7 @@ private:
     inline void addToStmt2TypeMap(SVFStmt* edge)
     {
         bool added = KindToSVFStmtSetMap[edge->getEdgeKind()].insert(edge).second;
+        (void)added; // Suppress warning of unused variable under release build
         assert(added && "duplicated edge, not added!!!");
         if (edge->isPTAEdge())
         {
@@ -494,7 +495,8 @@ private:
     /// Add indirect callsites
     inline void addIndirectCallsites(const CallICFGNode* cs,NodeID funPtr)
     {
-        bool added = indCallSiteToFunPtrMap.insert(std::make_pair(cs,funPtr)).second;
+        bool added = indCallSiteToFunPtrMap.emplace(cs, funPtr).second;
+        (void) added;
         funPtrToCallSitesMap[funPtr].insert(cs);
         assert(added && "adding the same indirect callsite twice?");
     }

package/SVF-linux/include/SABER/SaberCondAllocator.h

@@ -148,7 +148,9 @@ public:
     {
         const SVFFunction*  keyFunc = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(bbKey->getParent());
         const SVFFunction*  valueFunc = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(bbValue->getParent());
-        assert((keyFunc == valueFunc) && "two basicblocks should be in the same function!");
+        bool funcEq = (keyFunc == valueFunc);
+        (void)funcEq; // Suppress warning of unused variable under release build
+        assert(funcEq && "two basicblocks should be in the same function!");
 
         return keyFunc->postDominate(bbKey,bbValue);
     }
@@ -157,7 +159,10 @@ public:
     {
         const SVFFunction*  keyFunc = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(bbKey->getParent());
         const SVFFunction*  valueFunc = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(bbValue->getParent());
-        assert((keyFunc == valueFunc) && "two basicblocks should be in the same function!");
+        bool funcEq = (keyFunc == valueFunc);
+        (void)funcEq; // Suppress warning of unused variable under release build
+
+        assert(funcEq && "two basicblocks should be in the same function!");
 
         return keyFunc->dominate(bbKey,bbValue);
     }

package/SVF-linux/include/SVF-FE/IRAnnotator.h

@@ -101,7 +101,9 @@ private:
             LocationSet locationSet = LocationSet(locationSetOffset);
             SVF::NodeID gepnodeId = pag->getGepObjVar(baseNodeId, locationSet);
 
-            assert(nodeId == gepnodeId && "nodeId != gepnodeId");
+            bool idEq = (nodeId == gepnodeId);
+            (void)idEq; // Suppress warning of unused variable under release build
+            assert(idEq && "nodeId is not equal to gepnodeId?");
         }
     }
 

package/SVF-linux/include/Util/SparseBitVector.h

@@ -321,6 +321,7 @@ public:
             if (Bits[i] != 0)
                 return i * BITWORD_SIZE + countTrailingZeros(Bits[i]);
         assert(false && "SBV: find_first: SBV cannot be empty");
+        abort();
     }
 
     /// find_last - Returns the index of the last set bit.
@@ -334,6 +335,7 @@ public:
                        countLeadingZeros(Bits[Idx]) - 1;
         }
         assert(false && "SBV: find_last: SBV cannot be empty");
+        abort();
     }
 
     /// find_next - Returns the index of the next set bit starting from the

package/SVF-osx/include/DDA/DDAVFSolver.h

@@ -470,9 +470,8 @@ protected:
         assert(obj && "object not found!!");
         if(obj->isStack())
         {
-            if(const Function* fun = _pag->getGNode(id)->getFunction())
+            if(const SVFFunction* svffun = _pag->getGNode(id)->getFunction())
             {
-                const SVFFunction* svffun = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(fun);
                 return _callGraphSCC->isInCycle(_callGraph->getCallGraphNode(svffun)->getId());
             }
         }

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

@@ -58,9 +58,9 @@ public:
 
     typedef Map<const SVFFunction*, FunEntryICFGNode *> FunToFunEntryNodeMapTy;
     typedef Map<const SVFFunction*, FunExitICFGNode *> FunToFunExitNodeMapTy;
-    typedef Map<const Instruction*, CallICFGNode *> CSToCallNodeMapTy;
-    typedef Map<const Instruction*, RetICFGNode *> CSToRetNodeMapTy;
-    typedef Map<const Instruction*, IntraICFGNode *> InstToBlockNodeMapTy;
+    typedef Map<const SVFInstruction*, CallICFGNode *> CSToCallNodeMapTy;
+    typedef Map<const SVFInstruction*, RetICFGNode *> CSToRetNodeMapTy;
+    typedef Map<const SVFInstruction*, IntraICFGNode *> InstToBlockNodeMapTy;
     typedef std::vector<const SVFLoop *> SVFLoopVec;
     typedef Map<const ICFGNode *, SVFLoopVec> ICFGNodeToSVFLoopVec;
 
@@ -122,7 +122,7 @@ public:
     }
 
     /// Whether node is in a loop
-    inline bool isInLoop(const Instruction *inst)
+    inline bool isInLoop(const SVFInstruction* inst)
     {
         return isInLoop(getICFGNode(inst));
     }
@@ -159,8 +159,8 @@ protected:
     //@{
     ICFGEdge* addIntraEdge(ICFGNode* srcNode, ICFGNode* dstNode);
     ICFGEdge* addConditionalIntraEdge(ICFGNode* srcNode, ICFGNode* dstNode, const Value* condition, s32_t branchCondVal);
-    ICFGEdge* addCallEdge(ICFGNode* srcNode, ICFGNode* dstNode, const Instruction* cs);
-    ICFGEdge* addRetEdge(ICFGNode* srcNode, ICFGNode* dstNode, const Instruction* cs);
+    ICFGEdge* addCallEdge(ICFGNode* srcNode, ICFGNode* dstNode, const SVFInstruction* cs);
+    ICFGEdge* addRetEdge(ICFGNode* srcNode, ICFGNode* dstNode, const SVFInstruction* cs);
     //@}
 
     /// sanitize Intra edges, verify that both nodes belong to the same function.
@@ -194,13 +194,13 @@ public:
     /// Get a basic block ICFGNode
     /// TODO:: need to fix the assertions
     //@{
-    ICFGNode* getICFGNode(const Instruction* inst);
+    ICFGNode* getICFGNode(const SVFInstruction* inst);
 
-    CallICFGNode* getCallICFGNode(const Instruction* inst);
+    CallICFGNode* getCallICFGNode(const SVFInstruction* inst);
 
-    RetICFGNode* getRetICFGNode(const Instruction* inst);
+    RetICFGNode* getRetICFGNode(const SVFInstruction* inst);
 
-    IntraICFGNode* getIntraICFGNode(const Instruction* inst);
+    IntraICFGNode* getIntraICFGNode(const SVFInstruction* inst);
 
     FunEntryICFGNode* getFunEntryICFGNode(const SVFFunction*  fun);
 
@@ -220,14 +220,14 @@ public:
 private:
 
     /// Get/Add IntraBlock ICFGNode
-    inline IntraICFGNode* getIntraBlock(const Instruction* inst)
+    inline IntraICFGNode* getIntraBlock(const SVFInstruction* inst)
     {
         InstToBlockNodeMapTy::const_iterator it = InstToBlockNodeMap.find(inst);
         if (it == InstToBlockNodeMap.end())
             return nullptr;
         return it->second;
     }
-    inline IntraICFGNode* addIntraBlock(const Instruction* inst)
+    inline IntraICFGNode* addIntraBlock(const SVFInstruction* inst)
     {
         IntraICFGNode* sNode = new IntraICFGNode(totalICFGNode++,inst);
         addICFGNode(sNode);
@@ -268,14 +268,14 @@ private:
     }
 
     /// Get/Add a call node
-    inline CallICFGNode* addCallBlock(const Instruction* cs)
+    inline CallICFGNode* addCallBlock(const SVFInstruction* cs)
     {
         CallICFGNode* sNode = new CallICFGNode(totalICFGNode++, cs);
         addICFGNode(sNode);
         CSToCallNodeMap[cs] = sNode;
         return sNode;
     }
-    inline CallICFGNode* getCallBlock(const Instruction* cs)
+    inline CallICFGNode* getCallBlock(const SVFInstruction* cs)
     {
         CSToCallNodeMapTy::const_iterator it = CSToCallNodeMap.find(cs);
         if (it == CSToCallNodeMap.end())
@@ -284,14 +284,14 @@ private:
     }
 
     /// Get/Add a return node
-    inline RetICFGNode* getRetBlock(const Instruction* cs)
+    inline RetICFGNode* getRetBlock(const SVFInstruction* cs)
     {
         CSToRetNodeMapTy::const_iterator it = CSToRetNodeMap.find(cs);
         if (it == CSToRetNodeMap.end())
             return nullptr;
         return it->second;
     }
-    inline RetICFGNode* addRetBlock(const Instruction* cs)
+    inline RetICFGNode* addRetBlock(const SVFInstruction* cs)
     {
         CallICFGNode* callBlockNode = getCallICFGNode(cs);
         RetICFGNode* sNode = new RetICFGNode(totalICFGNode++, cs, callBlockNode);

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

@@ -169,16 +169,16 @@ class CallCFGEdge : public ICFGEdge
 {
 
 private:
-    const Instruction*  cs;
+    const SVFInstruction*  cs;
     std::vector<const CallPE*> callPEs;
 public:
     /// Constructor
-    CallCFGEdge(ICFGNode* s, ICFGNode* d, const Instruction*  c):
+    CallCFGEdge(ICFGNode* s, ICFGNode* d, const SVFInstruction*  c):
         ICFGEdge(s,d,CallCF),cs(c)
     {
     }
     /// Return callsite ID
-    inline const Instruction*  getCallSite() const
+    inline const SVFInstruction*  getCallSite() const
     {
         return cs;
     }
@@ -217,16 +217,16 @@ class RetCFGEdge : public ICFGEdge
 {
 
 private:
-    const Instruction*  cs;
+    const SVFInstruction*  cs;
     const RetPE* retPE;
 public:
     /// Constructor
-    RetCFGEdge(ICFGNode* s, ICFGNode* d, const Instruction*  c):
+    RetCFGEdge(ICFGNode* s, ICFGNode* d, const SVFInstruction*  c):
         ICFGEdge(s,d,RetCF),cs(c),retPE(nullptr)
     {
     }
     /// Return callsite ID
-    inline const Instruction*  getCallSite() const
+    inline const SVFInstruction*  getCallSite() const
     {
         return cs;
     }

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

@@ -83,7 +83,7 @@ public:
     }
 
     /// Return the function of this ICFGNode
-    virtual const BasicBlock* getBB() const
+    virtual const SVFBasicBlock* getBB() const
     {
         return bb;
     }
@@ -130,7 +130,7 @@ public:
 
 protected:
     const SVFFunction* fun;
-    const BasicBlock* bb;
+    const SVFBasicBlock* bb;
     VFGNodeList VFGNodes; //< a list of VFGNodes
     SVFStmtList pagEdges; //< a list of PAGEdges
 
@@ -175,16 +175,16 @@ public:
 class IntraICFGNode : public ICFGNode
 {
 private:
-    const Instruction *inst;
+    const SVFInstruction *inst;
 
 public:
-    IntraICFGNode(NodeID id, const Instruction *i) : ICFGNode(id, IntraBlock), inst(i)
+    IntraICFGNode(NodeID id, const SVFInstruction *i) : ICFGNode(id, IntraBlock), inst(i)
     {
-        fun = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(inst->getFunction());
+        fun = inst->getFunction();
         bb = inst->getParent();
     }
 
-    inline const Instruction *getInst() const
+    inline const SVFInstruction *getInst() const
     {
         return inst;
     }
@@ -366,18 +366,18 @@ class CallICFGNode : public InterICFGNode
 public:
     typedef std::vector<const SVFVar *> ActualParmNodeVec;
 private:
-    const Instruction* cs;
+    const SVFInstruction* cs;
     const RetICFGNode* ret;
     ActualParmNodeVec APNodes;
 public:
-    CallICFGNode(NodeID id, const Instruction* c) : InterICFGNode(id, FunCallBlock), cs(c), ret(nullptr)
+    CallICFGNode(NodeID id, const SVFInstruction* c) : InterICFGNode(id, FunCallBlock), cs(c), ret(nullptr)
     {
-        fun = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(cs->getFunction());
+        fun = cs->getFunction();
         bb = cs->getParent();
     }
 
     /// Return callsite
-    inline const Instruction* getCallSite() const
+    inline const SVFInstruction* getCallSite() const
     {
         return cs;
     }
@@ -398,11 +398,11 @@ public:
     /// Return callsite
     inline const SVFFunction* getCaller() const
     {
-        return LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(cs->getFunction());
+        return cs->getFunction();
     }
 
     /// Return Basic Block
-    inline const BasicBlock* getParent() const
+    inline const SVFBasicBlock* getParent() const
     {
         return cs->getParent();
     }
@@ -459,19 +459,19 @@ class RetICFGNode : public InterICFGNode
 {
 
 private:
-    const Instruction* cs;
+    const SVFInstruction* cs;
     const SVFVar *actualRet;
     const CallICFGNode* callBlockNode;
 public:
-    RetICFGNode(NodeID id, const Instruction* c, CallICFGNode* cb) :
+    RetICFGNode(NodeID id, const SVFInstruction* c, CallICFGNode* cb) :
         InterICFGNode(id, FunRetBlock), cs(c), actualRet(nullptr), callBlockNode(cb)
     {
-        fun = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(cs->getFunction());
+        fun = cs->getFunction();
         bb = cs->getParent();
     }
 
     /// Return callsite
-    inline const Instruction* getCallSite() const
+    inline const SVFInstruction* getCallSite() const
     {
         return cs;
     }

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

@@ -78,7 +78,7 @@ protected:
     SVFStmt* hasLabeledEdge(SVFVar* src, SVFVar* op1, SVFStmt::PEDGEK kind, const SVFVar* op2);
 
     /// Map a value to a set of edges
-    inline void mapValueToEdge(const Value *V, SVFStmt *edge)
+    inline void mapValueToEdge(const Value* V, SVFStmt *edge)
     {
         auto inserted = valueToEdgeMap.emplace(V, SVFStmtSet{edge});
         if (!inserted.second)
@@ -108,7 +108,7 @@ public:
         return fromFile;
     }
     /// Get all SVFIR Edges that corresponds to an LLVM value
-    inline const SVFStmtSet& getValueEdges(const Value *V)
+    inline const SVFStmtSet& getValueEdges(const Value* V)
     {
         auto it = valueToEdgeMap.find(V);
         if (it == valueToEdgeMap.end())
@@ -121,7 +121,7 @@ public:
 
     /// Get SVFIR Node according to LLVM value
     ///getNode - Return the node corresponding to the specified pointer.
-    inline NodeID getValueNode(const Value *V)
+    inline NodeID getValueNode(const Value* V)
     {
         return symInfo->getValSym(V);
     }
@@ -131,19 +131,19 @@ public:
     }
     /// getObject - Return the obj node id refer to the memory object for the
     /// specified global, heap or alloca instruction according to llvm value.
-    inline NodeID getObjectNode(const Value *V)
+    inline NodeID getObjectNode(const Value* V)
     {
         return symInfo->getObjSym(V);
     }
     /// GetReturnNode - Return the unique node representing the return value of a function
     inline NodeID getReturnNode(const SVFFunction* func) const
     {
-        return symInfo->getRetSym(func->getLLVMFun());
+        return symInfo->getRetSym(func);
     }
     /// getVarargNode - Return the unique node representing the variadic argument of a variadic function.
     inline NodeID getVarargNode(const SVFFunction* func) const
     {
-        return symInfo->getVarargSym(func->getLLVMFun());
+        return symInfo->getVarargSym(func);
     }
     inline NodeID getBlackHoleNode() const
     {

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

@@ -163,8 +163,8 @@ class ThreadCallGraph: public PTACallGraph
 public:
     typedef Set<const CallICFGNode*> InstSet;
     typedef InstSet CallSiteSet;
-    typedef std::vector<const Instruction*> InstVector;
-    typedef Map<const Instruction*, InstSet> CallToInstMap;
+    typedef std::vector<const SVFInstruction*> InstVector;
+    typedef Map<const SVFInstruction*, InstSet> CallToInstMap;
     typedef Set<CallSiteSet*> CtxSet;
     typedef ThreadForkEdge::ForkEdgeSet ForkEdgeSet;
     typedef Map<const CallICFGNode*, ForkEdgeSet> CallInstToForkEdgesMap;