svf-tools 1.0.340 → 1.0.344

package/lib/SVF-FE/ICFGBuilder.cpp

@@ -58,7 +58,7 @@ void ICFGBuilder::build(SVFModule* svfModule)
  */
 void ICFGBuilder::processFunEntry(const SVFFunction*  fun, WorkList& worklist)
 {
-    FunEntryBlockNode* FunEntryBlockNode = icfg->getFunEntryBlockNode(fun);
+    FunEntryICFGNode* FunEntryICFGNode = icfg->getFunEntryBlockNode(fun);
     const Instruction* entryInst = &((fun->getLLVMFun()->getEntryBlock()).front());
     InstVec insts;
     if (isIntrinsicInst(entryInst))
@@ -69,7 +69,7 @@ void ICFGBuilder::processFunEntry(const SVFFunction*  fun, WorkList& worklist)
             nit != enit; ++nit)
     {
         ICFGNode* instNode = getOrAddBlockICFGNode(*nit);           //add interprocedure edge
-        icfg->addIntraEdge(FunEntryBlockNode, instNode);
+        icfg->addIntraEdge(FunEntryICFGNode, instNode);
         worklist.push(*nit);
     }
 }
@@ -92,8 +92,8 @@ void ICFGBuilder::processFunBody(WorkList& worklist)
             {
                 const Function* fun = inst->getFunction();
                 const SVFFunction* svfFun = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(fun);
-                FunExitBlockNode* FunExitBlockNode = icfg->getFunExitBlockNode(svfFun);
-                icfg->addIntraEdge(srcNode, FunExitBlockNode);
+                FunExitICFGNode* FunExitICFGNode = icfg->getFunExitBlockNode(svfFun);
+                icfg->addIntraEdge(srcNode, FunExitICFGNode);
             }
             InstVec nextInsts;
             getNextInsts(inst, nextInsts);
@@ -105,8 +105,7 @@ void ICFGBuilder::processFunBody(WorkList& worklist)
                 ICFGNode* dstNode = getOrAddBlockICFGNode(succ);
                 if (isNonInstricCallSite(inst))
                 {
-                    RetBlockNode* retICFGNode = getOrAddRetICFGNode(inst);
-                    icfg->addIntraEdge(srcNode, retICFGNode);
+                    RetICFGNode* retICFGNode = getOrAddRetICFGNode(inst);
                     srcNode = retICFGNode;
                 }
 
@@ -118,8 +117,7 @@ void ICFGBuilder::processFunBody(WorkList& worklist)
                     else 
                         icfg->addIntraEdge(srcNode, dstNode);
                 }
-
-                if (const SwitchInst* si = SVFUtil::dyn_cast<SwitchInst>(inst))
+                else if (const SwitchInst* si = SVFUtil::dyn_cast<SwitchInst>(inst))
                 {
                     icfg->addConditionalIntraEdge(srcNode, dstNode, si->getCondition(),branchID);
                 }
@@ -140,14 +138,14 @@ void ICFGBuilder::processFunBody(WorkList& worklist)
  */
 void ICFGBuilder::processFunExit(const SVFFunction*  fun)
 {
-    FunExitBlockNode* FunExitBlockNode = icfg->getFunExitBlockNode(fun);
+    FunExitICFGNode* FunExitICFGNode = icfg->getFunExitBlockNode(fun);
 
     for (inst_iterator II = inst_begin(fun->getLLVMFun()), EE = inst_end(fun->getLLVMFun()); II != EE; ++II)
     {
         const Instruction *inst = &*II;
         if(SVFUtil::isa<ReturnInst>(inst)) {
             ICFGNode* instNode = getOrAddBlockICFGNode(inst);
-            icfg->addIntraEdge(instNode, FunExitBlockNode);
+            icfg->addIntraEdge(instNode, FunExitICFGNode);
         }
     }
 }
@@ -159,13 +157,12 @@ void ICFGBuilder::processFunExit(const SVFFunction*  fun)
  * (1) Add and get CallBlockICFGNode
  * (2) Handle call instruction by creating interprocedural edges
  */
-InterBlockNode* ICFGBuilder::getOrAddInterBlockICFGNode(const Instruction* inst)
+InterICFGNode* ICFGBuilder::getOrAddInterBlockICFGNode(const Instruction* inst)
 {
     assert(SVFUtil::isCallSite(inst) && "not a call instruction?");
     assert(SVFUtil::isNonInstricCallSite(inst) && "associating an intrinsic debug instruction with an ICFGNode!");
-    CallBlockNode* callICFGNode = getOrAddCallICFGNode(inst);
-    if (const SVFFunction*  callee = getCallee(inst))
-        addICFGInterEdges(inst, callee);                       //creating interprocedural edges
+    CallICFGNode* callICFGNode = getOrAddCallICFGNode(inst);
+    addICFGInterEdges(inst, getCallee(inst));                       //creating interprocedural edges
     return callICFGNode;
 }
 
@@ -174,15 +171,24 @@ InterBlockNode* ICFGBuilder::getOrAddInterBlockICFGNode(const Instruction* inst)
  */
 void ICFGBuilder::addICFGInterEdges(const Instruction* cs, const SVFFunction* callee)
 {
-    CallBlockNode* CallBlockNode = getOrAddCallICFGNode(cs);
-    FunEntryBlockNode* calleeEntryNode = icfg->getFunEntryBlockNode(callee);
-    icfg->addCallEdge(CallBlockNode, calleeEntryNode, cs);
-
-    if (!isExtCall(callee))
-    {
-        RetBlockNode* retBlockNode = getOrAddRetICFGNode(cs);
-        FunExitBlockNode* calleeExitNode = icfg->getFunExitBlockNode(callee);
+    CallICFGNode* CallICFGNode = getOrAddCallICFGNode(cs);
+    RetICFGNode* retBlockNode = getOrAddRetICFGNode(cs);
+
+    /// direct call  
+    if(callee){
+        FunEntryICFGNode* calleeEntryNode = icfg->getFunEntryBlockNode(callee);
+        FunExitICFGNode* calleeExitNode = icfg->getFunExitBlockNode(callee);
+        icfg->addCallEdge(CallICFGNode, calleeEntryNode, cs);
         icfg->addRetEdge(calleeExitNode, retBlockNode, cs);
+        /// if this is an external function (no function body)
+        if (isExtCall(callee))
+        {
+           icfg->addIntraEdge(calleeEntryNode, calleeExitNode); 
+        }
+    }
+    /// indirect call (don't know callee)
+    else{
+        icfg->addIntraEdge(CallICFGNode, retBlockNode); 
     }
 }
 /*
@@ -196,15 +202,15 @@ void ICFGBuilder::connectGlobalToProgEntry(SVFModule* svfModule)
     if(mainFunc == nullptr)
         return;
 
-    FunEntryBlockNode* entryNode = icfg->getFunEntryBlockNode(mainFunc);
-    GlobalBlockNode* globalNode = icfg->getGlobalBlockNode();
+    FunEntryICFGNode* entryNode = icfg->getFunEntryBlockNode(mainFunc);
+    GlobalICFGNode* globalNode = icfg->getGlobalBlockNode();
 
     std::vector<ICFGEdge*> toBeRemovedEdges;
     for(ICFGEdge* edge : entryNode->getOutEdges())
         toBeRemovedEdges.push_back(edge);
     
     for(ICFGEdge* edge : toBeRemovedEdges){
-        assert(SVFUtil::isa<IntraCFGEdge>(edge) && "the outgoing edge of FunEntryBlockNode is not an intraCFGEdge?");
+        assert(SVFUtil::isa<IntraCFGEdge>(edge) && "the outgoing edge of FunEntryICFGNode is not an intraCFGEdge?");
         icfg->removeICFGEdge(edge);
         IntraCFGEdge* intraEdge = new IntraCFGEdge(globalNode, edge->getDstNode());
         icfg->addICFGEdge(intraEdge); 

package/lib/SVF-FE/SVFIRBuilder.cpp

@@ -754,8 +754,8 @@ void SVFIRBuilder::visitCallSite(CallSite cs)
     DBOUT(DPAGBuild,
           outs() << "process callsite " << *cs.getInstruction() << "\n");
 
-    CallBlockNode* callBlockNode = pag->getICFG()->getCallBlockNode(cs.getInstruction());
-    RetBlockNode* retBlockNode = pag->getICFG()->getRetBlockNode(cs.getInstruction());
+    CallICFGNode* callBlockNode = pag->getICFG()->getCallBlockNode(cs.getInstruction());
+    RetICFGNode* retBlockNode = pag->getICFG()->getRetBlockNode(cs.getInstruction());
 
     pag->addCallSite(callBlockNode);
 
@@ -918,7 +918,7 @@ void SVFIRBuilder::handleDirectCall(CallSite cs, const SVFFunction *F)
     if (!cs.getType()->isVoidTy())
     {
         NodeID srcret = getReturnNode(F);
-        CallBlockNode* icfgNode = pag->getICFG()->getCallBlockNode(cs.getInstruction());
+        CallICFGNode* icfgNode = pag->getICFG()->getCallBlockNode(cs.getInstruction());
         addRetEdge(srcret, dstrec,icfgNode);
     }
     //Iterators for the actual and formal parameters
@@ -940,7 +940,7 @@ void SVFIRBuilder::handleDirectCall(CallSite cs, const SVFFunction *F)
 
         NodeID dstFA = getValueNode(FA);
         NodeID srcAA = getValueNode(AA);
-        CallBlockNode* icfgNode = pag->getICFG()->getCallBlockNode(cs.getInstruction());
+        CallICFGNode* icfgNode = pag->getICFG()->getCallBlockNode(cs.getInstruction());
         addCallEdge(srcAA, dstFA, icfgNode);
     }
     //Any remaining actual args must be varargs.
@@ -952,7 +952,7 @@ void SVFIRBuilder::handleDirectCall(CallSite cs, const SVFFunction *F)
         {
             Value *AA = *itA;
             NodeID vnAA = getValueNode(AA);
-            CallBlockNode* icfgNode = pag->getICFG()->getCallBlockNode(cs.getInstruction());
+            CallICFGNode* icfgNode = pag->getICFG()->getCallBlockNode(cs.getInstruction());
             addCallEdge(vnAA,vaF, icfgNode);
         }
     }
@@ -1435,7 +1435,7 @@ void SVFIRBuilder::handleExtCall(CallSite cs, const SVFFunction *callee)
                     /// Connect actual parameter to formal parameter of the start routine
                     if(SVFUtil::isa<PointerType>(actualParm->getType()) && SVFUtil::isa<PointerType>(formalParm->getType()) )
                     {
-                        CallBlockNode* icfgNode = pag->getICFG()->getCallBlockNode(inst);
+                        CallICFGNode* icfgNode = pag->getICFG()->getCallBlockNode(inst);
                         addThreadForkEdge(pag->getValueNode(actualParm), pag->getValueNode(formalParm),icfgNode);
                     }
                 }
@@ -1464,7 +1464,7 @@ void SVFIRBuilder::handleExtCall(CallSite cs, const SVFFunction *callee)
                 /// Connect actual parameter to formal parameter of the start routine
                 if(SVFUtil::isa<PointerType>(actualParm->getType()) && SVFUtil::isa<PointerType>(formalParm->getType()) )
                 {
-                    CallBlockNode* icfgNode = pag->getICFG()->getCallBlockNode(inst);
+                    CallICFGNode* icfgNode = pag->getICFG()->getCallBlockNode(inst);
                     addThreadForkEdge(pag->getValueNode(actualParm), pag->getValueNode(formalParm),icfgNode);
                 }
             }
@@ -1486,7 +1486,7 @@ void SVFIRBuilder::handleExtCall(CallSite cs, const SVFFunction *callee)
  */
 void SVFIRBuilder::handleIndCall(CallSite cs)
 {
-    const CallBlockNode* cbn = pag->getICFG()->getCallBlockNode(cs.getInstruction());
+    const CallICFGNode* cbn = pag->getICFG()->getCallBlockNode(cs.getInstruction());
     pag->addIndirectCallsites(cbn,pag->getValueNode(cs.getCalledValue()));
 }
 

package/lib/SVF-FE/SymbolTableBuilder.cpp

@@ -567,7 +567,7 @@ void SymbolTableBuilder::initTypeInfo(ObjTypeInfo* typeinfo, const Value* val){
     {
         typeinfo->setFlag(ObjTypeInfo::GLOBVAR_OBJ);
         if(SymbolTableInfo::SymbolInfo()->isConstantObjSym(val))
-            typeinfo->setFlag(ObjTypeInfo::CONST_OBJ);
+            typeinfo->setFlag(ObjTypeInfo::CONST_GLOBAL_OBJ);
         analyzeGlobalStackObjType(typeinfo,val);
         objSize = getObjSize(val);
     }
@@ -591,7 +591,7 @@ void SymbolTableBuilder::initTypeInfo(ObjTypeInfo* typeinfo, const Value* val){
     }
     else if(SVFUtil::isConstantData(val))
     {
-        typeinfo->setFlag(ObjTypeInfo::CONST_OBJ);
+        typeinfo->setFlag(ObjTypeInfo::CONST_DATA);
     }
     else{
         assert("what other object do we have??");

package/lib/Util/Options.cpp

@@ -296,10 +296,10 @@ namespace SVF
         llvm::cl::desc("Dump dot graph of SVFIR")
     );
 
-    const llvm::cl::opt<bool> Options::PAGDotGraphShorter(
-            "dump-pag-shorter",
+    const llvm::cl::opt<bool> Options::ShowSVFIRValue(
+            "show-ir-value",
             llvm::cl::init(true),
-            llvm::cl::desc("If dumping dot graph of SVFIR, use shorter lines")
+            llvm::cl::desc("Show values of SVFIR (e.g., when generating dot graph)")
     );
 
     const llvm::cl::opt<bool> Options::DumpICFG(

package/lib/Util/PTAStat.cpp

@@ -170,13 +170,13 @@ void PTAStat::performStat()
                 numOfHasVarArray++;
             if(mem->isVarStruct())
                 numOfHasVarStruct++;
-            if(mem->isConstArray())
+            if(mem->isConstantArray())
                 numOfHasConstArray++;
-            if(mem->isConstStruct())
+            if(mem->isConstantStruct())
                 numOfHasConstStruct++;
             if(mem->hasPtrObj() == false)
                 numOfScalar++;
-            if(mem->isConstant())
+            if(mem->isConstDataOrConstGlobal())
                 numOfConstant++;
 
             if (mem->isFieldInsensitive())

package/lib/Util/SVFUtil.cpp

@@ -359,6 +359,8 @@ std::string SVFUtil::getSourceLoc(const Value* val)
     }
     rawstr << " }";
 
+    if(rawstr.str()=="{  }")
+        return "";
     return rawstr.str();
 }
 

package/lib/Util/TypeBasedHeapCloning.cpp

@@ -565,7 +565,7 @@ void TypeBasedHeapCloning::validateTBHCTests(SVFModule*)
     for (u32_t i = 0; i < llvmModuleSet->getModuleNum(); ++i)
     {
         const SVFIR::CallSiteSet &callSites = ppag->getCallSiteSet();
-        for (const CallBlockNode *cbn : callSites)
+        for (const CallICFGNode *cbn : callSites)
         {
             const CallSite &cs = SVFUtil::getLLVMCallSite(cbn->getCallSite());
             const Function *fn = cs.getCalledFunction();

package/lib/WPA/Andersen.cpp

@@ -654,7 +654,7 @@ bool Andersen::updateCallGraph(const CallSiteToFunPtrMap& callsites)
 void Andersen::heapAllocatorViaIndCall(CallSite cs, NodePairSet &cpySrcNodes)
 {
     assert(SVFUtil::getCallee(cs) == nullptr && "not an indirect callsite?");
-    RetBlockNode* retBlockNode = pag->getICFG()->getRetBlockNode(cs.getInstruction());
+    RetICFGNode* retBlockNode = pag->getICFG()->getRetBlockNode(cs.getInstruction());
     const PAGNode* cs_return = pag->getCallSiteRet(retBlockNode);
     NodeID srcret;
     CallSite2DummyValPN::const_iterator it = callsite2DummyValPN.find(cs);
@@ -687,8 +687,8 @@ void Andersen::connectCaller2CalleeParams(CallSite cs, const SVFFunction* F, Nod
 
     DBOUT(DAndersen, outs() << "connect parameters from indirect callsite " << *cs.getInstruction() << " to callee " << *F << "\n");
 
-    CallBlockNode* callBlockNode = pag->getICFG()->getCallBlockNode(cs.getInstruction());
-    RetBlockNode* retBlockNode = pag->getICFG()->getRetBlockNode(cs.getInstruction());
+    CallICFGNode* callBlockNode = pag->getICFG()->getCallBlockNode(cs.getInstruction());
+    RetICFGNode* retBlockNode = pag->getICFG()->getRetBlockNode(cs.getInstruction());
 
     if(SVFUtil::isHeapAllocExtFunViaRet(F) && pag->callsiteHasRet(retBlockNode))
     {

package/lib/WPA/FlowSensitive.cpp

@@ -661,7 +661,7 @@ bool FlowSensitive::updateCallGraph(const CallSiteToFunPtrMap& callsites)
     const CallEdgeMap &andersCallEdgeMap = ander->getIndCallMap();
     for (typename CallEdgeMap::value_type &csfs : newEdges)
     {
-        const CallBlockNode *potentialCallSite = csfs.first;
+        const CallICFGNode *potentialCallSite = csfs.first;
         FunctionSet &potentialFunctionSet = csfs.second;
 
         // Check this callsite even calls anything per Andersen's.
@@ -709,7 +709,7 @@ void FlowSensitive::connectCallerAndCallee(const CallEdgeMap& newEdges, SVFGEdge
     CallEdgeMap::const_iterator eiter = newEdges.end();
     for (; iter != eiter; iter++)
     {
-        const CallBlockNode* cs = iter->first;
+        const CallICFGNode* cs = iter->first;
         const FunctionSet & functions = iter->second;
         for (FunctionSet::const_iterator func_iter = functions.begin(); func_iter != functions.end(); func_iter++)
         {

package/lib/WPA/TypeAnalysis.cpp

@@ -79,7 +79,7 @@ void TypeAnalysis::callGraphSolveBasedOnCHA(const CallSiteToFunPtrMap& callsites
 {
     for(CallSiteToFunPtrMap::const_iterator iter = callsites.begin(), eiter = callsites.end(); iter!=eiter; ++iter)
     {
-        const CallBlockNode* cbn = iter->first;
+        const CallICFGNode* cbn = iter->first;
         CallSite cs = SVFUtil::getLLVMCallSite(cbn->getCallSite());
         if (isVirtualCallSite(cs))
         {

package/lib/WPA/VersionedFlowSensitive.cpp

@@ -441,7 +441,7 @@ void VersionedFlowSensitive::buildDeltaMaps(void)
     deltaMap.resize(svfg->getTotalNodeNum(), false);
 
     // Call block nodes corresponding to all delta nodes.
-    Set<const CallBlockNode *> deltaCBNs;
+    Set<const CallICFGNode *> deltaCBNs;
 
     for (SVFG::const_iterator it = svfg->begin(); it != svfg->end(); ++it)
     {
@@ -463,10 +463,10 @@ void VersionedFlowSensitive::buildDeltaMaps(void)
             if (isDelta)
             {
                 // TODO: could we use deltaCBNs in the call above, avoiding this loop?
-                for (const CallBlockNode *cbn : callsites) deltaCBNs.insert(cbn);
+                for (const CallICFGNode *cbn : callsites) deltaCBNs.insert(cbn);
             }
         }
-        else if (const CallBlockNode *cbn = svfg->isCallSiteRetSVFGNode(s))
+        else if (const CallICFGNode *cbn = svfg->isCallSiteRetSVFGNode(s))
         {
             isDelta = cbn->isIndirectCall();
             if (isDelta) deltaCBNs.insert(cbn);
@@ -482,7 +482,7 @@ void VersionedFlowSensitive::buildDeltaMaps(void)
         const NodeID l = it->first;
         const SVFGNode *s = it->second;
 
-        if (const CallBlockNode *cbn = SVFUtil::dyn_cast<CallBlockNode>(s->getICFGNode()))
+        if (const CallICFGNode *cbn = SVFUtil::dyn_cast<CallICFGNode>(s->getICFGNode()))
         {
             if (deltaCBNs.find(cbn) != deltaCBNs.end()) deltaSourceMap[l] = true;
         }

package/lib/WPA/WPAPass.cpp

@@ -247,7 +247,7 @@ ModRefInfo WPAPass::getModRefInfo(const CallInst* callInst)
 {
     assert(Options::PASelected.isSet(PointerAnalysis::AndersenWaveDiff_WPA) && Options::AnderSVFG && "mod-ref query is only support with -ander and -svfg turned on");
     ICFG* icfg = _svfg->getPAG()->getICFG();
-    const CallBlockNode* cbn = icfg->getCallBlockNode(callInst);
+    const CallICFGNode* cbn = icfg->getCallBlockNode(callInst);
     return _svfg->getMSSA()->getMRGenerator()->getModRefInfo(cbn);
 }
 
@@ -258,7 +258,7 @@ ModRefInfo WPAPass::getModRefInfo(const CallInst* callInst, const Value* V)
 {
     assert(Options::PASelected.isSet(PointerAnalysis::AndersenWaveDiff_WPA) && Options::AnderSVFG && "mod-ref query is only support with -ander and -svfg turned on");
     ICFG* icfg = _svfg->getPAG()->getICFG();
-    const CallBlockNode* cbn = icfg->getCallBlockNode(callInst);
+    const CallICFGNode* cbn = icfg->getCallBlockNode(callInst);
     return _svfg->getMSSA()->getMRGenerator()->getModRefInfo(cbn, V);
 }
 
@@ -269,7 +269,7 @@ ModRefInfo WPAPass::getModRefInfo(const CallInst* callInst1, const CallInst* cal
 {
     assert(Options::PASelected.isSet(PointerAnalysis::AndersenWaveDiff_WPA) && Options::AnderSVFG && "mod-ref query is only support with -ander and -svfg turned on");
     ICFG* icfg = _svfg->getPAG()->getICFG();
-    const CallBlockNode* cbn1 = icfg->getCallBlockNode(callInst1);
-    const CallBlockNode* cbn2 = icfg->getCallBlockNode(callInst2);
+    const CallICFGNode* cbn1 = icfg->getCallBlockNode(callInst1);
+    const CallICFGNode* cbn2 = icfg->getCallBlockNode(callInst2);
     return _svfg->getMSSA()->getMRGenerator()->getModRefInfo(cbn1, cbn2);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.340",
+  "version": "1.0.344",
   "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": {