svf-tools 1.0.442 → 1.0.445

package/include/Graphs/CFLGraph.h

@@ -0,0 +1,175 @@
+//===----- CFLGraph.h -- Graph for context-free language reachability analysis --//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * CFLGraph.h
+ *
+ *  Created on: March 5, 2022
+ *      Author: Yulei Sui
+ */
+
+#ifndef CFLG_H_
+#define CFLG_H_
+
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <regex>
+#include "CFL/CFLGrammar.h"
+#include "Graphs/GenericGraph.h"
+
+namespace SVF
+{
+class CFLNode;
+
+typedef GenericEdge<CFLNode> GenericCFLEdgeTy;
+
+class CFLEdge: public GenericCFLEdgeTy
+{
+public:
+    CFLEdge(CFLNode *s, CFLNode *d, GEdgeFlag k = 0):
+        GenericCFLEdgeTy(s,d,k)
+    {
+    }
+    ~CFLEdge() override = default;
+};
+
+
+typedef GenericNode<CFLNode,CFLEdge> GenericCFLNodeTy;
+class CFLNode: public GenericCFLNodeTy
+{
+public:
+    CFLNode (NodeID i = 0, GNodeK k = 0):
+        GenericCFLNodeTy(i, k)
+    {
+    }
+    ~CFLNode() override = default;
+};
+
+/// Edge-labeled graph for CFL Reachability analysis
+typedef GenericGraph<CFLNode,CFLEdge> GenericCFLGraphTy;
+class CFLGraph: public GenericCFLGraphTy
+{
+public:
+    typedef u32_t Symbol;
+    typedef GenericNode<CFLNode,CFLEdge>::GEdgeSetTy CFLEdgeSet;
+    Map<std::string, Symbol> label2SymMap;
+    Symbol startSymbol;
+
+    CFLGraph()
+    {
+    }
+    ~CFLGraph() override = default;
+
+    /// Build graph by copying nodes and edges from any graph inherited from GenericGraph
+    template<class N, class E> 
+    void build(GenericGraph<N,E>* graph){
+        for(auto it = graph->begin(); it!= graph->end(); it++){
+            CFLNode* node = new CFLNode((*it).first);
+            addCFLNode((*it).first, node);
+        }
+        for(auto it = graph->begin(); it!= graph->end(); it++){
+            N* node = (*it).second;
+            for(E* edge : node->getOutEdges())
+            {
+                addCFLEdge(getGNode(edge->getSrcID()), getGNode(edge->getDstID()), edge->getEdgeKind());
+            }
+        }
+    }
+
+    /// Build Bidirectional graph by copying nodes and edges from any graph inherited from GenericGraph
+    template<class N, class E> 
+    void buildBigraph(GenericGraph<N,E>* graph){
+        for(auto it = graph->begin(); it!= graph->end(); it++){
+            CFLNode* node = new CFLNode((*it).first);
+            addCFLNode((*it).first, node);
+        }
+        for(auto it = graph->begin(); it!= graph->end(); it++){
+            N* node = (*it).second;
+            for(E* edge : node->getOutEdges())
+            {
+                addCFLEdge(getGNode(edge->getSrcID()), getGNode(edge->getDstID()), edge->getEdgeKind());
+                std::string key = "";                
+                for (auto &i : this->label2SymMap)
+                {
+                    if (i.second == edge->getEdgeKind())
+                    {
+                        key = i.first;
+                    }
+                }
+                key.append("bar");
+                addCFLEdge(getGNode(edge->getDstID()), getGNode(edge->getSrcID()), this->label2SymMap[key]);
+            }
+        }
+    }
+
+    virtual void addCFLNode(NodeID id, CFLNode* node);
+
+    virtual const CFLEdge* addCFLEdge(CFLNode* src, CFLNode* dst, CFLEdge::GEdgeFlag label);
+
+    virtual const CFLEdge* hasEdge(CFLNode* src, CFLNode* dst, CFLEdge::GEdgeFlag label);
+
+    void dump(const std::string& filename);
+
+    void view();
+
+    /// Build graph from file
+    void build(std::string filename);
+    
+    /// Build graph from Dot
+    void buildFromDot(std::string filename);
+
+    /// Set label2Sym from External
+    void setMap(Map<std::string, Symbol>* terminals, Map<std::string, Symbol>* nonterminals);
+
+private:
+    CFLEdgeSet cflEdgeSet;
+    Symbol current;
+    bool externMap;
+};
+
+}
+
+namespace llvm
+{
+/* !
+ * GraphTraits specializations for generic graph algorithms.
+ * Provide graph traits for traversing from a constraint node using standard graph traversals.
+ */
+template<> struct GraphTraits<SVF::CFLNode*> : public GraphTraits<SVF::GenericNode<SVF::CFLNode,SVF::CFLEdge>*  >
+{
+};
+
+/// Inverse GraphTraits specializations for call graph node, it is used for inverse traversal.
+template<>
+struct GraphTraits<Inverse<SVF::CFLNode *> > : public GraphTraits<Inverse<SVF::GenericNode<SVF::CFLNode,SVF::CFLEdge>* > >
+{
+};
+
+template<> struct GraphTraits<SVF::CFLGraph*> : public GraphTraits<SVF::GenericGraph<SVF::CFLNode,SVF::CFLEdge>* >
+{
+    typedef SVF::CFLNode *NodeRef;
+};
+
+} // End namespace llvm
+
+#endif /* CFLG_H_ */

package/include/Graphs/IRGraph.h

@@ -53,7 +53,7 @@ public:
 
 protected:
     SVFStmt::KindToSVFStmtMapTy KindToSVFStmtSetMap;  // < SVFIR edge map containing all PAGEdges
-    SVFStmt::KindToSVFStmtMapTy KindToPTASVFStmtSetMap;  // < SVFIR edge map containing only pointer-related edges, i.e, both RHS and RHS are of pointer type
+    SVFStmt::KindToSVFStmtMapTy KindToPTASVFStmtSetMap;  // < SVFIR edge map containing only pointer-related edges, i.e, both LHS and RHS are of pointer type
     bool fromFile; ///< Whether the SVFIR is built according to user specified data from a txt file
     NodeID nodeNumAfterPAGBuild; // initial node number after building SVFIR, excluding later added nodes, e.g., gepobj nodes
     u32_t totalPTAPAGEdge;

package/include/MemoryModel/PointerAnalysis.h

@@ -79,9 +79,9 @@ public:
         FSTBHC_WPA,		///< Sparse flow-sensitive type-based heap cloning WPA
         VFS_WPA,		///< Versioned sparse flow-sensitive WPA
         FSCS_WPA,			///< Flow-, context- sensitive WPA
-        FSCSPS_WPA,		///< Flow-, context-, path- sensitive WPA
-        ADAPTFSCS_WPA,		///< Adaptive Flow-, context-, sensitive WPA
-        ADAPTFSCSPS_WPA,	///< Adaptive Flow-, context-, path- sensitive WPA
+        CFLFICI_WPA,		///< Flow-, context-, insensitive CFL-reachability-based analysis
+        CFLFSCI_WPA,		///< Flow-insensitive, context-sensitive  CFL-reachability-based analysis
+        CFLFSCS_WPA,	///< Flow-, context-, CFL-reachability-based analysis
         TypeCPP_WPA, ///<  Type-based analysis for C++
 
         // Demand driven analysis

package/include/SABER/SrcSnkDDA.h

@@ -30,7 +30,8 @@
 #ifndef SRCSNKANALYSIS_H_
 #define SRCSNKANALYSIS_H_
 
-#include "SrcSnkSolver.h"
+
+#include "Util/GraphReachSolver.h"
 #include "Graphs/SVFGOPT.h"
 #include "SABER/ProgSlice.h"
 #include "SABER/SaberSVFGBuilder.h"
@@ -38,7 +39,7 @@
 namespace SVF
 {
 
-typedef SrcSnkSolver<SVFG*,CxtDPItem> CFLSrcSnkSolver;
+typedef GraphReachSolver<SVFG*,CxtDPItem> CFLSrcSnkSolver;
 
 /*!
  * General source-sink analysis, which serves as a base analysis to be extended for various clients

package/include/Util/GraphReachSolver.h

@@ -0,0 +1,186 @@
+//===- GraphReachSolver.h -- Generic graph reachability solver---------------------------------//
+//
+//                     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 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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * GraphReachSolver.h
+ *
+ *  Created on: Apr 1, 2014
+ *      Author: Yulei Sui
+ */
+
+#ifndef CFLSOLVER_H_
+#define CFLSOLVER_H_
+
+#include "Util/WorkList.h"
+#include "Util/DPItem.h"
+
+namespace SVF
+{
+
+/*
+ * Generic Graph Reachability solver for demand-driven analysis based on different graphs (e.g. SVFIR, VFG, ThreadVFG)
+ * Extend this class for sophisticated CFL-reachability resolution (e.g. field, flow, path)
+ */
+template<class GraphType, class DPIm = DPItem>
+class GraphReachSolver
+{
+
+public:
+    ///Define the GTraits and node iterator
+    typedef llvm::GraphTraits<GraphType> GTraits;
+    typedef typename GTraits::NodeType          GNODE;
+    typedef typename GTraits::EdgeType          GEDGE;
+    typedef typename GTraits::nodes_iterator node_iterator;
+    typedef typename GTraits::ChildIteratorType child_iterator;
+
+    /// Define inverse GTraits and note iterator
+    typedef llvm::GraphTraits<llvm::Inverse<GNODE *> > InvGTraits;
+    typedef typename InvGTraits::ChildIteratorType inv_child_iterator;
+
+    /// Define worklist
+    typedef FIFOWorkList<DPIm> WorkList;
+
+protected:
+
+    /// Constructor
+    GraphReachSolver(): _graph(nullptr)
+    {
+    }
+    /// Destructor
+    virtual ~GraphReachSolver()
+    {
+    }
+    /// Get/Set graph methods
+    //@{
+    const inline GraphType graph() const
+    {
+        return _graph;
+    }
+    inline void setGraph(GraphType g)
+    {
+        _graph = g;
+    }
+    //@}
+
+    inline GNODE* getNode(NodeID id) const
+    {
+        return _graph->getGNode(id);
+    }
+    virtual inline NodeID getNodeIDFromItem(const DPIm& item) const
+    {
+        return item.getCurNodeID();
+    }
+    /// CFL forward traverse solve
+    virtual void forwardTraverse(DPIm& it)
+    {
+        pushIntoWorklist(it);
+
+        while (!isWorklistEmpty())
+        {
+            DPIm item = popFromWorklist();
+            FWProcessCurNode(item);
+
+            GNODE* v = getNode(getNodeIDFromItem(item));
+            child_iterator EI = GTraits::child_begin(v);
+            child_iterator EE = GTraits::child_end(v);
+            for (; EI != EE; ++EI)
+            {
+                FWProcessOutgoingEdge(item,*(EI.getCurrent()) );
+            }
+        }
+    }
+    /// CFL forward traverse solve
+    virtual void backwardTraverse(DPIm& it)
+    {
+        pushIntoWorklist(it);
+
+        while (!isWorklistEmpty())
+        {
+            DPIm item = popFromWorklist();
+            BWProcessCurNode(item);
+
+            GNODE* v = getNode(getNodeIDFromItem(item));
+            inv_child_iterator EI = InvGTraits::child_begin(v);
+            inv_child_iterator EE = InvGTraits::child_end(v);
+            for (; EI != EE; ++EI)
+            {
+                BWProcessIncomingEdge(item,*(EI.getCurrent()) );
+            }
+        }
+    }
+    /// Process the DP item
+    //@{
+    virtual void FWProcessCurNode(const DPIm&)
+    {
+    }
+    virtual void BWProcessCurNode(const DPIm&)
+    {
+    }
+    //@}
+    /// Propagation for the solving, to be implemented in the child class
+    //@{
+    virtual void FWProcessOutgoingEdge(const DPIm& item, GEDGE* edge)
+    {
+        DPIm newItem(item);
+        newItem.setCurNodeID(edge->getDstID());
+        pushIntoWorklist(newItem);
+    }
+    virtual void BWProcessIncomingEdge(const DPIm& item, GEDGE* edge)
+    {
+        DPIm newItem(item);
+        newItem.setCurNodeID(edge->getSrcID());
+        pushIntoWorklist(newItem);
+    }
+    //@}
+    /// Worklist operations
+    //@{
+    inline DPIm popFromWorklist()
+    {
+        return worklist.pop();
+    }
+    inline bool pushIntoWorklist(DPIm& item)
+    {
+        return worklist.push(item);
+    }
+    inline bool isWorklistEmpty()
+    {
+        return worklist.empty();
+    }
+    inline bool isInWorklist(DPIm& item)
+    {
+        return worklist.find(item);
+    }
+    //@}
+
+private:
+
+    /// Graph
+    GraphType _graph;
+
+    /// Worklist for resolution
+    WorkList worklist;
+
+};
+
+} // End namespace SVF
+
+#endif /* CFLSOLVER_H_ */

package/include/Util/Options.h

@@ -254,6 +254,12 @@ public:
     // DOTGraphTraits
     static const llvm::cl::opt<bool> ShowHiddenNode;
 
+    // CFL option
+    static const llvm::cl::opt<std::string> InputFilename;
+    static const llvm::cl::opt<std::string> GrammarFilename;
+    static const llvm::cl::opt<bool> GraphIsFromDot;
+    static const llvm::cl::opt<bool> GrammarIsEBNF;
+    static const llvm::cl::opt<bool> FlexSymMap;
 };
 }  // namespace SVF