add argvalvar

svf-llvm/lib/SVFIRBuilder.cpp

@@ -244,6 +244,13 @@ void SVFIRBuilder::initialiseNodes()
             const CallGraphNode* cgn = llvmModuleSet()->getCallGraphNode(func);
             // add value node representing the function
             pag->addFunValNode(cgn, iter->second, icfgNode);
+        } else if (auto argval = SVFUtil::dyn_cast<Argument>(llvmValue)) {
+            pag->addArgValNode(
+                llvmModuleSet()->getCallGraphNode(argval->getParent()),
+                argval->getArgNo(), LLVMUtil::isArgOfUncalledFunction(argval), iter->second,
+                icfgNode);
+            llvmModuleSet()->addToLLVMVal2SVFVarMap(
+                argval, pag->getGNode(iter->second));
         }
         else if (auto fpValue = SVFUtil::dyn_cast<ConstantFP>(llvmValue))
         {

svf/include/Graphs/GenericGraph.h

@@ -154,6 +154,7 @@ class SVFBaseNode
         // ┌── 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 @@ class SVFBaseNode
 
     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 @@ class SVFBaseNode
 
     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;

svf/include/SVFIR/SVFIR.h

@@ -578,6 +578,13 @@ class SVFIR : public IRGraph
         return addValNode(nullptr, node, i);
     }
 
+    NodeID addArgValNode(const CallGraphNode* callGraphNode, u32_t argNo,
+                         bool isUncalled, NodeID i, const ICFGNode* icfgNode) {
+        ArgValVar* node =
+            new ArgValVar(i, callGraphNode, argNo, isUncalled, icfgNode);
+        return addValNode(nullptr, node, i);
+    }
+
     inline NodeID addConstantFPValNode(const SVFValue* curInst, double dval, const NodeID i,
                                        const ICFGNode* icfgNode)
     {

svf/include/SVFIR/SVFVariables.h

@@ -133,11 +133,6 @@ class SVFVar : public GenericPAGNodeTy
             {
                 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,82 @@ class ObjVar: public SVFVar
 };
 
 
+/**
+ * @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, const CallGraphNode* callGraphNode, u32_t argNo,
+              bool isUncalled, const ICFGNode* icn, 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

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

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);

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;

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(SVF::NodeID i, const SVF::CallGraphNode* callGraphNode,
+                     SVF::u32_t argNo, bool isUncalled,
+                     const SVF::ICFGNode* icn, 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;
 }
-

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)
 {

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?");