svf-lib 1.0.2319 → 1.0.2321

package/SVF-osx/Release-build/include/SVF/CFL/CFLSolver.h

@@ -0,0 +1,374 @@
+//===----- CFLSolver.h -- Context-free language reachability solver--------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * CFLSolver.h
+ *
+ *  Created on: March 5, 2022
+ *      Author: Yulei Sui， Yuxiang Lei
+ */
+
+#ifndef INCLUDE_CFL_CFLSolver_H_
+#define INCLUDE_CFL_CFLSolver_H_
+
+#include "Graphs/CFLGraph.h"
+#include "CFL/CFGrammar.h"
+#include "Util/WorkList.h"
+
+using namespace std;
+
+namespace SVF
+{
+typedef GrammarBase::Symbol Label;
+
+class CFLSolver
+{
+
+public:
+    /// Define worklist
+    typedef FIFOWorkList<const CFLEdge*> WorkList;
+    typedef CFGrammar::Production Production;
+    typedef CFGrammar::Symbol Symbol;
+
+    static double numOfChecks;
+
+    CFLSolver(CFLGraph* _graph, CFGrammar* _grammar): graph(_graph), grammar(_grammar)
+    {
+    }
+
+    virtual ~CFLSolver()
+    {
+        delete graph;
+        delete grammar;
+    }
+
+    /// Initialize worklist
+    virtual void initialize();
+
+    /// Process CFLEdge
+    virtual void processCFLEdge(const CFLEdge* Y_edge);
+
+    /// Start solving
+    virtual void solve();
+
+    /// Return CFL Graph
+    inline const CFLGraph* getGraph() const
+    {
+        return graph;
+    }
+
+    /// Return CFL Grammar
+    inline const CFGrammar* getGrammar() const
+    {
+        return grammar;
+    }
+    virtual inline bool pushIntoWorklist(const CFLEdge* item)
+    {
+        return worklist.push(item);
+    }
+    virtual inline bool isWorklistEmpty()
+    {
+        return worklist.empty();
+    }
+
+protected:
+    /// Worklist operations
+    //@{
+    inline const CFLEdge* popFromWorklist()
+    {
+        return worklist.pop();
+    }
+
+    inline bool isInWorklist(const CFLEdge* item)
+    {
+        return worklist.find(item);
+    }
+    //@}
+
+protected:
+    CFLGraph* graph;
+    CFGrammar* grammar;
+    /// Worklist for resolution
+    WorkList worklist;
+
+};
+
+/// Solver Utilize CFLData
+class POCRSolver : public CFLSolver
+{
+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;
+
+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:
+
+    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();
+    }
+    //@}
+
+    POCRSolver(CFLGraph* _graph, CFGrammar* _grammar) : CFLSolver(_graph, _grammar)
+    {
+        buildCFLData();
+    }
+    /// Destructor
+    virtual ~POCRSolver()
+    {
+    }
+
+    /// Process CFLEdge
+    virtual void processCFLEdge(const CFLEdge* Y_edge);
+
+    /// Init CFLData
+    virtual void buildCFLData();
+
+    virtual void initialize();
+};
+/*!
+ * 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
+ */
+/// Solver Utilize Hybrid Representation of Graph
+class POCRHybridSolver : public POCRSolver
+{
+//Hybrid
+//{@
+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)
+
+    bool hasInd_h(NodeID src, NodeID dst);
+
+    /// Add a node dst to tree(src)
+    TreeNode* addInd_h(NodeID src, NodeID dst);
+
+    /// Get the node dst in tree(src)
+    TreeNode* getNode_h(NodeID src, NodeID dst)
+    {
+        return indMap[dst][src];
+    }
+
+    /// add v into desc(x) as a child of u
+    void insertEdge_h(TreeNode* u, TreeNode* v)
+    {
+        u->children.insert(v);
+    }
+
+    void addArc_h(NodeID src, NodeID dst);
+
+    void meld_h(NodeID x, TreeNode* uNode, TreeNode* vNode);
+//@}
+public:
+    POCRHybridSolver(CFLGraph* _graph, CFGrammar* _grammar) : POCRSolver(_graph, _grammar)
+    {
+    }
+    /// Destructor
+    virtual ~POCRHybridSolver()
+    {
+        for (auto iter1: indMap)
+        {
+            for (auto iter2: iter1.second)
+            {
+                delete iter2.second;
+                iter2.second = NULL;
+            }
+        }
+    }
+
+    /// Process CFLEdge
+    virtual void processCFLEdge(const CFLEdge* Y_edge);
+
+    virtual void initialize();
+
+public:
+    void addArc(NodeID src, NodeID dst);
+    void meld(NodeID x, TreeNode* uNode, TreeNode* vNode);
+};
+}
+
+#endif /* INCLUDE_CFL_CFLSolver_H_*/

package/SVF-osx/Release-build/include/SVF/CFL/CFLStat.h

@@ -0,0 +1,67 @@
+//===- CFLStat.h -- CFL statistics--------------------------------------------//
+//
+//                     SVF: Static Value-Flow Analysis
+//
+// Copyright (C) <2013-2017>  <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/>.
+//
+//===----------------------------------------------------------------------===//
+
+
+/*
+ * CFLStat.h
+ *
+ *  Created on: 17/9/2022
+ *      Author: Pei Xu
+ */
+
+#ifndef CFL_CFLSTAT_H_
+#define CFL_CFLSTAT_H_
+
+#include "Util/PTAStat.h"
+#include "CFL/CFLAlias.h"
+#include "CFL/CFLVF.h"
+
+namespace SVF
+{
+
+/*!
+ * Statistics of CFL's analysis
+ */
+class CFLStat : public PTAStat
+{
+private:
+    CFLBase* pta;
+
+public:
+    CFLStat(CFLBase* p);
+
+    virtual ~CFLStat()
+    {
+    }
+
+    virtual void performStat();
+
+    void CFLGraphStat();
+
+    void CFLGrammarStat();
+
+    void CFLSolverStat();
+};
+
+} // End namespace SVF
+
+#endif /* CFL_CFLSTAT_H_ */

package/SVF-osx/Release-build/include/SVF/CFL/CFLVF.h

@@ -0,0 +1,68 @@
+//===----- CFLVF.h -- CFL Value-Flow Client--------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * CFLVF.h
+ *
+ *  Created on: September 5, 2022
+ *      Author: Pei Xu
+ */
+
+#ifndef INCLUDE_CFL_CFLVF_H_
+#define INCLUDE_CFL_CFLVF_H_
+
+
+#include "CFL/CFLBase.h"
+#include "CFL/CFLStat.h"
+#include "CFL/CFLSVFGBuilder.h"
+#include "WPA/Andersen.h"
+
+namespace SVF
+{
+class CFLVF : public CFLBase
+{
+
+public:
+    CFLVF(SVFIR* ir) : CFLBase(ir, PointerAnalysis::CFLFSCS_WPA)
+    {
+    }
+
+    /// Parameter Checking
+    virtual void checkParameter();
+
+    /// Initialize the grammar, graph, solver
+    virtual void initialize();
+
+    /// Print grammar and graph
+    virtual void finalize();
+
+    /// Build CFLGraph via VFG
+    void buildCFLGraph();
+
+private:
+    CFLSVFGBuilder memSSA;
+    SVFG* svfg;
+};
+
+} // End namespace SVF
+
+#endif /* INCLUDE_CFL_CFLVF_H_*/

package/SVF-osx/Release-build/include/SVF/CFL/GrammarBuilder.h

@@ -0,0 +1,100 @@
+//===----- GrammarBuilder.h -- CFL Grammar 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 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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * GrammarBuilder.h
+ *
+ *  Created on: April 26, 2022
+ *      Author: Pei Xu
+ */
+
+#ifndef INCLUDE_CFL_GRAMMARBUILDER_H_
+#define INCLUDE_CFL_GRAMMARBUILDER_H_
+
+#include "CFL/CFGrammar.h"
+
+namespace SVF
+{
+
+/**
+ * Build Grammar from a user specified grammar text
+ *
+ * Symbol Format:
+ *      <kind> [bar] [ _alpha | _number ]
+ *      kind: any nonspace string start with alphabet, epsilon stand for empty string
+ *      bar: stand for reverse edge
+ *      alpha: any single alpha
+ *      number: any number
+ *      start with capital: nonterminal
+ *      start with noncapital: terminal
+ *
+ * Production Format:
+ *      <symbol> -> <symbol> *;
+ *      LHS and RHS, Separate by '->', symbol separate by ' ', end by ';'
+ *      support '*', '?', '(', ')'
+ *
+ * Input Format:
+ *      Start:
+ *      M                   // Specify Start Symbol in Second Line
+ *      Terminal:
+ *      Addr Copy Store Load Gep Vgep // Specify the order of terminal Addr->0, Copy->1 ..
+ *      Productions:        // Each Symbol separate by 'Space', production end with ';'
+ *      M -> V d;           // Terminal in NonCapital
+ *      M -> dbar V d;      // NonTerminal in Capital
+ *      V -> M abar M a M;  // LHS and RHS, Separate by '->'
+ *      V -> ( M ? abar ) * M ? ( a M ? ) *;    // Support '(' ')' '?' '*' four regular expression sign
+ *      Gep_j -> Gep_i F vgep; // Support variable attribute with variable attribute
+ *      Gep_1 -> Gep_2;      // Support fix number attribute
+ *
+ */
+
+class GrammarBuilder
+{
+private:
+    std::string fileName;
+    GrammarBase *grammar;
+
+    /// Parse start symbol and production from file string
+    const inline std::string parseProductionsString() const;
+
+    /// Parse whole production string to production vector
+    const inline std::vector<std::string> loadWordProductions() const;
+
+    /// Strip front and tail space
+    const inline std::string stripSpace(std::string s) const;
+
+public:
+    GrammarBuilder(std::string fileName): fileName(fileName), grammar(nullptr)
+    {
+        grammar = new GrammarBase();
+    };
+
+    /// Build grammarBase from fileName
+    GrammarBase* build() const;
+
+    /// Build grammarBase from fileName with preset str2KindMap
+    GrammarBase* build(Map<std::string, SVF::GrammarBase::Symbol> &preMap) const;
+};
+
+} // SVF
+
+#endif /* INCLUDE_CFL_GRAMMARBUILDER_H_ */