svf-tools 1.0.1025 → 1.0.1027

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.1025",
+  "version": "1.0.1027",
   "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/GenericGraph.h

@@ -154,6 +154,7 @@ public:
         // ┌── SVFVar: Classes of top-level variables (ValVar) and address-taken variables (ObjVar)
         // │   └── ValVar: Classes of top-level variable nodes
         ValNode,                 // ├──Represents a standard value variable
+        ArgNode,                 // ├──Represents an argument value variable
         FunValNode,              // ├──Represents a Function value variable
         GepValNode,              // ├──Represents a GEP value variable
         RetNode,                 // ├──Represents a return value node
@@ -289,7 +290,7 @@ protected:
 
     static inline bool isSVFVarKind(GNodeK n)
     {
-        static_assert(DummyObjNode - ValNode == 23,
+        static_assert(DummyObjNode - ValNode == 24,
                       "The number of SVFVarKinds has changed, make sure the "
                       "range is correct");
 
@@ -298,7 +299,7 @@ protected:
 
     static inline bool isValVarKinds(GNodeK n)
     {
-        static_assert(DummyValNode - ValNode == 11,
+        static_assert(DummyValNode - ValNode == 12,
                       "The number of ValVarKinds has changed, make sure the "
                       "range is correct");
         return n <= DummyValNode && n >= ValNode;

package/svf/include/Graphs/VFGNode.h

@@ -82,7 +82,7 @@ public:
     }
 
     /// Return the corresponding LLVM value, if possible, nullptr otherwise.
-    virtual const SVFValue* getValue() const
+    virtual const SVFVar* getValue() const
     {
         return nullptr;
     }
@@ -190,7 +190,7 @@ public:
     }
     //@}
 
-    const SVFValue* getValue() const override;
+    const SVFVar* getValue() const override;
     const std::string toString() const override;
 };
 
@@ -401,7 +401,9 @@ public:
 
     const NodeBS getDefSVFVars() const override;
 
-    const SVFValue* getValue() const override;
+    const SVFVar* getValue() const override;
+
+
     const std::string toString() const override;
 };
 
@@ -476,7 +478,7 @@ public:
 
     const NodeBS getDefSVFVars() const override;
 
-    const SVFValue* getValue() const override;
+    const SVFVar* getValue() const override;
     const std::string toString() const override;
 };
 
@@ -736,7 +738,7 @@ public:
 
     const NodeBS getDefSVFVars() const override;
 
-    const SVFValue* getValue() const override;
+    const SVFVar* getValue() const override;
     const std::string toString() const override;
 };
 
@@ -879,7 +881,7 @@ public:
     }
     //@}
 
-    const SVFValue* getValue() const override;
+    const SVFVar* getValue() const override;
     const std::string toString() const override;
 };
 

package/svf/include/SVFIR/SVFIR.h

@@ -578,6 +578,13 @@ private:
         return addValNode(nullptr, node, i);
     }
 
+    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);
+    }
+
     inline NodeID addConstantFPValNode(const SVFValue* curInst, double dval, const NodeID i,
                                        const ICFGNode* icfgNode)
     {

package/svf/include/SVFIR/SVFStatements.h

@@ -78,7 +78,7 @@ public:
     };
 
 private:
-    const SVFValue* value;           ///< LLVM value
+    const SVFVar* value;           ///< LLVM value
     const SVFBasicBlock* basicBlock; ///< LLVM BasicBlock
     ICFGNode* icfgNode;              ///< ICFGNode
     EdgeID edgeId;                   ///< Edge ID
@@ -134,20 +134,16 @@ public:
 
     /// Get/set methods for llvm instruction
     //@{
-    inline const SVFInstruction* getInst() const
-    {
-        if (const SVFInstruction* i = SVFUtil::dyn_cast<SVFInstruction>(value))
-            return i;
-        return nullptr;
-    }
-    inline void setValue(const SVFValue* val)
+
+    inline void setValue(const SVFVar* val)
     {
         value = val;
     }
-    inline const SVFValue* getValue() const
+    inline const SVFVar* getValue() const
     {
         return value;
     }
+
     inline void setBB(const SVFBasicBlock* bb)
     {
         basicBlock = bb;
@@ -321,7 +317,7 @@ private:
     AddrStmt(const AddrStmt&);       ///< place holder
     void operator=(const AddrStmt&); ///< place holder
 
-    std::vector<SVFValue*> arrSize;	///< Array size of the allocated memory
+    std::vector<SVFVar*> arrSize;	///< Array size of the allocated memory
 
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -345,13 +341,13 @@ public:
 
     virtual const std::string toString() const override;
 
-    inline void addArrSize(SVFValue* size)   //TODO:addSizeVar
+    inline void addArrSize(SVFVar* size)   //TODO:addSizeVar
     {
         arrSize.push_back(size);
     }
 
     ///< get array size of the allocated memory
-    inline const std::vector<SVFValue*>& getArrSize() const   //TODO:getSizeVars
+    inline const std::vector<SVFVar*>& getArrSize() const   //TODO:getSizeVars
     {
         return arrSize;
     }

package/svf/include/SVFIR/SVFVariables.h

@@ -133,11 +133,6 @@ public:
             {
                 return inst->getParent()->getParent();
             }
-            // For function arguments, return their parent function
-            else if (auto arg = SVFUtil::dyn_cast<SVFArgument>(value))
-            {
-                return arg->getParent();
-            }
         }
 
         // Return nullptr for globals/constants with no parent function
@@ -388,6 +383,83 @@ public:
 };
 
 
+/**
+ * @brief Class representing a function argument variable in the SVFIR
+ *
+ * This class models function argument in the program analysis. It extends ValVar
+ * to specifically handle function argument.
+ */
+class ArgValVar: public ValVar
+{
+    friend class SVFIRWriter;
+    friend class SVFIRReader;
+
+private:
+    const CallGraphNode* cgNode;
+    u32_t argNo;
+    bool uncalled;
+
+protected:
+    /// Constructor to create function argument (for SVFIRReader/deserialization)
+    ArgValVar(NodeID i, PNODEK ty = ArgNode) : ValVar(i, ty) {}
+
+public:
+    ///  Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const ArgValVar*)
+    {
+        return true;
+    }
+    static inline bool classof(const ValVar* node)
+    {
+        return node->getNodeKind() == ArgNode;
+    }
+    static inline bool classof(const SVFVar* node)
+    {
+        return node->getNodeKind() == ArgNode;
+    }
+    static inline bool classof(const GenericPAGNodeTy* node)
+    {
+        return node->getNodeKind() == ArgNode;
+    }
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return node->getNodeKind() == ArgNode;
+    }
+    //@}
+
+    /// Constructor
+    ArgValVar(NodeID i, u32_t argNo, const ICFGNode* icn, const CallGraphNode* callGraphNode,
+              bool isUncalled = false, PNODEK ty = ArgNode);
+
+    /// Return name of a LLVM value
+    inline const std::string getValueName() const
+    {
+        if (value)
+            return value->getName() + " (argument valvar)";
+        return " (argument valvar)";
+    }
+
+    virtual const SVFFunction* getFunction() const;
+
+    const SVFFunction* getParent() const;
+
+    ///  Return the index of this formal argument in its containing function.
+    /// For example in "void foo(int a, float b)" a is 0 and b is 1.
+    inline u32_t getArgNo() const
+    {
+        return argNo;
+    }
+
+    inline bool isArgOfUncalledFunction() const
+    {
+        return uncalled;
+    }
+
+    virtual const std::string toString() const;
+};
+
+
 /*
  * Gep Value (Pointer) variable, this variable can be dynamic generated for field sensitive analysis
  * e.g. memcpy, temp gep value variable needs to be created

package/svf/include/Util/SVFUtil.h

@@ -351,6 +351,8 @@ inline bool isArgOfUncalledFunction(const SVFValue* svfval)
         return false;
 }
 
+bool isArgOfUncalledFunction(const SVFVar* svfvar);
+
 const ObjVar* getObjVarOfValVar(const ValVar* valVar);
 
 /// Return thread fork function

package/svf/lib/AE/Core/AbstractState.cpp

@@ -485,7 +485,6 @@ const SVFType* AbstractState::getPointeeElement(NodeID id)
 
 u32_t AbstractState::getAllocaInstByteSize(const AddrStmt *addr)
 {
-    SVFIR* svfir = PAG::getPAG();
     if (const ObjVar* objvar = SVFUtil::dyn_cast<ObjVar>(addr->getRHSVar()))
     {
         objvar->getType();
@@ -497,18 +496,18 @@ u32_t AbstractState::getAllocaInstByteSize(const AddrStmt *addr)
 
         else
         {
-            const std::vector<SVFValue*>& sizes = addr->getArrSize();
+            const std::vector<SVFVar*>& sizes = addr->getArrSize();
             // Default element size is set to 1.
             u32_t elementSize = 1;
             u64_t res = elementSize;
-            for (const SVFValue* value: sizes)
+            for (const SVFVar* value: sizes)
             {
-                if (!inVarToValTable(svfir->getValueNode(value)))
+                if (!inVarToValTable(value->getId()))
                 {
-                    (*this)[svfir->getValueNode(value)] = IntervalValue(Options::MaxFieldLimit());
+                    (*this)[value->getId()] = IntervalValue(Options::MaxFieldLimit());
                 }
                 IntervalValue itv =
-                    (*this)[svfir->getValueNode(value)].getInterval();
+                    (*this)[value->getId()].getInterval();
                 res = res * itv.ub().getIntNumeral() > Options::MaxFieldLimit()? Options::MaxFieldLimit(): res * itv.ub().getIntNumeral();
             }
             return (u32_t)res;

package/svf/lib/Graphs/VFG.cpp

@@ -1073,29 +1073,29 @@ const SVFFunction* VFG::isFunEntryVFGNode(const VFGNode* node) const
 }
 
 
-const SVFValue* StmtVFGNode::getValue() const
+const SVFVar* StmtVFGNode::getValue() const
 {
     return getPAGEdge()->getValue();
 }
 
-const SVFValue* CmpVFGNode::getValue() const
+const SVFVar* CmpVFGNode::getValue() const
 {
-    return getRes()->getValue();
+    return getRes();
 }
 
-const SVFValue* BinaryOPVFGNode::getValue() const
+const SVFVar* BinaryOPVFGNode::getValue() const
 {
-    return getRes()->getValue();
+    return getRes();
 }
 
-const SVFValue* PHIVFGNode::getValue() const
+const SVFVar* PHIVFGNode::getValue() const
 {
-    return getRes()->hasValue() ? getRes()->getValue(): nullptr;
+    return getRes()->hasValue() ? getRes(): nullptr;
 }
 
-const SVFValue* ArgumentVFGNode::getValue() const
+const SVFVar* ArgumentVFGNode::getValue() const
 {
-    return param->hasValue() ? param->getValue() : nullptr;
+    return param->hasValue() ? param : nullptr;
 }
 
 /*!

package/svf/lib/MTA/MTA.cpp

@@ -164,7 +164,7 @@ void MTA::detect(SVFModule* module)
         for (Set<const StoreStmt*>::const_iterator sit = stores.begin(), esit = stores.end(); sit != esit; ++sit)
         {
             const StoreStmt* store = *sit;
-            if(load->getInst()==nullptr || store->getInst()==nullptr)
+            if(SVFUtil::isa<GlobalICFGNode>(load->getICFGNode()) || SVFUtil::isa<GlobalICFGNode>(store->getICFGNode()))
                 continue;
             if(mhp->mayHappenInParallelInst(load->getICFGNode(),store->getICFGNode()) && pta->alias(load->getRHSVarID(),store->getLHSVarID()))
                 if(lsa->isProtectedByCommonLock(load->getICFGNode(),store->getICFGNode()) == false)

package/svf/lib/SABER/SaberCondAllocator.cpp

@@ -399,27 +399,28 @@ bool SaberCondAllocator::isTestNotNullExpr(const ICFGNode* test) const
 bool SaberCondAllocator::isTestContainsNullAndTheValue(const CmpStmt *cmp) const
 {
 
+    // must be val var?
     const SVFVar* op0 = cmp->getOpVar(0);
     const SVFVar* op1 = cmp->getOpVar(1);
     if (SVFUtil::isa<ConstantNullPtrValVar>(op1))
     {
-        Set<const SVFValue* > inDirVal;
+        Set<const SVFVar* > inDirVal;
         inDirVal.insert(getCurEvalSVFGNode()->getValue());
         for (const auto &it: getCurEvalSVFGNode()->getOutEdges())
         {
             inDirVal.insert(it->getDstNode()->getValue());
         }
-        return inDirVal.find(op0->getValue()) != inDirVal.end();
+        return inDirVal.find(op0) != inDirVal.end();
     }
     else if (SVFUtil::isa<ConstantNullPtrValVar>(op0))
     {
-        Set<const SVFValue* > inDirVal;
+        Set<const SVFVar* > inDirVal;
         inDirVal.insert(getCurEvalSVFGNode()->getValue());
         for (const auto &it: getCurEvalSVFGNode()->getOutEdges())
         {
             inDirVal.insert(it->getDstNode()->getValue());
         }
-        return inDirVal.find(op1->getValue()) != inDirVal.end();
+        return inDirVal.find(op1) != inDirVal.end();
     }
     return false;
 }

package/svf/lib/SVFIR/SVFFileSystem.cpp

@@ -222,6 +222,7 @@ cJSON* SVFIRWriter::virtToJson(const SVFVar* var)
         CASE(DummyValNode, DummyValVar);
         CASE(DummyObjNode, DummyObjVar);
         CASE(FunObjNode, FunObjVar);
+        CASE(ArgNode, ArgValVar);
         CASE(FunValNode, FunValVar);
         CASE(HeapObjNode, HeapObjVar);
         CASE(StackObjNode, StackObjVar);

package/svf/lib/SVFIR/SVFIR.cpp

@@ -670,11 +670,10 @@ bool SVFIR::isValidPointer(NodeID nodeId) const
 
     if (node->hasValue() && node->isPointer())
     {
-        if(const SVFArgument* arg = SVFUtil::dyn_cast<SVFArgument>(node->getValue()))
-        {
-            if (!(arg->getParent()->isDeclaration()))
-                return true;
-        }
+        if (const ValVar* pVar = pag->getBaseValVar(nodeId))
+            if (const ArgValVar* arg = SVFUtil::dyn_cast<ArgValVar>(pVar))
+                if (!(arg->getParent()->isDeclaration()))
+                    return true;
     }
 
     if ((node->getInEdges().empty() && node->getOutEdges().empty()))
@@ -694,7 +693,7 @@ bool SVFIR::isValidTopLevelPtr(const SVFVar* node)
                 return true;
             }
             else if(node->hasValue())
-                return !SVFUtil::isArgOfUncalledFunction(node->getValue());
+                return !SVFUtil::isArgOfUncalledFunction(node);
         }
     }
     return false;

package/svf/lib/SVFIR/SVFVariables.cpp

@@ -46,6 +46,7 @@ SVFVar::SVFVar(const SVFValue* val, NodeID i, PNODEK k) :
     switch (k)
     {
     case ValNode:
+    case ArgNode:
     case ConstantDataValNode:
     case GlobalValNode:
     case BlackHoleNode:
@@ -144,6 +145,39 @@ const std::string ObjVar::toString() const
     return rawstr.str();
 }
 
+ArgValVar::ArgValVar(NodeID i, u32_t argNo, const ICFGNode* icn,
+                     const SVF::CallGraphNode* callGraphNode, bool isUncalled,
+                     SVF::SVFVar::PNODEK ty)
+    : ValVar(callGraphNode->getFunction()->getArg(argNo), i, ty, icn),
+      cgNode(callGraphNode), argNo(argNo), uncalled(isUncalled)
+{
+    isPtr =
+        callGraphNode->getFunction()->getArg(argNo)->getType()->isPointerTy();
+}
+
+const SVFFunction* ArgValVar::getFunction() const
+{
+    return getParent();
+}
+
+const SVFFunction* ArgValVar::getParent() const
+{
+    return cgNode->getFunction();
+}
+
+const std::string ArgValVar::toString() const
+{
+    std::string str;
+    std::stringstream rawstr(str);
+    rawstr << "ArgValVar ID: " << getId();
+    if (Options::ShowSVFIRValue())
+    {
+        rawstr << "\n";
+        rawstr << valueOnlyToString();
+    }
+    return rawstr.str();
+}
+
 const std::string GepValVar::toString() const
 {
     std::string str;
@@ -468,4 +502,3 @@ bool SVFVar::isConstDataOrAggDataButNotNullPtr() const
     else
         return false;
 }
-

package/svf/lib/Util/SVFUtil.cpp

@@ -425,6 +425,14 @@ const SVFFunction* SVFUtil::getProgEntryFunction()
     return nullptr;
 }
 
+bool SVFUtil::isArgOfUncalledFunction(const SVFVar* svfvar)
+{
+    const ValVar* pVar = PAG::getPAG()->getBaseValVar(svfvar->getId());
+    if(const ArgValVar* arg = SVFUtil::dyn_cast<ArgValVar>(pVar))
+        return arg->isArgOfUncalledFunction();
+    else
+        return false;
+}
 
 const ObjVar* SVFUtil::getObjVarOfValVar(const SVF::ValVar* valVar)
 {

package/svf/lib/Util/ThreadAPI.cpp

@@ -207,13 +207,13 @@ const SVFVar* ThreadAPI::getLockVal(const ICFGNode *cs) const
 const SVFVar* ThreadAPI::getJoinedThread(const CallICFGNode *cs) const
 {
     assert(isTDJoin(cs) && "not a thread join function!");
-    const SVFVar* join = cs->getArgument(0);
+    const ValVar* join = cs->getArgument(0);
     for(const SVFStmt* stmt : join->getInEdges())
     {
         if(SVFUtil::isa<LoadStmt>(stmt))
             return stmt->getSrcNode();
     }
-    if(SVFUtil::isa<SVFArgument>(join->getValue()))
+    if(SVFUtil::isa<ArgValVar>(join))
         return join;
 
     assert(false && "the value of the first argument at join is not a load instruction?");

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

@@ -307,8 +307,7 @@ protected:
         AddrStmt* edge = addAddrEdge(src, dst);
         if (inst.getArraySize())
         {
-            SVFValue* arrSz = llvmModuleSet()->getSVFValue(inst.getArraySize());
-            edge->addArrSize(arrSz);
+            edge->addArrSize(pag->getGNode(getValueNode(inst.getArraySize())));
         }
         return edge;
     }
@@ -334,8 +333,7 @@ protected:
             if (cs->arg_size() > 0)
             {
                 const llvm::Value* val = cs->getArgOperand(0);
-                SVFValue* svfval = llvmModuleSet()->getSVFValue(val);
-                edge->addArrSize(svfval);
+                edge->addArrSize(pag->getGNode(getValueNode(val)));
             }
         }
         // Check if the function called is 'calloc' and process its arguments.
@@ -344,8 +342,10 @@ protected:
         {
             if (cs->arg_size() > 1)
             {
-                edge->addArrSize(llvmModuleSet()->getSVFValue(cs->getArgOperand(0)));
-                edge->addArrSize(llvmModuleSet()->getSVFValue(cs->getArgOperand(1)));
+                edge->addArrSize(
+                    pag->getGNode(getValueNode(cs->getArgOperand(0))));
+                edge->addArrSize(
+                    pag->getGNode(getValueNode(cs->getArgOperand(1))));
             }
         }
         else
@@ -353,8 +353,7 @@ protected:
             if (cs->arg_size() > 0)
             {
                 const llvm::Value* val = cs->getArgOperand(0);
-                SVFValue* svfval = llvmModuleSet()->getSVFValue(val);
-                edge->addArrSize(svfval);
+                edge->addArrSize(pag->getGNode(getValueNode(val)));
             }
         }
         return edge;

package/svf-llvm/lib/SVFIRBuilder.cpp

@@ -245,6 +245,15 @@ void SVFIRBuilder::initialiseNodes()
             // add value node representing the function
             pag->addFunValNode(cgn, iter->second, icfgNode);
         }
+        else if (auto argval = SVFUtil::dyn_cast<Argument>(llvmValue))
+        {
+            pag->addArgValNode(
+                iter->second, argval->getArgNo(), icfgNode,
+                llvmModuleSet()->getCallGraphNode(argval->getParent()),
+                LLVMUtil::isArgOfUncalledFunction(argval));
+            llvmModuleSet()->addToLLVMVal2SVFVarMap(
+                argval, pag->getGNode(iter->second));
+        }
         else if (auto fpValue = SVFUtil::dyn_cast<ConstantFP>(llvmValue))
         {
             pag->addConstantFPValNode(iter->first, LLVMUtil::getDoubleValue(fpValue), iter->second, icfgNode);
@@ -1433,7 +1442,7 @@ void SVFIRBuilder::setCurrentBBAndValueForPAGEdge(PAGEdge* edge)
 
     assert(curVal && "current Val is nullptr?");
     edge->setBB(curBB!=nullptr ? curBB : nullptr);
-    edge->setValue(curVal);
+    edge->setValue(pag->getGNode(pag->getValueNode(curVal)));
     // backmap in valuToEdgeMap
     pag->mapValueToEdge(curVal, edge);
     ICFGNode* icfgNode = pag->getICFG()->getGlobalICFGNode();

package/svf-llvm/tools/Example/svf-ex.cpp

@@ -41,21 +41,21 @@ using namespace SVF;
 /*!
  * An example to query alias results of two SVF values
  */
-SVF::AliasResult aliasQuery(PointerAnalysis* pta, const SVFValue* v1, const SVFValue* v2)
+SVF::AliasResult aliasQuery(PointerAnalysis* pta, const SVFVar* v1, const SVFVar* v2)
 {
-    return pta->alias(v1, v2);
+    return pta->alias(v1->getId(), v2->getId());
 }
 
 /*!
  * An example to print points-to set of an SVF value
  */
-std::string printPts(PointerAnalysis* pta, const SVFValue* svfval)
+std::string printPts(PointerAnalysis* pta, const SVFVar* svfval)
 {
 
     std::string str;
     raw_string_ostream rawstr(str);
 
-    NodeID pNodeId = pta->getPAG()->getValueNode(svfval);
+    NodeID pNodeId = svfval->getId();
     const PointsTo& pts = pta->getPts(pNodeId);
     for (PointsTo::iterator ii = pts.begin(), ie = pts.end();
             ii != ie; ii++)
@@ -105,13 +105,11 @@ void dummyVisit(const VFGNode* node)
 /*!
  * An example to query/collect all the uses of a definition of a value along value-flow graph (VFG)
  */
-void traverseOnVFG(const SVFG* vfg, const SVFValue* svfval)
+void traverseOnVFG(const SVFG* vfg, const SVFVar* svfval)
 {
-    SVFIR* pag = SVFIR::getPAG();
-    PAGNode* pNode = pag->getGNode(pag->getValueNode(svfval));
-    if (!vfg->hasDefSVFGNode(pNode))
+    if (!vfg->hasDefSVFGNode(svfval))
         return;
-    const VFGNode* vNode = vfg->getDefSVFGNode(pNode);
+    const VFGNode* vNode = vfg->getDefSVFGNode(svfval);
     FIFOWorkList<const VFGNode*> worklist;
     Set<const VFGNode*> visited;
     worklist.push(vNode);