svf-tools 1.0.782 → 1.0.783

package/svf/include/Graphs/CFBasicBlockG.h

@@ -30,7 +30,7 @@
 #ifndef SVF_CFBASICBLOCKG_H
 #define SVF_CFBASICBLOCKG_H
 #include "Util/SVFUtil.h"
-#include "Graphs/ICFGNode.h"
+#include "Graphs/ICFG.h"
 #include "Graphs/GenericGraph.h"
 
 namespace SVF
@@ -43,8 +43,33 @@ typedef GenericEdge<CFBasicBlockNode> GenericCFBasicBlockEdgeTy;
 class CFBasicBlockEdge : public GenericCFBasicBlockEdgeTy
 {
 public:
-    CFBasicBlockEdge(CFBasicBlockNode *src, CFBasicBlockNode *dst) : GenericCFBasicBlockEdgeTy(src, dst, 0) {}
+    typedef struct equalCFBBEdge
+    {
+        bool
+        operator()(const CFBasicBlockEdge *lhs, const CFBasicBlockEdge *rhs) const
+        {
+            if (lhs->getSrcID() != rhs->getSrcID())
+                return lhs->getSrcID() < rhs->getSrcID();
+            else if (lhs->getDstID() != rhs->getDstID())
+                return lhs->getDstID() < rhs->getDstID();
+            else
+                return lhs->getICFGEdge() < rhs->getICFGEdge();
+        }
+    } equalICFGEdgeWrapper;
+
+    typedef OrderedSet<CFBasicBlockEdge *, equalICFGEdgeWrapper> CFBBEdgeSetTy;
+    typedef CFBBEdgeSetTy::iterator iterator;
+    typedef CFBBEdgeSetTy::const_iterator const_iterator;
+
+private:
+    const ICFGEdge *_icfgEdge;
 
+public:
+    CFBasicBlockEdge(CFBasicBlockNode* src, CFBasicBlockNode* dst,
+                     const ICFGEdge* edge)
+        : GenericCFBasicBlockEdgeTy(src, dst, 0), _icfgEdge(edge)
+    {
+    }
 
     friend std::ostream &operator<<(std::ostream &o, const CFBasicBlockEdge &edge)
     {
@@ -54,20 +79,50 @@ public:
 
     virtual const std::string toString() const
     {
-        return std::to_string(getSrcID()) + " --> " + std::to_string(getDstID());
+        return _icfgEdge->toString();
+    }
+
+    inline const ICFGEdge *getICFGEdge() const
+    {
+        return _icfgEdge;
+    }
+
+    using SVF::GenericEdge<NodeType>::operator==;
+    /// Add the hash function for std::set (we also can overload operator< to implement this)
+    //  and duplicated elements in the set are not inserted (binary tree comparison)
+    //@{
+
+    virtual inline bool operator==(const CFBasicBlockEdge *rhs) const
+    {
+        return (rhs->getSrcID() == this->getSrcID() && rhs->getDstID() == this->getDstID() &&
+                rhs->getICFGEdge() == this->getICFGEdge());
     }
+    //@}
+
 };
 
 typedef GenericNode<CFBasicBlockNode, CFBasicBlockEdge> GenericCFBasicBlockNodeTy;
 
 class CFBasicBlockNode : public GenericCFBasicBlockNodeTy
 {
+public:
+    typedef CFBasicBlockEdge::CFBBEdgeSetTy CFBBEdgeSetTy;
+    typedef CFBasicBlockEdge::CFBBEdgeSetTy ::iterator iterator;
+    typedef CFBasicBlockEdge::CFBBEdgeSetTy::const_iterator const_iterator;
+
 private:
-    const SVFBasicBlock *_svfBasicBlock; /// Every CFBasicBlockNode holds a SVFBasicBlock
     std::vector<const ICFGNode *> _icfgNodes; /// Every CBFGNode holds a vector of ICFGNodes
+    CFBBEdgeSetTy InEdges; ///< all incoming edge of this node
+    CFBBEdgeSetTy OutEdges; ///< all outgoing edge of this node
 
 public:
-    CFBasicBlockNode(u32_t id, const SVFBasicBlock *svfBasicBlock);
+    CFBasicBlockNode(std::vector<const ICFGNode*> icfgNodes)
+        : GenericCFBasicBlockNodeTy((*icfgNodes.begin())->getId(), 0),
+          _icfgNodes(SVFUtil::move(icfgNodes))
+    {
+    }
+
+    CFBasicBlockNode(const SVFBasicBlock* bb);
 
     friend std::ostream &operator<<(std::ostream &o, const CFBasicBlockNode &node)
     {
@@ -79,17 +134,20 @@ public:
 
     inline std::string getName() const
     {
-        return _svfBasicBlock->getName();
+        assert(!_icfgNodes.empty() && "no ICFG nodes in CFBB");
+        return (*_icfgNodes.begin())->getBB()->getName();
     }
 
     inline const SVFBasicBlock *getSVFBasicBlock() const
     {
-        return _svfBasicBlock;
+        assert(!_icfgNodes.empty() && "no ICFG nodes in CFBB");
+        return (*_icfgNodes.begin())->getBB();
     }
 
     inline const SVFFunction *getFunction() const
     {
-        return _svfBasicBlock->getFunction();
+        assert(!_icfgNodes.empty() && "no ICFG nodes in CFBB");
+        return (*_icfgNodes.begin())->getFun();
     }
 
     inline std::vector<const ICFGNode *>::const_iterator begin() const
@@ -101,6 +159,187 @@ public:
     {
         return _icfgNodes.cend();
     }
+
+    inline void removeNode(const ICFGNode* node)
+    {
+        const auto it = std::find(_icfgNodes.begin(), _icfgNodes.end(), node);
+        assert(it != _icfgNodes.end() && "icfg node not in BB?");
+        _icfgNodes.erase(it);
+    }
+
+    inline void addNode(const ICFGNode* node)
+    {
+        _icfgNodes.push_back(node);
+    }
+
+    inline u32_t getICFGNodeNum() const
+    {
+        return _icfgNodes.size();
+    }
+
+public:
+    /// Get incoming/outgoing edge set
+    ///@{
+    inline const CFBBEdgeSetTy &getOutEdges() const
+    {
+        return OutEdges;
+    }
+
+    inline const CFBBEdgeSetTy &getInEdges() const
+    {
+        return InEdges;
+    }
+    ///@}
+
+    /// Has incoming/outgoing edge set
+    //@{
+    inline bool hasIncomingEdge() const
+    {
+        return (InEdges.empty() == false);
+    }
+
+    inline bool hasOutgoingEdge() const
+    {
+        return (OutEdges.empty() == false);
+    }
+    //@}
+
+    ///  iterators
+    //@{
+    inline iterator OutEdgeBegin()
+    {
+        return OutEdges.begin();
+    }
+
+    inline iterator OutEdgeEnd()
+    {
+        return OutEdges.end();
+    }
+
+    inline iterator InEdgeBegin()
+    {
+        return InEdges.begin();
+    }
+
+    inline iterator InEdgeEnd()
+    {
+        return InEdges.end();
+    }
+
+    inline const_iterator OutEdgeBegin() const
+    {
+        return OutEdges.begin();
+    }
+
+    inline const_iterator OutEdgeEnd() const
+    {
+        return OutEdges.end();
+    }
+
+    inline const_iterator InEdgeBegin() const
+    {
+        return InEdges.begin();
+    }
+
+    inline const_iterator InEdgeEnd() const
+    {
+        return InEdges.end();
+    }
+    //@}
+
+    /// Iterators used for SCC detection, overwrite it in child class if necessory
+    //@{
+    virtual inline iterator directOutEdgeBegin()
+    {
+        return OutEdges.begin();
+    }
+
+    virtual inline iterator directOutEdgeEnd()
+    {
+        return OutEdges.end();
+    }
+
+    virtual inline iterator directInEdgeBegin()
+    {
+        return InEdges.begin();
+    }
+
+    virtual inline iterator directInEdgeEnd()
+    {
+        return InEdges.end();
+    }
+
+    virtual inline const_iterator directOutEdgeBegin() const
+    {
+        return OutEdges.begin();
+    }
+
+    virtual inline const_iterator directOutEdgeEnd() const
+    {
+        return OutEdges.end();
+    }
+
+    virtual inline const_iterator directInEdgeBegin() const
+    {
+        return InEdges.begin();
+    }
+
+    virtual inline const_iterator directInEdgeEnd() const
+    {
+        return InEdges.end();
+    }
+    //@}
+
+    /// Add incoming and outgoing edges
+    //@{
+    inline bool addIncomingEdge(CFBasicBlockEdge *inEdge)
+    {
+        return InEdges.insert(inEdge).second;
+    }
+
+    inline bool addOutgoingEdge(CFBasicBlockEdge *outEdge)
+    {
+        return OutEdges.insert(outEdge).second;
+    }
+    //@}
+
+    /// Remove incoming and outgoing edges
+    ///@{
+    inline u32_t removeIncomingEdge(CFBasicBlockEdge *edge)
+    {
+        iterator it = InEdges.find(edge);
+        assert(it != InEdges.end() && "can not find in edge in SVFG node");
+        return InEdges.erase(edge);
+    }
+
+    inline u32_t removeOutgoingEdge(CFBasicBlockEdge *edge)
+    {
+        iterator it = OutEdges.find(edge);
+        assert(it != OutEdges.end() && "can not find out edge in SVFG node");
+        return OutEdges.erase(edge);
+    }
+    ///@}
+
+    /// Find incoming and outgoing edges
+    //@{
+    inline CFBasicBlockEdge *hasIncomingEdge(CFBasicBlockEdge *edge) const
+    {
+        const_iterator it = InEdges.find(edge);
+        if (it != InEdges.end())
+            return *it;
+        else
+            return nullptr;
+    }
+
+    inline CFBasicBlockEdge *hasOutgoingEdge(CFBasicBlockEdge *edge) const
+    {
+        const_iterator it = OutEdges.find(edge);
+        if (it != OutEdges.end())
+            return *it;
+        else
+            return nullptr;
+    }
+    //@}
 };
 
 typedef GenericGraph<CFBasicBlockNode, CFBasicBlockEdge> GenericCFBasicBlockGTy;
@@ -108,22 +347,14 @@ typedef GenericGraph<CFBasicBlockNode, CFBasicBlockEdge> GenericCFBasicBlockGTy;
 class CFBasicBlockGraph : public GenericCFBasicBlockGTy
 {
     friend class CFBasicBlockGBuilder;
-
-public:
-    typedef Map<const SVFBasicBlock *, CFBasicBlockNode *> SVFBasicBlockToCFBasicBlockNodeMap;
-
 private:
-    SVFBasicBlockToCFBasicBlockNodeMap _bbToNode;
-    const SVFFunction *_svfFunction;
     u32_t _totalCFBasicBlockNode{0};
     u32_t _totalCFBasicBlockEdge{0};
+    Map<const SVFBasicBlock*, CFBasicBlockNode*> _bbToNode;
 
 public:
 
-    CFBasicBlockGraph(const SVFFunction *svfFunction) : _svfFunction(svfFunction)
-    {
-
-    }
+    CFBasicBlockGraph() = default;
 
     ~CFBasicBlockGraph() override = default;
 
@@ -139,16 +370,31 @@ public:
         return getGNode(id);
     }
 
-    inline CFBasicBlockNode *getCFBasicBlockNode(const SVFBasicBlock *bb) const
+    inline bool hasCFBasicBlockNode(NodeID id) const
     {
-        auto it = _bbToNode.find(bb);
-        if (it == _bbToNode.end()) return nullptr;
-        return it->second;
+        return hasGNode(id);
     }
 
-    inline bool hasCFBasicBlockEdge(CFBasicBlockNode *src, CFBasicBlockNode *dst) const
+    inline CFBasicBlockNode* getCFBasicBlockNode(const SVFBasicBlock* bb) const
     {
-        CFBasicBlockEdge edge(src, dst);
+        if (bb && _bbToNode.find(bb) != _bbToNode.end())
+        {
+            return _bbToNode.at(bb);
+        }
+        else
+        {
+            return nullptr;
+        }
+    }
+
+    inline bool hasCFBasicBlockNode(const SVFBasicBlock* bb) const
+    {
+        return bb && _bbToNode.find(bb) != _bbToNode.end();
+    }
+
+    bool hasCFBasicBlockEdge(CFBasicBlockNode *src, CFBasicBlockNode *dst, ICFGEdge *icfgEdge)
+    {
+        CFBasicBlockEdge edge(src, dst, icfgEdge);
         CFBasicBlockEdge *outEdge = src->hasOutgoingEdge(&edge);
         CFBasicBlockEdge *inEdge = dst->hasIncomingEdge(&edge);
         if (outEdge && inEdge)
@@ -160,17 +406,79 @@ public:
             return false;
     }
 
-    CFBasicBlockEdge* getCFBasicBlockEdge(const CFBasicBlockNode *src, const CFBasicBlockNode *dst);
+    inline bool hasCFBasicBlockEdge(CFBasicBlockNode *src, CFBasicBlockNode *dst) const
+    {
+        for (const auto &e: src->getOutEdges())
+        {
+            if (e->getDstNode() == dst)
+                return true;
+        }
+        return false;
+    }
 
-    CFBasicBlockEdge* getCFBasicBlockEdge(const SVFBasicBlock *src, const SVFBasicBlock *dst);
+    CFBasicBlockEdge* getCFBasicBlockEdge(const CFBasicBlockNode *src, const CFBasicBlockNode *dst, const ICFGEdge *icfgEdge);
 
-private:
+    std::vector<CFBasicBlockEdge*> getCFBasicBlockEdge(const CFBasicBlockNode *src, const CFBasicBlockNode *dst);
 
-    /// Add a CFBasicBlockNode
-    inline const CFBasicBlockNode* getOrAddCFBasicBlockNode(const SVFBasicBlock *bb);
+    /// Remove a ICFGEdgeWrapper
+    inline void removeCFBBEdge(CFBasicBlockEdge *edge)
+    {
+        if (edge->getDstNode()->hasIncomingEdge(edge))
+        {
+            edge->getDstNode()->removeIncomingEdge(edge);
+        }
+        if (edge->getSrcNode()->hasOutgoingEdge(edge))
+        {
+            edge->getSrcNode()->removeOutgoingEdge(edge);
+        }
+        delete edge;
+        _totalCFBasicBlockEdge--;
+    }
+
+    /// Remove a ICFGNodeWrapper
+    inline void removeCFBBNode(CFBasicBlockNode *node)
+    {
+        std::set<CFBasicBlockEdge *> temp;
+        for (CFBasicBlockEdge *e: node->getInEdges())
+            temp.insert(e);
+        for (CFBasicBlockEdge *e: node->getOutEdges())
+            temp.insert(e);
+        for (CFBasicBlockEdge *e: temp)
+        {
+            removeCFBBEdge(e);
+        }
+        removeGNode(node);
+        _totalCFBasicBlockNode--;
+    }
 
-    inline const CFBasicBlockEdge *getOrAddCFBasicBlockEdge(CFBasicBlockNode *src, CFBasicBlockNode *dst);
 
+    /// Remove node from nodeID
+    inline bool removeCFBBNode(NodeID id)
+    {
+        if (hasGNode(id))
+        {
+            removeCFBBNode(getGNode(id));
+            return true;
+        }
+        return false;
+    }
+
+    /// Add ICFGEdgeWrapper
+    inline bool addCFBBEdge(CFBasicBlockEdge *edge)
+    {
+        bool added1 = edge->getDstNode()->addIncomingEdge(edge);
+        bool added2 = edge->getSrcNode()->addOutgoingEdge(edge);
+        assert(added1 && added2 && "edge not added??");
+        _totalCFBasicBlockEdge++;
+        return true;
+    }
+
+    /// Add a ICFGNodeWrapper
+    virtual inline void addCFBBNode(CFBasicBlockNode *node)
+    {
+        addGNode(node->getId(), node);
+        _totalCFBasicBlockNode++;
+    }
 };
 
 class CFBasicBlockGBuilder
@@ -180,9 +488,11 @@ private:
     CFBasicBlockGraph* _CFBasicBlockG;
 
 public:
-    CFBasicBlockGBuilder(const SVFFunction *func) : _CFBasicBlockG(new CFBasicBlockGraph(func)) {}
+    CFBasicBlockGBuilder() : _CFBasicBlockG() {}
+
+    virtual void build(SVFModule* module);
 
-    void build();
+    virtual void build(ICFG* icfg);
 
     inline CFBasicBlockGraph* getCFBasicBlockGraph()
     {

package/svf/lib/Graphs/CFBasicBlockG.cpp

@@ -32,13 +32,18 @@
 
 namespace SVF
 {
-CFBasicBlockNode::CFBasicBlockNode(u32_t id, const SVFBasicBlock *svfBasicBlock) : GenericCFBasicBlockNodeTy(id, 0),
-    _svfBasicBlock(svfBasicBlock)
+CFBasicBlockNode::CFBasicBlockNode(const SVFBasicBlock* svfBasicBlock)
+    : GenericCFBasicBlockNodeTy(
+          PAG::getPAG()
+          ->getICFG()
+          ->getICFGNode(*svfBasicBlock->getInstructionList().begin())
+          ->getId(),
+          0)
 {
     for (auto it = svfBasicBlock->begin(); it != svfBasicBlock->end(); ++it)
     {
-        const SVFInstruction *ins = *it;
-        ICFGNode *icfgNode = PAG::getPAG()->getICFG()->getICFGNode(ins);
+        const SVFInstruction* ins = *it;
+        ICFGNode* icfgNode = PAG::getPAG()->getICFG()->getICFGNode(ins);
         _icfgNodes.push_back(icfgNode);
     }
 }
@@ -47,7 +52,7 @@ const std::string CFBasicBlockNode::toString() const
 {
     std::string rawStr;
     std::stringstream stringstream(rawStr);
-    stringstream << "Block Name: " << _svfBasicBlock->getName() << "\n";
+    stringstream << "Block Name: " << getName() << "\n";
     for (const auto &icfgNode: _icfgNodes)
     {
         stringstream << icfgNode->toString() << "\n";
@@ -55,19 +60,14 @@ const std::string CFBasicBlockNode::toString() const
     return stringstream.str();
 }
 
-CFBasicBlockEdge* CFBasicBlockGraph::getCFBasicBlockEdge(const SVFBasicBlock *src, const SVFBasicBlock *dst)
-{
-    return getCFBasicBlockEdge(getCFBasicBlockNode(src), getCFBasicBlockNode(dst));
-}
-
-CFBasicBlockEdge* CFBasicBlockGraph::getCFBasicBlockEdge(const CFBasicBlockNode *src, const CFBasicBlockNode *dst)
+CFBasicBlockEdge* CFBasicBlockGraph::getCFBasicBlockEdge(const CFBasicBlockNode *src, const CFBasicBlockNode *dst, const ICFGEdge* icfgEdge)
 {
     CFBasicBlockEdge *edge = nullptr;
     size_t counter = 0;
     for (auto iter = src->OutEdgeBegin();
             iter != src->OutEdgeEnd(); ++iter)
     {
-        if ((*iter)->getDstID() == dst->getId())
+        if ((*iter)->getDstID() == dst->getId() && (*iter)->getICFGEdge() == icfgEdge)
         {
             counter++;
             edge = (*iter);
@@ -77,42 +77,103 @@ CFBasicBlockEdge* CFBasicBlockGraph::getCFBasicBlockEdge(const CFBasicBlockNode
     return edge;
 }
 
-const CFBasicBlockNode* CFBasicBlockGraph::getOrAddCFBasicBlockNode(const SVFBasicBlock *bb)
+std::vector<CFBasicBlockEdge*> CFBasicBlockGraph::getCFBasicBlockEdge(const CFBasicBlockNode *src, const CFBasicBlockNode *dst)
 {
-    auto it = _bbToNode.find(bb);
-    if (it != _bbToNode.end()) return it->second;
-    CFBasicBlockNode *node = new CFBasicBlockNode(_totalCFBasicBlockNode++, bb);
-    _bbToNode[bb] = node;
-    addGNode(node->getId(), node);
-    return node;
+    std::vector<CFBasicBlockEdge*> edges;
+    for (auto iter = src->OutEdgeBegin();
+            iter != src->OutEdgeEnd(); ++iter)
+    {
+        if ((*iter)->getDstID() == dst->getId())
+        {
+            edges.push_back(*iter);
+        }
+    }
+    return SVFUtil::move(edges);
 }
 
-const CFBasicBlockEdge* CFBasicBlockGraph::getOrAddCFBasicBlockEdge(CFBasicBlockNode *src, CFBasicBlockNode *dst)
+void CFBasicBlockGBuilder::build(SVFModule* module)
 {
-    if (const CFBasicBlockEdge *edge = getCFBasicBlockEdge(src, dst)) return edge;
-    CFBasicBlockEdge *edge = new CFBasicBlockEdge(src, dst);
-    bool added1 = edge->getDstNode()->addIncomingEdge(edge);
-    bool added2 = edge->getSrcNode()->addOutgoingEdge(edge);
-    (void) added1;
-    (void) added2;
-    assert(added1 && added2 && "edge not added??");
-    _totalCFBasicBlockEdge++;
-    return edge;
+    _CFBasicBlockG = new CFBasicBlockGraph();
+    Map<const SVFBasicBlock*, CFBasicBlockNode*> bbToNode;
+    for (const auto& func : *module)
+    {
+        for (const auto& bb : *func)
+        {
+            CFBasicBlockNode* pNode = new CFBasicBlockNode(bb);
+            bbToNode[bb] = pNode;
+            _CFBasicBlockG->addCFBBNode(pNode);
+        }
+    }
+
+    for (const auto& func : *module)
+    {
+        for (const auto& bb : *func)
+        {
+            for (const auto &succ: bb->getSuccessors())
+            {
+                ICFG *icfg = PAG::getPAG()->getICFG();
+                const ICFGNode *pred = icfg->getICFGNode(bb->getTerminator());
+                const ICFGEdge *edge = nullptr;
+                for (const auto &inst: succ->getInstructionList())
+                {
+                    if (const ICFGEdge *e = icfg->getICFGEdge(pred, icfg->getICFGNode(inst), ICFGEdge::ICFGEdgeK::IntraCF))
+                    {
+                        edge = e;
+                        break;
+                    }
+                }
+                if (SVFUtil::isa<IntraCFGEdge>(edge))
+                {
+                    CFBasicBlockEdge *pEdge = new CFBasicBlockEdge(bbToNode[bb], bbToNode[succ], edge);
+                    _CFBasicBlockG->addCFBBEdge(pEdge);
+                }
+            }
+        }
+    }
+    _CFBasicBlockG->_bbToNode = bbToNode;
 }
 
-void CFBasicBlockGBuilder::build()
+void CFBasicBlockGBuilder::build(ICFG* icfg)
 {
-    for (const auto &bb: *_CFBasicBlockG->_svfFunction)
+    _CFBasicBlockG = new CFBasicBlockGraph();
+    Map<const SVFBasicBlock*, CFBasicBlockNode*> bbToNode;
+    for (const auto& node : *icfg)
     {
-        _CFBasicBlockG->getOrAddCFBasicBlockNode(bb);
+        CFBasicBlockNode* pNode  = nullptr;
+        if (const SVFBasicBlock* bb = node.second->getBB())
+        {
+            if (bbToNode.find(bb) == bbToNode.end())
+            {
+                pNode = new CFBasicBlockNode({node.second});
+                bbToNode[node.second->getBB()] = pNode;
+                _CFBasicBlockG->addCFBBNode(pNode);
+            }
+            else
+            {
+                pNode = bbToNode[node.second->getBB()];
+                pNode->addNode(node.second);
+            }
+        }
     }
-    for (const auto &bb: *_CFBasicBlockG->_svfFunction)
+
+    for (const auto& node : *icfg)
     {
-        for (const auto &succ: bb->getSuccessors())
+        for (const auto &succ: node.second->getOutEdges())
         {
-            _CFBasicBlockG->getOrAddCFBasicBlockEdge(_CFBasicBlockG->getCFBasicBlockNode(bb),
-                    _CFBasicBlockG->getCFBasicBlockNode(succ));
+            const SVFFunction* node_fun = node.second->getFun();
+            const SVFFunction* succ_fun = succ->getDstNode()->getFun();
+            const SVFBasicBlock* node_bb = node.second->getBB();
+            const SVFBasicBlock* succ_bb = succ->getDstNode()->getBB();
+            if (node_fun == succ_fun)
+            {
+                if (node_bb != succ_bb)
+                {
+                    CFBasicBlockEdge *pEdge = new CFBasicBlockEdge(bbToNode[node_bb], bbToNode[succ_bb], succ);
+                    _CFBasicBlockG->addCFBBEdge(pEdge);
+                }
+            }
         }
     }
+    _CFBasicBlockG->_bbToNode = bbToNode;
 }
 }