svf-tools 1.0.620 → 1.0.621

package/include/CFL/CFLData.h

@@ -0,0 +1,316 @@
+//===----- 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/include/CFL/CFLDataBuilder.h

@@ -0,0 +1,91 @@
+//===----- 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_*/

package/include/CFL/CFLSolver.h

@@ -33,6 +33,7 @@
 #include "Graphs/CFLGraph.h"
 #include "CFL/CFLGrammar.h"
 #include "Util/WorkList.h"
+#include "CFL/CFLData.h"
 
 
 namespace SVF
@@ -110,6 +111,26 @@ private:
 
 };
 
+/// Solver Utilize CFLData
+class POCRSolver : public CFLSolver
+{
+    /// Destructor
+    virtual ~POCRSolver()
+    {
+        delete _cflData;
+    }
+
+    CFLData* cflData()
+    {
+        return _cflData;
+    }
+
+    //virtual void initialize();
+
+private:
+    CFLData* _cflData;
+
+};
 }
 
 #endif /* INCLUDE_CFL_CFLSolver_H_*/

package/include/Util/Options.h

@@ -255,6 +255,7 @@ public:
     static const Option<bool> FlexSymMap;
     static const Option<bool>  PEGTransfer;
     static const Option<bool>  CFLSVFG;
+    static const Option<bool> POCRAlias;
 
     // Loop Analysis
     static const Option<bool> LoopAnalysis;

package/lib/CFL/CFLAlias.cpp

@@ -237,3 +237,39 @@ void CFLAlias::solve()
     double end = stat->getClk(true);
     timeOfSolving += (end - start) / TIMEINTERVAL;
 }
+
+double POCRAlias::timeOfBuildCFLData = 0;            // Time of building CFLData from CFLGraph
+
+void POCRAlias::initialize()
+{
+    stat = new CFLStat(this);
+
+    // Build CFL Grammar
+    buildCFLGrammar();
+
+    // Build CFL Graph
+    buildCFLGraph();
+
+    // Build CFL Data
+    buildCFLData();
+
+    // Normalize CFL Grammar
+    normalizeCFLGrammar();
+
+    // Initialize sovler
+    solver = new CFLSolver(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/lib/Util/Options.cpp

@@ -823,6 +823,11 @@ const Option<bool> Options::CFLSVFG(
     false
 );
 
+const Option<bool> Options::POCRAlias(
+    "pocr-alias",
+    "When explicit to true, cfl data builder will transfer CFL graph to CFLData.",
+    false
+);
 
 const Option<bool> Options::LoopAnalysis(
     "loop-analysis",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.620",
+  "version": "1.0.621",
   "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/tools/CFL/cfl.cpp

@@ -59,6 +59,8 @@ int main(int argc, char ** argv)
     std::unique_ptr<CFLBase> cfl;
     if (Options::CFLSVFG())
         cfl = std::make_unique<CFLVF>(svfir);
+    else if (Options::POCRAlias())
+        cfl = std::make_unique<POCRAlias>(svfir);
     else
         cfl = std::make_unique<CFLAlias>(svfir); // if no svfg is specified, we use CFLAlias as the default one.
     cfl->analyze();