svf-tools 1.0.980 → 1.0.981

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.980",
+  "version": "1.0.981",
   "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/Graphs/ICFG.h

@@ -198,12 +198,21 @@ public:
     //@{
     ICFGNode* getICFGNode(const SVFInstruction* inst);
 
+    /// Whether has the ICFGNode
+    bool hasICFGNode(const SVFInstruction* inst);
+
     CallICFGNode* getCallICFGNode(const SVFInstruction* inst);
 
+    CallICFGNode* addCallICFGNode(const SVFInstruction* inst);
+
     RetICFGNode* getRetICFGNode(const SVFInstruction* inst);
 
+    RetICFGNode* addRetICFGNode(const SVFInstruction* inst);
+
     IntraICFGNode* getIntraICFGNode(const SVFInstruction* inst);
 
+    IntraICFGNode* addIntraICFGNode(const SVFInstruction* inst);
+
     FunEntryICFGNode* getFunEntryICFGNode(const SVFFunction*  fun);
 
     FunExitICFGNode* getFunExitICFGNode(const SVFFunction*  fun);

package/svf/include/MSSA/MemRegion.h

@@ -470,9 +470,9 @@ public:
     }
     //@}
     /// Whether this instruction has SVFIR Edge
-    bool hasSVFStmtList(const SVFInstruction* inst);
+    bool hasSVFStmtList(const ICFGNode* icfgNode);
     /// Given an instruction, get all its the PAGEdge (statement) in sequence
-    SVFStmtList& getPAGEdgesFromInst(const SVFInstruction* inst);
+    SVFStmtList& getPAGEdgesFromInst(const ICFGNode* node);
 
     /// getModRefInfo APIs
     //@{

package/svf/include/MTA/MHP.h

@@ -341,8 +341,7 @@ public:
         NodeID parentTid = tct->getParentThread(tid);
         const CxtThread& parentct = tct->getTCTNode(parentTid)->getCxtThread();
         const SVFFunction* parentRoutine = tct->getStartRoutineOfCxtThread(parentct);
-        const SVFInstruction* inst = parentRoutine->getExitBB()->back();
-        return tct->getICFGNode(inst);
+        return parentRoutine->getExitBB()->back();
     }
 
     /// Get loop for join site

package/svf/include/SVFIR/SVFIR.h

@@ -658,7 +658,7 @@ private:
     /// Add Load edge
     LoadStmt* addLoadStmt(NodeID src, NodeID dst);
     /// Add Store edge
-    StoreStmt* addStoreStmt(NodeID src, NodeID dst, const IntraICFGNode* val);
+    StoreStmt* addStoreStmt(NodeID src, NodeID dst, const ICFGNode* val);
     /// Add Call edge
     CallPE* addCallPE(NodeID src, NodeID dst, const CallICFGNode* cs,
                       const FunEntryICFGNode* entry);

package/svf/include/SVFIR/SVFStatements.h

@@ -478,7 +478,7 @@ public:
     //@}
 
     /// constructor
-    StoreStmt(SVFVar* s, SVFVar* d, const IntraICFGNode* st);
+    StoreStmt(SVFVar* s, SVFVar* d, const ICFGNode* st);
 
     virtual const std::string toString() const override;
 };

package/svf/include/SVFIR/SVFValue.h

@@ -524,6 +524,8 @@ public:
     }
 };
 
+class ICFGNode;
+
 class SVFBasicBlock : public SVFValue
 {
     friend class LLVMModuleSet;
@@ -531,21 +533,26 @@ class SVFBasicBlock : public SVFValue
     friend class SVFIRReader;
     friend class SVFIRBuilder;
     friend class SVFFunction;
+    friend class ICFGBuilder;
+    friend class ICFG;
 
 public:
-    typedef std::vector<const SVFInstruction*>::const_iterator const_iterator;
+    typedef std::vector<const ICFGNode*>::const_iterator const_iterator;
 
 private:
-    std::vector<const SVFInstruction*> allInsts;    ///< all Instructions in this BasicBlock
+    std::vector<const ICFGNode*> allICFGNodes;    ///< all ICFGNodes in this BasicBlock
     std::vector<const SVFBasicBlock*> succBBs;  ///< all successor BasicBlocks of this BasicBlock
     std::vector<const SVFBasicBlock*> predBBs;  ///< all predecessor BasicBlocks of this BasicBlock
     const SVFFunction* fun;                 /// Function where this BasicBlock is
 
 protected:
     ///@{ attributes to be set only through Module builders e.g., LLVMModule
-    inline void addInstruction(const SVFInstruction* inst)
+
+    inline void addICFGNode(const ICFGNode* icfgNode)
     {
-        allInsts.push_back(inst);
+        assert(std::find(getICFGNodeList().begin(), getICFGNodeList().end(),
+                         icfgNode) == getICFGNodeList().end() && "duplicated icfgnode");
+        allICFGNodes.push_back(icfgNode);
     }
 
     inline void addSuccBasicBlock(const SVFBasicBlock* succ)
@@ -570,19 +577,19 @@ public:
         return node->getKind() == SVFBB;
     }
 
-    inline const std::vector<const SVFInstruction*>& getInstructionList() const
+    inline const std::vector<const ICFGNode*>& getICFGNodeList() const
     {
-        return allInsts;
+        return allICFGNodes;
     }
 
     inline const_iterator begin() const
     {
-        return allInsts.begin();
+        return allICFGNodes.begin();
     }
 
     inline const_iterator end() const
     {
-        return allInsts.end();
+        return allICFGNodes.end();
     }
 
     inline const SVFFunction* getParent() const
@@ -595,20 +602,18 @@ public:
         return fun;
     }
 
-    inline const SVFInstruction* front() const
+    inline const ICFGNode* front() const
     {
-        return allInsts.front();
+        assert(!allICFGNodes.empty() && "bb empty?");
+        return allICFGNodes.front();
     }
 
-    inline const SVFInstruction* back() const
+    inline const ICFGNode* back() const
     {
-        return allInsts.back();
+        assert(!allICFGNodes.empty() && "bb empty?");
+        return allICFGNodes.back();
     }
 
-    /// Returns the terminator instruction if the block is well formed or null
-    /// if the block is not well formed.
-    const SVFInstruction* getTerminator() const;
-
     inline const std::vector<const SVFBasicBlock*>& getSuccessors() const
     {
         return succBBs;

package/svf/include/Util/SVFUtil.h

@@ -168,6 +168,8 @@ void dumpPointsToList(const PointsToList& ptl);
 
 /// Return true if it is an llvm intrinsic instruction
 bool isIntrinsicInst(const SVFInstruction* inst);
+bool isIntrinsicInst(const ICFGNode* inst);
+
 //@}
 
 /// Whether an instruction is a call or invoke instruction
@@ -184,6 +186,10 @@ inline bool isCallSite(const SVFValue* val)
         return false;
 }
 
+bool isCallSite(const ICFGNode* inst);
+
+bool isRetInstNode(const ICFGNode* node);
+
 /// Whether an instruction is a callsite in the application code, excluding llvm intrinsic calls
 inline bool isNonInstricCallSite(const SVFInstruction* inst)
 {
@@ -192,6 +198,14 @@ inline bool isNonInstricCallSite(const SVFInstruction* inst)
     return isCallSite(inst);
 }
 
+/// Whether an instruction is a callsite in the application code, excluding llvm intrinsic calls
+inline bool isNonInstricCallSite(const ICFGNode* inst)
+{
+    if(isIntrinsicInst(inst))
+        return false;
+    return isCallSite(inst);
+}
+
 /// Return LLVM callsite given an instruction
 inline CallSite getSVFCallSite(const SVFInstruction* inst)
 {
@@ -250,6 +264,8 @@ inline const SVFFunction* getCallee(const SVFInstruction *inst)
     CallSite cs(inst);
     return getCallee(cs);
 }
+
+const SVFFunction* getCallee(const ICFGNode *inst);
 //@}
 
 /// Given a map mapping points-to sets to a count, adds from into to.
@@ -402,27 +418,20 @@ inline bool isArgOfUncalledFunction(const SVFValue* svfval)
 
 /// Return thread fork function
 //@{
-inline const SVFValue* getForkedFun(const CallSite cs)
-{
-    return ThreadAPI::getThreadAPI()->getForkedFun(cs.getInstruction());
-}
 inline const SVFValue* getForkedFun(const SVFInstruction *inst)
 {
     return ThreadAPI::getThreadAPI()->getForkedFun(inst);
 }
 //@}
 
-/// This function servers a allocation wrapper detector
-inline bool isAnAllocationWraper(const SVFInstruction*)
-{
-    return false;
-}
 
 inline bool isExtCall(const CallSite cs)
 {
     return isExtCall(getCallee(cs));
 }
 
+bool isExtCall(const ICFGNode* node);
+
 inline bool isExtCall(const SVFInstruction *inst)
 {
     return isExtCall(getCallee(inst));
@@ -451,10 +460,7 @@ inline bool isHeapAllocExtCallViaRet(const SVFInstruction *inst)
     return isPtrTy && isHeapAllocExtFunViaRet(getCallee(inst));
 }
 
-inline bool isHeapAllocExtCall(const CallSite cs)
-{
-    return isHeapAllocExtCallViaRet(cs) || isHeapAllocExtCallViaArg(cs);
-}
+bool isHeapAllocExtCall(const ICFGNode* cs);
 
 inline bool isHeapAllocExtCall(const SVFInstruction *inst)
 {
@@ -477,10 +483,6 @@ inline bool isReallocExtCall(const CallSite cs)
 
 /// Return true if this is a thread creation call
 ///@{
-inline bool isThreadForkCall(const CallSite cs)
-{
-    return ThreadAPI::getThreadAPI()->isTDFork(cs.getInstruction());
-}
 inline bool isThreadForkCall(const SVFInstruction *inst)
 {
     return ThreadAPI::getThreadAPI()->isTDFork(inst);

package/svf/lib/AE/Svfexe/AbstractInterpretation.cpp

@@ -845,9 +845,8 @@ void AbstractInterpretation::SkipRecursiveCall(const CallICFGNode *callNode)
     FIFOWorkList<const ICFGNode *> instWorklist;
     for (const SVFBasicBlock * bb: callfun->getReachableBBs())
     {
-        for (const SVFInstruction* inst: bb->getInstructionList())
+        for (const ICFGNode* node: bb->getICFGNodeList())
         {
-            const ICFGNode* node = icfg->getICFGNode(inst);
             for (const SVFStmt *stmt: node->getSVFStmts())
             {
                 if (const StoreStmt *store = SVFUtil::dyn_cast<StoreStmt>(stmt))

package/svf/lib/Graphs/ICFG.cpp

@@ -119,7 +119,8 @@ const std::string FunExitICFGNode::toString() const
     rawstr << " {fun: " << fun->getName();
     // ensure the enclosing function has exit basic block
     if (!isExtCall(fun) && fun->hasReturn())
-        rawstr << fun->getExitBB()->front()->getSourceLoc();
+        if(const IntraICFGNode* intraICFGNode = dyn_cast<IntraICFGNode>(fun->getExitBB()->front()))
+            rawstr << intraICFGNode->getInst()->getSourceLoc();
     rawstr << "}";
     for (const SVFStmt *stmt : getSVFStmts())
         rawstr << "\n" << stmt->toString();
@@ -229,7 +230,6 @@ ICFGNode* ICFG::getICFGNode(const SVFInstruction* inst)
         node = getCallICFGNode(inst);
     else if(SVFUtil::isIntrinsicInst(inst))
         node = getIntraICFGNode(inst);
-//			assert (false && "associating an intrinsic instruction with an ICFGNode!");
     else
         node = getIntraICFGNode(inst);
 
@@ -237,39 +237,70 @@ ICFGNode* ICFG::getICFGNode(const SVFInstruction* inst)
     return node;
 }
 
+bool ICFG::hasICFGNode(const SVF::SVFInstruction* inst)
+{
+    ICFGNode* node;
+    if(SVFUtil::isNonInstricCallSite(inst))
+        node = getCallBlock(inst);
+    else if(SVFUtil::isIntrinsicInst(inst))
+        node = getIntraBlock(inst);
+    else
+        node = getIntraBlock(inst);
+
+    return node != nullptr;
+}
+
 
 CallICFGNode* ICFG::getCallICFGNode(const SVFInstruction* inst)
 {
-    if(SVFUtil::isCallSite(inst) ==false)
-        outs() << inst->toString() << "\n";
     assert(SVFUtil::isCallSite(inst) && "not a call instruction?");
     assert(SVFUtil::isNonInstricCallSite(inst) && "associating an intrinsic debug instruction with an ICFGNode!");
     CallICFGNode* node = getCallBlock(inst);
-    if(node==nullptr)
-        node = addCallBlock(inst);
     assert (node!=nullptr && "no CallICFGNode for this instruction?");
     return node;
 }
 
+CallICFGNode* ICFG::addCallICFGNode(const SVFInstruction* inst)
+{
+    assert(SVFUtil::isCallSite(inst) && "not a call instruction?");
+    assert(SVFUtil::isNonInstricCallSite(inst) && "associating an intrinsic debug instruction with an ICFGNode!");
+    assert(getCallBlock(inst)==nullptr && "duplicate CallICFGNode");
+    return addCallBlock(inst);
+}
+
 RetICFGNode* ICFG::getRetICFGNode(const SVFInstruction* inst)
 {
     assert(SVFUtil::isCallSite(inst) && "not a call instruction?");
     assert(SVFUtil::isNonInstricCallSite(inst) && "associating an intrinsic debug instruction with an ICFGNode!");
     RetICFGNode* node = getRetBlock(inst);
-    if(node==nullptr)
-        node = addRetBlock(inst);
     assert (node!=nullptr && "no RetICFGNode for this instruction?");
     return node;
 }
 
+RetICFGNode* ICFG::addRetICFGNode(const SVFInstruction* inst)
+{
+    assert(SVFUtil::isCallSite(inst) && "not a call instruction?");
+    assert(SVFUtil::isNonInstricCallSite(inst) && "associating an intrinsic debug instruction with an ICFGNode!");
+    assert(getRetBlock(inst)==nullptr && "duplicate RetICFGNode");
+    return addRetBlock(inst);
+}
+
 IntraICFGNode* ICFG::getIntraICFGNode(const SVFInstruction* inst)
 {
     IntraICFGNode* node = getIntraBlock(inst);
-    if(node==nullptr)
-        node = addIntraBlock(inst);
+    assert (node!=nullptr && "no IntraICFGNode for this instruction?");
     return node;
 }
 
+
+IntraICFGNode* ICFG::addIntraICFGNode(const SVFInstruction* inst)
+{
+    IntraICFGNode* node = getIntraBlock(inst);
+    assert (node==nullptr && "no IntraICFGNode for this instruction?");
+    return addIntraBlock(inst);
+}
+
+
 /// Add a function entry node
 FunEntryICFGNode* ICFG::getFunEntryICFGNode(const SVFFunction*  fun)
 {

package/svf/lib/Graphs/SVFG.cpp

@@ -111,7 +111,11 @@ const std::string MSSAPHISVFGNode::toString() const
     rawstr << ")\n";
 
     rawstr << getResVer()->getMR()->dumpStr();
-    rawstr << getICFGNode()->getBB()->back()->getSourceLoc();
+    if (const IntraICFGNode* intraNode =
+                dyn_cast<IntraICFGNode>(getICFGNode()->getBB()->back()))
+    {
+        rawstr << intraNode->getInst()->getSourceLoc();
+    }
     return rawstr.str();
 }
 
@@ -271,8 +275,8 @@ void SVFG::addSVFGNodesForAddrTakenVars()
         for(PHISet::iterator pi = it->second.begin(), epi = it->second.end(); pi!=epi; ++pi)
         {
             MemSSA::PHI* phi =  *pi;
-            const SVFInstruction* inst = phi->getBasicBlock()->front();
-            addIntraMSSAPHISVFGNode(pag->getICFG()->getICFGNode(inst), phi->opVerBegin(), phi->opVerEnd(),phi->getResVer(), totalVFGNode++);
+            const ICFGNode* inst = phi->getBasicBlock()->front();
+            addIntraMSSAPHISVFGNode(const_cast<ICFGNode*>(inst), phi->opVerBegin(), phi->opVerEnd(),phi->getResVer(), totalVFGNode++);
         }
     }
     /// initialize memory SSA entry chi nodes

package/svf/lib/Graphs/SVFGReadWrite.cpp

@@ -100,8 +100,8 @@ void SVFG::writeToFile(const string& filename)
             // opvers
             f << " >= MVER: {";
             f << *phiNode->getResVer();
-            const SVFInstruction* inst = phiNode->getICFGNode()->getBB()->front();
-            f << "} >= ICFGNodeID: " << pag->getICFG()->getICFGNode(inst)->getId();
+            const ICFGNode* inst = phiNode->getICFGNode()->getBB()->front();
+            f << "} >= ICFGNodeID: " << inst->getId();
             f << " >= OPVers: {";
             for (auto x: opvers)
             {

package/svf/lib/MSSA/MemRegion.cpp

@@ -147,24 +147,26 @@ void MRGenerator::generateMRs()
     updateAliasMRs();
 }
 
-bool MRGenerator::hasSVFStmtList(const SVFInstruction* inst)
+bool MRGenerator::hasSVFStmtList(const ICFGNode* node)
 {
     SVFIR* pag = pta->getPAG();
     if (ptrOnlyMSSA)
-        return pag->hasPTASVFStmtList(pag->getICFG()->getICFGNode(inst));
+        return pag->hasPTASVFStmtList(node);
     else
-        return pag->hasSVFStmtList(pag->getICFG()->getICFGNode(inst));
+        return pag->hasSVFStmtList(node);
 }
 
-SVFIR::SVFStmtList& MRGenerator::getPAGEdgesFromInst(const SVFInstruction* inst)
+
+SVFIR::SVFStmtList& MRGenerator::getPAGEdgesFromInst(const ICFGNode* node)
 {
     SVFIR* pag = pta->getPAG();
     if (ptrOnlyMSSA)
-        return pag->getPTASVFStmtList(pag->getICFG()->getICFGNode(inst));
+        return pag->getPTASVFStmtList(node);
     else
-        return pag->getSVFStmtList(pag->getICFG()->getICFGNode(inst));
+        return pag->getSVFStmtList(node);
 }
 
+
 /*!
  * Generate memory regions for loads/stores
  */
@@ -185,11 +187,9 @@ void MRGenerator::collectModRefForLoadStore()
                 iter != eiter; ++iter)
         {
             const SVFBasicBlock* bb = *iter;
-            for (SVFBasicBlock::const_iterator bit = bb->begin(), ebit = bb->end();
-                    bit != ebit; ++bit)
+            for (const auto& inst: bb->getICFGNodeList())
             {
-                const SVFInstruction* svfInst = *bit;
-                SVFStmtList& pagEdgeList = getPAGEdgesFromInst(svfInst);
+                SVFStmtList& pagEdgeList = getPAGEdgesFromInst(inst);
                 for (SVFStmtList::iterator bit = pagEdgeList.begin(), ebit =
                             pagEdgeList.end(); bit != ebit; ++bit)
                 {
@@ -603,7 +603,7 @@ bool MRGenerator::handleCallsiteModRef(NodeBS& mod, NodeBS& ref, const CallICFGN
     /// if a callee is a heap allocator function, then its mod set of this callsite is the heap object.
     if(isHeapAllocExtCall(cs->getCallSite()))
     {
-        SVFStmtList& pagEdgeList = getPAGEdgesFromInst(cs->getCallSite());
+        SVFStmtList& pagEdgeList = getPAGEdgesFromInst(cs);
         for (SVFStmtList::const_iterator bit = pagEdgeList.begin(),
                 ebit = pagEdgeList.end(); bit != ebit; ++bit)
         {
@@ -669,7 +669,7 @@ NodeBS MRGenerator::getModInfoForCall(const CallICFGNode* cs)
 {
     if (isExtCall(cs->getCallSite()) && !isHeapAllocExtCall(cs->getCallSite()))
     {
-        SVFStmtList& pagEdgeList = getPAGEdgesFromInst(cs->getCallSite());
+        SVFStmtList& pagEdgeList = getPAGEdgesFromInst(cs);
         NodeBS mods;
         for (SVFStmtList::const_iterator bit = pagEdgeList.begin(), ebit =
                     pagEdgeList.end(); bit != ebit; ++bit)
@@ -693,7 +693,7 @@ NodeBS MRGenerator::getRefInfoForCall(const CallICFGNode* cs)
 {
     if (isExtCall(cs->getCallSite()) && !isHeapAllocExtCall(cs->getCallSite()))
     {
-        SVFStmtList& pagEdgeList = getPAGEdgesFromInst(cs->getCallSite());
+        SVFStmtList& pagEdgeList = getPAGEdgesFromInst(cs);
         NodeBS refs;
         for (SVFStmtList::const_iterator bit = pagEdgeList.begin(), ebit =
                     pagEdgeList.end(); bit != ebit; ++bit)

package/svf/lib/MSSA/MemSSA.cpp

@@ -114,7 +114,6 @@ void MemSSA::buildMemSSA(const SVFFunction& fun)
 void MemSSA::createMUCHI(const SVFFunction& fun)
 {
 
-    SVFIR* pag = pta->getPAG();
 
     DBOUT(DMSSA,
           outs() << "\t creating mu chi for function " << fun.getName()
@@ -142,9 +141,8 @@ void MemSSA::createMUCHI(const SVFFunction& fun)
     {
         const SVFBasicBlock* bb = *iter;
         varKills.clear();
-        for (SVFBasicBlock::const_iterator it = bb->begin(), eit = bb->end(); it != eit; ++it)
+        for (const auto& inst: bb->getICFGNodeList())
         {
-            const SVFInstruction* inst = *it;
             if(mrGen->hasSVFStmtList(inst))
             {
                 SVFStmtList& pagEdgeList = mrGen->getPAGEdgesFromInst(inst);
@@ -160,7 +158,7 @@ void MemSSA::createMUCHI(const SVFFunction& fun)
             }
             if (isNonInstricCallSite(inst))
             {
-                const CallICFGNode* cs = pag->getICFG()->getCallICFGNode(inst);
+                const CallICFGNode* cs = cast<CallICFGNode>(inst);
                 if(mrGen->hasRefMRSet(cs))
                     AddCallSiteMU(cs,mrGen->getCallSiteRefMRSet(cs));
 
@@ -263,7 +261,6 @@ void MemSSA::SSARename(const SVFFunction& fun)
 void MemSSA::SSARenameBB(const SVFBasicBlock& bb)
 {
 
-    SVFIR* pag = pta->getPAG();
     // record which mem region needs to pop stack
     MRVector memRegs;
 
@@ -281,13 +278,11 @@ void MemSSA::SSARenameBB(const SVFBasicBlock& bb)
     // 		rewrite r' with top mrver of stack(r)
     // 		rewrite r with new name
 
-    for (SVFBasicBlock::const_iterator it = bb.begin(), eit = bb.end();
-            it != eit; ++it)
+    for (const auto& pNode: bb.getICFGNodeList())
     {
-        const SVFInstruction* inst = *it;
-        if(mrGen->hasSVFStmtList(inst))
+        if(mrGen->hasSVFStmtList(pNode))
         {
-            SVFStmtList& pagEdgeList = mrGen->getPAGEdgesFromInst(inst);
+            SVFStmtList& pagEdgeList = mrGen->getPAGEdgesFromInst(pNode);
             for(SVFStmtList::const_iterator bit = pagEdgeList.begin(), ebit= pagEdgeList.end();
                     bit!=ebit; ++bit)
             {
@@ -300,16 +295,16 @@ void MemSSA::SSARenameBB(const SVFBasicBlock& bb)
 
             }
         }
-        if (isNonInstricCallSite(inst))
+        if (isNonInstricCallSite(pNode))
         {
-            const CallICFGNode* cs = pag->getICFG()->getCallICFGNode(inst);
+            const CallICFGNode* cs = cast<CallICFGNode>(pNode);
             if(mrGen->hasRefMRSet(cs))
                 RenameMuSet(getMUSet(cs));
 
             if(mrGen->hasModMRSet(cs))
                 RenameChiSet(getCHISet(cs),memRegs);
         }
-        else if(inst->isRetInst())
+        else if(isRetInstNode(pNode))
         {
             const SVFFunction* fun = bb.getParent();
             RenameMuSet(getReturnMuSet(fun));
@@ -579,7 +574,6 @@ u32_t MemSSA::getBBPhiNum() const
  */
 void MemSSA::dumpMSSA(OutStream& Out)
 {
-    SVFIR* pag = pta->getPAG();
 
     for (SVFModule::iterator fit = pta->getModule()->begin(), efit = pta->getModule()->end();
             fit != efit; ++fit)
@@ -611,14 +605,12 @@ void MemSSA::dumpMSSA(OutStream& Out)
             }
 
             bool last_is_chi = false;
-            for (SVFBasicBlock::const_iterator it = bb->begin(), eit = bb->end();
-                    it != eit; ++it)
+            for (const auto& inst: bb->getICFGNodeList())
             {
-                const SVFInstruction* inst = *it;
                 bool isAppCall = isNonInstricCallSite(inst) && !isExtCall(inst);
                 if (isAppCall || isHeapAllocExtCall(inst))
                 {
-                    const CallICFGNode* cs = pag->getICFG()->getCallICFGNode(inst);
+                    const CallICFGNode* cs = cast<CallICFGNode>(inst);
                     if(hasMU(cs))
                     {
                         if (!last_is_chi)

package/svf/lib/MTA/LockAnalysis.cpp

@@ -74,9 +74,8 @@ void LockAnalysis::collectLockUnlocksites()
     {
         for (const SVFBasicBlock* bb : F->getBasicBlockList())
         {
-            for (const SVFInstruction* inst : bb->getInstructionList())
+            for (const ICFGNode* icfgNode : bb->getICFGNodeList())
             {
-                const ICFGNode* icfgNode = tct->getICFGNode(inst);
                 if (tcg->getThreadAPI()->isTDRelease(icfgNode))
                 {
                     unlocksites.insert(icfgNode);
@@ -180,8 +179,8 @@ bool LockAnalysis::intraForwardTraverse(const ICFGNode* lockSite, InstSet& unloc
     {
         const ICFGNode *I = worklist.back();
         worklist.pop_back();
-        const SVFInstruction* exitInst = svfFun->getExitBB()->back();
-        if(tct->getICFGNode(exitInst) == I)
+        const ICFGNode* exitInst = svfFun->getExitBB()->back();
+        if(exitInst == I)
             return false;
 
         // Skip the visited Instructions.
@@ -220,7 +219,7 @@ bool LockAnalysis::intraBackwardTraverse(const InstSet& unlockSet, InstSet& back
     for(InstSet::const_iterator it = unlockSet.begin(), eit = unlockSet.end(); it!=eit; ++it)
     {
         const ICFGNode* unlockSite = *it;
-        const SVFInstruction* entryInst = unlockSite->getFun()->getEntryBlock()->back();
+        const ICFGNode* entryInst = unlockSite->getFun()->getEntryBlock()->back();
         worklist.push_back(*it);
 
         while (!worklist.empty())
@@ -228,7 +227,7 @@ bool LockAnalysis::intraBackwardTraverse(const InstSet& unlockSet, InstSet& back
             const ICFGNode *I = worklist.back();
             worklist.pop_back();
 
-            if(tct->getICFGNode(entryInst) == I)
+            if(entryInst == I)
                 return false;
 
             // Skip the visited Instructions.
@@ -337,8 +336,8 @@ void LockAnalysis::analyzeLockSpanCxtStmt()
         if (!isLockCandidateFun(*it))
             continue;
         CallStrCxt cxt;
-        const SVFInstruction* frontInst = (*it)->getEntryBlock()->front();
-        CxtStmt cxtstmt(cxt, tct->getICFGNode(frontInst));
+        const ICFGNode* frontInst = (*it)->getEntryBlock()->front();
+        CxtStmt cxtstmt(cxt, frontInst);
         pushToCTSWorkList(cxtstmt);
     }
 
@@ -375,7 +374,7 @@ void LockAnalysis::analyzeLockSpanCxtStmt()
         {
             handleCall(cts);
         }
-        else if (isa<IntraICFGNode>(curInst) && cast<IntraICFGNode>(curInst)->getInst()->isRetInst())
+        else if (isRetInstNode(curInst))
         {
             handleRet(cts);
         }
@@ -417,8 +416,8 @@ void LockAnalysis::handleFork(const CxtStmt& cts)
             const SVFFunction* svfcallee = (*cgIt)->getDstNode()->getFunction();
             CallStrCxt newCxt = curCxt;
             pushCxt(newCxt,call,svfcallee);
-            const SVFInstruction* svfInst = svfcallee->getEntryBlock()->front();
-            CxtStmt newCts(newCxt, tct->getICFGNode(svfInst));
+            const ICFGNode* svfInst = svfcallee->getEntryBlock()->front();
+            CxtStmt newCts(newCxt, svfInst);
             markCxtStmtFlag(newCts, cts);
         }
     }
@@ -441,8 +440,8 @@ void LockAnalysis::handleCall(const CxtStmt& cts)
                 continue;
             CallStrCxt newCxt = curCxt;
             pushCxt(newCxt, call, svfcallee);
-            const SVFInstruction* svfInst = svfcallee->getEntryBlock()->front();
-            CxtStmt newCts(newCxt, tct->getICFGNode(svfInst));
+            const ICFGNode* svfInst = svfcallee->getEntryBlock()->front();
+            CxtStmt newCts(newCxt, svfInst);
             markCxtStmtFlag(newCts, cts);
         }
     }