svf-tools 1.0.983 → 1.0.985

package/svf/lib/WPA/AndersenSCD.cpp

@@ -281,10 +281,9 @@ bool AndersenSCD::updateCallGraph(const PointerAnalysis::CallSiteToFunPtrMap& ca
     NodePairSet cpySrcNodes;	/// nodes as a src of a generated new copy edge
     for(CallEdgeMap::iterator it = newEdges.begin(), eit = newEdges.end(); it!=eit; ++it )
     {
-        CallSite cs = SVFUtil::getSVFCallSite(it->first);
         for(FunctionSet::iterator cit = it->second.begin(), ecit = it->second.end(); cit!=ecit; ++cit)
         {
-            connectCaller2CalleeParams(cs,*cit,cpySrcNodes);
+            connectCaller2CalleeParams(it->first,*cit,cpySrcNodes);
         }
     }
 

package/svf/lib/WPA/Steensgaard.cpp

@@ -135,12 +135,11 @@ bool Steensgaard::updateCallGraph(const CallSiteToFunPtrMap& callsites)
     for (CallEdgeMap::iterator it = newEdges.begin(), eit = newEdges.end();
             it != eit; ++it)
     {
-        CallSite cs = SVFUtil::getSVFCallSite(it->first);
         for (FunctionSet::iterator cit = it->second.begin(),
                 ecit = it->second.end();
                 cit != ecit; ++cit)
         {
-            connectCaller2CalleeParams(cs, *cit, cpySrcNodes);
+            connectCaller2CalleeParams(it->first, *cit, cpySrcNodes);
         }
     }
     for (NodePairSet::iterator it = cpySrcNodes.begin(),
@@ -156,11 +155,10 @@ bool Steensgaard::updateCallGraph(const CallSiteToFunPtrMap& callsites)
     return (!newEdges.empty());
 }
 
-void Steensgaard::heapAllocatorViaIndCall(CallSite cs, NodePairSet& cpySrcNodes)
+void Steensgaard::heapAllocatorViaIndCall(const CallICFGNode* cs, NodePairSet& cpySrcNodes)
 {
     assert(SVFUtil::getCallee(cs) == nullptr && "not an indirect callsite?");
-    RetICFGNode* retBlockNode =
-        pag->getICFG()->getRetICFGNode(cs.getInstruction());
+    const RetICFGNode* retBlockNode = cs->getRetICFGNode();
     const PAGNode* cs_return = pag->getCallSiteRet(retBlockNode);
     NodeID srcret;
     CallSite2DummyValPN::const_iterator it = callsite2DummyValPN.find(cs);
@@ -171,7 +169,7 @@ void Steensgaard::heapAllocatorViaIndCall(CallSite cs, NodePairSet& cpySrcNodes)
     else
     {
         NodeID valNode = pag->addDummyValNode();
-        NodeID objNode = pag->addDummyObjNode(cs.getType());
+        NodeID objNode = pag->addDummyObjNode(cs->getCallSite()->getType());
         addPts(valNode, objNode);
         callsite2DummyValPN.insert(std::make_pair(cs, valNode));
         consCG->addConstraintNode(new ConstraintNode(valNode), valNode);
@@ -187,7 +185,7 @@ void Steensgaard::heapAllocatorViaIndCall(CallSite cs, NodePairSet& cpySrcNodes)
 /*!
  * Connect formal and actual parameters for indirect callsites
  */
-void Steensgaard::connectCaller2CalleeParams(CallSite cs, const SVFFunction* F,
+void Steensgaard::connectCaller2CalleeParams(const CallICFGNode* cs, const SVFFunction* F,
         NodePairSet& cpySrcNodes)
 {
     assert(F);
@@ -196,10 +194,8 @@ void Steensgaard::connectCaller2CalleeParams(CallSite cs, const SVFFunction* F,
           << cs.getInstruction()->toString() << " to callee "
           << *F << "\n");
 
-    CallICFGNode* callBlockNode =
-        pag->getICFG()->getCallICFGNode(cs.getInstruction());
-    RetICFGNode* retBlockNode =
-        pag->getICFG()->getRetICFGNode(cs.getInstruction());
+    const CallICFGNode* callBlockNode = cs;
+    const RetICFGNode* retBlockNode = cs->getRetICFGNode();
 
     if (SVFUtil::isHeapAllocExtFunViaRet(F) &&
             pag->callsiteHasRet(retBlockNode))
@@ -285,7 +281,7 @@ void Steensgaard::connectCaller2CalleeParams(CallSite cs, const SVFFunction* F,
         if (csArgIt != csArgEit)
         {
             writeWrnMsg("too many args to non-vararg func.");
-            writeWrnMsg("(" + cs.getInstruction()->getSourceLoc() + ")");
+            writeWrnMsg("(" + cs->getSourceLoc() + ")");
         }
     }
 }

package/svf/lib/WPA/TypeAnalysis.cpp

@@ -77,10 +77,9 @@ void TypeAnalysis::callGraphSolveBasedOnCHA(const CallSiteToFunPtrMap& callsites
     for(CallSiteToFunPtrMap::const_iterator iter = callsites.begin(), eiter = callsites.end(); iter!=eiter; ++iter)
     {
         const CallICFGNode* cbn = iter->first;
-        CallSite cs = SVFUtil::getSVFCallSite(cbn);
-        if (cs.isVirtualCall())
+        if (cbn->isVirtualCall())
         {
-            const SVFValue* vtbl = cs.getVtablePtr();
+            const SVFValue* vtbl = cbn->getVtablePtr();
             (void)vtbl; // Suppress warning of unused variable under release build
             assert(pag->hasValueNode(vtbl));
             VFunSet vfns;

package/svf/lib/WPA/WPAPass.cpp

@@ -218,33 +218,26 @@ AliasResult WPAPass::alias(const SVFValue* V1, const SVFValue* V2)
 /*!
  * Return mod-ref result of a Callsite
  */
-ModRefInfo WPAPass::getModRefInfo(const CallSite callInst)
+ModRefInfo WPAPass::getModRefInfo(const CallICFGNode* callInst)
 {
     assert(Options::PASelected(PointerAnalysis::AndersenWaveDiff_WPA) && Options::AnderSVFG() && "mod-ref query is only support with -ander and -svfg turned on");
-    ICFG* icfg = _svfg->getPAG()->getICFG();
-    const CallICFGNode* cbn = icfg->getCallICFGNode(callInst.getInstruction());
-    return _svfg->getMSSA()->getMRGenerator()->getModRefInfo(cbn);
+    return _svfg->getMSSA()->getMRGenerator()->getModRefInfo(callInst);
 }
 
 /*!
  * Return mod-ref results of a Callsite to a specific memory location
  */
-ModRefInfo WPAPass::getModRefInfo(const CallSite callInst, const SVFValue* V)
+ModRefInfo WPAPass::getModRefInfo(const CallICFGNode* callInst, const SVFValue* V)
 {
     assert(Options::PASelected(PointerAnalysis::AndersenWaveDiff_WPA) && Options::AnderSVFG() && "mod-ref query is only support with -ander and -svfg turned on");
-    ICFG* icfg = _svfg->getPAG()->getICFG();
-    const CallICFGNode* cbn = icfg->getCallICFGNode(callInst.getInstruction());
-    return _svfg->getMSSA()->getMRGenerator()->getModRefInfo(cbn, V);
+    return _svfg->getMSSA()->getMRGenerator()->getModRefInfo(callInst, V);
 }
 
 /*!
  * Return mod-ref result between two CallInsts
  */
-ModRefInfo WPAPass::getModRefInfo(const CallSite callInst1, const CallSite callInst2)
+ModRefInfo WPAPass::getModRefInfo(const CallICFGNode* callInst1, const CallICFGNode* callInst2)
 {
     assert(Options::PASelected(PointerAnalysis::AndersenWaveDiff_WPA) && Options::AnderSVFG() && "mod-ref query is only support with -ander and -svfg turned on");
-    ICFG* icfg = _svfg->getPAG()->getICFG();
-    const CallICFGNode* cbn1 = icfg->getCallICFGNode(callInst1.getInstruction());
-    const CallICFGNode* cbn2 = icfg->getCallICFGNode(callInst2.getInstruction());
-    return _svfg->getMSSA()->getMRGenerator()->getModRefInfo(cbn1, cbn2);
+    return _svfg->getMSSA()->getMRGenerator()->getModRefInfo(callInst1, callInst2);
 }

package/svf-llvm/include/SVF-LLVM/DCHG.h

@@ -249,12 +249,12 @@ public:
 
     void print(void);
 
-    virtual bool csHasVFnsBasedonCHA(CallSite cs) override
+    virtual bool csHasVFnsBasedonCHA(const CallICFGNode* cs) override
     {
         return csHasVtblsBasedonCHA(cs);
     }
 
-    virtual const VFunSet &getCSVFsBasedonCHA(CallSite cs) override;
+    virtual const VFunSet &getCSVFsBasedonCHA(const CallICFGNode* cs) override;
 
     virtual bool csHasVtblsBasedonCHA(CallBase* cs)
     {
@@ -268,14 +268,14 @@ public:
         return getNode(type)->getVTable() != nullptr;
     }
 
-    virtual bool csHasVtblsBasedonCHA(CallSite cs) override
+    virtual bool csHasVtblsBasedonCHA(const CallICFGNode* cs) override
     {
         assert(false && "not supported!");
         abort();
     }
 
-    virtual const VTableSet &getCSVtblsBasedonCHA(CallSite cs) override;
-    virtual void getVFnsFromVtbls(CallSite cs, const VTableSet &vtbls, VFunSet &virtualFunctions) override;
+    virtual const VTableSet &getCSVtblsBasedonCHA(const CallICFGNode* cs) override;
+    virtual void getVFnsFromVtbls(const SVFCallInst* cs, const VTableSet &vtbls, VFunSet &virtualFunctions) override;
 
     /// Returns true if a is a transitive base of b. firstField determines
     /// whether to consider first-field edges.
@@ -373,7 +373,7 @@ protected:
     /// Maps types to a set with their vtable and all their children's.
     Map<const DIType*, VTableSet> vtblCHAMap;
     /// Maps callsites to a set of potential virtual functions based on CHA.
-    Map<CallSite, VFunSet> csCHAMap;
+    Map<const CallICFGNode*, VFunSet> csCHAMap;
     /// Maps types to their canonical type (many-to-one).
     Map<const DIType*, const DIType*> canonicalTypeMap;
     /// Set of all possible canonical types (i.e. values of canonicalTypeMap).
@@ -414,7 +414,7 @@ private:
     /// Retrieves the metadata associated with a *virtual* callsite.
     const DIType* getCSStaticType(CallBase* cs) const;
 
-    const DIType *getCSStaticType(CallSite cs) const
+    const DIType *getCSStaticType(const CallICFGNode* cs) const
     {
         assert(false && "not supported!");
         abort();

package/svf-llvm/include/SVF-LLVM/LLVMUtil.h

@@ -287,14 +287,6 @@ inline static DataLayout* getDataLayout(Module* mod)
     return dl;
 }
 
-/// Get the next instructions following control flow
-void getNextInsts(const Instruction* curInst,
-                  std::vector<const SVFInstruction*>& instList);
-
-/// Get the previous instructions following control flow
-void getPrevInsts(const Instruction* curInst,
-                  std::vector<const SVFInstruction*>& instList);
-
 /// Get the next instructions following control flow
 void getNextInsts(const Instruction* curInst,
                   std::vector<const Instruction*>& instList);

package/svf-llvm/lib/CHGBuilder.cpp

@@ -1,4 +1,4 @@
-//===----- CHGBuiler.cpp -- Class hierarchy graph builder ---------------------------//
+//===----- CHGBuilder.cpp -- Class hierarchy graph builder ---------------------------//
 //
 //                     SVF: Static Value-Flow Analysis
 //
@@ -21,7 +21,7 @@
 //===----------------------------------------------------------------------===//
 
 /*
- * CHGBuiler.cpp
+ * CHGBuilder.cpp
  *
  *  Created on: Jun 4, 2021
  *      Author: Yulei Sui
@@ -679,10 +679,10 @@ void CHGBuilder::buildCSToCHAVtblsAndVfnsMap()
                     }
                     if (vtbls.size() > 0)
                     {
-                        CallSite cs(LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(callInst));
+                        const SVFInstruction* cs = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(callInst);
                         chg->csToCHAVtblsMap[cs] = vtbls;
                         VFunSet virtualFunctions;
-                        chg->getVFnsFromVtbls(cs, vtbls, virtualFunctions);
+                        chg->getVFnsFromVtbls(SVFUtil::cast<SVFCallInst>(cs), vtbls, virtualFunctions);
                         if (virtualFunctions.size() > 0)
                             chg->csToCHAVFnsMap[cs] = virtualFunctions;
                     }

package/svf-llvm/lib/DCHG.cpp

@@ -544,7 +544,7 @@ void DCHGraph::buildCHG(bool extend)
     }
 }
 
-const VFunSet &DCHGraph::getCSVFsBasedonCHA(CallSite cs)
+const VFunSet &DCHGraph::getCSVFsBasedonCHA(const CallICFGNode* cs)
 {
     if (csCHAMap.find(cs) != csCHAMap.end())
     {
@@ -553,7 +553,7 @@ const VFunSet &DCHGraph::getCSVFsBasedonCHA(CallSite cs)
 
     VFunSet vfns;
     const VTableSet &vtbls = getCSVtblsBasedonCHA(cs);
-    getVFnsFromVtbls(cs, vtbls, vfns);
+    getVFnsFromVtbls(SVFUtil::cast<SVFCallInst>(cs->getCallSite()), vtbls, vfns);
 
     // Cache.
     csCHAMap.insert({cs, vfns});
@@ -561,7 +561,7 @@ const VFunSet &DCHGraph::getCSVFsBasedonCHA(CallSite cs)
     return csCHAMap[cs];
 }
 
-const VTableSet &DCHGraph::getCSVtblsBasedonCHA(CallSite cs)
+const VTableSet &DCHGraph::getCSVtblsBasedonCHA(const CallICFGNode* cs)
 {
     const DIType *type = getCanonicalType(getCSStaticType(cs));
     // Check if we've already computed.
@@ -589,10 +589,11 @@ const VTableSet &DCHGraph::getCSVtblsBasedonCHA(CallSite cs)
     return vtblCHAMap[type];
 }
 
-void DCHGraph::getVFnsFromVtbls(CallSite cs, const VTableSet &vtbls, VFunSet &virtualFunctions)
+void DCHGraph::getVFnsFromVtbls(const SVFCallInst* callsite, const VTableSet &vtbls, VFunSet &virtualFunctions)
 {
-    size_t idx = cs.getFunIdxInVtable();
-    std::string funName = cs.getFunNameOfVirtualCall();
+    const SVFVirtualCallInst* cs = SVFUtil::cast<SVFVirtualCallInst>(callsite);
+    size_t idx = cs->getFunIdxInVtable();
+    std::string funName = cs->getFunNameOfVirtualCall();
     for (const SVFGlobalValue *vtbl : vtbls)
     {
         assert(vtblToTypeMap.find(vtbl) != vtblToTypeMap.end() && "floating vtbl");
@@ -610,7 +611,7 @@ void DCHGraph::getVFnsFromVtbls(CallSite cs, const VTableSet &vtbls, VFunSet &vi
 
             const Function* callee = vfnV[idx];
             // Practically a copy of that in lib/MemoryModel/CHA.cpp
-            if (cs.arg_size() == callee->arg_size() || (cs.isVarArg() && callee->isVarArg()))
+            if (cs->arg_size() == callee->arg_size() || (cs->isVarArg() && callee->isVarArg()))
             {
                 cppUtil::DemangledName dname = cppUtil::demangle(callee->getName().str());
                 std::string calleeName = dname.funcName;

package/svf-llvm/lib/ICFGBuilder.cpp

@@ -258,8 +258,8 @@ void ICFGBuilder::addICFGInterEdges(const SVFInstruction* cs, const SVFFunction*
         {
             FunEntryICFGNode* calleeEntryNode = icfg->getFunEntryICFGNode(callee);
             FunExitICFGNode* calleeExitNode = icfg->getFunExitICFGNode(callee);
-            icfg->addCallEdge(callICFGNode, calleeEntryNode, cs);
-            icfg->addRetEdge(calleeExitNode, retBlockNode, cs);
+            icfg->addCallEdge(callICFGNode, calleeEntryNode);
+            icfg->addRetEdge(calleeExitNode, retBlockNode);
         }
     }
     /// indirect call (don't know callee)

package/svf-llvm/lib/LLVMModule.cpp

@@ -373,8 +373,6 @@ void LLVMModuleSet::initSVFBasicBlock(const Function* func)
                     svfcall->addArgument(svfval);
                 }
             }
-            LLVMUtil::getNextInsts(inst, getSVFInstruction(inst)->getSuccInstructions());
-            LLVMUtil::getPrevInsts(inst, getSVFInstruction(inst)->getPredInstructions());
         }
     }
     // For no return functions, we set the last block as exit BB

package/svf-llvm/lib/LLVMUtil.cpp

@@ -297,64 +297,6 @@ const Value*  LLVMUtil::stripAllCasts(const Value* val)
     return nullptr;
 }
 
-/// Get the next instructions following control flow
-void LLVMUtil::getNextInsts(const Instruction* curInst, std::vector<const SVFInstruction*>& instList)
-{
-    if (!curInst->isTerminator())
-    {
-        const Instruction* nextInst = curInst->getNextNode();
-        const SVFInstruction* svfNextInst = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(nextInst);
-        if (LLVMUtil::isIntrinsicInst(nextInst))
-            getNextInsts(nextInst, instList);
-        else
-            instList.push_back(svfNextInst);
-    }
-    else
-    {
-        const BasicBlock* BB = curInst->getParent();
-        // Visit all successors of BB in the CFG
-        for (succ_const_iterator it = succ_begin(BB), ie = succ_end(BB); it != ie; ++it)
-        {
-            const Instruction* nextInst = &((*it)->front());
-            const SVFInstruction* svfNextInst = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(nextInst);
-            if (LLVMUtil::isIntrinsicInst(nextInst))
-                getNextInsts(nextInst, instList);
-            else
-                instList.push_back(svfNextInst);
-        }
-    }
-}
-
-
-/// Get the previous instructions following control flow
-void LLVMUtil::getPrevInsts(const Instruction* curInst, std::vector<const SVFInstruction*>& instList)
-{
-
-    if (curInst != &(curInst->getParent()->front()))
-    {
-        const Instruction* prevInst = curInst->getPrevNode();
-        const SVFInstruction* svfPrevInst = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(prevInst);
-        if (LLVMUtil::isIntrinsicInst(prevInst))
-            getPrevInsts(prevInst, instList);
-        else
-            instList.push_back(svfPrevInst);
-    }
-    else
-    {
-        const BasicBlock* BB = curInst->getParent();
-        // Visit all successors of BB in the CFG
-        for (const_pred_iterator it = pred_begin(BB), ie = pred_end(BB); it != ie; ++it)
-        {
-            const Instruction* prevInst = &((*it)->back());
-            const SVFInstruction* svfPrevInst = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(prevInst);
-            if (LLVMUtil::isIntrinsicInst(prevInst))
-                getPrevInsts(prevInst, instList);
-            else
-                instList.push_back(svfPrevInst);
-        }
-    }
-}
-
 /*
  * Get the first dominated cast instruction for heap allocations since they typically come from void* (i8*)
  * for example, %4 = call align 16 i8* @malloc(i64 10); %5 = bitcast i8* %4 to i32*

package/svf-llvm/lib/SVFIRExtAPI.cpp

@@ -127,13 +127,13 @@ void SVFIRBuilder::handleExtCall(const CallBase* cs, const SVFFunction* svfCalle
     const SVFCallInst* svfCall = SVFUtil::cast<SVFCallInst>(svfInst);
     const CallICFGNode *callICFGNode = pag->getICFG()->getCallICFGNode(svfInst);
 
-    if (isHeapAllocExtCallViaRet(svfCall))
+    if (isHeapAllocExtCallViaRet(callICFGNode))
     {
         NodeID val = pag->getValueNode(svfInst);
         NodeID obj = pag->getObjectNode(svfInst);
         addAddrWithHeapSz(obj, val, cs);
     }
-    else if (isHeapAllocExtCallViaArg(svfCall))
+    else if (isHeapAllocExtCallViaArg(callICFGNode))
     {
         u32_t arg_pos = getHeapAllocHoldingArgPosition(svfCallee);
         const SVFValue* arg = svfCall->getArgOperand(arg_pos);