svf-lib 1.0.1888 → 1.0.1889

package/SVF-linux/Release-build/include/AE/Core/ICFGWTO.h

@@ -52,6 +52,10 @@ public:
 
     explicit ICFGWTO(ICFG* graph, const ICFGNode* node) : Base(graph, node) {}
 
+    virtual ~ICFGWTO()
+    {
+    }
+
     inline void forEachSuccessor(
         const ICFGNode* node,
         std::function<void(const ICFGNode*)> func) const override

package/SVF-linux/Release-build/include/AE/Core/IntervalExeState.h

@@ -433,6 +433,8 @@ public:
         return *this;
     }
 
+    virtual void printExprValues(std::ostream &oss) const override;
+
     /// move constructor
     IntervalExeState(IntervalExeState &&rhs) : IntervalESBase(std::move(rhs))
     {

package/SVF-linux/Release-build/include/AE/Svfexe/AbstractExecution.h

@@ -32,7 +32,7 @@
 #include "AE/Svfexe/SVFIR2ItvExeState.h"
 #include "Util/WorkList.h"
 #include "MSSA/SVFGBuilder.h"
-#include "AE/Core/CFBasicBlockGWTO.h"
+#include "AE/Core/ICFGWTO.h"
 #include "WPA/Andersen.h"
 #include "Util/SVFBugReport.h"
 
@@ -46,7 +46,7 @@ class AEAPI;
 enum class AEKind
 {
     AbstractExecution,
-    BufOverflowChecker
+    BufOverflowChecker,
 };
 
 /// AEStat: Statistic for AE
@@ -120,7 +120,6 @@ public:
 
     virtual void runOnModule(SVFIR* svfModule);
 
-
     /// Destructor
     virtual ~AbstractExecution();
 
@@ -145,37 +144,37 @@ protected:
     void markRecursiveFuns();
 
     /**
-     * Check if execution state exist by merging states of predecessor blocks
+     * Check if execution state exist by merging states of predecessor nodes
      *
-     * @param block The basic block to analyse
-     * @return if this block has preceding execution state
+     * @param node The ICFGNode to analyse
+     * @return if this node has preceding execution state
      */
-    bool hasInEdgesES(const CFBasicBlockNode *block);
+    bool hasInEdgesES(const ICFGNode *node);
 
     /**
      * Check if execution state exist at the branch edge
      *
-     * @param intraEdge the edge from CmpStmt to the next Block
+     * @param intraEdge the edge from CmpStmt to the next node
      * @return if this edge is feasible
      */
     bool hasBranchES(const IntraCFGEdge* intraEdge, IntervalExeState& es);
 
     /**
-     * handle instructions in svf basic blocks
+     * handle instructions in ICFGNode
      *
      * @param block basic block that has a series of instructions
      */
-    void handleBlock(const CFBasicBlockNode *block);
+    void handleWTONode(const ICFGNode* node);
 
     /**
-     * handle one instruction in svf basic blocks
+     * handle one instruction in ICFGNode
      *
      * @param node ICFGNode which has a single instruction
      */
     virtual void handleICFGNode(const ICFGNode *node);
 
     /**
-     * handle call node in svf basic blocks
+     * handle call node in ICFGNode
      *
      * @param node ICFGNode which has a single CallICFGNode
      */
@@ -186,7 +185,7 @@ protected:
      *
      * @param cycle WTOCycle which has weak topo order of basic blocks and nested cycles
      */
-    virtual void handleCycle(const CFBasicBlockGWTOCycle *cycle);
+    virtual void handleCycle(const ICFGWTOCycle *cycle);
 
     /**
      * handle user defined function, ext function is not included.
@@ -221,7 +220,7 @@ protected:
     *
     * @param cmpStmt CmpStmt is a conditional branch statement
     * @param succ the value of cmpStmt (True or False)
-    * @return if this block has preceding execution state
+    * @return if this ICFGNode has preceding execution state
     */
     bool hasCmpBranchES(const CmpStmt* cmpStmt, s64_t succ, IntervalExeState& es);
 
@@ -230,7 +229,7 @@ protected:
     *
     * @param var var in switch inst
     * @param succ the case value of switch inst
-    * @return if this block has preceding execution state
+    * @return if this ICFGNode has preceding execution state
     */
     bool hasSwitchBranchES(const SVFVar* var, s64_t succ, IntervalExeState& es);
 
@@ -249,33 +248,32 @@ protected:
     SVFBugReport _recoder;
     std::vector<const CallICFGNode*> _callSiteStack;
     Map<const ICFGNode *, std::string> _nodeToBugInfo;
+    AndersenWaveDiff *_ander;
+    Map<const SVFFunction*, ICFGWTO *> _funcToWTO;
+    Set<const SVFFunction*> _recursiveFuns;
 
 private:
     // helper functions in handleCallSite
-    bool isExtCall(const CallICFGNode* callNode);
-    void extCallPass(const CallICFGNode* callNode);
-    bool isRecursiveCall(const CallICFGNode* callNode);
-    void recursiveCallPass(const CallICFGNode* callNode);
-    bool isDirectCall(const CallICFGNode* callNode);
-    void directCallFunPass(const CallICFGNode* callNode);
-    bool isIndirectCall(const CallICFGNode* callNode);
-    void indirectCallFunPass(const CallICFGNode* callNode);
+    virtual bool isExtCall(const CallICFGNode* callNode);
+    virtual void extCallPass(const CallICFGNode* callNode);
+    virtual bool isRecursiveCall(const CallICFGNode* callNode);
+    virtual void recursiveCallPass(const CallICFGNode* callNode);
+    virtual bool isDirectCall(const CallICFGNode* callNode);
+    virtual void directCallFunPass(const CallICFGNode* callNode);
+    virtual bool isIndirectCall(const CallICFGNode* callNode);
+    virtual void indirectCallFunPass(const CallICFGNode* callNode);
 
     // helper functions in hasInEdgesES
-    bool isFunEntry(const CFBasicBlockNode* block);
-    bool isGlobalEntry(const CFBasicBlockNode* block);
+    bool isFunEntry(const ICFGNode* node);
+    bool isGlobalEntry(const ICFGNode* node);
 
     // helper functions in handleCycle
-    bool widenFixpointPass(const CFBasicBlockNode* cycle_head, IntervalExeState& pre_es);
-    bool narrowFixpointPass(const CFBasicBlockNode* cycle_head, IntervalExeState& pre_es);
+    bool widenFixpointPass(const ICFGNode* cycle_head, IntervalExeState& pre_es);
+    bool narrowFixpointPass(const ICFGNode* cycle_head, IntervalExeState& pre_es);
 
     // private data
-    CFBasicBlockGraph* _CFBlockG;
-    AndersenWaveDiff *_ander;
-    Map<const CFBasicBlockNode*, IntervalExeState> _preES;
-    Map<const CFBasicBlockNode*, IntervalExeState> _postES;
-    Map<const SVFFunction*, CFBasicBlockGWTO *> _funcToWTO;
-    Set<const SVFFunction*> _recursiveFuns;
+    Map<const ICFGNode*, IntervalExeState> _preES;
+    Map<const ICFGNode*, IntervalExeState> _postES;
     std::string _moduleName;
 
 };

package/SVF-linux/Release-build/include/Graphs/IRGraph.h

@@ -36,7 +36,6 @@
 #include "Util/NodeIDAllocator.h"
 #include "Util/SVFUtil.h"
 #include "Graphs/ICFG.h"
-#include "Graphs/CFBasicBlockG.h"
 
 namespace SVF
 {

package/package.json

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

package/SVF-linux/Release-build/include/AE/Core/CFBasicBlockGWTO.h

@@ -1,85 +0,0 @@
-//===- CFBasicBlockGWTO.h -- WTO for CFBasicBlockGraph----------------------//
-//
-//                     SVF: Static Value-Flow Analysis
-//
-// Copyright (C) <2013->  <Yulei Sui>
-//
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-//===----------------------------------------------------------------------===//
-
-/*
- * CFBasicBlockGWTO.h
- *
- * The implementation is based on F. Bourdoncle's paper:
- * "Efficient chaotic iteration strategies with widenings", Formal
- * Methods in Programming and Their Applications, 1993, pages 128-141.
- *
- *  Created on: Jan 22, 2024
- *      Author: Xiao Cheng
- *
- */
-#ifndef SVF_CFBASICBLOCKGWTO_H
-#define SVF_CFBASICBLOCKGWTO_H
-#include "Graphs/CFBasicBlockG.h"
-#include "Graphs/WTO.h"
-
-namespace SVF
-{
-typedef WTOComponent<CFBasicBlockGraph> CFBasicBlockGWTOComp;
-typedef WTONode<CFBasicBlockGraph> CFBasicBlockGWTONode;
-typedef WTOCycle<CFBasicBlockGraph> CFBasicBlockGWTOCycle;
-
-class CFBasicBlockGWTO : public WTO<CFBasicBlockGraph>
-{
-public:
-    typedef WTO<CFBasicBlockGraph> Base;
-    typedef WTOComponentVisitor<CFBasicBlockGraph>::WTONodeT
-    CFBasicBlockGWTONode;
-
-    explicit CFBasicBlockGWTO(CFBasicBlockGraph* graph,
-                              const CFBasicBlockNode* node)
-        : Base(graph, node)
-    {
-    }
-
-    virtual ~CFBasicBlockGWTO() = default;
-
-    inline void forEachSuccessor(
-        const CFBasicBlockNode* node,
-        std::function<void(const CFBasicBlockNode*)> func) const override
-    {
-        if (const auto* callNode =
-                    SVFUtil::dyn_cast<CallICFGNode>(node->getICFGNodes().front()))
-        {
-            const CFBasicBlockNode* succ = _graph->getCFBasicBlockNode(
-                                               callNode->getRetICFGNode()->getId());
-            func(succ);
-        }
-        else
-        {
-            for (const auto& e : node->getOutEdges())
-            {
-                if (e->getICFGEdge() &&
-                        (!e->getICFGEdge()->isIntraCFGEdge() ||
-                         node->getFunction() != e->getDstNode()->getFunction()))
-                    continue;
-                func(e->getDstNode());
-            }
-        }
-    }
-};
-} // namespace SVF
-#endif // SVF_CFBASICBLOCKGWTO_H

package/SVF-linux/Release-build/include/Graphs/CFBasicBlockG.h

@@ -1,581 +0,0 @@
-//===- CFBasicBlockG.h ----------------------------------------------------------------//
-//
-//                     SVF: Static Value-Flow Analysis
-//
-// Copyright (C) <2013->  <Yulei Sui>
-//
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-//===----------------------------------------------------------------------===//
-
-/*
- * CFBasicBlockG.h
- *
- *  Created on: 24 Dec. 2022
- *      Author: Xiao, Jiawei
- */
-
-#ifndef SVF_CFBASICBLOCKG_H
-#define SVF_CFBASICBLOCKG_H
-#include "Util/SVFUtil.h"
-#include "Graphs/ICFG.h"
-#include "Graphs/GenericGraph.h"
-
-namespace SVF
-{
-class CFBasicBlockNode;
-class SVFIR;
-
-typedef GenericEdge<CFBasicBlockNode> GenericCFBasicBlockEdgeTy;
-
-class CFBasicBlockEdge : public GenericCFBasicBlockEdgeTy
-{
-public:
-    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)
-    {
-    }
-
-    CFBasicBlockEdge(CFBasicBlockNode* src, CFBasicBlockNode* dst)
-        : GenericCFBasicBlockEdgeTy(src, dst, 0), _icfgEdge(nullptr)
-    {
-    }
-
-    friend std::ostream &operator<<(std::ostream &o, const CFBasicBlockEdge &edge)
-    {
-        o << edge.toString();
-        return o;
-    }
-
-    virtual const std::string toString() const
-    {
-        std::string str;
-        std::stringstream rawstr(str);
-        rawstr << "CFBBGEdge: [CFBBGNode" << getDstID() << " <-- CFBBGNode" << getSrcID() << "]\t";
-        return rawstr.str();
-    }
-
-    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:
-    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(std::vector<const ICFGNode*> icfgNodes)
-        : GenericCFBasicBlockNodeTy((*icfgNodes.begin())->getId(), 0),
-          _icfgNodes(SVFUtil::move(icfgNodes))
-    {
-    }
-
-    virtual ~CFBasicBlockNode()
-    {
-        for (auto edge : OutEdges)
-            delete edge;
-    }
-
-    friend std::ostream &operator<<(std::ostream &o, const CFBasicBlockNode &node)
-    {
-        o << node.toString();
-        return o;
-    }
-
-    virtual const std::string toString() const;
-
-    inline std::string getName() const
-    {
-        assert(!_icfgNodes.empty() && "no ICFG nodes in CFBB");
-        return (*_icfgNodes.begin())->getBB()->getName();
-    }
-
-    inline const std::vector<const ICFGNode*>& getICFGNodes() const
-    {
-        return _icfgNodes;
-    }
-
-    inline const SVFFunction *getFunction() const
-    {
-        assert(!_icfgNodes.empty() && "no ICFG nodes in CFBB");
-        return (*_icfgNodes.begin())->getFun();
-    }
-
-    inline std::vector<const ICFGNode *>::const_iterator begin() const
-    {
-        return _icfgNodes.cbegin();
-    }
-
-    inline std::vector<const ICFGNode *>::const_iterator end() const
-    {
-        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();
-    }
-    //@}
-
-    /// 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)
-    {
-        assert(InEdges.find(edge) != InEdges.end() && "can not find in edge in SVFG node");
-        return InEdges.erase(edge);
-    }
-
-    inline u32_t removeOutgoingEdge(CFBasicBlockEdge *edge)
-    {
-        assert(OutEdges.find(edge) != 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;
-
-class CFBasicBlockGraph : public GenericCFBasicBlockGTy
-{
-    friend class CFBasicBlockGBuilder;
-private:
-    u32_t _totalCFBasicBlockNode{0};
-    u32_t _totalCFBasicBlockEdge{0};
-public:
-
-    CFBasicBlockGraph() = default;
-
-    ~CFBasicBlockGraph() override = default;
-
-    /// Dump graph into dot file
-    void dump(const std::string &filename)
-    {
-        GraphPrinter::WriteGraphToFile(SVFUtil::outs(), filename, this);
-    }
-
-    inline CFBasicBlockNode *getCFBasicBlockNode(u32_t id) const
-    {
-        if (!hasGNode(id)) return nullptr;
-        return getGNode(id);
-    }
-
-    inline bool hasCFBasicBlockNode(NodeID id) const
-    {
-        return hasGNode(id);
-    }
-
-
-    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)
-        {
-            assert(outEdge == inEdge && "edges not match");
-            return true;
-        }
-        else
-            return false;
-    }
-
-    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 CFBasicBlockNode *src, const CFBasicBlockNode *dst, const ICFGEdge *icfgEdge);
-
-    std::vector<CFBasicBlockEdge*> getCFBasicBlockEdge(const CFBasicBlockNode *src, const CFBasicBlockNode *dst);
-
-    /// 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--;
-    }
-
-
-    /// 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 added1 && added2;
-    }
-
-    /// Add a ICFGNodeWrapper
-    virtual inline void addCFBBNode(CFBasicBlockNode *node)
-    {
-        addGNode(node->getId(), node);
-        _totalCFBasicBlockNode++;
-    }
-};
-
-}
-
-
-namespace SVF
-{
-/* !
- * GenericGraphTraits specializations for generic graph algorithms.
- * Provide graph traits for traversing from a constraint node using standard graph ICFGTraversals.
- */
-template<>
-struct GenericGraphTraits<SVF::CFBasicBlockNode *>
-    : public GenericGraphTraits<SVF::GenericNode<SVF::CFBasicBlockNode, SVF::CFBasicBlockEdge> *>
-{
-};
-
-/// Inverse GenericGraphTraits specializations for call graph node, it is used for inverse ICFGTraversal.
-template<>
-struct GenericGraphTraits<Inverse< SVF::CFBasicBlockNode *> > : public GenericGraphTraits<
-    Inverse<SVF::GenericNode<SVF::CFBasicBlockNode, SVF::CFBasicBlockEdge> *> >
-{
-};
-
-template<>
-struct GenericGraphTraits<SVF::CFBasicBlockGraph *>
-    : public GenericGraphTraits<SVF::GenericGraph<SVF::CFBasicBlockNode, SVF::CFBasicBlockEdge> *>
-{
-    typedef SVF::CFBasicBlockNode *NodeRef;
-};
-
-} // End namespace SVF
-
-namespace SVF
-{
-template<>
-struct DOTGraphTraits<SVF::CFBasicBlockGraph *> : public DOTGraphTraits<SVF::SVFIR *>
-{
-
-    typedef SVF::CFBasicBlockNode NodeType;
-
-    DOTGraphTraits(bool isSimple = false) :
-        DOTGraphTraits<SVF::SVFIR *>(isSimple)
-    {
-    }
-
-    /// Return name of the graph
-    static std::string getGraphName(SVF::CFBasicBlockGraph *)
-    {
-        return "CFBasicBlockGraph";
-    }
-
-    std::string getNodeLabel(NodeType *node, SVF::CFBasicBlockGraph *graph)
-    {
-        return getSimpleNodeLabel(node, graph);
-    }
-
-    /// Return the label of an ICFG node
-    static std::string getSimpleNodeLabel(NodeType *node, SVF::CFBasicBlockGraph *)
-    {
-        std::string str;
-        std::stringstream rawstr(str);
-        rawstr << "NodeID: " << node->getId() << "\n";
-        rawstr << node->toString();
-
-        return rawstr.str();
-    }
-
-    static std::string getNodeAttributes(NodeType *node, SVF::CFBasicBlockGraph *)
-    {
-        std::string str;
-        std::stringstream rawstr(str);
-        if(node->getICFGNodes().size() == 1)
-        {
-            const ICFGNode* n = node->getICFGNodes()[0];
-            if(SVFUtil::isa<IntraICFGNode>(n))
-            {
-                rawstr <<  "color=black";
-            }
-            else if(SVFUtil::isa<FunEntryICFGNode>(n))
-            {
-                rawstr <<  "color=yellow";
-            }
-            else if(SVFUtil::isa<FunExitICFGNode>(n))
-            {
-                rawstr <<  "color=green";
-            }
-            else if(SVFUtil::isa<CallICFGNode>(n))
-            {
-                rawstr <<  "color=red";
-            }
-            else if(SVFUtil::isa<RetICFGNode>(n))
-            {
-                rawstr <<  "color=blue";
-            }
-            else if(SVFUtil::isa<GlobalICFGNode>(n))
-            {
-                rawstr <<  "color=purple";
-            }
-            else
-                assert(false && "no such kind of node!!");
-        }
-        else
-        {
-            rawstr << "color=black";
-        }
-        rawstr <<  "";
-        return rawstr.str();
-    }
-
-    template<class EdgeIter>
-    static std::string getEdgeAttributes(NodeType *, EdgeIter EI, SVF::CFBasicBlockGraph *)
-    {
-        CFBasicBlockEdge* edge = *(EI.getCurrent());
-        assert(edge && "No edge found!!");
-        if (edge->getICFGEdge())
-        {
-            if (SVFUtil::isa<CallCFGEdge>(edge->getICFGEdge()))
-            {
-                return "style=solid,color=red";
-            }
-            else if (SVFUtil::isa<RetCFGEdge>(edge->getICFGEdge()))
-                return "style=solid,color=blue";
-            else
-                return "style=solid";
-        }
-        else
-        {
-            return "style=solid";
-        }
-    }
-
-    template<class EdgeIter>
-    static std::string getEdgeSourceLabel(NodeType *, EdgeIter EI)
-    {
-        CFBasicBlockEdge* edge = *(EI.getCurrent());
-        assert(edge && "No edge found!!");
-
-        std::string str;
-        std::stringstream rawstr(str);
-        if (edge->getICFGEdge())
-        {
-            if (const CallCFGEdge* dirCall = SVFUtil::dyn_cast<CallCFGEdge>(edge->getICFGEdge()))
-                rawstr << dirCall->getCallSite();
-            else if (const RetCFGEdge* dirRet = SVFUtil::dyn_cast<RetCFGEdge>(edge->getICFGEdge()))
-                rawstr << dirRet->getCallSite();
-        }
-        return rawstr.str();
-    }
-};
-}
-#endif //SVF_CFBASICBLOCKG_H

package/SVF-linux/Release-build/include/Util/CFBasicBlockGBuilder.h

@@ -1,64 +0,0 @@
-//===- CFBasicBlockGBuilder.h ----------------------------------------------------------------//
-//
-//                     SVF: Static Value-Flow Analysis
-//
-// Copyright (C) <2013->  <Yulei Sui>
-//
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-//===----------------------------------------------------------------------===//
-
-/*
- * CFBasicBlockGBuilder.h
- *
- *  Created on: 17 Oct. 2023
- *      Author: Xiao, Jiawei
- */
-
-#include "Graphs/CFBasicBlockG.h"
-
-namespace SVF
-{
-
-class CFBasicBlockGBuilder
-{
-
-private:
-    CFBasicBlockGraph* _CFBasicBlockG;
-
-public:
-    CFBasicBlockGBuilder() : _CFBasicBlockG() {}
-
-    ~CFBasicBlockGBuilder()
-    {
-        delete _CFBasicBlockG;
-    }
-
-    virtual void build(ICFG* icfg);
-
-    inline CFBasicBlockGraph* getCFBasicBlockGraph()
-    {
-        return _CFBasicBlockG;
-    }
-private:
-    void initCFBasicBlockGNodes(ICFG *icfg, Map<const SVFBasicBlock *, std::vector<CFBasicBlockNode *>> &bbToNodes);
-
-    void addInterBBEdge(ICFG *icfg, Map<const SVFBasicBlock *, std::vector<CFBasicBlockNode *>> &bbToNodes);
-
-    void addIntraBBEdge(ICFG *icfg, Map<const SVFBasicBlock *, std::vector<CFBasicBlockNode *>> &bbToNodes);
-
-    void addInterProceduralEdge(ICFG *icfg, Map<const SVFBasicBlock *, std::vector<CFBasicBlockNode *>> &bbToNodes);
-};
-}