svf-lib 1.0.2509 → 1.0.2511

package/SVF-linux-aarch64/include/AE/Core/AbstractState.h

@@ -78,7 +78,7 @@ public:
     AddressValue getGepObjAddrs(u32_t pointer, IntervalValue offset);
 
     // initObjVar
-    void initObjVar(ObjVar* objVar);
+    void initObjVar(const ObjVar* objVar);
     // getElementIndex
     IntervalValue getElementIndex(const GepStmt* gep);
     // getByteOffset

package/SVF-linux-aarch64/include/DDA/DDAVFSolver.h

@@ -344,9 +344,9 @@ protected:
         }
     }
     /// GetDefinition SVFG
-    inline const SVFGNode* getDefSVFGNode(const PAGNode* pagNode) const
+    inline const SVFGNode* getDefSVFGNode(const ValVar* valVar) const
     {
-        return getSVFG()->getDefSVFGNode(pagNode);
+        return getSVFG()->getDefSVFGNode(valVar);
     }
     /// Backward traverse along indirect value flows
     void backtraceAlongIndirectVF(CPtSet& pts, const DPIm& oldDpm)
@@ -497,7 +497,7 @@ protected:
             {
                 NodeID funPtr = _pag->getFunPtr(cbn);
                 DPIm funPtrDpm(dpm);
-                funPtrDpm.setLocVar(getSVFG()->getDefSVFGNode(_pag->getSVFVar(funPtr)),funPtr);
+                funPtrDpm.setLocVar(getSVFG()->getDefSVFGNode(_pag->getValVar(funPtr)),funPtr);
                 findPT(funPtrDpm);
             }
         }
@@ -510,7 +510,7 @@ protected:
             {
                 NodeID funPtr = _pag->getFunPtr(*it);
                 DPIm funPtrDpm(dpm);
-                funPtrDpm.setLocVar(getSVFG()->getDefSVFGNode(_pag->getSVFVar(funPtr)),funPtr);
+                funPtrDpm.setLocVar(getSVFG()->getDefSVFGNode(_pag->getValVar(funPtr)),funPtr);
                 findPT(funPtrDpm);
             }
         }

package/SVF-linux-aarch64/include/Graphs/SVFG.h

@@ -74,7 +74,7 @@ class SVFG : public VFG
 
 public:
     typedef VFGNodeIDToNodeMapTy SVFGNodeIDToNodeMapTy;
-    typedef Map<const SVFVar*, NodeID> SVFVarToDefMapTy;
+    typedef Map<const ValVar*, NodeID> ValVarToDefMapTy;
     typedef Map<const MRVer*, NodeID> MSSAVarToDefMapTy;
     typedef NodeBS ActualINSVFGNodeSet;
     typedef NodeBS ActualOUTSVFGNodeSet;
@@ -167,16 +167,16 @@ public:
     /// Connect SVFG nodes between caller and callee for indirect call site
     virtual void connectCallerAndCallee(const CallICFGNode* cs, const FunObjVar* callee, SVFGEdgeSetTy& edges);
 
-    /// Given a svfVar, return its definition site
-    inline const SVFGNode* getDefSVFGNode(const SVFVar* svfVar) const
+    /// Given a valVar, return its definition site
+    inline const SVFGNode* getDefSVFGNode(const ValVar* valVar) const
     {
-        return getSVFGNode(getDef(svfVar));
+        return getSVFGNode(getDef(valVar));
     }
 
-    /// Given a svfVar, return whether it has definition site
-    inline bool hasDefSVFGNode(const SVFVar* svfVar) const
+    /// Given a valVar, return whether it has definition site
+    inline bool hasDefSVFGNode(const ValVar* valVar) const
     {
-        return hasDef(svfVar) && hasSVFGNode(getDef(svfVar));
+        return hasDef(valVar) && hasSVFGNode(getDef(valVar));
     }
 
     /// Given a ValVar and its SVFGNode, find the definition-site ICFGNode
@@ -323,7 +323,7 @@ protected:
 
     /// Get inter value flow edges between indirect call site and callee.
     //@{
-    virtual inline void getInterVFEdgeAtIndCSFromAPToFP(const SVFVar* cs_arg, const SVFVar* fun_arg, const CallICFGNode*, CallSiteID csId, SVFGEdgeSetTy& edges)
+    virtual inline void getInterVFEdgeAtIndCSFromAPToFP(const ValVar* cs_arg, const ValVar* fun_arg, const CallICFGNode*, CallSiteID csId, SVFGEdgeSetTy& edges)
     {
         SVFGNode* actualParam = getSVFGNode(getDef(cs_arg));
         SVFGNode* formalParam = getSVFGNode(getDef(fun_arg));
@@ -332,7 +332,7 @@ protected:
         edges.insert(edge);
     }
 
-    virtual inline void getInterVFEdgeAtIndCSFromFRToAR(const SVFVar* fun_ret, const SVFVar* cs_ret, CallSiteID csId, SVFGEdgeSetTy& edges)
+    virtual inline void getInterVFEdgeAtIndCSFromFRToAR(const ValVar* fun_ret, const ValVar* cs_ret, CallSiteID csId, SVFGEdgeSetTy& edges)
     {
         SVFGNode* formalRet = getSVFGNode(getDef(fun_ret));
         SVFGNode* actualRet = getSVFGNode(getDef(cs_ret));
@@ -363,19 +363,19 @@ protected:
     //@}
 
 
-    /// Given a SVFVar, set/get its def SVFG node (definition of top level pointers)
+    /// Given a ValVar, set/get its def SVFG node (definition of top level pointers)
     //@{
-    inline void setDef(const SVFVar* svfVar, const SVFGNode* node)
+    inline void setDef(const ValVar* valVar, const SVFGNode* node)
     {
-        VFG::setDef(svfVar, node);
+        VFG::setDef(valVar, node);
     }
-    inline NodeID getDef(const SVFVar* svfVar) const
+    inline NodeID getDef(const ValVar* valVar) const
     {
-        return VFG::getDef(svfVar);
+        return VFG::getDef(valVar);
     }
-    inline bool hasDef(const SVFVar* svfVar) const
+    inline bool hasDef(const ValVar* valVar) const
     {
-        return VFG::hasDef(svfVar);
+        return VFG::hasDef(valVar);
     }
     //@}
 

package/SVF-linux-aarch64/include/Graphs/SVFGOPT.h

@@ -95,7 +95,7 @@ protected:
 
     /// Connect SVFG nodes between caller and callee for indirect call sites
     //@{
-    inline void connectAParamAndFParam(const SVFVar* cs_arg, const SVFVar* fun_arg, const CallICFGNode*, CallSiteID csId, SVFGEdgeSetTy& edges) override
+    inline void connectAParamAndFParam(const ValVar* cs_arg, const ValVar* fun_arg, const CallICFGNode*, CallSiteID csId, SVFGEdgeSetTy& edges) override
     {
         NodeID phiId = getDef(fun_arg);
         SVFGEdge* edge = addCallEdge(getDef(cs_arg), phiId, csId);
@@ -107,7 +107,7 @@ protected:
         }
     }
     /// Connect formal-ret and actual ret
-    inline void connectFRetAndARet(const SVFVar* fun_ret, const SVFVar* cs_ret, CallSiteID csId, SVFGEdgeSetTy& edges) override
+    inline void connectFRetAndARet(const ValVar* fun_ret, const ValVar* cs_ret, CallSiteID csId, SVFGEdgeSetTy& edges) override
     {
         NodeID phiId = getDef(cs_ret);
         NodeID retdef = getDef(fun_ret);
@@ -244,7 +244,7 @@ private:
         return (inter1 && inter2);
     }
 
-    inline void addInterPHIOperands(PHISVFGNode* phi, const SVFVar* operand)
+    inline void addInterPHIOperands(PHISVFGNode* phi, const ValVar* operand)
     {
         phi->setOpVer(phi->getOpVerNum(), operand);
     }
@@ -267,10 +267,10 @@ private:
         return sNode;
     }
 
-    inline void resetDef(const SVFVar* svfVar, const SVFGNode* node)
+    inline void resetDef(const ValVar* valVar, const SVFGNode* node)
     {
-        SVFVarToDefMapTy::iterator it = SVFVarToDefMap.find(svfVar);
-        assert(it != SVFVarToDefMap.end() && "a SVFIR node doesn't have definition before");
+        ValVarToDefMapTy::iterator it = ValVarToDefMap.find(valVar);
+        assert(it != ValVarToDefMap.end() && "a SVFIR node doesn't have definition before");
         it->second = node->getId();
     }
 

package/SVF-linux-aarch64/include/Graphs/VFG.h

@@ -59,7 +59,7 @@ public:
 
     typedef OrderedMap<NodeID, VFGNode *> VFGNodeIDToNodeMapTy;
     typedef Set<VFGNode*> VFGNodeSet;
-    typedef Map<const SVFVar*, NodeID> SVFVarToDefMapTy;
+    typedef Map<const ValVar*, NodeID> ValVarToDefMapTy;
     typedef Map<std::pair<NodeID,const CallICFGNode*>, ActualParmVFGNode *> SVFVarToActualParmMapTy;
     typedef Map<const SVFVar*, ActualRetVFGNode *> SVFVarToActualRetMapTy;
     typedef Map<const SVFVar*, FormalParmVFGNode *> SVFVarToFormalParmMapTy;
@@ -86,7 +86,7 @@ public:
 
 protected:
     NodeID totalVFGNode;
-    SVFVarToDefMapTy SVFVarToDefMap;	///< map a pag node to its definition SVG node
+    ValVarToDefMapTy ValVarToDefMap;	///< map a pag node to its definition SVG node
     SVFVarToActualParmMapTy SVFVarToActualParmMap; ///< map a SVFVar to an actual parameter
     SVFVarToActualRetMapTy SVFVarToActualRetMap; ///< map a SVFVar to an actual return
     SVFVarToFormalParmMapTy SVFVarToFormalParmMap; ///< map a SVFVar to a formal parameter
@@ -185,10 +185,10 @@ public:
     }
     //@}
 
-    /// Given a svfVar, return its definition site
-    inline const VFGNode* getDefVFGNode(const SVFVar* svfVar) const
+    /// Given a valVar, return its definition site
+    inline const VFGNode* getDefVFGNode(const ValVar* valVar) const
     {
-        return getVFGNode(getDef(svfVar));
+        return getVFGNode(getDef(valVar));
     }
 
     // Given an VFG node, return true if it has a left hand side top level pointer (PAGnode)
@@ -324,11 +324,11 @@ public:
     const FunObjVar* isFunEntryVFGNode(const VFGNode* node) const;
 
     /// Whether a SVFVar has a blackhole or const object as its definition
-    inline bool hasBlackHoleConstObjAddrAsDef(const SVFVar* svfVar) const
+    inline bool hasBlackHoleConstObjAddrAsDef(const ValVar* valVar) const
     {
-        if (hasDef(svfVar))
+        if (hasDef(valVar))
         {
-            const VFGNode* defNode = getVFGNode(getDef(svfVar));
+            const VFGNode* defNode = getVFGNode(getDef(valVar));
             if (const AddrVFGNode* addr = SVFUtil::dyn_cast<AddrVFGNode>(defNode))
             {
                 if (SVFIR::getPAG()->isBlkObjOrConstantObj(addr->getSVFStmt()->getSrcID()))
@@ -445,7 +445,7 @@ protected:
     /// Connect VFG nodes between caller and callee for indirect call site
     //@{
     /// Connect actual-param and formal param
-    virtual inline void connectAParamAndFParam(const SVFVar* csArg, const SVFVar* funArg, const CallICFGNode* cbn, CallSiteID csId, VFGEdgeSetTy& edges)
+    virtual inline void connectAParamAndFParam(const ValVar* csArg, const ValVar* funArg, const CallICFGNode* cbn, CallSiteID csId, VFGEdgeSetTy& edges)
     {
         NodeID actualParam = getActualParmVFGNode(csArg, cbn)->getId();
         NodeID formalParam = getFormalParmVFGNode(funArg)->getId();
@@ -454,7 +454,7 @@ protected:
             edges.insert(edge);
     }
     /// Connect formal-ret and actual ret
-    virtual inline void connectFRetAndARet(const SVFVar* funReturn, const SVFVar* csReturn, CallSiteID csId, VFGEdgeSetTy& edges)
+    virtual inline void connectFRetAndARet(const ValVar* funReturn, const ValVar* csReturn, CallSiteID csId, VFGEdgeSetTy& edges)
     {
         NodeID formalRet = getFormalRetVFGNode(funReturn)->getId();
         NodeID actualRet = getActualRetVFGNode(csReturn)->getId();
@@ -464,30 +464,30 @@ protected:
     }
     //@}
 
-    /// Given a SVFVar, set/get its def VFG node (definition of top level pointers)
+    /// Given a ValVar, set/get its def VFG node (definition of top level pointers)
     //@{
-    inline void setDef(const SVFVar* svfVar, const VFGNode* node)
+    inline void setDef(const ValVar* valVar, const VFGNode* node)
     {
-        SVFVarToDefMapTy::iterator it = SVFVarToDefMap.find(svfVar);
-        if(it == SVFVarToDefMap.end())
+        ValVarToDefMapTy::iterator it = ValVarToDefMap.find(valVar);
+        if(it == ValVarToDefMap.end())
         {
-            SVFVarToDefMap[svfVar] = node->getId();
+            ValVarToDefMap[valVar] = node->getId();
             assert(hasVFGNode(node->getId()) && "not in the map!!");
         }
         else
         {
-            assert((it->second == node->getId()) && "a SVFVar can only have unique definition ");
+            assert((it->second == node->getId()) && "a ValVar can only have unique definition ");
         }
     }
-    inline NodeID getDef(const SVFVar* svfVar) const
+    inline NodeID getDef(const ValVar* valVar) const
     {
-        SVFVarToDefMapTy::const_iterator it = SVFVarToDefMap.find(svfVar);
-        assert(it!=SVFVarToDefMap.end() && "SVFVar does not have a definition??");
+        ValVarToDefMapTy::const_iterator it = ValVarToDefMap.find(valVar);
+        assert(it!=ValVarToDefMap.end() && "ValVar does not have a definition??");
         return it->second;
     }
-    inline bool hasDef(const SVFVar* svfVar) const
+    inline bool hasDef(const ValVar* valVar) const
     {
-        return (SVFVarToDefMap.find(svfVar) != SVFVarToDefMap.end());
+        return (ValVarToDefMap.find(valVar) != ValVarToDefMap.end());
     }
     //@}
 
@@ -544,7 +544,7 @@ protected:
     }
     /// Add a Dummy VFG node for null pointer definition
     /// To be noted for black hole pointer it has already has address edge connected
-    inline void addNullPtrVFGNode(const SVFVar* svfVar)
+    inline void addNullPtrVFGNode(const ValVar* svfVar)
     {
         NullPtrVFGNode* sNode = new NullPtrVFGNode(totalVFGNode++,svfVar);
         addVFGNode(sNode, pag->getICFG()->getGlobalICFGNode());
@@ -555,7 +555,7 @@ protected:
     {
         AddrVFGNode* sNode = new AddrVFGNode(totalVFGNode++,addr);
         addStmtVFGNode(sNode, addr);
-        setDef(addr->getLHSVar(),sNode);
+        setDef(SVFUtil::cast<ValVar>(addr->getLHSVar()),sNode);
     }
     /// Add a Copy VFG node
     inline void addCopyVFGNode(const CopyStmt* copy)
@@ -589,7 +589,7 @@ protected:
     /// Add an actual parameter VFG node
     /// To be noted that multiple actual parameters may have same value (SVFVar)
     /// So we need to make a pair <SVFVarID,CallSiteID> to find the right VFGParmNode
-    inline void addActualParmVFGNode(const SVFVar* aparm, const CallICFGNode* cs)
+    inline void addActualParmVFGNode(const ValVar* aparm, const CallICFGNode* cs)
     {
         ActualParmVFGNode* sNode = new ActualParmVFGNode(totalVFGNode++,aparm,cs);
         addVFGNode(sNode, const_cast<CallICFGNode*>(cs));
@@ -597,7 +597,7 @@ protected:
         /// do not set def here, this node is not a variable definition
     }
     /// Add a formal parameter VFG node
-    inline void addFormalParmVFGNode(const SVFVar* fparm, const FunObjVar* fun, CallPESet& callPEs)
+    inline void addFormalParmVFGNode(const ValVar* fparm, const FunObjVar* fun, CallPESet& callPEs)
     {
         FormalParmVFGNode* sNode = new FormalParmVFGNode(totalVFGNode++,fparm,fun);
         addVFGNode(sNode, pag->getICFG()->getFunEntryICFGNode(fun));
@@ -611,7 +611,7 @@ protected:
     /// Add a callee Return VFG node
     /// To be noted that here we assume returns of a procedure have already been unified into one
     /// Otherwise, we need to handle formalRet using <SVFVarID,CallSiteID> pair to find FormalRetVFG node same as handling actual parameters
-    inline void addFormalRetVFGNode(const SVFVar* uniqueFunRet, const FunObjVar* fun, RetPESet& retPEs)
+    inline void addFormalRetVFGNode(const ValVar* uniqueFunRet, const FunObjVar* fun, RetPESet& retPEs)
     {
         FormalRetVFGNode *sNode = new FormalRetVFGNode(totalVFGNode++, uniqueFunRet, fun);
         addVFGNode(sNode, pag->getICFG()->getFunExitICFGNode(fun));
@@ -630,7 +630,7 @@ protected:
         }
     }
     /// Add a callsite Receive VFG node
-    inline void addActualRetVFGNode(const SVFVar* ret,const CallICFGNode* cs)
+    inline void addActualRetVFGNode(const ValVar* ret,const CallICFGNode* cs)
     {
         ActualRetVFGNode* sNode = new ActualRetVFGNode(totalVFGNode++,ret,cs);
         addVFGNode(sNode, const_cast<RetICFGNode*>(cs->getRetICFGNode()));
@@ -640,7 +640,8 @@ protected:
     /// Add an llvm PHI VFG node
     inline void addIntraPHIVFGNode(const MultiOpndStmt* edge)
     {
-        IntraPHIVFGNode* sNode = new IntraPHIVFGNode(totalVFGNode++,edge->getRes());
+        const ValVar* res = SVFUtil::cast<ValVar>(edge->getRes());
+        IntraPHIVFGNode* sNode = new IntraPHIVFGNode(totalVFGNode++,res);
         u32_t pos = 0;
         for(auto var : edge->getOpndVars())
         {
@@ -648,13 +649,14 @@ protected:
             pos++;
         }
         addVFGNode(sNode,edge->getICFGNode());
-        setDef(edge->getRes(),sNode);
-        SVFVarToIntraPHIVFGNodeMap[edge->getRes()] = sNode;
+        setDef(res,sNode);
+        SVFVarToIntraPHIVFGNodeMap[res] = sNode;
     }
     /// Add a Compare VFG node
     inline void addCmpVFGNode(const CmpStmt* edge)
     {
-        CmpVFGNode* sNode = new CmpVFGNode(totalVFGNode++, edge->getRes());
+        const ValVar* res = SVFUtil::cast<ValVar>(edge->getRes());
+        CmpVFGNode* sNode = new CmpVFGNode(totalVFGNode++, res);
         u32_t pos = 0;
         for(auto var : edge->getOpndVars())
         {
@@ -662,13 +664,14 @@ protected:
             pos++;
         }
         addVFGNode(sNode,edge->getICFGNode());
-        setDef(edge->getRes(),sNode);
-        SVFVarToCmpVFGNodeMap[edge->getRes()] = sNode;
+        setDef(res,sNode);
+        SVFVarToCmpVFGNodeMap[res] = sNode;
     }
     /// Add a BinaryOperator VFG node
     inline void addBinaryOPVFGNode(const BinaryOPStmt* edge)
     {
-        BinaryOPVFGNode* sNode = new BinaryOPVFGNode(totalVFGNode++, edge->getRes());
+        const ValVar* res = SVFUtil::cast<ValVar>(edge->getRes());
+        BinaryOPVFGNode* sNode = new BinaryOPVFGNode(totalVFGNode++, res);
         u32_t pos = 0;
         for(auto var : edge->getOpndVars())
         {
@@ -676,8 +679,8 @@ protected:
             pos++;
         }
         addVFGNode(sNode,edge->getICFGNode());
-        setDef(edge->getRes(),sNode);
-        SVFVarToBinaryOPVFGNodeMap[edge->getRes()] = sNode;
+        setDef(res,sNode);
+        SVFVarToBinaryOPVFGNodeMap[res] = sNode;
     }
     /// Add a UnaryOperator VFG node
     inline void addUnaryOPVFGNode(const UnaryOPStmt* edge)

package/SVF-linux-aarch64/include/Graphs/VFGNode.h

@@ -209,6 +209,22 @@ public:
     LoadVFGNode(NodeID id, const LoadStmt* edge): StmtVFGNode(id, edge,Load)
     {
 
+    }
+    inline const ValVar* getSrcNode() const
+    {
+        return SVFUtil::cast<ValVar>(StmtVFGNode::getSrcNode());
+    }
+    inline const ValVar* getDstNode() const
+    {
+        return SVFUtil::cast<ValVar>(StmtVFGNode::getDstNode());
+    }
+    inline const ValVar* getRHSVar() const
+    {
+        return getSrcNode();
+    }
+    inline const ValVar* getLHSVar() const
+    {
+        return getDstNode();
     }
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
@@ -254,6 +270,22 @@ public:
     StoreVFGNode(NodeID id,const StoreStmt* edge): StmtVFGNode(id,edge,Store)
     {
 
+    }
+    inline const ValVar* getSrcNode() const
+    {
+        return SVFUtil::cast<ValVar>(StmtVFGNode::getSrcNode());
+    }
+    inline const ValVar* getDstNode() const
+    {
+        return SVFUtil::cast<ValVar>(StmtVFGNode::getDstNode());
+    }
+    inline const ValVar* getRHSVar() const
+    {
+        return getSrcNode();
+    }
+    inline const ValVar* getLHSVar() const
+    {
+        return getDstNode();
     }
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
@@ -299,6 +331,22 @@ public:
     CopyVFGNode(NodeID id,const CopyStmt* copy): StmtVFGNode(id,copy,Copy)
     {
 
+    }
+    inline const ValVar* getSrcNode() const
+    {
+        return SVFUtil::cast<ValVar>(StmtVFGNode::getSrcNode());
+    }
+    inline const ValVar* getDstNode() const
+    {
+        return SVFUtil::cast<ValVar>(StmtVFGNode::getDstNode());
+    }
+    inline const ValVar* getRHSVar() const
+    {
+        return getSrcNode();
+    }
+    inline const ValVar* getLHSVar() const
+    {
+        return getDstNode();
     }
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
@@ -337,9 +385,9 @@ public:
 class CmpVFGNode: public VFGNode
 {
 public:
-    typedef Map<u32_t,const SVFVar*> OPVers;
+    typedef Map<u32_t,const ValVar*> OPVers;
 protected:
-    const SVFVar* res;
+    const ValVar* res;
     OPVers opVers;
 
 private:
@@ -349,7 +397,7 @@ private:
 
 public:
     /// Constructor
-    CmpVFGNode(NodeID id,const SVFVar* r): VFGNode(id,Cmp), res(r) { }
+    CmpVFGNode(NodeID id,const ValVar* r): VFGNode(id,Cmp), res(r) { }
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
     static inline bool classof(const CmpVFGNode *)
@@ -371,17 +419,17 @@ public:
     //@}
     /// Operands at a BinaryNode
     //@{
-    inline const SVFVar* getOpVer(u32_t pos) const
+    inline const ValVar* getOpVer(u32_t pos) const
     {
         OPVers::const_iterator it = opVers.find(pos);
         assert(it!=opVers.end() && "version is nullptr, did not rename?");
         return it->second;
     }
-    inline void setOpVer(u32_t pos, const SVFVar* node)
+    inline void setOpVer(u32_t pos, const ValVar* node)
     {
         opVers[pos] = node;
     }
-    inline const SVFVar* getRes() const
+    inline const ValVar* getRes() const
     {
         return res;
     }
@@ -414,9 +462,9 @@ public:
 class BinaryOPVFGNode: public VFGNode
 {
 public:
-    typedef Map<u32_t,const SVFVar*> OPVers;
+    typedef Map<u32_t,const ValVar*> OPVers;
 protected:
-    const SVFVar* res;
+    const ValVar* res;
     OPVers opVers;
 
 private:
@@ -426,7 +474,7 @@ private:
 
 public:
     /// Constructor
-    BinaryOPVFGNode(NodeID id,const SVFVar* r): VFGNode(id,BinaryOp), res(r) { }
+    BinaryOPVFGNode(NodeID id,const ValVar* r): VFGNode(id,BinaryOp), res(r) { }
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
     static inline bool classof(const BinaryOPVFGNode *)
@@ -448,17 +496,17 @@ public:
     //@}
     /// Operands at a BinaryNode
     //@{
-    inline const SVFVar* getOpVer(u32_t pos) const
+    inline const ValVar* getOpVer(u32_t pos) const
     {
         OPVers::const_iterator it = opVers.find(pos);
         assert(it!=opVers.end() && "version is nullptr, did not rename?");
         return it->second;
     }
-    inline void setOpVer(u32_t pos, const SVFVar* node)
+    inline void setOpVer(u32_t pos, const ValVar* node)
     {
         opVers[pos] = node;
     }
-    inline const SVFVar* getRes() const
+    inline const ValVar* getRes() const
     {
         return res;
     }
@@ -488,9 +536,9 @@ public:
 class UnaryOPVFGNode: public VFGNode
 {
 public:
-    typedef Map<u32_t,const SVFVar*> OPVers;
+    typedef Map<u32_t,const ValVar*> OPVers;
 protected:
-    const SVFVar* res;
+    const ValVar* res;
     OPVers opVers;
 
 private:
@@ -500,7 +548,7 @@ private:
 
 public:
     /// Constructor
-    UnaryOPVFGNode(NodeID id, const SVFVar *r) : VFGNode(id, UnaryOp), res(r) { }
+    UnaryOPVFGNode(NodeID id, const ValVar *r) : VFGNode(id, UnaryOp), res(r) { }
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
     static inline bool classof(const UnaryOPVFGNode *)
@@ -522,21 +570,21 @@ public:
     //@}
     /// Operands at a UnaryNode
     //@{
-    inline const SVFVar* getOpVer(u32_t pos) const
+    inline const ValVar* getOpVer(u32_t pos) const
     {
         OPVers::const_iterator it = opVers.find(pos);
         assert(it!=opVers.end() && "version is nullptr, did not rename?");
         return it->second;
     }
-    inline void setOpVer(u32_t pos, const SVFVar* node)
+    inline void setOpVer(u32_t pos, const ValVar* node)
     {
         opVers[pos] = node;
     }
-    inline const SVFVar* getRes() const
+    inline const ValVar* getRes() const
     {
         return res;
     }
-    inline const SVFVar* getOpVar() const
+    inline const ValVar* getOpVar() const
     {
         assert(getOpVerNum()==1 && "UnaryNode can only have one operand!");
         return getOpVer(0);
@@ -634,6 +682,22 @@ public:
     GepVFGNode(NodeID id,const GepStmt* edge): StmtVFGNode(id,edge,Gep)
     {
 
+    }
+    inline const ValVar* getSrcNode() const
+    {
+        return SVFUtil::cast<ValVar>(StmtVFGNode::getSrcNode());
+    }
+    inline const ValVar* getDstNode() const
+    {
+        return SVFUtil::cast<ValVar>(StmtVFGNode::getDstNode());
+    }
+    inline const ValVar* getRHSVar() const
+    {
+        return getSrcNode();
+    }
+    inline const ValVar* getLHSVar() const
+    {
+        return getDstNode();
     }
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
@@ -671,14 +735,14 @@ class PHIVFGNode : public VFGNode
 {
 
 public:
-    typedef Map<u32_t,const SVFVar*> OPVers;
+    typedef Map<u32_t,const ValVar*> OPVers;
 protected:
-    const SVFVar* res;
+    const ValVar* res;
     OPVers opVers;
 
 public:
     /// Constructor
-    PHIVFGNode(NodeID id, const SVFVar* r,VFGNodeK k = TPhi);
+    PHIVFGNode(NodeID id, const ValVar* r,VFGNodeK k = TPhi);
 
     /// Whether this phi node is of pointer type (used for pointer analysis).
     inline bool isPTANode() const
@@ -688,17 +752,17 @@ public:
 
     /// Operands at a llvm PHINode
     //@{
-    inline const SVFVar* getOpVer(u32_t pos) const
+    inline const ValVar* getOpVer(u32_t pos) const
     {
         OPVers::const_iterator it = opVers.find(pos);
         assert(it!=opVers.end() && "version is nullptr, did not rename?");
         return it->second;
     }
-    inline void setOpVer(u32_t pos, const SVFVar* node)
+    inline void setOpVer(u32_t pos, const ValVar* node)
     {
         opVers[pos] = node;
     }
-    inline const SVFVar* getRes() const
+    inline const ValVar* getRes() const
     {
         return res;
     }
@@ -756,7 +820,7 @@ private:
     OPIncomingBBs opIncomingBBs;
 public:
     /// Constructor
-    IntraPHIVFGNode(NodeID id, const SVFVar* r): PHIVFGNode(id, r, TIntraPhi)
+    IntraPHIVFGNode(NodeID id, const ValVar* r): PHIVFGNode(id, r, TIntraPhi)
     {
     }
 
@@ -766,7 +830,7 @@ public:
         assert(it!=opIncomingBBs.end() && "version is nullptr, did not rename?");
         return it->second;
     }
-    inline void setOpVerAndBB(u32_t pos, const SVFVar* node, const ICFGNode* bb)
+    inline void setOpVerAndBB(u32_t pos, const ValVar* node, const ICFGNode* bb)
     {
         opVers[pos] = node;
         opIncomingBBs[pos] = bb;
@@ -812,6 +876,22 @@ public:
     AddrVFGNode(NodeID id, const AddrStmt* edge): StmtVFGNode(id, edge,Addr)
     {
 
+    }
+    inline const ObjVar* getSrcNode() const
+    {
+        return SVFUtil::cast<ObjVar>(StmtVFGNode::getSrcNode());
+    }
+    inline const ValVar* getDstNode() const
+    {
+        return SVFUtil::cast<ValVar>(StmtVFGNode::getDstNode());
+    }
+    inline const ValVar* getLHSVar() const
+    {
+        return getDstNode();
+    }
+    inline const ObjVar* getRHSVar() const
+    {
+        return getSrcNode();
     }
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
@@ -847,11 +927,11 @@ class ArgumentVFGNode : public VFGNode
 {
 
 protected:
-    const SVFVar* param;
+    const ValVar* param;
 
 public:
     /// Constructor
-    ArgumentVFGNode(NodeID id, const SVFVar* p, VFGNodeK k): VFGNode(id,k), param(p)
+    ArgumentVFGNode(NodeID id, const ValVar* p, VFGNodeK k): VFGNode(id,k), param(p)
     {
     }
 
@@ -894,7 +974,7 @@ private:
     const CallICFGNode* cs;
 public:
     /// Constructor
-    ActualParmVFGNode(NodeID id, const SVFVar* n, const CallICFGNode* c) :
+    ActualParmVFGNode(NodeID id, const ValVar* n, const CallICFGNode* c) :
         ArgumentVFGNode(id, n, AParm), cs(c)
     {
     }
@@ -906,7 +986,7 @@ public:
     }
 
     /// Return parameter
-    inline const SVFVar* getParam() const
+    inline const ValVar* getParam() const
     {
         return param;
     }
@@ -952,13 +1032,13 @@ private:
 
 public:
     /// Constructor
-    FormalParmVFGNode(NodeID id, const SVFVar* n, const FunObjVar* f):
+    FormalParmVFGNode(NodeID id, const ValVar* n, const FunObjVar* f):
         ArgumentVFGNode(id, n, FParm),  fun(f)
     {
     }
 
     /// Return parameter
-    inline const SVFVar* getParam() const
+    inline const ValVar* getParam() const
     {
         return param;
     }
@@ -1028,7 +1108,7 @@ private:
 
 public:
     /// Constructor
-    ActualRetVFGNode(NodeID id, const SVFVar* n, const CallICFGNode* c) :
+    ActualRetVFGNode(NodeID id, const ValVar* n, const CallICFGNode* c) :
         ArgumentVFGNode(id, n, ARet), cs(c)
     {
     }
@@ -1043,7 +1123,7 @@ public:
         return cs->getCaller();
     }
     /// Receive parameter at callsite
-    inline const SVFVar* getRev() const
+    inline const ValVar* getRev() const
     {
         return param;
     }
@@ -1091,10 +1171,10 @@ private:
 
 public:
     /// Constructor
-    FormalRetVFGNode(NodeID id, const SVFVar* n, const FunObjVar* f);
+    FormalRetVFGNode(NodeID id, const ValVar* n, const FunObjVar* f);
 
     /// Return value at callee
-    inline const SVFVar* getRet() const
+    inline const ValVar* getRet() const
     {
         return param;
     }

package/SVF-linux-aarch64/include/MemoryModel/AccessPath.h

@@ -41,6 +41,7 @@ namespace SVF
 {
 
 class SVFVar;
+class ValVar;
 
 
 /*
@@ -58,7 +59,7 @@ public:
         NonOverlap, Overlap, Subset, Superset, Same
     };
 
-    typedef std::pair<const SVFVar*, const SVFType*> IdxOperandPair;
+    typedef std::pair<const ValVar*, const SVFType*> IdxOperandPair;
     typedef std::vector<IdxOperandPair> IdxOperandPairs;
 
     /// Constructor
@@ -144,7 +145,7 @@ public:
     u32_t getElementNum(const SVFType* type) const;
 
 
-    bool addOffsetVarAndGepTypePair(const SVFVar* var, const SVFType* gepIterType);
+    bool addOffsetVarAndGepTypePair(const ValVar* var, const SVFType* gepIterType);
 
     /// Return TRUE if this is a constant location set.
     bool isConstantOffset() const;
@@ -156,13 +157,13 @@ public:
     }
 
     /// Return byte offset from the beginning of the structure to the field where it is located for struct type
-    u32_t getStructFieldOffset(const SVFVar* idxOperandVar, const SVFStructType* idxOperandType) const;
+    u32_t getStructFieldOffset(const ValVar* idxOperandVar, const SVFStructType* idxOperandType) const;
 
     /// Dump location set
     std::string dump() const;
 
 protected:
-    inline void addIdxOperandPair(std::pair<const SVFVar*, const SVFType*> pair)
+    inline void addIdxOperandPair(std::pair<const ValVar*, const SVFType*> pair)
     {
         idxOperandPairs.push_back(pair);
     }

package/SVF-linux-aarch64/include/SABER/SaberSVFGBuilder.h

@@ -60,7 +60,7 @@ public:
     }
 
     /// Add ActualParmVFGNode
-    inline void addActualParmVFGNode(const SVFVar* svfVar, const CallICFGNode* cs)
+    inline void addActualParmVFGNode(const ValVar* svfVar, const CallICFGNode* cs)
     {
         svfg->addActualParmVFGNode(svfVar, cs);
     }

package/SVF-linux-aarch64/include/SVFIR/SVFIR.h

@@ -55,12 +55,12 @@ public:
     typedef Map<NodeID,CallSiteSet> FunPtrToCallSitesMap;
     typedef Map<NodeID,NodeBS> MemObjToFieldsMap;
     typedef std::vector<const SVFStmt*> SVFStmtList;
-    typedef std::vector<const SVFVar*> SVFVarList;
+    typedef std::vector<const ValVar*> ValVarList;
     typedef Map<const SVFVar*,PhiStmt*> PHINodeMap;
-    typedef Map<const FunObjVar*,SVFVarList> FunToArgsListMap;
-    typedef Map<const CallICFGNode*,SVFVarList> CSToArgsListMap;
-    typedef Map<const RetICFGNode*,const SVFVar*> CSToRetMap;
-    typedef Map<const FunObjVar*,const SVFVar*> FunToRetMap;
+    typedef Map<const FunObjVar*,ValVarList> FunToArgsListMap;
+    typedef Map<const CallICFGNode*,ValVarList> CSToArgsListMap;
+    typedef Map<const RetICFGNode*,const ValVar*> CSToRetMap;
+    typedef Map<const FunObjVar*,const ValVar*> FunToRetMap;
     typedef Map<const FunObjVar*,SVFStmtSet> FunToPAGEdgeSetMap;
     typedef Map<const ICFGNode*,SVFStmtList> ICFGNode2SVFStmtsMap;
     typedef Map<NodeID, NodeID> NodeToNodeMap;
@@ -132,6 +132,16 @@ public:
     {
         return getGNode(id);
     }
+    inline const ValVar* getValVar(NodeID id) const
+    {
+        if(const SVFVar* var = getSVFVar(id))
+            return SVFUtil::dyn_cast<ValVar>(var);
+        else
+        {
+            assert(false && "the Node is not a ValVar");
+            return nullptr;
+        }
+    }
     inline const ObjVar* getObjVar(NodeID id) const
     {
         if(const SVFVar* var = getSVFVar(id))
@@ -355,7 +365,7 @@ public:
         return funArgsListMap;
     }
     /// Get function arguments list
-    inline const SVFVarList& getFunArgsList(const FunObjVar*  func) const
+    inline const ValVarList& getFunArgsList(const FunObjVar*  func) const
     {
         FunToArgsListMap::const_iterator it = funArgsListMap.find(func);
         assert(it != funArgsListMap.end() && "this function doesn't have arguments");
@@ -372,7 +382,7 @@ public:
         return callSiteArgsListMap;
     }
     /// Get callsite argument list
-    inline const SVFVarList& getCallSiteArgsList(const CallICFGNode* cs) const
+    inline const ValVarList& getCallSiteArgsList(const CallICFGNode* cs) const
     {
         CSToArgsListMap::const_iterator it = callSiteArgsListMap.find(cs);
         assert(it != callSiteArgsListMap.end() && "this call site doesn't have arguments");
@@ -384,7 +394,7 @@ public:
         return callSiteRetMap;
     }
     /// Get callsite return
-    inline const SVFVar* getCallSiteRet(const RetICFGNode* cs) const
+    inline const ValVar* getCallSiteRet(const RetICFGNode* cs) const
     {
         CSToRetMap::const_iterator it = callSiteRetMap.find(cs);
         assert(it != callSiteRetMap.end() && "this call site doesn't have return");
@@ -400,7 +410,7 @@ public:
         return funRetMap;
     }
     /// Get function return list
-    inline const SVFVar* getFunRet(const FunObjVar*  func) const
+    inline const ValVar* getFunRet(const FunObjVar*  func) const
     {
         FunToRetMap::const_iterator it = funRetMap.find(func);
         assert(it != funRetMap.end() && "this function doesn't have return");
@@ -595,25 +605,25 @@ private:
     /// Get/set method for function/callsite arguments and returns
     //@{
     /// Add function arguments
-    inline void addFunArgs(const FunObjVar* fun, const SVFVar* arg)
+    inline void addFunArgs(const FunObjVar* fun, const ValVar* arg)
     {
         FunEntryICFGNode* funEntryBlockNode = icfg->getFunEntryICFGNode(fun);
         addFunArgs(funEntryBlockNode, fun, arg);
     }
 
-    inline void addFunArgs(FunEntryICFGNode* funEntryBlockNode, const FunObjVar* fun, const SVFVar* arg)
+    inline void addFunArgs(FunEntryICFGNode* funEntryBlockNode, const FunObjVar* fun, const ValVar* arg)
     {
         funEntryBlockNode->addFormalParms(arg);
         funArgsListMap[fun].push_back(arg);
     }
     /// Add function returns
-    inline void addFunRet(const FunObjVar* fun, const SVFVar* ret)
+    inline void addFunRet(const FunObjVar* fun, const ValVar* ret)
     {
         FunExitICFGNode* funExitBlockNode = icfg->getFunExitICFGNode(fun);
         addFunRet(funExitBlockNode, fun, ret);
     }
 
-    inline void addFunRet(FunExitICFGNode* funExitBlockNode, const FunObjVar* fun, const SVFVar* ret)
+    inline void addFunRet(FunExitICFGNode* funExitBlockNode, const FunObjVar* fun, const ValVar* ret)
     {
         funExitBlockNode->addFormalRet(ret);
         funRetMap[fun] = ret;
@@ -625,7 +635,7 @@ private:
         callSiteArgsListMap[callBlockNode].push_back(arg);
     }
     /// Add callsite returns
-    inline void addCallSiteRets(RetICFGNode* retBlockNode,const SVFVar* arg)
+    inline void addCallSiteRets(RetICFGNode* retBlockNode,const ValVar* arg)
     {
         retBlockNode->addActualRet(arg);
         callSiteRetMap[retBlockNode]= arg;

package/SVF-linux-aarch64/include/SVFIR/SVFStatements.h

@@ -38,6 +38,8 @@ namespace SVF
 {
 
 class SVFVar;
+class ValVar;
+class ObjVar;
 class ICFGNode;
 class IntraICFGNode;
 class CallICFGNode;
@@ -423,6 +425,11 @@ public:
     {
         return true;
     }
+
+    const ValVar* getLHSVar() const;
+    const ObjVar* getRHSVar() const;
+    const ValVar* getDstNode() const;
+    const ObjVar* getSrcNode() const;
 };
 
 /*!
@@ -507,6 +514,11 @@ public:
     /// constructor
     CopyStmt(SVFVar* s, SVFVar* d, CopyKind k) : AssignStmt(s, d, SVFStmt::Copy), copyKind(k) {}
 
+    const ValVar* getRHSVar() const;
+    const ValVar* getLHSVar() const;
+    const ValVar* getSrcNode() const;
+    const ValVar* getDstNode() const;
+
     virtual const std::string toString() const override;
 
 private:
@@ -544,6 +556,11 @@ public:
     /// constructor
     StoreStmt(SVFVar* s, SVFVar* d, const ICFGNode* st);
 
+    const ValVar* getRHSVar() const;
+    const ValVar* getLHSVar() const;
+    const ValVar* getSrcNode() const;
+    const ValVar* getDstNode() const;
+
     virtual const std::string toString() const override;
 
 };
@@ -579,6 +596,11 @@ public:
     /// constructor
     LoadStmt(SVFVar* s, SVFVar* d) : AssignStmt(s, d, SVFStmt::Load) {}
 
+    const ValVar* getRHSVar() const;
+    const ValVar* getLHSVar() const;
+    const ValVar* getSrcNode() const;
+    const ValVar* getDstNode() const;
+
     virtual const std::string toString() const override;
 };
 
@@ -660,6 +682,11 @@ public:
     {
     }
 
+    const ValVar* getRHSVar() const;
+    const ValVar* getLHSVar() const;
+    const ValVar* getSrcNode() const;
+    const ValVar* getDstNode() const;
+
     virtual const std::string toString() const;
 
 
@@ -719,6 +746,11 @@ public:
     }
     //@}
 
+    const ValVar* getRHSVar() const;
+    const ValVar* getLHSVar() const;
+    const ValVar* getSrcNode() const;
+    const ValVar* getDstNode() const;
+
     virtual const std::string toString() const override;
 };
 
@@ -775,6 +807,11 @@ public:
     }
     //@}
 
+    const ValVar* getRHSVar() const;
+    const ValVar* getLHSVar() const;
+    const ValVar* getSrcNode() const;
+    const ValVar* getDstNode() const;
+
     virtual const std::string toString() const override;
 
 };
@@ -786,10 +823,8 @@ class MultiOpndStmt : public SVFStmt
 {
     friend class GraphDBClient;
 
-
-
 public:
-    typedef std::vector<SVFVar*> OPVars;
+    typedef std::vector<ValVar*> OPVars;
 
 private:
     MultiOpndStmt();                      ///< place holder
@@ -803,7 +838,7 @@ private:
 protected:
     OPVars opVars;
     /// Constructor, only used by subclasses but not external users
-    MultiOpndStmt(SVFVar* r, const OPVars& opnds, GEdgeFlag k);
+    MultiOpndStmt(ValVar* r, const OPVars& opnds, GEdgeFlag k);
 
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -827,7 +862,7 @@ public:
     /// `r` is OpVar
     //@{
     /// Operand SVFVars
-    inline const SVFVar* getOpVar(u32_t pos) const
+    inline const ValVar* getOpVar(u32_t pos) const
     {
         return opVars.at(pos);
     }
@@ -897,13 +932,13 @@ public:
     //@}
 
     /// constructor
-    PhiStmt(SVFVar* res, const OPVars& opnds, const OpICFGNodeVec& icfgNodes)
+    PhiStmt(ValVar* res, const OPVars& opnds, const OpICFGNodeVec& icfgNodes)
         : MultiOpndStmt(res, opnds, SVFStmt::Phi), opICFGNodes(icfgNodes)
     {
         assert(opnds.size() == icfgNodes.size() &&
                "Numbers of operands and their ICFGNodes are not consistent?");
     }
-    void addOpVar(SVFVar* op, const ICFGNode* inode)
+    void addOpVar(ValVar* op, const ICFGNode* inode)
     {
         opVars.push_back(op);
         opICFGNodes.push_back(inode);
@@ -971,18 +1006,18 @@ public:
     //@}
 
     /// constructor
-    SelectStmt(SVFVar* res, const OPVars& opnds, const SVFVar* cond);
+    SelectStmt(ValVar* res, const OPVars& opnds, const SVFVar* cond);
     virtual const std::string toString() const override;
 
     inline const SVFVar* getCondition() const
     {
         return condition;
     }
-    inline const SVFVar* getTrueValue() const
+    inline const ValVar* getTrueValue() const
     {
         return getOpVar(0);
     }
-    inline const SVFVar* getFalseValue() const
+    inline const ValVar* getFalseValue() const
     {
         return getOpVar(1);
     }
@@ -1061,7 +1096,7 @@ public:
     //@}
 
     /// constructor
-    CmpStmt(SVFVar* res, const OPVars& opnds, u32_t pre);
+    CmpStmt(ValVar* res, const OPVars& opnds, u32_t pre);
 
     u32_t getPredicate() const
     {
@@ -1128,7 +1163,7 @@ public:
     //@}
 
     /// constructor
-    BinaryOPStmt(SVFVar* res, const OPVars& opnds, u32_t oc);
+    BinaryOPStmt(ValVar* res, const OPVars& opnds, u32_t oc);
 
     u32_t getOpcode() const
     {
@@ -1180,23 +1215,14 @@ public:
     //@}
 
     /// constructor
-    UnaryOPStmt(SVFVar* s, SVFVar* d, u32_t oc)
-        : SVFStmt(s, d, SVFStmt::UnaryOp), opcode(oc)
-    {
-    }
+    UnaryOPStmt(ValVar* s, ValVar* d, u32_t oc);
 
     u32_t getOpcode() const
     {
         return opcode;
     }
-    inline const SVFVar* getOpVar() const
-    {
-        return SVFStmt::getSrcNode();
-    }
-    inline const SVFVar* getRes() const
-    {
-        return SVFStmt::getDstNode();
-    }
+    const ValVar* getOpVar() const;
+    const ValVar* getRes() const;
     NodeID getOpVarID() const;
     NodeID getResID() const;
 
@@ -1223,8 +1249,8 @@ private:
     NodeID getDstID(); ///< place holder, use getResID() instead
 
     SuccAndCondPairVec successors;
-    const SVFVar* cond;
-    const SVFVar* brInst;
+    const ValVar* cond;
+    const ValVar* brInst;
 
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -1244,19 +1270,15 @@ public:
     //@}
 
     /// constructor
-    BranchStmt(SVFVar* inst, SVFVar* c, const SuccAndCondPairVec& succs)
-        : SVFStmt(c, inst, SVFStmt::Branch), successors(succs), cond(c),
-          brInst(inst)
-    {
-    }
+    BranchStmt(ValVar* inst, ValVar* c, const SuccAndCondPairVec& succs);
 
     /// The branch is unconditional if cond is a null value
     bool isUnconditional() const;
     /// The branch is conditional if cond is not a null value
     bool isConditional() const;
     /// Return the condition
-    const SVFVar* getCondition() const;
-    const SVFVar* getBranchInst() const
+    const ValVar* getCondition() const;
+    const ValVar* getBranchInst() const
     {
         return brInst;
     }
@@ -1327,6 +1349,11 @@ public:
     {
     }
 
+    const ValVar* getRHSVar() const;
+    const ValVar* getLHSVar() const;
+    const ValVar* getSrcNode() const;
+    const ValVar* getDstNode() const;
+
     virtual const std::string toString() const;
 
 };
@@ -1366,6 +1393,11 @@ public:
     {
     }
 
+    const ValVar* getRHSVar() const;
+    const ValVar* getLHSVar() const;
+    const ValVar* getSrcNode() const;
+    const ValVar* getDstNode() const;
+
     virtual const std::string toString() const;
 
 };

package/SVF-linux-x86_64/include/AE/Core/AbstractState.h

@@ -300,6 +300,8 @@ public:
 
     void printAbstractState() const;
 
+    std::string toString() const;
+
     u32_t hash() const;
 
     // lhs == rhs for varToValMap

package/SVF-linux-x86_64/include/AE/Svfexe/AbstractInterpretation.h

@@ -109,11 +109,11 @@ public:
         detectors.push_back(std::move(detector));
     }
 
-    /// Retrieve the abstract state from the trace for a given ICFG node; asserts if no trace exists
-    AbstractState& getAbstractState(const ICFGNode* node);
-
-    /// Check if an abstract state exists in the trace for a given ICFG node
-    bool hasAbstractState(const ICFGNode* node);
+    /// Retrieve SVFVar given its ID; asserts if no such variable exists
+    inline const SVFVar* getSVFVar(NodeID varId) const
+    {
+        return svfir->getSVFVar(varId);
+    }
 
     /// Retrieve abstract value for a top-level variable at a given ICFG node
     const AbstractValue& getAbstractValue(const ICFGNode* node, const ValVar* var);
@@ -124,6 +124,24 @@ public:
     /// Retrieve abstract value for any SVF variable at a given ICFG node
     const AbstractValue& getAbstractValue(const ICFGNode* node, const SVFVar* var);
 
+    /// Set abstract value for a top-level variable at a given ICFG node
+    void updateAbstractValue(const ICFGNode* node, const ValVar* var, const AbstractValue& val);
+
+    /// Set abstract value for an address-taken variable at a given ICFG node
+    void updateAbstractValue(const ICFGNode* node, const ObjVar* var, const AbstractValue& val);
+
+    /// Set abstract value for any SVF variable at a given ICFG node
+    void updateAbstractValue(const ICFGNode* node, const SVFVar* var, const AbstractValue& val);
+
+    /// Propagate an ObjVar's abstract value from defSite to all its use-site ICFGNodes via SVFG
+    void propagateObjVarAbsVal(const ObjVar* var, const ICFGNode* defSite);
+
+    /// Retrieve the abstract state from the trace for a given ICFG node; asserts if no trace exists
+    AbstractState& getAbstractState(const ICFGNode* node);
+
+    /// Check if an abstract state exists in the trace for a given ICFG node
+    bool hasAbstractState(const ICFGNode* node);
+
     /// Retrieve abstract state filtered to specific top-level variables
     void getAbstractState(const ICFGNode* node, const Set<const ValVar*>& vars, AbstractState& result);
 

package/SVF-linux-x86_64/include/AE/Svfexe/PreAnalysis.h

@@ -65,6 +65,12 @@ public:
     {
         return callGraphSCC;
     }
+    SVFG* getSVFG() const
+    {
+        return svfg;
+    }
+    /// Given an ObjVar and its def-site ICFGNode, find all use-site ICFGNodes
+    const Set<const ICFGNode*> getUseSitesOfObjVar(const ObjVar* obj, const ICFGNode* node) const;
 
     /// Build WTO for each function using call graph SCC
     void initWTO();
@@ -78,6 +84,7 @@ public:
 private:
     SVFIR* svfir;
     ICFG* icfg;
+    SVFG* svfg;
     AndersenWaveDiff* pta;
     CallGraph* callGraph;
     CallGraphSCC* callGraphSCC;

package/SVF-linux-x86_64/include/Graphs/SVFG.h

@@ -181,19 +181,19 @@ public:
 
     /// Given a ValVar and its SVFGNode, find the definition-site ICFGNode
     /// by following incoming direct VFGEdges (asserts unique definition)
-    const ICFGNode* getDefSiteOfValVar(const ValVar* var, const SVFGNode* node) const;
+    const ICFGNode* getDefSiteOfValVar(const ValVar* var) const;
 
-    /// Given an ObjVar and its SVFGNode, find the definition-site ICFGNode
+    /// Given an ObjVar and its use-site ICFGNode, find the definition-site ICFGNode
     /// by following incoming IndirectSVFGEdges whose pts contains the ObjVar (asserts unique definition)
-    const ICFGNode* getDefSiteOfObjVar(const ObjVar* obj, const SVFGNode* node) const;
+    const ICFGNode* getDefSiteOfObjVar(const ObjVar* obj, const ICFGNode* node) const;
 
-    /// Given a ValVar and its SVFStmt, find all use-site ICFGNodes
-    /// by following outgoing direct VFGEdges from its definition SVFGNode
-    const Set<const ICFGNode*> getUseSitesOfValVar(const ValVar* var, const SVFGNode* vNode) const;
+    /// Given a ValVar, find all use-site ICFGNodes
+    /// by following outgoing direct VFGEdges from its unique definition SVFGNode
+    const Set<const ICFGNode*> getUseSitesOfValVar(const ValVar* var) const;
 
-    /// Given an ObjVar and its SVFStmt, find all use-site ICFGNodes
+    /// Given an ObjVar and its def-site ICFGNode, find all use-site ICFGNodes
     /// by following outgoing IndirectSVFGEdges whose pts contains the ObjVar
-    const Set<const ICFGNode*> getUseSitesOfObjVar(const ObjVar* obj, const SVFGNode* vNode) const;
+    const Set<const ICFGNode*> getUseSitesOfObjVar(const ObjVar* obj, const ICFGNode* node) const;
 
     /// Perform statistics
     void performStat();

package/SVF-linux-x86_64/include/Util/Options.h

@@ -240,6 +240,7 @@ public:
     static const Option<u32_t> LoopBound;
 
     // Abstract Execution
+    static const Option<bool> SparseAE;
     static const Option<u32_t> WidenDelay;
     /// recursion handling mode, Default: TOP
     static const OptionMap<u32_t> HandleRecur;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-lib",
-  "version": "1.0.2509",
+  "version": "1.0.2511",
   "description": "SVF's npm support",
   "main": "index.js",
   "scripts": {