svf-lib 1.0.2211 → 1.0.2213

package/SVF-linux/Release-build/include/SVFIR/SVFIR.h

@@ -57,12 +57,11 @@ public:
     typedef std::vector<const SVFStmt*> SVFStmtList;
     typedef std::vector<const SVFVar*> SVFVarList;
     typedef Map<const SVFVar*,PhiStmt*> PHINodeMap;
-    typedef Map<const SVFFunction*,SVFVarList> FunToArgsListMap;
+    typedef Map<const FunObjVar*,SVFVarList> FunToArgsListMap;
     typedef Map<const CallICFGNode*,SVFVarList> CSToArgsListMap;
     typedef Map<const RetICFGNode*,const SVFVar*> CSToRetMap;
-    typedef Map<const SVFFunction*,const SVFVar*> FunToRetMap;
-    typedef Map<const SVFFunction*,const FunObjVar *> FunToFunObjVarMap;
-    typedef Map<const SVFFunction*,SVFStmtSet> FunToPAGEdgeSetMap;
+    typedef Map<const FunObjVar*,const SVFVar*> FunToRetMap;
+    typedef Map<const FunObjVar*,SVFStmtSet> FunToPAGEdgeSetMap;
     typedef Map<const ICFGNode*,SVFStmtList> ICFGNode2SVFStmtsMap;
     typedef Map<NodeID, NodeID> NodeToNodeMap;
     typedef std::pair<NodeID, APOffset> NodeOffset;
@@ -89,7 +88,6 @@ private:
     CSToArgsListMap callSiteArgsListMap;	///< Map a callsite to a list of all its actual parameters
     CSToRetMap callSiteRetMap;	///< Map a callsite to its callsite returns PAGNodes
     FunToRetMap funRetMap;	///< Map a function to its unique function return PAGNodes
-    FunToFunObjVarMap funToFunObjvarMap;    ///< Map a function to its unique function object PAGNodes
     CallSiteToFunPtrMap indCallSiteToFunPtrMap; ///< Map an indirect callsite to its function pointer
     FunPtrToCallSitesMap funPtrToCallSitesMap;	///< Map a function pointer to the callsites where it is used
     /// Valid pointers for pointer analysis resolution connected by SVFIR edges (constraints)
@@ -196,6 +194,8 @@ public:
         return callGraph;
     }
 
+    const FunObjVar* getFunObjVar(const std::string& name);
+
     /// Get/set methods to get SVFStmts based on their kinds and ICFGNodes
     //@{
     /// Get edges set according to its kind
@@ -263,7 +263,7 @@ public:
     }
 
     /// Function has arguments list
-    inline bool hasFunArgsList(const SVFFunction* func) const
+    inline bool hasFunArgsList(const FunObjVar* func) const
     {
         return (funArgsListMap.find(func) != funArgsListMap.end());
     }
@@ -273,7 +273,7 @@ public:
         return funArgsListMap;
     }
     /// Get function arguments list
-    inline const SVFVarList& getFunArgsList(const SVFFunction*  func) const
+    inline const SVFVarList& getFunArgsList(const FunObjVar*  func) const
     {
         FunToArgsListMap::const_iterator it = funArgsListMap.find(func);
         assert(it != funArgsListMap.end() && "this function doesn't have arguments");
@@ -318,24 +318,18 @@ public:
         return funRetMap;
     }
     /// Get function return list
-    inline const SVFVar* getFunRet(const SVFFunction*  func) const
+    inline const SVFVar* getFunRet(const FunObjVar*  func) const
     {
         FunToRetMap::const_iterator it = funRetMap.find(func);
         assert(it != funRetMap.end() && "this function doesn't have return");
         return it->second;
     }
-    inline bool funHasRet(const SVFFunction* func) const
+    inline bool funHasRet(const FunObjVar* func) const
     {
         return funRetMap.find(func) != funRetMap.end();
     }
     //@}
 
-    inline const FunObjVar* getFunObjVar(const SVFFunction*  node) const
-    {
-        FunToFunObjVarMap::const_iterator it = funToFunObjvarMap.find(node);
-        assert(it != funToFunObjvarMap.end() && "this function doesn't have funobjvar");
-        return it->second;
-    }
     /// Node and edge statistics
     //@{
     inline u32_t getFieldValNodeNum() const
@@ -503,14 +497,14 @@ private:
     /// Get/set method for function/callsite arguments and returns
     //@{
     /// Add function arguments
-    inline void addFunArgs(const SVFFunction* fun, const SVFVar* arg)
+    inline void addFunArgs(const FunObjVar* fun, const SVFVar* arg)
     {
         FunEntryICFGNode* funEntryBlockNode = icfg->getFunEntryICFGNode(fun);
         funEntryBlockNode->addFormalParms(arg);
         funArgsListMap[fun].push_back(arg);
     }
     /// Add function returns
-    inline void addFunRet(const SVFFunction* fun, const SVFVar* ret)
+    inline void addFunRet(const FunObjVar* fun, const SVFVar* ret)
     {
         FunExitICFGNode* funExitBlockNode = icfg->getFunExitICFGNode(fun);
         funExitBlockNode->addFormalRet(ret);
@@ -546,13 +540,13 @@ private:
         return addValNode(node);
     }
 
-    NodeID addFunValNode(NodeID i, const ICFGNode* icfgNode, const SVFFunction* callGraphNode, const SVFType* type)
+    NodeID addFunValNode(NodeID i, const ICFGNode* icfgNode, const FunObjVar* funObjVar, const SVFType* type)
     {
-        FunValVar* node = new FunValVar(i, icfgNode, callGraphNode, type);
+        FunValVar* node = new FunValVar(i, icfgNode, funObjVar, type);
         return addValNode(node);
     }
 
-    NodeID addArgValNode(NodeID i, u32_t argNo, const ICFGNode* icfgNode, const SVFFunction* callGraphNode, const SVFType* type)
+    NodeID addArgValNode(NodeID i, u32_t argNo, const ICFGNode* icfgNode, const FunObjVar* callGraphNode, const SVFType* type)
     {
         ArgValVar* node =
             new ArgValVar(i, argNo, icfgNode, callGraphNode, type);
@@ -624,11 +618,10 @@ private:
         return addObjNode(stackObj);
     }
 
-    NodeID addFunObjNode(NodeID id,  ObjTypeInfo* ti, const SVFFunction* callGraphNode, const SVFType* type, const ICFGNode* node)
+    NodeID addFunObjNode(NodeID id,  ObjTypeInfo* ti, const SVFType* type, const ICFGNode* node)
     {
         memToFieldsMap[id].set(id);
-        FunObjVar* funObj = new FunObjVar(id, ti, callGraphNode, type, node);
-        funToFunObjvarMap[callGraphNode] = funObj;
+        FunObjVar* funObj = new FunObjVar(id, ti, type, node);
         return addObjNode(funObj);
     }
 
@@ -677,13 +670,13 @@ private:
     }
 
     /// Add a unique return node for a procedure
-    inline NodeID addRetNode(NodeID i, const SVFFunction* callGraphNode, const SVFType* type, const ICFGNode* icn)
+    inline NodeID addRetNode(NodeID i, const FunObjVar* callGraphNode, const SVFType* type, const ICFGNode* icn)
     {
         SVFVar *node = new RetValPN(i, callGraphNode, type, icn);
         return addRetNode(callGraphNode, node);
     }
     /// Add a unique vararg node for a procedure
-    inline NodeID addVarargNode(NodeID i, const SVFFunction* val, const SVFType* type, const ICFGNode* n)
+    inline NodeID addVarargNode(NodeID i, const FunObjVar* val, const SVFType* type, const ICFGNode* n)
     {
         SVFVar *node = new VarArgValPN(i, val, type, n);
         return addNode(node);
@@ -757,12 +750,12 @@ private:
         return addNode(node);
     }
     /// Add a unique return node for a procedure
-    inline NodeID addRetNode(const SVFFunction*, SVFVar *node)
+    inline NodeID addRetNode(const FunObjVar*, SVFVar *node)
     {
         return addNode(node);
     }
     /// Add a unique vararg node for a procedure
-    inline NodeID addVarargNode(const SVFFunction*, SVFVar *node)
+    inline NodeID addVarargNode(const FunObjVar*, SVFVar *node)
     {
         return addNode(node);
     }

package/SVF-linux/Release-build/include/SVFIR/SVFValue.h

@@ -522,6 +522,7 @@ public:
 };
 
 class ICFGNode;
+class FunObjVar;
 
 class SVFInstruction : public SVFValue
 {
@@ -551,7 +552,7 @@ public:
         return bb;
     }
 
-    inline const SVFFunction* getFunction() const
+    inline const FunObjVar* getFunction() const
     {
         return bb->getParent();
     }
@@ -630,7 +631,7 @@ public:
     {
         return SVFUtil::dyn_cast<SVFFunction>(calledVal);
     }
-    inline  const SVFFunction* getCaller() const
+    inline  const FunObjVar* getCaller() const
     {
         return getFunction();
     }

package/SVF-linux/Release-build/include/SVFIR/SVFVariables.h

@@ -101,7 +101,7 @@ public:
     virtual const std::string getValueName() const = 0;
 
     /// Get containing function, or null for globals/constants
-    virtual inline const SVFFunction* getFunction() const
+    virtual inline const FunObjVar* getFunction() const
     {
         return nullptr;
     }
@@ -183,17 +183,7 @@ public:
     }
 
     /// Check if this pointer is in an uncalled function
-    inline virtual bool ptrInUncalledFunction() const
-    {
-        if (const SVFFunction* fun = getFunction())
-        {
-            return fun->isUncalledFunction();
-        }
-        else
-        {
-            return false;
-        }
-    }
+    virtual bool ptrInUncalledFunction() const;
 
     /// Check if this variable represents constant/aggregate data
     virtual bool isConstDataOrAggData() const
@@ -302,7 +292,7 @@ public:
         return icfgNode;
     }
 
-    virtual const SVFFunction* getFunction() const;
+    virtual const FunObjVar* getFunction() const;
 
     virtual const std::string toString() const;
 };
@@ -366,7 +356,7 @@ class ArgValVar: public ValVar
     friend class SVFIRReader;
 
 private:
-    const SVFFunction* cgNode;
+    const FunObjVar* cgNode;
     u32_t argNo;
 
 protected:
@@ -399,7 +389,7 @@ public:
     //@}
 
     /// Constructor
-    ArgValVar(NodeID i, u32_t argNo, const ICFGNode* icn, const SVFFunction* callGraphNode,
+    ArgValVar(NodeID i, u32_t argNo, const ICFGNode* icn, const FunObjVar* callGraphNode,
               const SVFType* svfType);
 
     /// Return name of a LLVM value
@@ -408,9 +398,9 @@ public:
         return getName() + " (argument valvar)";
     }
 
-    virtual const SVFFunction* getFunction() const;
+    virtual const FunObjVar* getFunction() const;
 
-    const SVFFunction* getParent() const;
+    const FunObjVar* 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.
@@ -419,10 +409,7 @@ public:
         return argNo;
     }
 
-    inline bool isArgOfUncalledFunction() const
-    {
-        return getFunction()->isUncalledFunction();
-    }
+    bool isArgOfUncalledFunction() const;
 
     virtual bool isPointer() const;
 
@@ -506,7 +493,7 @@ public:
         return gepValType;
     }
 
-    virtual const SVFFunction* getFunction() const
+    virtual const FunObjVar* getFunction() const
     {
         return base->getFunction();
     }
@@ -725,7 +712,7 @@ public:
         typeInfo = nullptr;
     }
 
-    virtual const SVFFunction* getFunction() const;
+    virtual const FunObjVar* getFunction() const;
 
 };
 
@@ -807,7 +794,7 @@ public:
         return getName() + "_" + std::to_string(apOffset);
     }
 
-    virtual const SVFFunction* getFunction() const
+    virtual const FunObjVar* getFunction() const
     {
         return base->getFunction();
     }
@@ -963,113 +950,326 @@ public:
 
 class CallGraphNode;
 
-class FunValVar : public ValVar
+class FunObjVar : public BaseObjVar
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
+    friend class SVFIRBuilder;
+
+public:
+    typedef SVFLoopAndDomInfo::BBSet BBSet;
+    typedef SVFLoopAndDomInfo::BBList BBList;
+    typedef SVFLoopAndDomInfo::LoopBBs LoopBBs;
+
+    typedef BasicBlockGraph::IDToNodeMapTy::const_iterator const_bb_iterator;
+
+
 private:
-    const SVFFunction* callGraphNode;
+    bool isDecl;   /// return true if this function does not have a body
+    bool intrinsic; /// return true if this function is an intrinsic function (e.g., llvm.dbg), which does not reside in the application code
+    bool isAddrTaken; /// return true if this function is address-taken (for indirect call purposes)
+    bool isUncalled;    /// return true if this function is never called
+    bool isNotRet;   /// return true if this function never returns
+    bool supVarArg;    /// return true if this function supports variable arguments
+    const SVFFunctionType* funcType; /// FunctionType, which is different from the type (PointerType) of this SVF Function
+    SVFLoopAndDomInfo* loopAndDom;  /// the loop and dominate information
+    const FunObjVar * realDefFun;  /// the definition of a function across multiple modules
+    BasicBlockGraph* bbGraph; /// the basic block graph of this function
+    std::vector<const ArgValVar*> allArgs;    /// all formal arguments of this function
+    SVFBasicBlock *exitBlock;             /// a 'single' basic block having no successors and containing return instruction in a function
+
+
+private:
+    /// Constructor to create empty ObjVar (for SVFIRReader/deserialization)
+    FunObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i,node, FunObjNode) {}
 
 public:
     ///  Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const FunValVar*)
+    static inline bool classof(const FunObjVar*)
     {
         return true;
     }
-    static inline bool classof(const ValVar* node)
+    static inline bool classof(const BaseObjVar* node)
     {
-        return node->getNodeKind() == FunValNode;
+        return node->getNodeKind() == FunObjNode;
+    }
+    static inline bool classof(const ObjVar* node)
+    {
+        return node->getNodeKind() == FunObjNode;
     }
     static inline bool classof(const SVFVar* node)
     {
-        return node->getNodeKind() == FunValNode;
+        return node->getNodeKind() == FunObjNode;
     }
     static inline bool classof(const GenericPAGNodeTy* node)
     {
-        return node->getNodeKind() == FunValNode;
+        return node->getNodeKind() == FunObjNode;
     }
     static inline bool classof(const SVFBaseNode* node)
     {
-        return node->getNodeKind() == FunValNode;
+        return node->getNodeKind() == FunObjNode;
     }
     //@}
 
-    inline virtual const SVFFunction* getFunction() const
+    /// Constructor
+    FunObjVar(NodeID i, ObjTypeInfo* ti, const SVFType* svfType, const ICFGNode* node);
+
+    void initFunObjVar(bool decl, bool intrinc, bool addr, bool uncalled, bool notret, bool vararg, const SVFFunctionType *ft,
+                       SVFLoopAndDomInfo *ld, const FunObjVar *real, BasicBlockGraph *bbg,
+                       const std::vector<const ArgValVar *> &allarg, SVFBasicBlock *exit);
+
+    void setRelDefFun(const FunObjVar *real)
     {
-        return callGraphNode;
+        realDefFun = real;
     }
 
-    /// Constructor
-    FunValVar(NodeID i, const ICFGNode* icn, const SVFFunction* cgn, const SVFType* svfType);
+    virtual const FunObjVar*getFunction() const;
 
+    inline void addArgument(const ArgValVar *arg)
+    {
+        allArgs.push_back(arg);
+    }
+    inline bool isDeclaration() const
+    {
+        return isDecl;
+    }
 
-    virtual bool isPointer() const
+    inline bool isIntrinsic() const
     {
-        return true;
+        return intrinsic;
+    }
+
+    inline bool hasAddressTaken() const
+    {
+        return isAddrTaken;
+    }
+
+    inline bool isVarArg() const
+    {
+        return supVarArg;
+    }
+
+    inline bool isUncalledFunction() const
+    {
+        return isUncalled;
+    }
+
+    inline bool hasReturn() const
+    {
+        return  !isNotRet;
+    }
+
+    /// Returns the FunctionType
+    inline const SVFFunctionType* getFunctionType() const
+    {
+        return funcType;
+    }
+
+    /// Returns the FunctionType
+    inline const SVFType* getReturnType() const
+    {
+        return funcType->getReturnType();
+    }
+
+    inline SVFLoopAndDomInfo* getLoopAndDomInfo()
+    {
+        return loopAndDom;
+    }
+
+    inline const std::vector<const SVFBasicBlock*>& getReachableBBs() const
+    {
+        return loopAndDom->getReachableBBs();
+    }
+
+    inline void getExitBlocksOfLoop(const SVFBasicBlock* bb, BBList& exitbbs) const
+    {
+        return loopAndDom->getExitBlocksOfLoop(bb,exitbbs);
+    }
+
+    inline bool hasLoopInfo(const SVFBasicBlock* bb) const
+    {
+        return loopAndDom->hasLoopInfo(bb);
     }
 
+    const LoopBBs& getLoopInfo(const SVFBasicBlock* bb) const
+    {
+        return loopAndDom->getLoopInfo(bb);
+    }
+
+    inline const SVFBasicBlock* getLoopHeader(const BBList& lp) const
+    {
+        return loopAndDom->getLoopHeader(lp);
+    }
+
+    inline bool loopContainsBB(const BBList& lp, const SVFBasicBlock* bb) const
+    {
+        return loopAndDom->loopContainsBB(lp,bb);
+    }
+
+    inline const Map<const SVFBasicBlock*,BBSet>& getDomTreeMap() const
+    {
+        return loopAndDom->getDomTreeMap();
+    }
+
+    inline const Map<const SVFBasicBlock*,BBSet>& getDomFrontierMap() const
+    {
+        return loopAndDom->getDomFrontierMap();
+    }
+
+    inline bool isLoopHeader(const SVFBasicBlock* bb) const
+    {
+        return loopAndDom->isLoopHeader(bb);
+    }
+
+    inline bool dominate(const SVFBasicBlock* bbKey, const SVFBasicBlock* bbValue) const
+    {
+        return loopAndDom->dominate(bbKey,bbValue);
+    }
+
+    inline bool postDominate(const SVFBasicBlock* bbKey, const SVFBasicBlock* bbValue) const
+    {
+        return loopAndDom->postDominate(bbKey,bbValue);
+    }
+
+    inline const FunObjVar* getDefFunForMultipleModule() const
+    {
+        if(realDefFun==nullptr)
+            return this;
+        return realDefFun;
+    }
+
+    void setBasicBlockGraph(BasicBlockGraph* graph)
+    {
+        this->bbGraph = graph;
+    }
+
+    BasicBlockGraph* getBasicBlockGraph()
+    {
+        return bbGraph;
+    }
+
+    const BasicBlockGraph* getBasicBlockGraph() const
+    {
+        return bbGraph;
+    }
+
+    inline bool hasBasicBlock() const
+    {
+        return bbGraph && bbGraph->begin() != bbGraph->end();
+    }
+
+    inline const SVFBasicBlock* getEntryBlock() const
+    {
+        assert(hasBasicBlock() && "function does not have any Basicblock, external function?");
+        assert(bbGraph->begin()->second->getInEdges().size() == 0 && "the first basic block is not entry block");
+        return bbGraph->begin()->second;
+    }
+
+    inline const SVFBasicBlock* getExitBB() const
+    {
+        assert(hasBasicBlock() && "function does not have any Basicblock, external function?");
+        assert(exitBlock && "must have an exitBlock");
+        return exitBlock;
+    }
+
+    inline void setExitBlock(SVFBasicBlock *bb)
+    {
+        assert(!exitBlock && "have already set exit Basicblock!");
+        exitBlock = bb;
+    }
+
+
+    u32_t inline arg_size() const
+    {
+        return allArgs.size();
+    }
+
+    inline const ArgValVar*  getArg(u32_t idx) const
+    {
+        assert (idx < allArgs.size() && "getArg() out of range!");
+        return allArgs[idx];
+    }
+
+    inline const SVFBasicBlock* front() const
+    {
+        return getEntryBlock();
+    }
+
+    inline const SVFBasicBlock* back() const
+    {
+        assert(hasBasicBlock() && "function does not have any Basicblock, external function?");
+        /// Carefully! 'back' is just the last basic block of function,
+        /// but not necessarily a exit basic block
+        /// more refer to: https://github.com/SVF-tools/SVF/pull/1262
+        return std::prev(bbGraph->end())->second;
+    }
+
+    inline const_bb_iterator begin() const
+    {
+        return bbGraph->begin();
+    }
+
+    inline const_bb_iterator end() const
+    {
+        return bbGraph->end();
+    }
+
+    virtual bool isIsolatedNode() const;
+
     virtual const std::string toString() const;
 };
-
-class FunObjVar : public BaseObjVar
+class FunValVar : public ValVar
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
-
-private:
-    const SVFFunction* callGraphNode;
-
 private:
-    /// Constructor to create empty ObjVar (for SVFIRReader/deserialization)
-    FunObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i,node, FunObjNode) {}
+    const FunObjVar* funObjVar;
 
 public:
     ///  Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const FunObjVar*)
+    static inline bool classof(const FunValVar*)
     {
         return true;
     }
-    static inline bool classof(const BaseObjVar* node)
-    {
-        return node->getNodeKind() == FunObjNode;
-    }
-    static inline bool classof(const ObjVar* node)
+    static inline bool classof(const ValVar* node)
     {
-        return node->getNodeKind() == FunObjNode;
+        return node->getNodeKind() == FunValNode;
     }
     static inline bool classof(const SVFVar* node)
     {
-        return node->getNodeKind() == FunObjNode;
+        return node->getNodeKind() == FunValNode;
     }
     static inline bool classof(const GenericPAGNodeTy* node)
     {
-        return node->getNodeKind() == FunObjNode;
+        return node->getNodeKind() == FunValNode;
     }
     static inline bool classof(const SVFBaseNode* node)
     {
-        return node->getNodeKind() == FunObjNode;
+        return node->getNodeKind() == FunValNode;
     }
     //@}
 
-    /// Constructor
-    FunObjVar(NodeID i, ObjTypeInfo* ti, const SVFFunction* cgNode, const SVFType* svfType, const ICFGNode* node);
-
-    inline const SVFFunction* getCallGraphNode() const
+    inline virtual const FunObjVar* getFunction() const
     {
-        return callGraphNode;
+        return funObjVar->getFunction();
     }
 
-    virtual const SVFFunction* getFunction() const;
+    /// Constructor
+    FunValVar(NodeID i, const ICFGNode* icn, const FunObjVar* cgn, const SVFType* svfType);
 
-    virtual bool isPointer() const;
 
-    virtual bool isIsolatedNode() const;
+    virtual bool isPointer() const
+    {
+        return true;
+    }
 
     virtual const std::string toString() const;
 };
 
+
+
 class GlobalValVar : public ValVar
 {
     friend class SVFIRWriter;
@@ -1782,7 +1982,7 @@ class RetValPN : public ValVar
     friend class SVFIRReader;
 
 private:
-    const SVFFunction* callGraphNode;
+    const FunObjVar* callGraphNode;
 private:
     /// Constructor to create empty RetValPN (for SVFIRReader/deserialization)
     RetValPN(NodeID i) : ValVar(i, RetValNode) {}
@@ -1813,14 +2013,14 @@ public:
 
 
     /// Constructor
-    RetValPN(NodeID i, const SVFFunction* node, const SVFType* svfType, const ICFGNode* icn);
+    RetValPN(NodeID i, const FunObjVar* node, const SVFType* svfType, const ICFGNode* icn);
 
-    inline const SVFFunction* getCallGraphNode() const
+    inline const FunObjVar* getCallGraphNode() const
     {
         return callGraphNode;
     }
 
-    virtual const SVFFunction* getFunction() const;
+    virtual const FunObjVar* getFunction() const;
 
     virtual bool isPointer() const;
 
@@ -1838,7 +2038,7 @@ class VarArgValPN : public ValVar
     friend class SVFIRWriter;
     friend class SVFIRReader;
 private:
-    const SVFFunction* callGraphNode;
+    const FunObjVar* callGraphNode;
 
 private:
     /// Constructor to create empty VarArgValPN (for SVFIRReader/deserialization)
@@ -1869,12 +2069,12 @@ public:
     //@}
 
     /// Constructor
-    VarArgValPN(NodeID i, const SVFFunction* node, const SVFType* svfType, const ICFGNode* icn)
+    VarArgValPN(NodeID i, const FunObjVar* node, const SVFType* svfType, const ICFGNode* icn)
         : ValVar(i, svfType, icn, VarargValNode), callGraphNode(node)
     {
     }
 
-    virtual const SVFFunction* getFunction() const;
+    virtual const FunObjVar* getFunction() const;
 
     /// Return name of a LLVM value
     const std::string getValueName() const;