svf-tools 1.0.642 → 1.0.644

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.642",
+  "version": "1.0.644",
   "description": "* <b>[TypeClone](https://github.com/SVF-tools/SVF/wiki/TypeClone) published in our [ECOOP paper](https://yuleisui.github.io/publications/ecoop20.pdf) is now available in SVF </b> * <b>SVF now uses a single script for its build. Just type [`source ./build.sh`](https://github.com/SVF-tools/SVF/blob/master/build.sh) in your terminal, that's it!</b> * <b>SVF now supports LLVM-10.0.0! </b> * <b>We thank [bsauce](https://github.com/bsauce) for writing a user manual of SVF ([link1](https://www.jianshu.com/p/068a08ec749c) and [link2](https://www.jianshu.com/p/777c30d4240e)) in Chinese </b> * <b>SVF now supports LLVM-9.0.0 (Thank [Byoungyoung Lee](https://github.com/SVF-tools/SVF/issues/142) for his help!). </b> * <b>SVF now supports a set of [field-sensitive pointer analyses](https://yuleisui.github.io/publications/sas2019a.pdf). </b> * <b>[Use SVF as an external lib](https://github.com/SVF-tools/SVF/wiki/Using-SVF-as-a-lib-in-your-own-tool) for your own project (Contributed by [Hongxu Chen](https://github.com/HongxuChen)). </b> * <b>SVF now supports LLVM-7.0.0. </b> * <b>SVF now supports Docker. [Try SVF in Docker](https://github.com/SVF-tools/SVF/wiki/Try-SVF-in-Docker)! </b> * <b>SVF now supports [LLVM-6.0.0](https://github.com/svf-tools/SVF/pull/38) (Contributed by [Jack Anthony](https://github.com/jackanth)). </b> * <b>SVF now supports [LLVM-4.0.0](https://github.com/svf-tools/SVF/pull/23) (Contributed by Jared Carlson. Thank [Jared](https://github.com/jcarlson23) and [Will](https://github.com/dtzWill) for their in-depth [discussions](https://github.com/svf-tools/SVF/pull/18) about updating SVF!) </b> * <b>SVF now supports analysis for C++ programs.</b> <br />",
   "main": "index.js",
   "scripts": {

package/svf/include/CFL/CFLAlias.h

@@ -32,8 +32,6 @@
 
 #include "CFL/CFLBase.h"
 #include "CFL/CFLStat.h"
-#include "CFL/CFLData.h"
-#include "CFL/CFLDataBuilder.h"
 
 namespace SVF
 {
@@ -142,34 +140,12 @@ private:
 class POCRAlias : public CFLAlias
 {
 public:
-    static double timeOfBuildCFLData;            // Time of building CFLData from CFLGraph
-
     POCRAlias(SVFIR* ir) : CFLAlias(ir)
     {
-        if (!_cflData)
-            _cflData = new CFLData();
-    }
-
-    /// Destructor
-    virtual ~POCRAlias()
-    {
-        delete _cflData;
-    }
-
-    CFLData* cflData()
-    {
-        return _cflData;
     }
 
     /// Initialize the grammar, graph, CFLData, solver
     virtual void initialize();
-
-    /// Init CFLData
-    virtual void buildCFLData();
-
-private:
-    /// Graph dataset
-    CFLData* _cflData;
 };
 } // End namespace SVF
 

package/svf/include/CFL/CFLSolver.h

@@ -24,7 +24,7 @@
  * CFLSolver.h
  *
  *  Created on: March 5, 2022
- *      Author: Yulei Sui
+ *      Author: Yulei Sui， Yuxiang Lei
  */
 
 #ifndef INCLUDE_CFL_CFLSolver_H_
@@ -33,12 +33,285 @@
 #include "Graphs/CFLGraph.h"
 #include "CFL/CFLGrammar.h"
 #include "Util/WorkList.h"
-#include "CFL/CFLData.h"
 
+using namespace std;
 
 namespace SVF
 {
 
+typedef GrammarBase::Symbol Label;
+/*!
+ * Adjacency-list graph representation
+ */
+class CFLData
+{
+public:
+    typedef std::map<const Label, NodeBS> TypeMap;                  // Label with SparseBitVector of NodeID
+    typedef std::unordered_map<NodeID, TypeMap> DataMap;            // Each Node has a TypeMap
+    typedef typename DataMap::iterator iterator;                    // iterator for each node
+    typedef typename DataMap::const_iterator const_iterator;        // const iterator
+
+protected:
+    DataMap succMap;                                                // succ map for nodes contains Label: Edgeset
+    DataMap predMap;                                                // pred map for nodes contains Label: edgeset
+    const NodeBS emptyData;                                         // ??
+    NodeBS diff;                                                    // ??
+
+    // union/add data
+    //@{
+    inline bool addPred(const NodeID key, const NodeID src, const Label ty)
+    {
+        return predMap[key][ty].test_and_set(src);
+    };
+
+    inline bool addSucc(const NodeID key, const NodeID dst, const Label ty)
+    {
+        return succMap[key][ty].test_and_set(dst);
+    };
+
+    inline bool addPreds(const NodeID key, const NodeBS& data, const Label ty)
+    {
+        if (data.empty())
+            return false;
+        return predMap[key][ty] |= data;                            // union of sparsebitvector (add to LHS)
+    }
+
+    inline bool addSuccs(const NodeID key, const NodeBS& data, const Label ty)
+    {
+        if (data.empty())
+            return false;
+        return succMap[key][ty] |= data;                            // // union of sparsebitvector (add to LHS)
+    }
+    //@}
+
+public:
+    // Constructor
+    CFLData()
+    {}
+
+    // Destructor
+    virtual ~CFLData()
+    {}
+
+    virtual void clear()
+    {
+        succMap.clear();
+        predMap.clear();
+    }
+
+    inline const_iterator begin() const
+    {
+        return succMap.begin();
+    }
+
+    inline const_iterator end() const
+    {
+        return succMap.end();
+    }
+
+    inline iterator begin()
+    {
+        return succMap.begin();
+    }
+
+    inline iterator end()
+    {
+        return succMap.end();
+    }
+
+    inline DataMap& getSuccMap()
+    {
+        return succMap;
+    }
+
+    inline DataMap& getPredMap()
+    {
+        return predMap;
+    }
+
+    inline TypeMap& getSuccMap(const NodeID key)
+    {
+        return succMap[key];
+    }
+
+    inline TypeMap& getPredMap(const NodeID key)
+    {
+        return predMap[key];
+    }
+
+    inline NodeBS& getSuccs(const NodeID key, const Label ty)
+    {
+        return succMap[key][ty];
+    }
+
+    inline NodeBS& getPreds(const NodeID key, const Label ty)
+    {
+        return predMap[key][ty];
+    }
+
+    // Alias data operations
+    //@{
+    inline bool addEdge(const NodeID src, const NodeID dst, const Label ty)
+    {
+        addSucc(src, dst, ty);
+        return addPred(dst, src, ty);
+    }
+
+    /// add edges and return the set of added edges (dst) for src
+    inline NodeBS addEdges(const NodeID src, const NodeBS& dstData, const Label ty)
+    {
+        NodeBS newDsts;
+        if (addSuccs(src, dstData, ty))
+        {
+            for (const NodeID datum: dstData)
+                if (addPred(datum, src, ty))
+                    newDsts.set(datum);
+        }
+        return newDsts;
+    }
+
+    /// add edges and return the set of added edges (src) for dst
+    inline NodeBS addEdges(const NodeBS& srcData, const NodeID dst, const Label ty)
+    {
+        NodeBS newSrcs;
+        if (addPreds(dst, srcData, ty))
+        {
+            for (const NodeID datum: srcData)
+                if (addSucc(datum, dst, ty))
+                    newSrcs.set(datum);
+        }
+        return newSrcs;
+    }
+
+    /// find src -> find src[ty] -> find dst in set
+    inline bool hasEdge(const NodeID src, const NodeID dst, const Label ty)
+    {
+        const_iterator iter1 = succMap.find(src);
+        if (iter1 == succMap.end())
+            return false;
+
+        auto iter2 = iter1->second.find(ty);
+        if (iter2 == iter1->second.end())
+            return false;
+
+        return iter2->second.test(dst);
+    }
+
+    /* This is a dataset version, to be modified to a cflData version */
+    inline void clearEdges(const NodeID key)
+    {
+        succMap[key].clear();
+        predMap[key].clear();
+    }
+    //@}
+};
+
+/*!
+ * Hybrid graph representation for transitive relations
+ * The implementation is based on
+ * Yuxiang Lei, Yulei Sui, Shuo Ding, and Qirun Zhang.
+ * Taming Transitive Redundancy for Context-Free Language Reachability.
+ * ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications
+ */
+class HybridData
+{
+public:
+    struct TreeNode
+    {
+        NodeID id;
+        std::unordered_set<TreeNode*> children;
+
+        TreeNode(NodeID nId) : id(nId)
+        {}
+
+        ~TreeNode()
+        {
+        }
+
+        inline bool operator==(const TreeNode& rhs) const
+        {
+            return id == rhs.id;
+        }
+
+        inline bool operator<(const TreeNode& rhs) const
+        {
+            return id < rhs.id;
+        }
+    };
+
+
+public:
+    Map<NodeID, std::unordered_map<NodeID, TreeNode*>> indMap;   // indMap[v][u] points to node v in tree(u)
+
+    HybridData()
+    {}
+
+    ~HybridData()
+    {
+        for (auto iter1: indMap)
+        {
+            for (auto iter2: iter1.second)
+            {
+                delete iter2.second;
+                iter2.second = NULL;
+            }
+        }
+    }
+
+    bool hasInd(NodeID src, NodeID dst)
+    {
+        auto it = indMap.find(dst);
+        if (it == indMap.end())
+            return false;
+        return (it->second.find(src) != it->second.end());
+    }
+
+    /// Add a node dst to tree(src)
+    TreeNode* addInd(NodeID src, NodeID dst)
+    {
+        auto resIns = indMap[dst].insert(std::make_pair(src, new TreeNode(dst)));
+        if (resIns.second)
+            return resIns.first->second;
+        return nullptr;
+    }
+
+    /// Get the node dst in tree(src)
+    TreeNode* getNode(NodeID src, NodeID dst)
+    {
+        return indMap[dst][src];
+    }
+
+    /// add v into desc(x) as a child of u
+    void insertEdge(TreeNode* u, TreeNode* v)
+    {
+        u->children.insert(v);
+    }
+
+    void addArc(NodeID src, NodeID dst)
+    {
+        if (!hasInd(src, dst))
+        {
+            for (auto iter: indMap[src])
+            {
+                meld(iter.first, getNode(iter.first, src), getNode(dst, dst));
+            }
+        }
+    }
+
+    void meld(NodeID x, TreeNode* uNode, TreeNode* vNode)
+    {
+        TreeNode* newVNode = addInd(x, vNode->id);
+        if (!newVNode)
+            return;
+
+        insertEdge(uNode, newVNode);
+        for (TreeNode* vChild: vNode->children)
+        {
+            meld(x, newVNode, vChild);
+        }
+    }
+};
+
 class CFLSolver
 {
 
@@ -54,20 +327,20 @@ public:
     {
     }
 
-    ~CFLSolver()
+    virtual ~CFLSolver()
     {
         delete graph;
         delete grammar;
     }
 
     /// Initialize worklist
-    void initialize();
+    virtual void initialize();
 
     /// Process CFLEdge
-    void processCFLEdge(const CFLEdge* Y_edge);
+    virtual void processCFLEdge(const CFLEdge* Y_edge);
 
     /// Start solving
-    void solve();
+    virtual void solve();
 
     /// Return CFL Graph
     inline const CFLGraph* getGraph() const
@@ -80,11 +353,11 @@ public:
     {
         return grammar;
     }
-    inline bool pushIntoWorklist(const CFLEdge* item)
+    virtual inline bool pushIntoWorklist(const CFLEdge* item)
     {
         return worklist.push(item);
     }
-    inline bool isWorklistEmpty()
+    virtual inline bool isWorklistEmpty()
     {
         return worklist.empty();
     }
@@ -103,7 +376,7 @@ protected:
     }
     //@}
 
-private:
+protected:
     CFLGraph* graph;
     CFLGrammar* grammar;
     /// Worklist for resolution
@@ -114,22 +387,52 @@ private:
 /// Solver Utilize CFLData
 class POCRSolver : public CFLSolver
 {
+public:
+    POCRSolver(CFLGraph* _graph, CFLGrammar* _grammar) : CFLSolver(_graph, _grammar), cflData(NULL)
+    {
+        if (!cflData)
+        {
+            cflData = new CFLData();
+            // Build CFL Data
+            buildCFLData();
+        }
+    }
     /// Destructor
     virtual ~POCRSolver()
     {
-        delete _cflData;
+        delete cflData;
+    }
+
+    /// Process CFLEdge
+    virtual void processCFLEdge(const CFLEdge* Y_edge);
+
+    /// Init CFLData
+    virtual void buildCFLData();
+
+    virtual bool addEdge(const CFLNode* src, const CFLNode* dst, const Label ty)
+    {
+        return cflData->addEdge(src->getId(), dst->getId(), ty);
     }
 
-    CFLData* cflData()
+    virtual bool addEdge(const NodeID srcId, const NodeID dstId, const Label ty)
     {
-        return _cflData;
+        return cflData->addEdge(srcId, dstId, ty);
     }
 
-    //virtual void initialize();
+    virtual void initialize();
 
-private:
-    CFLData* _cflData;
+    virtual NodeBS addEdges(const NodeID srcId, const NodeBS& dstData, const Label ty)
+    {
+        return cflData->addEdges(srcId, dstData, ty);
+    }
 
+
+    virtual NodeBS addEdges(const NodeBS& srcData, const NodeID dstId, const Label ty)
+    {
+        return cflData->addEdges(srcData, dstId, ty);
+    }
+private:
+    CFLData* cflData;
 };
 }
 

package/svf/lib/CFL/CFLAlias.cpp

@@ -238,8 +238,6 @@ void CFLAlias::solve()
     timeOfSolving += (end - start) / TIMEINTERVAL;
 }
 
-double POCRAlias::timeOfBuildCFLData = 0;            // Time of building CFLData from CFLGraph
-
 void POCRAlias::initialize()
 {
     stat = new CFLStat(this);
@@ -250,26 +248,9 @@ void POCRAlias::initialize()
     // Build CFL Graph
     buildCFLGraph();
 
-    // Build CFL Data
-    buildCFLData();
-
     // Normalize CFL Grammar
     normalizeCFLGrammar();
 
-    // Initialize sovler
-    solver = new CFLSolver(graph, grammar);
+    // Initialize POCRSolver
+    solver = new POCRSolver(graph, grammar);
 }
-
-
-void POCRAlias::buildCFLData()
-{
-    // Start building CFLGraph
-    double start = stat->getClk(true);
-
-    CFLDataBuilder cflDataBuilder = CFLDataBuilder(graph);
-    _cflData = cflDataBuilder.build();
-
-    // Get time of build graph
-    double end = stat->getClk(true);
-    timeOfBuildCFLData += (end - start) / TIMEINTERVAL;
-}

package/svf/lib/CFL/CFLSolver.cpp

@@ -127,4 +127,92 @@ void CFLSolver::solve()
         const CFLEdge* Y_edge = popFromWorklist();
         processCFLEdge(Y_edge);
     }
+}
+
+void POCRSolver::buildCFLData()
+{
+    for (CFLEdge* edge: graph->getCFLEdges())
+        addEdge(edge->getSrcID(), edge->getDstID(), edge->getEdgeKind());
+}
+
+void POCRSolver::processCFLEdge(const CFLEdge* Y_edge)
+{
+    CFLNode* i = Y_edge->getSrcNode();
+    CFLNode* j = Y_edge->getDstNode();
+
+    /// For each production X -> Y
+    ///     add X(i,j) if not exist to E and to worklist
+    Symbol Y = Y_edge->getEdgeKind();
+    if (grammar->hasProdsFromSingleRHS(Y))
+        for(const Production& prod : grammar->getProdsFromSingleRHS(Y))
+        {
+            Symbol X = grammar->getLHSSymbol(prod);
+            numOfChecks++;
+            if (addEdge(i->getId(), j->getId(), X))
+            {
+                const CFLEdge* newEdge = graph->addCFLEdge(Y_edge->getSrcNode(), Y_edge->getDstNode(), X);
+                pushIntoWorklist(newEdge);
+            }
+
+        }
+
+    /// For each production X -> Y Z
+    /// Foreach outgoing edge Z(j,k) from node j do
+    ///     add X(i,k) if not exist to E and to worklist
+    if (grammar->hasProdsFromFirstRHS(Y))
+        for(const Production& prod : grammar->getProdsFromFirstRHS(Y))
+        {
+            Symbol X = grammar->getLHSSymbol(prod);
+            NodeBS diffDsts = addEdges(i->getId(), cflData->getSuccMap(j->getId())[grammar->getSecondRHSSymbol(prod)], X);
+            numOfChecks += cflData->getSuccMap(j->getId())[grammar->getSecondRHSSymbol(prod)].count();
+            for (NodeID diffDst: diffDsts)
+            {
+                const CFLEdge* newEdge = graph->addCFLEdge(i, graph->getGNode(diffDst), X);
+                pushIntoWorklist(newEdge);
+            }
+        }
+
+    /// For each production X -> Z Y
+    /// Foreach incoming edge Z(k,i) to node i do
+    ///     add X(k,j) if not exist to E and to worklist
+    if(grammar->hasProdsFromSecondRHS(Y))
+        for(const Production& prod : grammar->getProdsFromSecondRHS(Y))
+        {
+            Symbol X = grammar->getLHSSymbol(prod);
+            NodeBS diffSrcs = addEdges(cflData->getPredMap(i->getId())[grammar->getFirstRHSSymbol(prod)], j->getId(), X);
+            numOfChecks += cflData->getPredMap(i->getId())[grammar->getFirstRHSSymbol(prod)].count();
+            for (NodeID diffSrc: diffSrcs)
+            {
+                const CFLEdge* newEdge = graph->addCFLEdge(graph->getGNode(diffSrc), j, X);
+                pushIntoWorklist(newEdge);
+            }
+        }
+}
+
+void POCRSolver::initialize()
+{
+    for(auto it = graph->begin(); it!= graph->end(); it++)
+    {
+        for(const CFLEdge* edge : (*it).second->getOutEdges())
+        {
+            pushIntoWorklist(edge);
+        }
+    }
+
+    /// Foreach production X -> epsilon
+    ///     add X(i,i) if not exist to E and to worklist
+    for(const Production& prod : grammar->getEpsilonProds())
+    {
+        for(auto IDMap : cflData->getSuccMap())
+        {
+            Symbol X = grammar->getLHSSymbol(prod);
+            if (cflData->addEdge(IDMap.first, IDMap.first, X))
+            {
+                CFLNode* i = graph->getGNode(IDMap.first);
+                const CFLEdge* newEdge = graph->addCFLEdge(i, i, X);
+                pushIntoWorklist(newEdge);
+            }
+
+        }
+    }
 }

package/svf-llvm/lib/LLVMModule.cpp

@@ -883,9 +883,15 @@ SVFConstantData* LLVMModuleSet::getSVFConstantData(const ConstantData* cd)
         SVFConstantData* svfcd = nullptr;
         if(const ConstantInt* cint = SVFUtil::dyn_cast<ConstantInt>(cd))
         {
-            /// bool true will be translated to -1 with getSExtValue, so call getZExtValue() if bitwidth = 1
-            svfcd = new SVFConstantInt(cd->getName().str(), getSVFType(cint->getType()), cint->getZExtValue(),
-                                       cint->getBitWidth() == 1? cint->getZExtValue(): cint->getSExtValue());
+            /// bitwidth == 1 : cint has value from getZExtValue() because `bool true` will be translated to -1 using sign extension (i.e., getSExtValue).
+            /// bitwidth <=64 1 : cint has value from getSExtValue()
+            /// bitwidth >64 1 : cint has value 0 because it represents an invalid int
+            if(cint->getBitWidth() == 1)
+                svfcd = new SVFConstantInt(cd->getName().str(), getSVFType(cint->getType()), cint->getZExtValue(), cint->getZExtValue());
+            else if(cint->getBitWidth() <= 64 && cint->getBitWidth() > 1)
+                svfcd = new SVFConstantInt(cd->getName().str(), getSVFType(cint->getType()), cint->getZExtValue(), cint->getSExtValue());
+            else
+                svfcd = new SVFConstantInt(cd->getName().str(), getSVFType(cint->getType()), 0, 0);
         }
         else if(const ConstantFP* cfp = SVFUtil::dyn_cast<ConstantFP>(cd))
         {

package/svf/include/CFL/CFLData.h

@@ -1,316 +0,0 @@
-//===----- CFLData.h -- Context Free Language Reachability Graph Data Structure--------------//
-//
-//                     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/>.
-//
-//===----------------------------------------------------------------------===//
-
-/*
- * CFLData.h
- *
- *  Created on: Nov 22, 2019
- *      Author: Yuxiang Lei
- *
- * The implementation is based on
- * Yuxiang Lei, Yulei Sui, Shuo Ding, and Qirun Zhang.
- * Taming Transitive Redundancy for Context-Free Language Reachability.
- * ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications
- */
-
-#ifndef INCLUDE_CFL_CFGDATA_H_
-#define INCLUDE_CFL_CFGDATA_H_
-
-#include "Util/WorkList.h"
-#include "CFL/CFLGrammar.h"
-
-namespace SVF
-{
-typedef GrammarBase::Symbol Label;
-/*!
- * Adjacency-list graph representation
- */
-class CFLData
-{
-public:
-    typedef std::map<const Label, NodeBS> TypeMap;                  // Label with SparseBitVector of NodeID
-    typedef std::unordered_map<NodeID, TypeMap> DataMap;            // Each Node has a TypeMap
-    typedef typename DataMap::iterator iterator;                    // iterator for each node
-    typedef typename DataMap::const_iterator const_iterator;        // const iterator
-
-protected:
-    DataMap succMap;                                                // succ map for nodes contains Label: Edgeset
-    DataMap predMap;                                                // pred map for nodes contains Label: edgeset
-    const NodeBS emptyData;                                         // ??
-    NodeBS diff;                                                    // ??
-
-    // union/add data
-    //@{
-    inline bool addPred(const NodeID key, const NodeID src, const Label ty)
-    {
-        return predMap[key][ty].test_and_set(src);
-    };
-
-    inline bool addSucc(const NodeID key, const NodeID dst, const Label ty)
-    {
-        return succMap[key][ty].test_and_set(dst);
-    };
-
-    inline bool addPreds(const NodeID key, const NodeBS& data, const Label ty)
-    {
-        if (data.empty())
-            return false;
-        return predMap[key][ty] |= data;                            // union of sparsebitvector (add to LHS)
-    }
-
-    inline bool addSuccs(const NodeID key, const NodeBS& data, const Label ty)
-    {
-        if (data.empty())
-            return false;
-        return succMap[key][ty] |= data;                            // // union of sparsebitvector (add to LHS)
-    }
-    //@}
-
-public:
-    // Constructor
-    CFLData()
-    {}
-
-    // Destructor
-    virtual ~CFLData()
-    {}
-
-    virtual void clear()
-    {
-        succMap.clear();
-        predMap.clear();
-    }
-
-    inline const_iterator begin() const
-    {
-        return succMap.begin();
-    }
-
-    inline const_iterator end() const
-    {
-        return succMap.end();
-    }
-
-    inline iterator begin()
-    {
-        return succMap.begin();
-    }
-
-    inline iterator end()
-    {
-        return succMap.end();
-    }
-
-    inline DataMap& getSuccMap()
-    {
-        return succMap;
-    }
-
-    inline DataMap& getPredMap()
-    {
-        return predMap;
-    }
-
-    inline TypeMap& getSuccMap(const NodeID key)
-    {
-        return succMap[key];
-    }
-
-    inline TypeMap& getPredMap(const NodeID key)
-    {
-        return predMap[key];
-    }
-
-    inline NodeBS& getSuccs(const NodeID key, const Label ty)
-    {
-        return succMap[key][ty];
-    }
-
-    inline NodeBS& getPreds(const NodeID key, const Label ty)
-    {
-        return predMap[key][ty];
-    }
-
-    // Alias data operations
-    //@{
-    inline bool addEdge(const NodeID src, const NodeID dst, const Label ty)
-    {
-        addSucc(src, dst, ty);
-        return addPred(dst, src, ty);
-    }
-
-    /// add edges and return the set of added edges (dst) for src
-    inline NodeBS addEdges(const NodeID src, const NodeBS& dstData, const Label ty)
-    {
-        NodeBS newDsts;
-        if (addSuccs(src, dstData, ty))
-        {
-            for (const NodeID datum: dstData)
-                if (addPred(datum, src, ty))
-                    newDsts.set(datum);
-        }
-        return newDsts;
-    }
-
-    /// add edges and return the set of added edges (src) for dst
-    inline NodeBS addEdges(const NodeBS& srcData, const NodeID dst, const Label ty)
-    {
-        NodeBS newSrcs;
-        if (addPreds(dst, srcData, ty))
-        {
-            for (const NodeID datum: srcData)
-                if (addSucc(datum, dst, ty))
-                    newSrcs.set(datum);
-        }
-        return newSrcs;
-    }
-
-    /// find src -> find src[ty] -> find dst in set
-    inline bool hasEdge(const NodeID src, const NodeID dst, const Label ty)
-    {
-        const_iterator iter1 = succMap.find(src);
-        if (iter1 == succMap.end())
-            return false;
-
-        auto iter2 = iter1->second.find(ty);
-        if (iter2 == iter1->second.end())
-            return false;
-
-        return iter2->second.test(dst);
-    }
-
-    /* This is a dataset version, to be modified to a cflData version */
-    inline void clearEdges(const NodeID key)
-    {
-        succMap[key].clear();
-        predMap[key].clear();
-    }
-    //@}
-};
-
-
-/*!
- * Hybrid graph representation for transitive relations
- */
-class HybridData
-{
-public:
-    struct TreeNode
-    {
-        NodeID id;
-        std::unordered_set<TreeNode*> children;
-
-        TreeNode(NodeID nId) : id(nId)
-        {}
-
-        ~TreeNode()
-        {
-        }
-
-        inline bool operator==(const TreeNode& rhs) const
-        {
-            return id == rhs.id;
-        }
-
-        inline bool operator<(const TreeNode& rhs) const
-        {
-            return id < rhs.id;
-        }
-    };
-
-
-public:
-    Map<NodeID, std::unordered_map<NodeID, TreeNode*>> indMap;   // indMap[v][u] points to node v in tree(u)
-
-    HybridData()
-    {}
-
-    ~HybridData()
-    {
-        for (auto iter1: indMap)
-        {
-            for (auto iter2: iter1.second)
-            {
-                delete iter2.second;
-                iter2.second = NULL;
-            }
-        }
-    }
-
-    bool hasInd(NodeID src, NodeID dst)
-    {
-        auto it = indMap.find(dst);
-        if (it == indMap.end())
-            return false;
-        return (it->second.find(src) != it->second.end());
-    }
-
-    /// Add a node dst to tree(src)
-    TreeNode* addInd(NodeID src, NodeID dst)
-    {
-        auto resIns = indMap[dst].insert(std::make_pair(src, new TreeNode(dst)));
-        if (resIns.second)
-            return resIns.first->second;
-        return nullptr;
-    }
-
-    /// Get the node dst in tree(src)
-    TreeNode* getNode(NodeID src, NodeID dst)
-    {
-        return indMap[dst][src];
-    }
-
-    /// add v into desc(x) as a child of u
-    void insertEdge(TreeNode* u, TreeNode* v)
-    {
-        u->children.insert(v);
-    }
-
-    void addArc(NodeID src, NodeID dst)
-    {
-        if (!hasInd(src, dst))
-        {
-            for (auto iter: indMap[src])
-            {
-                meld(iter.first, getNode(iter.first, src), getNode(dst, dst));
-            }
-        }
-    }
-
-    void meld(NodeID x, TreeNode* uNode, TreeNode* vNode)
-    {
-        TreeNode* newVNode = addInd(x, vNode->id);
-        if (!newVNode)
-            return;
-
-        insertEdge(uNode, newVNode);
-        for (TreeNode* vChild: vNode->children)
-        {
-            meld(x, newVNode, vChild);
-        }
-    }
-};
-
-
-}   // end namespace SVF
-
-#endif

package/svf/include/CFL/CFLDataBuilder.h

@@ -1,91 +0,0 @@
-//===----- CFLDataBuilder.h -- CFL Data Builder --------------//
-//
-//                     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/>.
-//
-//===----------------------------------------------------------------------===//
-
-/*
- * CFLGraphBuilder.h
- *
- *  Created on: Nov 6, 2022
- *      Author: Pei Xu
- */
-
-#ifndef INCLUDE_CFL_CFLDATABUILDER_H_
-#define INCLUDE_CFL_CFLDATABUILDER_H_
-
-#include "CFL/CFLData.h"
-#include "Graphs/CFLGraph.h"
-
-namespace SVF
-{
-
-/*!
- * Build CFLData from CFL graph
-
- */
-
-class CFLDataBuilder
-{
-protected:
-    CFLData* _cflData;
-    CFLGraph* _graph;
-
-public:
-    /// Constructor
-    CFLDataBuilder(CFLGraph* cflgraph) : _cflData(NULL), _graph(cflgraph)
-    {
-        if (!_cflData)
-            _cflData = new CFLData();
-    }
-
-    /// Destructor
-    virtual ~CFLDataBuilder()
-    {
-    }
-
-    CFLData* cflData()
-    {
-        return _cflData;
-    }
-
-    //CFL data operations
-    //@{
-    virtual bool addEdge(const NodeID srcId, const NodeID dstId, const Label ty)
-    {
-        return cflData()->addEdge(srcId, dstId, ty);
-    }
-
-    virtual NodeBS addEdges(const NodeID srcId, const NodeBS& dstData, const Label ty)
-    {
-        return cflData()->addEdges(srcId, dstData, ty);
-    }
-    //@}
-    CFLData* build()
-    {
-        for (CFLEdge* edge: _graph->getCFLEdges())
-            addEdge(edge->getSrcID(), edge->getDstID(), edge->getEdgeKind());
-        return  cflData();
-    }
-
-
-};
-}// SVF
-
-#endif /* INCLUDE_CFL_CFLGRAPHBUILDER_H_*/