svf-lib 1.0.1391 → 1.0.1392

package/SVF-linux/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-linux/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/package.json

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