svf-lib 1.0.982 → 1.0.983

package/SVF-linux/include/CFL/CFGNormalizer.h

@@ -0,0 +1,70 @@
+//===----- CFGNormalizer.h -- CFL Alias Analysis 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 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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * CFGNormalizer.h
+ *
+ *  Created on: April 19 , 2022
+ *      Author: Pei Xu
+ */
+
+#ifndef CFGNormalizer_H_
+#define CFGNormalizer_H_
+
+#include "CFLGrammar.h"
+
+namespace SVF{
+
+/*!
+ *  Normalize Grammar from a grammarbase
+ */
+
+class CFGNormalizer {
+
+public:
+    typedef u32_t Symbol;
+    typedef std::vector<Symbol> Production;
+    typedef Set<Production> Productions;
+
+    CFGNormalizer(){
+    }
+
+    /// Start Normalize (BIN Only)
+    // TODO: Add different Combination Transformation Option
+    CFLGrammar* normalize(GrammarBase *generalGrammar);
+private:
+
+    void ebnf_bin(GrammarBase *generalGrammar, CFLGrammar *grammar);
+
+    void ebnf_sign_replace(char sign, GrammarBase* generalGrammar, CFLGrammar *grammar);
+
+    int ebnf_bracket_match(Production& prod, int i, CFLGrammar *grammar) ;
+
+    Production strTrans(std::string strPro, CFLGrammar *grammar);
+
+    int check_head(Map<Symbol, Productions>& grammar, Production& rule);
+
+};
+
+} // End namespace SVF
+
+#endif /* CFGNormalizer_H_*/

package/SVF-linux/include/CFL/CFLAlias.h

@@ -0,0 +1,124 @@
+//===----- CFLAlias.h -- CFL Alias Analysis 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 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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * CFLAlias.h
+ *
+ *  Created on: March 5, 2022
+ *      Author: Yulei Sui
+ */
+
+
+#include "CFL/CFLSolver.h"
+#include "CFL/CFGNormalizer.h"
+#include "CFL/GrammarBuilder.h"
+#include "MemoryModel/PointerAnalysis.h"
+#include "Graphs/ConsG.h"
+#include "Util/Options.h"
+
+namespace SVF{
+
+class CFLAlias : public PointerAnalysis{
+
+public:
+    CFLAlias(SVFIR* ir) : PointerAnalysis(ir, PointerAnalysis::CFLFICI_WPA), svfir(ir), graph(nullptr), grammar(nullptr), solver(nullptr){
+    }
+
+    /// Destructor
+    virtual ~CFLAlias(){
+        delete graph;
+        delete grammar;
+        delete solver;
+    }
+
+    /// Start Analysis here (main part of pointer analysis). 
+    virtual void analyze(){
+        PointerAnalysis::initialize();
+        GrammarBuilder * gReader = new GrammarBuilder(Options::GrammarFilename);
+        CFGNormalizer *normalizer = new CFGNormalizer();
+        
+        graph = new CFLGraph();
+        if (Options::GraphIsFromDot == false){
+            // Maybe could put in SVFIR Class 
+            // In memory Graph does not have string type label
+            Map<std::string, SVF::CFLGraph::Symbol> ConstMap =  {{"Addr",0}, {"Copy", 1},{"Store", 2},{"Load", 3},{"Gep", 4},{"Vgep", 5},{"Addrbar",6}, {"Copybar", 7},{"Storebar", 8},{"Loadbar", 9},{"Gepbar", 10},{"Vgepbar", 11}};
+            ConstraintGraph *consCG = new ConstraintGraph(svfir);
+            svfir->dump("SVFIR");
+            // Can be put in build, copy from general graph
+            graph->label2SymMap = ConstMap;
+            graph->buildBigraph(consCG);
+            graph->dump("PAG");
+            delete consCG;
+            GrammarBase *generalGrammar = gReader->build(&ConstMap);
+            grammar = normalizer->normalize(generalGrammar);
+            graph->setMap(&grammar->terminals, &grammar->nonterminals);
+        }
+        else {
+            GrammarBase *generalGrammar = gReader->build();
+            grammar = normalizer->normalize(generalGrammar);
+            graph->setMap(&grammar->terminals, &grammar->nonterminals);
+            graph->buildFromDot(Options::InputFilename);     
+        }
+        graph->startSymbol = grammar->startSymbol;
+        solver = new CFLSolver(graph, grammar);
+        solver->solve();
+        graph->dump("map");
+        PointerAnalysis::finalize();
+    }
+
+    /// Interface exposed to users of our pointer analysis, given Value infos
+    virtual AliasResult alias(const Value* v1, const Value* v2) {
+        NodeID n1 = svfir->getValueNode(v1);
+        NodeID n2 = svfir->getValueNode(v2);
+        return alias(n1,n2);
+    }
+
+    /// Interface exposed to users of our pointer analysis, given PAGNodeID
+    virtual AliasResult alias(NodeID node1, NodeID node2) {
+        /// TODO:: Fix the edge label for a reachable alias relation if it is not 1;
+        if(graph->hasEdge(graph->getGNode(node1), graph->getGNode(node2), graph->startSymbol))
+            return AliasResult::MayAlias;
+        else
+            return AliasResult::NoAlias;
+    }
+
+    /// Get points-to targets of a pointer.
+    virtual const PointsTo& getPts(NodeID ptr) {
+        /// Check Outgoing edge Dst of ptr
+        //PointsTo * ps;
+        abort(); // to be implemented
+    }
+
+    /// Given an object, get all the nodes having whose pointsto contains the object
+    virtual const NodeSet& getRevPts(NodeID nodeId) {
+        /// Check Outgoing flowtobar edge dst of ptr
+        abort(); // to be implemented
+    }
+
+private:
+    SVFIR* svfir;
+    CFLGraph* graph;
+    CFLGrammar* grammar;
+    CFLSolver *solver;
+};
+
+}

package/SVF-linux/include/CFL/CFLGrammar.h

@@ -0,0 +1,127 @@
+//===----- CFLGrammar.h -- Context-free grammar --------------------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * CFLGrammar.h
+ *
+ *  Created on: March 5, 2022
+ *      Author: Yulei Sui
+ */
+#ifndef CFLGrammar_H_
+#define CFLGrammar_H_  
+#include "Util/BasicTypes.h"
+
+namespace SVF{
+
+class GrammarBase{
+public:
+    typedef u32_t Symbol;
+    typedef std::vector<Symbol> Production;
+    typedef Set<Production> Productions;
+    Map<std::string, Symbol> terminals;
+    Map<std::string, Symbol> nonterminals;
+
+    Symbol str2Sym(std::string str) const;
+    
+    std::string sym2Str(Symbol sym) const;
+
+    Symbol getSymbol(const Production& prod, u32_t pos){
+        return prod.at(pos);
+    }
+
+    Symbol insertTerminalSymbol(std::string strLit);
+    Symbol insertNonTerminalSymbol(std::string strLit);
+
+    Symbol startSymbol;
+    Symbol totalSymbol;
+    Map<Symbol, Productions> rawProductions;
+};
+
+class CFLGrammar : public GrammarBase{
+
+public:
+    Set<Production > epsilonProds;
+    Map<Symbol, Productions> singleRHS2Prods;
+    Map<Symbol, Productions> firstRHS2Prods;
+    Map<Symbol, Productions> secondRHS2Prods;
+    Symbol newTerminalSubscript;
+    CFLGrammar();
+
+    const Productions& getEpsilonProds() const{
+        return epsilonProds;
+    }
+
+    const bool hasProdsFromFirstRHS(Symbol sym) const{
+        auto it = firstRHS2Prods.find(sym);
+        return it!=firstRHS2Prods.end();
+    }
+
+    const bool hasProdsFromSingleRHS(Symbol sym) const{
+        auto it = singleRHS2Prods.find(sym);
+        return it!=singleRHS2Prods.end();
+    }
+
+    const bool hasProdsFromSecondRHS(Symbol sym) const{
+        auto it = secondRHS2Prods.find(sym);
+        return it!=secondRHS2Prods.end();
+    }
+
+    const Productions& getProdsFromSingleRHS(Symbol sym) const{
+        auto it = singleRHS2Prods.find(sym);
+        assert(it!=singleRHS2Prods.end() && "production (X -> sym) not found for sym!!");
+        return it->second;
+    }
+
+    const Productions& getProdsFromFirstRHS(Symbol sym) const{
+        auto it = firstRHS2Prods.find(sym);
+        assert(it!=firstRHS2Prods.end() && "production (X -> sym Y) not found for sym!!");
+        return it->second;
+    }
+
+    const Productions& getProdsFromSecondRHS(Symbol sym) const{
+        auto it = secondRHS2Prods.find(sym);
+        assert(it!=secondRHS2Prods.end() && "production (X -> Y sym) not found for sym!!");
+        return it->second;
+    }
+
+    Symbol getLHSSymbol(const Production& prod){
+        return prod.at(0);
+    }
+
+    Symbol getFirstRHSSymbol(const Production& prod){
+        return prod.at(1);
+    }
+
+    Symbol getSecondRHSSymbol(const Production& prod){
+        return prod.at(2);
+    }
+
+    inline int num_generator()
+    {
+        return newTerminalSubscript++;
+    }
+
+};
+
+
+}
+#endif /* CFLGrammar_H_ */

package/SVF-linux/include/CFL/CFLSolver.h

@@ -0,0 +1,94 @@
+//===----- 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 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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * CFLSolver.h
+ *
+ *  Created on: March 5, 2022
+ *      Author: Yulei Sui
+ */
+
+#include "Graphs/CFLGraph.h"
+#include "CFL/CFLGrammar.h"
+#include "Util/WorkList.h"
+
+
+namespace SVF{
+
+class CFLSolver{
+
+public:
+    /// Define worklist
+    typedef FIFOWorkList<const CFLEdge*> WorkList;
+    typedef CFLGrammar::Production Production;
+    typedef CFLGrammar::Symbol Symbol;
+
+    CFLSolver(CFLGraph* _graph, CFLGrammar* _grammar): graph(_graph), grammar(_grammar)
+    {
+    }
+
+    ~CFLSolver()
+    {
+    }
+
+    /// Start solving
+    void solve();
+
+    /// Return CFL Graph
+    inline const CFLGraph* getGraph() const {
+        return graph;
+    }
+
+    /// Return CFL Grammar
+    inline const CFLGrammar* getGrammar() const {
+        return grammar;
+    }
+
+protected:
+    /// Worklist operations
+    //@{
+    inline const CFLEdge* popFromWorklist()
+    {
+        return worklist.pop();
+    }
+    inline bool pushIntoWorklist(const CFLEdge* item)
+    {
+        return worklist.push(item);
+    }
+    inline bool isWorklistEmpty()
+    {
+        return worklist.empty();
+    }
+    inline bool isInWorklist(const CFLEdge* item)
+    {
+        return worklist.find(item);
+    }
+    //@}
+
+private: 
+    CFLGraph* graph;
+    CFLGrammar* grammar;
+    /// Worklist for resolution
+    WorkList worklist;
+};
+
+}

package/SVF-linux/include/CFL/GrammarBuilder.h

@@ -0,0 +1,65 @@
+//===----- CFGNormalizer.h -- CFL Alias Analysis 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 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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * GrammarBuilder.h
+ *
+ *  Created on: April 26, 2022
+ *      Author: Pei Xu
+ */
+
+
+#include "CFL/CFLGrammar.h"
+#include "Graphs/CFLGraph.h"
+
+namespace SVF{
+
+/*!
+ * Build Grammar from a user specified grammar text
+ * Input Format:
+ *      Start:              // Special string 'epsilon' for empty RHS
+ *      M                   // Specify Start Symbol in Second Line 
+ *      Productions:        // Each Symbol seperate 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, Seperate by '->'
+ *      V -> ( M ? abar ) * M ? ( a M ? ) *;    // Support '(' ')' '?' '*' four regular expression sign
+ * Note:
+ *      When provide EBNF form text (i.e Last production above),
+ *      Please specify -ebnf flag, otherwise regular experssion sign will treat as NonTerminal. 
+ */
+
+class GrammarBuilder{
+public:
+    std::string fileName;
+    GrammarBase *grammar;
+
+    GrammarBuilder(std::string fileName): fileName(fileName), grammar(nullptr){
+        grammar = new GrammarBase();
+    };
+
+    GrammarBase* build(); 
+
+    GrammarBase* build(Map<std::string, SVF::CFLGraph::Symbol> *preMap);
+};
+
+} // SVF 

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

package/package.json

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