svf-tools 1.0.317 → 1.0.321

package/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
     {
@@ -204,139 +197,21 @@ public:
             inst2PTAPAGEdgesMap[inst].push_back(edge);
     }
     /// Get global PAGEdges (not in a procedure)
-    inline void addGlobalPAGEdge(const SVFStmt* edge)
-    {
-        globPAGEdgesSet.insert(edge);
-    }
-    /// Get global PAGEdges (not in a procedure)
     inline PAGEdgeSet& getGlobalPAGEdgeSet()
     {
         return globPAGEdgesSet;
     }
-    /// Add phi node information
-    inline void addPhiNode(const SVFVar* res, const CopyPE* edge)
+    /// Get all callsites
+    inline const CallSiteSet& getCallSiteSet() const
     {
-        phiNodeMap[res].push_back(edge);
+        return callSiteSet;
     }
     /// 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()
-    {
-        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;
-    }
-    /// Add phi node information
-    inline void addCmpNode(const SVFVar* res, const CmpPE* edge)
-    {
-        cmpNodeMap[res].push_back(edge);
-    }
-    /// 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()
-    {
-        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;
-    }
-    //@}
 
-private:
-    /// Get/set method for function/callsite arguments and returns
-    //@{
-    /// Add function arguments
-    inline void addFunArgs(const SVFFunction* fun, const SVFVar* arg)
-    {
-        FunEntryBlockNode* funEntryBlockNode = icfg->getFunEntryBlockNode(fun);
-        funEntryBlockNode->addFormalParms(arg);
-        funArgsListMap[fun].push_back(arg);
-    }
-    /// Add function returns
-    inline void addFunRet(const SVFFunction* fun, const SVFVar* ret)
-    {
-        FunExitBlockNode* funExitBlockNode = icfg->getFunExitBlockNode(fun);
-        funExitBlockNode->addFormalRet(ret);
-        funRetMap[fun] = ret;
-    }
-    /// Add callsite arguments
-    inline void addCallSiteArgs(CallBlockNode* callBlockNode,const SVFVar* arg)
-    {
-        callBlockNode->addActualParms(arg);
-        callSiteArgsListMap[callBlockNode].push_back(arg);
-    }
-    /// Add callsite returns
-    inline void addCallSiteRets(RetBlockNode* retBlockNode,const SVFVar* arg)
-    {
-        retBlockNode->addActualRet(arg);
-        callSiteRetMap[retBlockNode]= arg;
-    }
-    /// Add indirect callsites
-    inline void addIndirectCallsites(const CallBlockNode* cs,NodeID funPtr)
-    {
-        bool added = indCallSiteToFunPtrMap.insert(std::make_pair(cs,funPtr)).second;
-        funPtrToCallSitesMap[funPtr].insert(cs);
-        assert(added && "adding the same indirect callsite twice?");
-    }
-
-public:
     /// Function has arguments list
     inline bool hasFunArgsList(const SVFFunction* func) const
     {
@@ -584,8 +459,72 @@ public:
     NodeBS& getAllFieldsObjNode(NodeID id);
     NodeBS getFieldsAfterCollapse(NodeID id);
     //@}
+    inline NodeID addDummyValNode()
+    {
+        return addDummyValNode(NodeIDAllocator::get()->allocateValueId());
+    }
+    inline NodeID addDummyObjNode(const Type* type = nullptr)
+    {
+        return addDummyObjNode(NodeIDAllocator::get()->allocateObjectId(), type);
+    }
+    /// Whether a node is a valid pointer
+    //@{
+    bool isValidPointer(NodeID nodeId) const;
+
+    bool isValidTopLevelPtr(const SVFVar* node);
+    //@}
+
+    /// Print SVFIR
+    void print();
 
 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
+    inline void addFunArgs(const SVFFunction* fun, const SVFVar* arg)
+    {
+        FunEntryBlockNode* funEntryBlockNode = icfg->getFunEntryBlockNode(fun);
+        funEntryBlockNode->addFormalParms(arg);
+        funArgsListMap[fun].push_back(arg);
+    }
+    /// Add function returns
+    inline void addFunRet(const SVFFunction* fun, const SVFVar* ret)
+    {
+        FunExitBlockNode* funExitBlockNode = icfg->getFunExitBlockNode(fun);
+        funExitBlockNode->addFormalRet(ret);
+        funRetMap[fun] = ret;
+    }
+    /// Add callsite arguments
+    inline void addCallSiteArgs(CallBlockNode* callBlockNode,const SVFVar* arg)
+    {
+        callBlockNode->addActualParms(arg);
+        callSiteArgsListMap[callBlockNode].push_back(arg);
+    }
+    /// Add callsite returns
+    inline void addCallSiteRets(RetBlockNode* retBlockNode,const SVFVar* arg)
+    {
+        retBlockNode->addActualRet(arg);
+        callSiteRetMap[retBlockNode]= arg;
+    }
+    /// Add indirect callsites
+    inline void addIndirectCallsites(const CallBlockNode* cs,NodeID funPtr)
+    {
+        bool added = indCallSiteToFunPtrMap.insert(std::make_pair(cs,funPtr)).second;
+        funPtrToCallSitesMap[funPtr].insert(cs);
+        assert(added && "adding the same indirect callsite twice?");
+    }
+
     /// add node into SVFIR
     //@{
     /// Add a value (pointer) node
@@ -674,18 +613,32 @@ private:
         return addNode(node,i);
     }
 
+    /// Add global PAGEdges (not in a procedure)
+    inline void addGlobalPAGEdge(const SVFStmt* edge)
+    {
+        globPAGEdgesSet.insert(edge);
+    }
+    /// Add callsites
+    inline void addCallSite(const CallBlockNode* call)
+    {
+        callSiteSet.insert(call);
+    }
     /// Add an edge into SVFIR
     //@{
     /// Add Address edge
     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, u32_t opcode);
     /// Add Copy edge
-    BinaryOPPE* addBinaryOPPE(NodeID src, NodeID dst);
+    BinaryOPPE* addBinaryOPPE(NodeID op1, NodeID op2, NodeID dst, u32_t opcode);
     /// Add Unary edge
-    UnaryOPPE* addUnaryOPPE(NodeID src, NodeID dst);
+    UnaryOPPE* addUnaryOPPE(NodeID src, NodeID dst, u32_t opcode);
+    /// Add BranchStmt
+    BranchStmt* addBranchStmt(NodeID br, NodeID cond, std::vector<const ICFGNode*> succs);
     /// Add Load edge
     LoadPE* addLoadPE(NodeID src, NodeID dst);
     /// Add Store edge
@@ -708,25 +661,6 @@ private:
 
     /// Set a pointer points-to black hole (e.g. int2ptr)
     SVFStmt* addBlackHoleAddrPE(NodeID node);
-
-public:
-    inline NodeID addDummyValNode()
-    {
-        return addDummyValNode(NodeIDAllocator::get()->allocateValueId());
-    }
-    inline NodeID addDummyObjNode(const Type* type = nullptr)
-    {
-        return addDummyObjNode(NodeIDAllocator::get()->allocateObjectId(), type);
-    }
-    /// Whether a node is a valid pointer
-    //@{
-    bool isValidPointer(NodeID nodeId) const;
-
-    bool isValidTopLevelPtr(const SVFVar* node);
-    //@}
-
-    /// Print SVFIR
-    void print();
 };
 
 typedef SVFIR PAG;