svf-tools 1.0.1026 → 1.0.1028

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.1026",
+  "version": "1.0.1028",
   "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/SVFIR/SVFIR.h

@@ -572,23 +572,30 @@ private:
         return addValNode(val, node, i);
     }
 
-    NodeID addFunValNode(const CallGraphNode* callGraphNode, NodeID i, const ICFGNode* icfgNode)
+    NodeID addFunValNode(NodeID i, const ICFGNode* icfgNode, const CallGraphNode* callGraphNode)
     {
-        FunValVar* node = new FunValVar(callGraphNode, i, icfgNode);
+        FunValVar* node = new FunValVar(i, icfgNode, callGraphNode);
         return addValNode(nullptr, node, i);
     }
 
-    inline NodeID addConstantFPValNode(const SVFValue* curInst, double dval, const NodeID 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, const NodeID i, double dval,
                                        const ICFGNode* icfgNode)
     {
-        SVFVar* node = new ConstantFPValVar(curInst,  dval, i, icfgNode);
+        SVFVar* node = new ConstantFPValVar(curInst,  i, dval, icfgNode);
         return addNode(node, i);
     }
 
-    inline NodeID addConstantIntValNode(const SVFValue* curInst, const std::pair<s64_t, u64_t>& intValue, const NodeID i,
+    inline NodeID addConstantIntValNode(const SVFValue* curInst, NodeID i, const std::pair<s64_t, u64_t>& intValue,
                                         const ICFGNode* icfgNode)
     {
-        SVFVar* node = new ConstantIntValVar(curInst, intValue.first, intValue.second, i, icfgNode);
+        SVFVar* node = new ConstantIntValVar(curInst, i, intValue.first, intValue.second, icfgNode);
         return addNode(node, i);
     }
 
@@ -622,47 +629,47 @@ private:
     /**
      * Creates and adds a heap object node to the SVFIR
      */
-    inline NodeID addHeapObjNode(const SVFValue* val, const SVFFunction* f, NodeID i)
+    inline NodeID addHeapObjNode(const SVFValue* val, NodeID i, const SVFFunction* f)
     {
         const MemObj* mem = getMemObj(val);
         assert(mem->getId() == i && "not same object id?");
         memToFieldsMap[i].set(i);
-        HeapObjVar *node = new HeapObjVar(f, val->getType(), i, mem);
+        HeapObjVar *node = new HeapObjVar(i, mem, val->getType(), f);
         return addObjNode(val, node, i);
     }
 
     /**
      * Creates and adds a stack object node to the SVFIR
      */
-    inline NodeID addStackObjNode(const SVFValue* val, const SVFFunction* f, NodeID i)
+    inline NodeID addStackObjNode(const SVFValue* val, NodeID i, const SVFFunction* f)
     {
         const MemObj* mem = getMemObj(val);
         assert(mem->getId() == i && "not same object id?");
         memToFieldsMap[i].set(i);
-        StackObjVar *node = new  StackObjVar(f, val->getType(), i, mem);
+        StackObjVar *node = new  StackObjVar(i, mem, val->getType(), f);
         return addObjNode(val, node, i);
     }
 
-    NodeID addFunObjNode(const CallGraphNode* callGraphNode, NodeID id);
+    NodeID addFunObjNode(NodeID id, const CallGraphNode* callGraphNode);
 
 
-    inline NodeID addConstantFPObjNode(const SVFValue* curInst, double dval, const NodeID i)
+    inline NodeID addConstantFPObjNode(const SVFValue* curInst, NodeID i, double dval)
     {
         const MemObj* mem = getMemObj(curInst);
         NodeID base = mem->getId();
         memToFieldsMap[base].set(mem->getId());
-        ConstantFPObjVar* node = new ConstantFPObjVar(curInst, dval, mem->getId(), mem);
+        ConstantFPObjVar* node = new ConstantFPObjVar(curInst, i, dval, mem);
         return addObjNode(curInst, node, mem->getId());
     }
 
 
-    inline NodeID addConstantIntObjNode(const SVFValue* curInst, const std::pair<s64_t, u64_t>& intValue, const NodeID i)
+    inline NodeID addConstantIntObjNode(const SVFValue* curInst, NodeID i, const std::pair<s64_t, u64_t>& intValue)
     {
         const MemObj* mem = getMemObj(curInst);
         NodeID base = mem->getId();
         memToFieldsMap[base].set(mem->getId());
         ConstantIntObjVar* node =
-            new ConstantIntObjVar(curInst, intValue.first, intValue.second, mem->getId(), mem);
+            new ConstantIntObjVar(curInst, i, intValue.first, intValue.second,  mem);
         return addObjNode(curInst, node, mem->getId());
     }
 
@@ -695,15 +702,15 @@ private:
     }
 
     /// Add a unique return node for a procedure
-    inline NodeID addRetNode(const CallGraphNode* callGraphNode, NodeID i)
+    inline NodeID addRetNode(NodeID i, const CallGraphNode* callGraphNode)
     {
-        SVFVar *node = new RetPN(callGraphNode,i);
+        SVFVar *node = new RetPN(i, callGraphNode);
         return addRetNode(callGraphNode, node, i);
     }
     /// Add a unique vararg node for a procedure
-    inline NodeID addVarargNode(const CallGraphNode* val, NodeID i)
+    inline NodeID addVarargNode(NodeID i, const CallGraphNode* val)
     {
-        SVFVar *node = new VarArgPN(val,i);
+        SVFVar *node = new VarArgPN(i, val);
         return addNode(node,i);
     }
 

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
@@ -652,8 +724,8 @@ public:
     //@}
 
     /// Constructor
-    HeapObjVar(const SVFFunction* func, const SVFType* svfType, NodeID i,
-               const MemObj* mem, PNODEK ty = HeapObjNode);
+    HeapObjVar(NodeID i, const MemObj* mem, const SVFType* svfType,
+               const SVFFunction* fun, PNODEK ty = HeapObjNode);
 
     /// Return name of a LLVM value
     inline const std::string getValueName() const
@@ -713,8 +785,8 @@ public:
     //@}
 
     /// Constructor
-    StackObjVar(const SVFFunction* f, const SVFType* svfType, NodeID i,
-                const MemObj* mem, PNODEK ty = StackObjNode);
+    StackObjVar(NodeID i, const MemObj* mem, const SVFType* svfType,
+                const SVFFunction* fun, PNODEK ty = StackObjNode);
 
     /// Return name of a LLVM value
     inline const std::string getValueName() const
@@ -766,7 +838,7 @@ public:
     }
 
     /// Constructor
-    FunValVar(const CallGraphNode* cgn, NodeID i, const ICFGNode* icn,
+    FunValVar(NodeID i, const ICFGNode* icn, const CallGraphNode* cgn,
               PNODEK ty = FunValNode);
 
     virtual const std::string toString() const;
@@ -814,7 +886,7 @@ public:
     //@}
 
     /// Constructor
-    FunObjVar(const CallGraphNode* cgNode, NodeID i, const MemObj* mem,
+    FunObjVar(NodeID i, const MemObj* mem, const CallGraphNode* cgNode,
               PNODEK ty = FunObjNode);
 
     inline const CallGraphNode* getCallGraphNode() const
@@ -997,7 +1069,7 @@ public:
     }
 
     /// Constructor
-    ConstantFPValVar(const SVFValue* val, double dv, NodeID i, const ICFGNode* icn,
+    ConstantFPValVar(const SVFValue* val, NodeID i, double dv, const ICFGNode* icn,
                      PNODEK ty = ConstantFPValNode)
         : ConstantDataValVar(val, i,  icn, ty), dval(dv)
     {
@@ -1056,7 +1128,7 @@ public:
     }
 
     /// Constructor
-    ConstantIntValVar(const SVFValue* val, s64_t sv, u64_t zv, NodeID i, const ICFGNode* icn,
+    ConstantIntValVar(const SVFValue* val, NodeID i, s64_t sv, u64_t zv, const ICFGNode* icn,
                       PNODEK ty = ConstantIntValNode)
         : ConstantDataValVar(val, i,  icn, ty), zval(zv), sval(sv)
     {
@@ -1255,7 +1327,7 @@ public:
     //@}
 
     /// Constructor
-    ConstantFPObjVar(const SVFValue* val, double dv, NodeID i, const MemObj* m, PNODEK ty = ConstantFPObjNode)
+    ConstantFPObjVar(const SVFValue* val, NodeID i, double dv, const MemObj* m, PNODEK ty = ConstantFPObjNode)
         : ConstantDataObjVar(val, i, m, ty), dval(dv)
     {
     }
@@ -1330,7 +1402,7 @@ public:
     //@}
 
     /// Constructor
-    ConstantIntObjVar(const SVFValue* val, s64_t sv, u64_t zv, NodeID i, const MemObj* m, PNODEK ty = ConstantIntObjNode)
+    ConstantIntObjVar(const SVFValue* val, NodeID i, s64_t sv, u64_t zv, const MemObj* m, PNODEK ty = ConstantIntObjNode)
         : ConstantDataObjVar(val, i, m, ty), zval(zv), sval(sv)
     {
     }
@@ -1433,7 +1505,7 @@ public:
 
 
     /// Constructor
-    RetPN(const CallGraphNode* node, NodeID i);
+    RetPN(NodeID i, const CallGraphNode* node);
 
     inline const CallGraphNode* getCallGraphNode() const
     {
@@ -1487,7 +1559,7 @@ public:
     //@}
 
     /// Constructor
-    VarArgPN(const CallGraphNode* node, NodeID i) : ValVar(nullptr, i, VarargNode), callGraphNode(node) {}
+    VarArgPN(NodeID i, const CallGraphNode* node) : ValVar(nullptr, i, VarargNode), callGraphNode(node) {}
 
     virtual const SVFFunction* getFunction() const;
 

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/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

@@ -472,14 +472,14 @@ NodeID SVFIR::addFIObjNode(const MemObj* obj)
     return addObjNode(obj->getValue(), node, obj->getId());
 }
 
-NodeID SVFIR::addFunObjNode(const CallGraphNode* callGraphNode, NodeID id)
+NodeID SVFIR::addFunObjNode(NodeID id, const CallGraphNode* callGraphNode)
 {
     const MemObj* mem = getMemObj(callGraphNode->getFunction());
     assert(mem->getId() == id && "not same object id?");
     //assert(findPAGNode(i) == false && "this node should not be created before");
     NodeID base = mem->getId();
     memToFieldsMap[base].set(mem->getId());
-    FunObjVar*node = new FunObjVar(callGraphNode, mem->getId(), mem);
+    FunObjVar*node = new FunObjVar(id, mem, callGraphNode);
     return addObjNode(mem->getValue(), node, mem->getId());
 }
 
@@ -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;
@@ -157,7 +191,7 @@ const std::string GepValVar::toString() const
     return rawstr.str();
 }
 
-RetPN::RetPN(const CallGraphNode* node, NodeID i) : ValVar(i, RetNode), callGraphNode(node)
+RetPN::RetPN(NodeID i, const CallGraphNode* node) : ValVar(i, RetNode), callGraphNode(node)
 {
     isPtr = node->getFunction()->getReturnType()->isPointerTy();
 }
@@ -198,8 +232,8 @@ const std::string BaseObjVar::toString() const
     return rawstr.str();
 }
 
-HeapObjVar::HeapObjVar(const SVFFunction* f, const SVFType* svfType, NodeID i,
-                       const MemObj* mem, PNODEK ty)
+HeapObjVar::HeapObjVar(NodeID i, const MemObj* mem, const SVFType* svfType,
+                       const SVFFunction* f, PNODEK ty)
     : BaseObjVar(mem->getValue(), i, mem, ty)
 {
     isPtr = svfType->isPointerTy();
@@ -219,8 +253,7 @@ const std::string HeapObjVar::toString() const
     return rawstr.str();
 }
 
-StackObjVar::StackObjVar(const SVFFunction* f, const SVFType* svfType, NodeID i,
-                         const MemObj* mem, PNODEK ty)
+StackObjVar::StackObjVar(NodeID i, const MemObj* mem, const SVFType* svfType, const SVFFunction* f, PNODEK ty)
     : BaseObjVar(mem->getValue(), i, mem, ty)
 {
     isPtr = svfType->isPointerTy();
@@ -242,8 +275,7 @@ const std::string StackObjVar::toString() const
 
 
 
-FunValVar::FunValVar(const CallGraphNode* cgn, NodeID i, const ICFGNode* icn,
-                     PNODEK ty)
+FunValVar::FunValVar(NodeID i, const ICFGNode* icn, const CallGraphNode* cgn, PNODEK ty)
     : ValVar(cgn->getFunction(), i, ty, icn), callGraphNode(cgn)
 {
     isPtr = cgn->getFunction()->getType()->isPointerTy();
@@ -392,7 +424,7 @@ const std::string ConstantNullPtrObjVar::toString() const
     return rawstr.str();
 }
 
-FunObjVar::FunObjVar(const CallGraphNode* cgNode, NodeID i, const MemObj* mem,
+FunObjVar::FunObjVar(NodeID i, const MemObj* mem, const CallGraphNode* cgNode,
                      PNODEK ty)
     : BaseObjVar(mem->getValue(), i, mem, ty), callGraphNode(cgNode)
 {
@@ -468,4 +500,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/lib/SVFIRBuilder.cpp

@@ -243,17 +243,26 @@ void SVFIRBuilder::initialiseNodes()
         {
             const CallGraphNode* cgn = llvmModuleSet()->getCallGraphNode(func);
             // add value node representing the function
-            pag->addFunValNode(cgn, iter->second, icfgNode);
+            pag->addFunValNode(iter->second, icfgNode, cgn);
+        }
+        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);
+            pag->addConstantFPValNode(iter->first, iter->second, LLVMUtil::getDoubleValue(fpValue), icfgNode);
             llvmModuleSet()->addToLLVMVal2SVFVarMap(
                 fpValue, pag->getGNode(iter->second));
         }
         else if (auto intValue = SVFUtil::dyn_cast<ConstantInt>(llvmValue))
         {
-            pag->addConstantIntValNode(iter->first, LLVMUtil::getIntegerValue(intValue), iter->second, icfgNode);
+            pag->addConstantIntValNode(iter->first, iter->second, LLVMUtil::getIntegerValue(intValue), icfgNode);
             llvmModuleSet()->addToLLVMVal2SVFVarMap(
                 intValue, pag->getGNode(iter->second));
         }
@@ -300,14 +309,14 @@ void SVFIRBuilder::initialiseNodes()
         // Check if the value is a function and add a function object node
         if (const Function* func = SVFUtil::dyn_cast<Function>(llvmValue))
         {
-            pag->addFunObjNode(llvmModuleSet()->getCallGraphNode(func), iter->second);
+            pag->addFunObjNode(iter->second, llvmModuleSet()->getCallGraphNode(func));
         }
         // Check if the value is a heap object and add a heap object node
         else if (LLVMUtil::isHeapObj(llvmValue))
         {
             const SVFFunction* f =
                 SVFUtil::cast<SVFInstruction>(iter->first)->getFunction();
-            pag->addHeapObjNode(iter->first, f, iter->second);
+            pag->addHeapObjNode(iter->first, iter->second, f);
             llvmModuleSet()->addToLLVMVal2SVFVarMap(
                 llvmValue, pag->getGNode(iter->second));
         }
@@ -316,19 +325,19 @@ void SVFIRBuilder::initialiseNodes()
         {
             const SVFFunction* f =
                 SVFUtil::cast<SVFInstruction>(iter->first)->getFunction();
-            pag->addStackObjNode(iter->first, f, iter->second);
+            pag->addStackObjNode(iter->first, iter->second, f);
             llvmModuleSet()->addToLLVMVal2SVFVarMap(
                 llvmValue, pag->getGNode(iter->second));
         }
         else if (auto fpValue = SVFUtil::dyn_cast<ConstantFP>(llvmValue))
         {
-            pag->addConstantFPObjNode(iter->first, LLVMUtil::getDoubleValue(fpValue), iter->second);
+            pag->addConstantFPObjNode(iter->first, iter->second, LLVMUtil::getDoubleValue(fpValue));
             llvmModuleSet()->addToLLVMVal2SVFVarMap(
                 fpValue, pag->getGNode(iter->second));
         }
         else if (auto intValue = SVFUtil::dyn_cast<ConstantInt>(llvmValue))
         {
-            pag->addConstantIntObjNode(iter->first, LLVMUtil::getIntegerValue(intValue), iter->second);
+            pag->addConstantIntObjNode(iter->first, iter->second, LLVMUtil::getIntegerValue(intValue));
             llvmModuleSet()->addToLLVMVal2SVFVarMap(
                 intValue, pag->getGNode(iter->second));
         }
@@ -362,10 +371,9 @@ void SVFIRBuilder::initialiseNodes()
             ++iter)
     {
         DBOUT(DPAGBuild, outs() << "add ret node " << iter->second << "\n");
-        pag->addRetNode(
-            llvmModuleSet()->getCallGraphNode(SVFUtil::cast<Function>(
-                    llvmModuleSet()->getLLVMValue(iter->first))),
-            iter->second);
+        pag->addRetNode(iter->second,
+                        llvmModuleSet()->getCallGraphNode(SVFUtil::cast<Function>(
+                                    llvmModuleSet()->getLLVMValue(iter->first))));
     }
 
     for (SymbolTableInfo::FunToIDMapTy::iterator iter =
@@ -373,10 +381,9 @@ void SVFIRBuilder::initialiseNodes()
             iter != symTable->varargSyms().end(); ++iter)
     {
         DBOUT(DPAGBuild, outs() << "add vararg node " << iter->second << "\n");
-        pag->addVarargNode(
-            llvmModuleSet()->getCallGraphNode(SVFUtil::cast<Function>(
-                    llvmModuleSet()->getLLVMValue(iter->first))),
-            iter->second);
+        pag->addVarargNode(iter->second,
+                           llvmModuleSet()->getCallGraphNode(SVFUtil::cast<Function>(
+                                       llvmModuleSet()->getLLVMValue(iter->first))));
     }
 
     /// add address edges for constant nodes.

package/svf-llvm/lib/SVFIRExtAPI.cpp

@@ -65,7 +65,7 @@ const Type* SVFIRBuilder::getBaseTypeAndFlattenedFields(const Value* V, std::vec
         {
             SymbolTableBuilder builder(pag->getSymbolInfo());
             builder.collectSym(offset);
-            pag->addConstantIntValNode(svfOffset, LLVMUtil::getIntegerValue(offset), pag->getSymbolInfo()->getValSym(svfOffset), nullptr);
+            pag->addConstantIntValNode(svfOffset, pag->getSymbolInfo()->getValSym(svfOffset), LLVMUtil::getIntegerValue(offset), nullptr);
         }
         ls.addOffsetVarAndGepTypePair(getPAG()->getGNode(getPAG()->getValueNode(svfOffset)), nullptr);
         fields.push_back(ls);