svf-lib 1.0.733 → 1.0.737

package/SVF-linux/include/WPA/FlowSensitive.h

@@ -58,7 +58,7 @@ public:
     typedef BVDataPTAImpl::MutDFPTDataTy::PtsMap PtsMap;
 
     /// Constructor
-    FlowSensitive(PAG* _pag, PTATY type = FSSPARSE_WPA) : WPASVFGFSSolver(), BVDataPTAImpl(_pag, type)
+    FlowSensitive(SVFIR* _pag, PTATY type = FSSPARSE_WPA) : WPASVFGFSSolver(), BVDataPTAImpl(_pag, type)
     {
         svfg = nullptr;
         solveTime = sccTime = processTime = propagationTime = updateTime = 0;
@@ -81,7 +81,7 @@ public:
     }
 
     /// Create signle instance of flow-sensitive pointer analysis
-    static FlowSensitive* createFSWPA(PAG* _pag)
+    static FlowSensitive* createFSWPA(SVFIR* _pag)
     {
         if (fspta == nullptr)
         {

package/SVF-linux/include/WPA/FlowSensitiveTBHC.h

@@ -33,7 +33,7 @@ public:
     static const MDNode *getRawCTirMetadata(const SVFGNode *);
 
     /// Constructor
-    FlowSensitiveTBHC(PAG* _pag, PTATY type = FSTBHC_WPA);
+    FlowSensitiveTBHC(SVFIR* _pag, PTATY type = FSTBHC_WPA);
 
     /// Destructor
     virtual ~FlowSensitiveTBHC() { };

package/SVF-linux/include/WPA/Steensgaard.h

@@ -26,13 +26,13 @@ public:
     typedef Map<NodeID, Set<NodeID>> NodeToSubsMap;
 
     /// Constructor
-    Steensgaard(PAG* _pag)
+    Steensgaard(SVFIR* _pag)
         :  AndersenBase(_pag, Steensgaard_WPA, true)
     {
     }
 
     /// Create an singleton instance
-    static Steensgaard* createSteensgaard(PAG* _pag)
+    static Steensgaard* createSteensgaard(SVFIR* _pag)
     {
         if(steens==nullptr)
         {

package/SVF-linux/include/WPA/TypeAnalysis.h

@@ -40,7 +40,7 @@ class TypeAnalysis:  public AndersenBase
 
 public:
     /// Constructor
-    TypeAnalysis(PAG* pag)
+    TypeAnalysis(SVFIR* pag)
         :  AndersenBase(pag, TypeCPP_WPA)
     {
     }

package/SVF-linux/include/WPA/VersionedFlowSensitive.h

@@ -47,7 +47,7 @@ public:
     static VersionedVar atKey(NodeID, Version);
 
     /// Constructor
-    VersionedFlowSensitive(PAG *_pag, PTATY type = VFS_WPA);
+    VersionedFlowSensitive(SVFIR *_pag, PTATY type = VFS_WPA);
 
     /// Initialize analysis
     virtual void initialize() override;
@@ -74,7 +74,7 @@ public:
     //@}
 
     /// Create single instance of versioned flow-sensitive points-to analysis.
-    static VersionedFlowSensitive *createVFSWPA(PAG *_pag)
+    static VersionedFlowSensitive *createVFSWPA(SVFIR *_pag)
     {
         if (vfspta == nullptr)
         {

package/SVF-linux/include/WPA/WPAStat.h

@@ -39,9 +39,8 @@ namespace SVF
 {
 
 class AndersenBase;
-class PAG;
+class SVFIR;
 class ConstraintGraph;
-class PAGNode;
 
 /*!
  * Statistics of Andersen's analysis

package/SVF-osx/include/Graphs/GenericGraph.h

@@ -108,7 +108,7 @@ public:
         }
     } equalGEdge;
 
-    inline bool operator==(const GenericEdge<NodeType>* rhs) const
+    virtual inline bool operator==(const GenericEdge<NodeType>* rhs) const
     {
         return (rhs->edgeFlag == this->edgeFlag && rhs->getSrcID() == this->getSrcID()
                 && rhs->getDstID() == this->getDstID());

package/SVF-osx/include/Graphs/IRGraph.h

@@ -51,16 +51,15 @@ public:
     typedef Set<const SVFStmt*> PAGEdgeSet;
     typedef Map<const Value*,PAGEdgeSet> ValueToEdgeMap;
 
-private:
+protected:
+    SVFStmt::PAGKindToEdgeSetMapTy PAGEdgeKindToSetMap;  // < SVFIR edge map containing all PAGEdges
+    SVFStmt::PAGKindToEdgeSetMapTy PTAPAGEdgeKindToSetMap;  // < SVFIR edge map containing only pointer-related edges, i.e, both RHS and RHS are of pointer type
     bool fromFile; ///< Whether the SVFIR is built according to user specified data from a txt file
     NodeID nodeNumAfterPAGBuild; // initial node number after building SVFIR, excluding later added nodes, e.g., gepobj nodes
     u32_t totalPTAPAGEdge;
-    SVFStmt::PAGKindToEdgeSetMapTy PAGEdgeKindToSetMap;  // < SVFIR edge map containing all PAGEdges
-    SVFStmt::PAGKindToEdgeSetMapTy PTAPAGEdgeKindToSetMap;  // < SVFIR edge map containing only pointer-related edges, i.e, both RHS and RHS are of pointer type
     ValueToEdgeMap valueToEdgeMap;	///< Map llvm::Values to all corresponding PAGEdges
     SymbolTableInfo* symInfo;
 
-protected:
     /// Add a node into the graph
     inline NodeID addNode(SVFVar* node, NodeID i)
     {
@@ -75,6 +74,9 @@ protected:
     /// Return true if this labeled edge exits, including store, call and load
     /// two store edge can have same dst and src but located in different basic blocks, thus flags are needed to distinguish them
     SVFStmt* hasLabeledEdge(SVFVar* src, SVFVar* dst, SVFStmt::PEDGEK kind, const ICFGNode* cs);
+    /// Return MultiOpndStmt since it has more than one operands (we use operand 2 here to make the flag)
+    SVFStmt* hasLabeledEdge(SVFVar* src, SVFVar* op1, SVFStmt::PEDGEK kind, const SVFVar* op2);
+
     /// Map a value to a set of edges
     inline void mapValueToEdge(const Value *V, SVFStmt *edge)
     {
@@ -102,17 +104,6 @@ public:
     {
         return fromFile;
     }
-    /// Get edges set according to its kind
-    inline SVFStmt::PAGEdgeSetTy& getEdgeSet(SVFStmt::PEDGEK kind)
-    {
-        return PAGEdgeKindToSetMap[kind];
-    }
-    /// Get PTA edges set according to its kind
-    inline SVFStmt::PAGEdgeSetTy& getPTAEdgeSet(SVFStmt::PEDGEK kind)
-    {
-        return PTAPAGEdgeKindToSetMap[kind];
-    }
-
     /// Get all SVFIR Edges that corresponds to an LLVM value
     inline const PAGEdgeSet& getValueEdges(const Value *V)
     {

package/SVF-osx/include/Graphs/VFG.h

@@ -561,70 +561,55 @@ protected:
         PAGNodeToActualRetMap[ret] = sNode;
     }
     /// Add an llvm PHI VFG node
-    inline void addIntraPHIVFGNode(const PAGNode* phiResNode, SVFIR::CopyPEList& oplist)
+    inline void addIntraPHIVFGNode(const PhiPE* edge)
     {
-        IntraPHIVFGNode* sNode = new IntraPHIVFGNode(totalVFGNode++,phiResNode);
+        IntraPHIVFGNode* sNode = new IntraPHIVFGNode(totalVFGNode++,edge->getRes());
         u32_t pos = 0;
-        const PAGEdge* edge = nullptr;
-        for(SVFIR::CopyPEList::const_iterator it = oplist.begin(), eit=oplist.end(); it!=eit; ++it,++pos)
+        for(auto var : edge->getOpndVars())
         {
-            edge = *it;
-            sNode->setOpVerAndBB(pos, edge->getSrcNode(), edge->getICFGNode());
+            sNode->setOpVerAndBB(pos, var, edge->getICFGNode());
+            pos++;
         }
-        assert(edge && "edge not found?");
         addVFGNode(sNode,edge->getICFGNode());
-        setDef(phiResNode,sNode);
-        PAGNodeToIntraPHIVFGNodeMap[phiResNode] = sNode;
+        setDef(edge->getRes(),sNode);
+        PAGNodeToIntraPHIVFGNodeMap[edge->getRes()] = sNode;
     }
     /// Add a Compare VFG node
-    inline void addCmpVFGNode(const PAGNode* resNode, SVFIR::CmpPEList& oplist)
+    inline void addCmpVFGNode(const CmpPE* edge)
     {
-        CmpVFGNode* sNode = new CmpVFGNode(totalVFGNode++, resNode);
+        CmpVFGNode* sNode = new CmpVFGNode(totalVFGNode++, edge->getRes());
         u32_t pos = 0;
-        const PAGEdge* edge = nullptr;
-        for(SVFIR::CmpPEList::const_iterator it = oplist.begin(), eit=oplist.end(); it!=eit; ++it,++pos)
+        for(auto var : edge->getOpndVars())
         {
-            edge = *it;
-            sNode->setOpVer(pos, edge->getSrcNode());
+            sNode->setOpVer(pos, var);
+            pos++;
         }
-        assert(edge && "edge not found?");
         addVFGNode(sNode,edge->getICFGNode());
-        setDef(resNode,sNode);
-        PAGNodeToCmpVFGNodeMap[resNode] = sNode;
+        setDef(edge->getRes(),sNode);
+        PAGNodeToCmpVFGNodeMap[edge->getRes()] = sNode;
     }
     /// Add a BinaryOperator VFG node
-    inline void addBinaryOPVFGNode(const PAGNode* resNode, SVFIR::BinaryOPList& oplist)
+    inline void addBinaryOPVFGNode(const BinaryOPPE* edge)
     {
-        BinaryOPVFGNode* sNode = new BinaryOPVFGNode(totalVFGNode++, resNode);
+        BinaryOPVFGNode* sNode = new BinaryOPVFGNode(totalVFGNode++, edge->getRes());
         u32_t pos = 0;
-        const PAGEdge* edge = nullptr;
-        for(SVFIR::BinaryOPList::const_iterator it = oplist.begin(), eit=oplist.end(); it!=eit; ++it,++pos)
+        for(auto var : edge->getOpndVars())
         {
-            edge = *it;
-            sNode->setOpVer(pos, (*it)->getSrcNode());
+            sNode->setOpVer(pos, var);
+            pos++;
         }
-
-        assert(edge && "edge not found?");
         addVFGNode(sNode,edge->getICFGNode());
-        setDef(resNode,sNode);
-        PAGNodeToBinaryOPVFGNodeMap[resNode] = sNode;
+        setDef(edge->getRes(),sNode);
+        PAGNodeToBinaryOPVFGNodeMap[edge->getRes()] = sNode;
     }
     /// Add a UnaryOperator VFG node
-    inline void addUnaryOPVFGNode(const PAGNode* resNode, SVFIR::UnaryOPList& oplist)
+    inline void addUnaryOPVFGNode(const UnaryOPPE* edge)
     {
-        UnaryOPVFGNode* sNode = new UnaryOPVFGNode(totalVFGNode++, resNode);
-        u32_t pos = 0;
-        const PAGEdge* edge = nullptr;
-        for(SVFIR::UnaryOPList::const_iterator it = oplist.begin(), eit=oplist.end(); it!=eit; ++it,++pos)
-        {
-            edge = *it;
-            sNode->setOpVer(pos, (*it)->getSrcNode());
-        }
-
-        assert(edge && "edge not found?");
+        UnaryOPVFGNode* sNode = new UnaryOPVFGNode(totalVFGNode++, edge->getDstNode());
+        sNode->setOpVer(0, edge->getSrcNode());
         addVFGNode(sNode,edge->getICFGNode());
-        setDef(resNode,sNode);
-        PAGNodeToUnaryOPVFGNodeMap[resNode] = sNode;
+        setDef(edge->getDstNode(),sNode);
+        PAGNodeToUnaryOPVFGNodeMap[edge->getDstNode()] = sNode;
     }
 };
 

package/SVF-osx/include/Graphs/VFGNode.h

@@ -330,7 +330,7 @@ public:
     CmpVFGNode(NodeID id,const PAGNode* r): VFGNode(id,Cmp), res(r)
     {
         const CmpInst* cmp = SVFUtil::dyn_cast<CmpInst>(r->getValue());
-        assert(cmp && "not a binary operator?");
+        assert(cmp && "not a compare operator?");
     }
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
@@ -1091,7 +1091,7 @@ public:
         return node->isPointer();
     }
     /// Return corresponding PAGNode
-    const PAGNode* getGNode() const
+    const PAGNode* getPAGNode() const
     {
         return node;
     }

package/SVF-osx/include/MemoryModel/SVFIR.h

@@ -56,13 +56,7 @@ public:
     typedef std::vector<const SVFStmt*> PAGEdgeList;
     typedef std::vector<const SVFVar*> PAGNodeList;
     typedef std::vector<const CopyPE*> CopyPEList;
-    typedef std::vector<const BinaryOPPE*> BinaryOPList;
-    typedef std::vector<const UnaryOPPE*> UnaryOPList;
-    typedef std::vector<const CmpPE*> CmpPEList;
-    typedef Map<const SVFVar*,CopyPEList> PHINodeMap;
-    typedef Map<const SVFVar*,BinaryOPList> BinaryNodeMap;
-    typedef Map<const SVFVar*,UnaryOPList> UnaryNodeMap;
-    typedef Map<const SVFVar*,CmpPEList> CmpNodeMap;
+    typedef Map<const SVFVar*,PhiPE*> PHINodeMap;
     typedef Map<const SVFFunction*,PAGNodeList> FunToArgsListMap;
     typedef Map<const CallBlockNode*,PAGNodeList> CSToArgsListMap;
     typedef Map<const RetBlockNode*,const SVFVar*> CSToRetMap;
@@ -87,9 +81,6 @@ private:
     MemObjToFieldsMap memToFieldsMap;	///< Map a mem object id to all its fields
     PAGEdgeSet globPAGEdgesSet;	///< Global PAGEdges without control flow information
     PHINodeMap phiNodeMap;	///< A set of phi copy edges
-    BinaryNodeMap binaryNodeMap;	///< A set of binary edges
-    UnaryNodeMap unaryNodeMap;	///< A set of unary edges
-    CmpNodeMap cmpNodeMap;	///< A set of comparision edges
     FunToArgsListMap funArgsListMap;	///< Map a function to a list of all its formal parameters
     CSToArgsListMap callSiteArgsListMap;	///< Map a callsite to a list of all its actual parameters
     CSToRetMap callSiteRetMap;	///< Map a callsite to its callsite returns PAGNodes
@@ -166,16 +157,18 @@ public:
     {
         return SymbolTableInfo::SymbolInfo()->getModule();
     }
-    inline void addCallSite(const CallBlockNode* call)
+    /// Get/set methods to get SVFStmts based on their kinds and ICFGNodes
+    //@{
+    /// Get edges set according to its kind
+    inline SVFStmt::PAGEdgeSetTy& getEdgeSet(SVFStmt::PEDGEK kind)
     {
-        callSiteSet.insert(call);
+        return PAGEdgeKindToSetMap[kind];
     }
-    inline const CallSiteSet& getCallSiteSet() const
+    /// Get PTA edges set according to its kind
+    inline SVFStmt::PAGEdgeSetTy& getPTAEdgeSet(SVFStmt::PEDGEK kind)
     {
-        return callSiteSet;
+        return PTAPAGEdgeKindToSetMap[kind];
     }
-    /// Get/set methods to get control flow information of a SVFStmt
-    //@{
     /// Whether this instruction has SVFIR Edge
     inline bool hasPAGEdgeList(const ICFGNode* inst) const
     {
@@ -213,93 +206,31 @@ public:
     {
         return globPAGEdgesSet;
     }
-    /// Add phi node information
-    inline void addPhiNode(const SVFVar* res, const CopyPE* edge)
-    {
-        phiNodeMap[res].push_back(edge);
-    }
-    /// Whether this SVFVar is a result operand a of phi node
-    inline bool isPhiNode(const SVFVar* node) const
-    {
-        return phiNodeMap.find(node) != phiNodeMap.end();
-    }
-    /// Get all phi copy edges
-    inline PHINodeMap& getPhiNodeMap()
-    {
-        return phiNodeMap;
-    }
-        /// Get the corresponding PhiCopyPEs
-    inline const CopyPEList& getPhiCopyPEs(const SVFVar* node) const{
-        PHINodeMap::const_iterator it = phiNodeMap.find(node);
-        assert(it != phiNodeMap.end() && "PhiCopyPEs not found!");
-        return it->second;
-    }
-    /// Add phi node information
-    inline void addBinaryNode(const SVFVar* res, const BinaryOPPE* edge)
-    {
-        binaryNodeMap[res].push_back(edge);
-    }
-    /// Whether this SVFVar is a result operand a of phi node
-    inline bool isBinaryNode(const SVFVar* node) const
-    {
-        return binaryNodeMap.find(node) != binaryNodeMap.end();
-    }
-    /// Get all phi copy edges
-    inline BinaryNodeMap& getBinaryNodeMap()
-    {
-        return binaryNodeMap;
-    }
-    /// Get the corresponding BinaryPEs
-    inline const BinaryOPList& getBinaryPEs(const SVFVar* node) const{
-        BinaryNodeMap::const_iterator it = binaryNodeMap.find(node);
-        assert(it != binaryNodeMap.end() && "BinaryPEs not found!");
-        return it->second;
-    }
-    /// Add unary node information
-    inline void addUnaryNode(const SVFVar* res, const UnaryOPPE* edge)
-    {
-        unaryNodeMap[res].push_back(edge);
-    }
-    /// Whether this SVFVar is an unary node
-    inline bool isUnaryNode(const SVFVar* node) const
-    {
-        return unaryNodeMap.find(node) != unaryNodeMap.end();
-    }
-    /// Get all unary edges
-    inline UnaryNodeMap& getUnaryNodeMap()
+    inline void addCallSite(const CallBlockNode* call)
     {
-        return unaryNodeMap;
-    }
-    /// Get the corresponding UnaryPEs
-    inline const UnaryOPList& getUnaryPEs(const SVFVar* node) const{
-        UnaryNodeMap::const_iterator it = unaryNodeMap.find(node);
-        assert(it != unaryNodeMap.end() && "UnaryPEs not found!");
-        return it->second;
+        callSiteSet.insert(call);
     }
-    /// Add phi node information
-    inline void addCmpNode(const SVFVar* res, const CmpPE* edge)
+    inline const CallSiteSet& getCallSiteSet() const
     {
-        cmpNodeMap[res].push_back(edge);
+        return callSiteSet;
     }
     /// Whether this SVFVar is a result operand a of phi node
-    inline bool isCmpNode(const SVFVar* node) const
-    {
-        return cmpNodeMap.find(node) != cmpNodeMap.end();
-    }
-    /// Get all phi copy edges
-    inline CmpNodeMap& getCmpNodeMap()
+    inline bool isPhiNode(const SVFVar* node) const
     {
-        return cmpNodeMap;
-    }
-    /// Get the corresponding CmpPEs
-    inline const CmpPEList& getCmpPEs(const SVFVar* node) const{
-        CmpNodeMap::const_iterator it = cmpNodeMap.find(node);
-        assert(it != cmpNodeMap.end() && "CmpPEs not found!");
-        return it->second;
+        return phiNodeMap.find(node) != phiNodeMap.end();
     }
-    //@}
 
 private:
+    /// Map a SVFStatement type to a set of corresponding SVF statements
+    inline void addToStmt2TypeMap(SVFStmt* edge) {
+        bool added = PAGEdgeKindToSetMap[edge->getEdgeKind()].insert(edge).second;
+        assert(added && "duplicated edge, not added!!!");
+        if (edge->isPTAEdge())
+        {
+            totalPTAPAGEdge++;
+            PTAPAGEdgeKindToSetMap[edge->getEdgeKind()].insert(edge);
+        }
+    }
     /// Get/set method for function/callsite arguments and returns
     //@{
     /// Add function arguments
@@ -680,10 +611,12 @@ private:
     AddrPE* addAddrPE(NodeID src, NodeID dst);
     /// Add Copy edge
     CopyPE* addCopyPE(NodeID src, NodeID dst);
+    /// Add phi node information
+    PhiPE*  addPhiNode(NodeID res, NodeID opnd);
     /// Add Copy edge
-    CmpPE* addCmpPE(NodeID src, NodeID dst);
+    CmpPE* addCmpPE(NodeID op1, NodeID op2, NodeID dst);
     /// Add Copy edge
-    BinaryOPPE* addBinaryOPPE(NodeID src, NodeID dst);
+    BinaryOPPE* addBinaryOPPE(NodeID op1, NodeID op2, NodeID dst);
     /// Add Unary edge
     UnaryOPPE* addUnaryOPPE(NodeID src, NodeID dst);
     /// Add Load edge