svf-lib 1.0.1613 → 1.0.1614

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

@@ -30,7 +30,7 @@
 #ifndef INCLUDE_CFL_CFGNORMALIZER_H_
 #define INCLUDE_CFL_CFGNORMALIZER_H_
 
-#include "CFLGrammar.h"
+#include "CFGrammar.h"
 
 namespace SVF
 {
@@ -53,30 +53,30 @@ public:
     }
 
     /// Binary Normal Form(BNF) normalization with variable attribute expanded
-    CFLGrammar* normalize(GrammarBase *generalGrammar);
+    CFGrammar* normalize(GrammarBase *generalGrammar);
 
     /// Expand every variable attribute in rawProductions of grammarbase
-    CFLGrammar* fillAttribute(CFLGrammar *grammar, const Map<CFLGrammar::Kind, Set<CFLGrammar::Attribute>>& kindToAttrsMap);
+    CFGrammar* fillAttribute(CFGrammar *grammar, const Map<CFGrammar::Kind, Set<CFGrammar::Attribute>>& kindToAttrsMap);
 
 private:
     /// Add nonterminal to tranfer long rules to binary rules
-    void ebnf_bin(CFLGrammar *grammar);
+    void ebnf_bin(CFGrammar *grammar);
 
-    void ebnfSignReplace(char sign, CFLGrammar *grammar);
+    void ebnfSignReplace(char sign, CFGrammar *grammar);
 
-    void barReplace(CFLGrammar *grammar);
+    void barReplace(CFGrammar *grammar);
 
-    void insertToCFLGrammar(CFLGrammar *grammar, GrammarBase::Production &prod);
+    void insertToCFLGrammar(CFGrammar *grammar, GrammarBase::Production &prod);
 
-    int ebnfBracketMatch(GrammarBase::Production& prod, int i, CFLGrammar *grammar) ;
+    int ebnfBracketMatch(GrammarBase::Production& prod, int i, CFGrammar *grammar) ;
 
     GrammarBase::Symbol check_head(GrammarBase::SymbolMap<GrammarBase::Symbol, GrammarBase::Productions>& grammar, GrammarBase::Production& rule);
 
-    void strTrans(std::string strPro, CFLGrammar *grammar, GrammarBase::Production& normalProd);
+    void strTrans(std::string strPro, CFGrammar *grammar, GrammarBase::Production& normalProd);
 
-    void getFilledProductions(GrammarBase::Production &prod,const NodeSet& nodeSet, CFLGrammar *grammar, GrammarBase::Productions& normalProds);
+    void getFilledProductions(GrammarBase::Production &prod,const NodeSet& nodeSet, CFGrammar *grammar, GrammarBase::Productions& normalProds);
 
-    void removeFirstSymbol(CFLGrammar *grammar);
+    void removeFirstSymbol(CFGrammar *grammar);
 };
 
 } // End namespace SVF

package/SVF-linux/svf/include/CFL/CFGrammar.h

@@ -0,0 +1,468 @@
+//===----- CFGrammar.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 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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * CFGrammar.h
+ *
+ *  Created on: March 5, 2022
+ *      Author: Yulei Sui
+ */
+#ifndef CFLGrammar_H_
+#define CFLGrammar_H_
+#include "SVFIR/SVFType.h"
+
+namespace SVF
+{
+
+class GrammarBase
+{
+public:
+    typedef u32_t Kind;
+    typedef u32_t Attribute;
+    typedef u32_t VariableAttribute;
+    typedef struct Symbol
+    {
+        Kind kind: 8;
+        Attribute attribute: 16;
+        VariableAttribute variableAttribute: 8;
+
+        /// Default Value for Symbol is 0.
+        Symbol() : kind(0), attribute(0), variableAttribute(0) {}
+
+        /// Contruct from u32_t move the bit to right field
+        Symbol(const u32_t& num) : kind(num & 0xFF), attribute((num >> 8 ) & 0xFFFF), variableAttribute((num >> 24)) {}
+
+        /// Conversion of u32_t
+        operator u32_t()
+        {
+            static_assert(sizeof(struct Symbol)==sizeof(u32_t), "sizeof(struct Symbol)!=sizeof(u32_t)");
+            u32_t num = 0;
+            num += this->variableAttribute << 24;
+            num += this->attribute << 8;
+            num += this->kind;
+            return num;
+        }
+
+        operator u32_t() const
+        {
+            static_assert(sizeof(struct Symbol)==sizeof(u32_t), "sizeof(struct Symbol)!=sizeof(u32_t)");
+            u32_t num = 0;
+            num += this->variableAttribute << 24;
+            num += this->attribute << 8;
+            num += this->kind;
+            return num;
+        }
+
+        bool operator<(const Symbol& rhs)
+        {
+            return u32_t(*this) < u32_t(rhs);
+        }
+
+        void operator=(const u32_t& i)
+        {
+            this->kind = EdgeKindMask & i;
+            this->attribute = i >> EdgeKindMaskBits;
+            this->variableAttribute = i >> AttributedKindMaskBits;
+        }
+
+        void operator=(unsigned long long num)
+        {
+            this->kind = num & 0xFF;
+            this->attribute = (num >> 8 ) & 0xFFFF;
+            this->variableAttribute = num >> 24;
+        }
+
+        bool operator==(const Symbol& s)
+        {
+            return ((this->kind == s.kind) && (this->attribute == s.attribute) && (this->variableAttribute == s.variableAttribute));
+        }
+
+        bool operator==(const Symbol& s) const
+        {
+            return ((kind == s.kind) && (attribute == s.attribute) && (variableAttribute == s.variableAttribute));
+        }
+
+        bool operator!=(const Symbol& s) const
+        {
+            return ! (*this == s) ;
+        }
+
+        bool operator==(const u32_t& i)
+        {
+            return  u32_t(*this) == u32_t(i);
+        }
+
+        bool operator==(const Kind& k) const
+        {
+            return (this->kind == k);
+        }
+    } Symbol;
+
+    class SymbolHash
+    {
+    public:
+        size_t operator()(const Symbol &s) const
+        {
+            std::hash<u32_t> h;
+            return h(u32_t(s));
+        }
+    };
+
+
+    struct SymbolVectorHash
+    {
+        size_t operator()(const std::vector<Symbol> &v) const
+        {
+            size_t h = v.size();
+
+            SymbolHash hf;
+            for (const Symbol &t : v)
+            {
+                h ^= hf(t) + 0x9e3779b9 + (h << 6) + (h >> 2);
+            }
+
+            return h;
+        }
+    };
+
+    template<typename Key, typename Value, typename Hash = SymbolHash,
+             typename KeyEqual = std::equal_to<Key>,
+             typename Allocator = std::allocator<std::pair<const Key, Value>>>
+                     using SymbolMap = std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>;
+
+             template <typename Key, typename Hash = SymbolVectorHash, typename KeyEqual = std::equal_to<Key>,
+                       typename Allocator = std::allocator<Key>>
+             using SymbolSet = std::unordered_set<Key, Hash, KeyEqual, Allocator>;
+
+             typedef std::vector<Symbol> Production;
+             typedef SymbolSet<Production> Productions;
+
+
+             inline Map<std::string, Kind>& getNonterminals()
+    {
+        return this->nonterminals;
+    }
+
+    inline void setNonterminals(Map<std::string, Kind>& nonterminals)
+    {
+        this->nonterminals = nonterminals;
+    }
+
+    inline Map<std::string, Kind>& getTerminals()
+    {
+        return this->terminals;
+    }
+
+    inline void setTerminals(Map<std::string, Kind>& terminals)
+    {
+        this->terminals = terminals;
+    }
+
+    inline Map<std::string, Kind>& getEBNFSigns()
+    {
+        return this->EBNFSigns;
+    }
+
+    inline void setEBNFSigns(Map<std::string, Kind>& EBNFSigns)
+    {
+        this->EBNFSigns = EBNFSigns;
+    }
+
+    inline SymbolMap<Symbol, Productions>& getRawProductions()
+    {
+        return this->rawProductions;
+    }
+
+    inline const Map<Kind,  Set<Attribute>>& getKindToAttrsMap() const
+    {
+        return this->kindToAttrsMap;
+    }
+
+    inline Kind getTotalKind()
+    {
+        return this->totalKind;
+    }
+
+    inline Kind getStartKind()
+    {
+        return this->startKind;
+    }
+
+    inline void setStartKind(Kind startKind)
+    {
+        this->startKind = startKind;
+    }
+
+    inline void setTotalKind(Kind totalKind)
+    {
+        this->totalKind = totalKind;
+    }
+
+    std::string extractKindStrFromSymbolStr(const std::string& symbolStr) const;
+
+    std::string extractAttributeStrFromSymbolStr(const std::string& symbolStr) const;
+
+    void setRawProductions(SymbolMap<Symbol, Productions>& rawProductions);
+
+    void setKindToAttrsMap(const Map<Kind,  Set<Attribute>>& kindToAttrsMap);
+
+    void setAttributeKinds(const Set<Kind>& attributeKind);
+
+    Kind strToKind(std::string str) const;
+
+    Symbol strToSymbol(const std::string str) const;
+
+    std::string kindToStr(Kind kind) const;
+
+    std::string symToStrDump(Symbol sym) const;
+
+    Symbol getSymbol(const Production& prod, u32_t pos)
+    {
+        return prod.at(pos);
+    }
+
+    inline const Set<Kind>& getAttrSyms() const
+    {
+        return this->attributeKinds;
+    }
+
+    /// Insert kind to nonterminal and return kind.
+    Kind insertNonterminalKind(std::string const kindStr);
+
+    /// From SymbolStr extract kind to inserted in nonterminal
+    /// symbolStr = <kindStr> [_] [ attributeStr | variableattributeStr ]
+    Kind insertTerminalKind(std::string strLit);
+
+    Symbol insertSymbol(std::string strLit);
+
+    Symbol insertNonTerminalSymbol(std::string strLit);
+
+    Symbol insertTerminalSymbol(std::string strLit);
+
+    Symbol insertEBNFSigns(std::string strLit);
+
+    void insertAttribute(Kind kind, Attribute a);
+
+    inline static Kind getAttributedKind(Attribute attribute, Kind kind)
+    {
+        return ((attribute << EdgeKindMaskBits)| kind );
+    }
+
+    inline static Kind getVariabledKind(VariableAttribute variableAttribute, Kind kind)
+    {
+        return ((variableAttribute << AttributedKindMaskBits) | kind);
+    }
+
+protected:
+    static constexpr unsigned char EdgeKindMaskBits = 8;  ///< We use the lower 8 bits to denote edge kind
+    static constexpr unsigned char AttributedKindMaskBits = 24; ///< We use the lower 24 bits to denote attributed kind
+    static constexpr u64_t EdgeKindMask = (~0ULL) >> (64 - EdgeKindMaskBits);
+    Kind startKind;
+private:
+    Map<std::string, Kind> nonterminals;
+    Map<std::string, Kind> terminals;
+    Map<std::string, Kind> EBNFSigns; /// Map contains Signs' String and associated Symbols
+    Set<Kind> attributeKinds;
+    Map<Kind,  Set<Attribute>> kindToAttrsMap;
+    SymbolMap<Symbol, Productions> rawProductions;
+    u32_t totalKind;
+};
+
+class CFGrammar : public GrammarBase
+{
+
+public:
+    CFGrammar();
+
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const CFGrammar *)
+    {
+        return true;
+    }
+
+    static inline bool classof(const GrammarBase *node)
+    {
+        return true;
+    }
+
+    Productions& getEpsilonProds()
+    {
+        return epsilonProds;
+    }
+
+    SymbolMap<Symbol, Productions>& getSingleRHSToProds()
+    {
+        return singleRHSToProds;
+    }
+
+    SymbolMap<Symbol, Productions>& getFirstRHSToProds()
+    {
+        return firstRHSToProds;
+    }
+
+    SymbolMap<Symbol, Productions>& getSecondRHSToProds()
+    {
+        return secondRHSToProds;
+    }
+
+    const bool hasProdsFromFirstRHS(const Symbol sym) const
+    {
+        auto it = firstRHSToProds.find(sym);
+        return it!=firstRHSToProds.end();
+    }
+
+    const bool hasProdsFromSingleRHS(const Symbol sym) const
+    {
+        auto it = singleRHSToProds.find(sym);
+        return it!=singleRHSToProds.end();
+    }
+
+    const bool hasProdsFromSecondRHS(const Symbol sym) const
+    {
+        auto it = secondRHSToProds.find(sym);
+        return it!=secondRHSToProds.end();
+    }
+
+    const Productions& getProdsFromSingleRHS(const Symbol sym) const
+    {
+        auto it = singleRHSToProds.find(sym);
+        assert(it!=singleRHSToProds.end() && "production (X -> sym) not found for sym!!");
+        return it->second;
+    }
+
+    const Productions& getProdsFromFirstRHS(const Symbol sym) const
+    {
+        auto it = firstRHSToProds.find(sym);
+        assert(it!=firstRHSToProds.end() && "production (X -> sym Y ) not found for sym!!");
+        return it->second;
+    }
+
+    const Productions& getProdsFromSecondRHS(const Symbol sym) const
+    {
+        auto it = secondRHSToProds.find(sym);
+        assert(it!=secondRHSToProds.end() && "production (X -> Y sym) not found for sym!!");
+        return it->second;
+    }
+
+
+    const Symbol& getLHSSymbol(const Production& prod) const
+    {
+        return prod.at(0);
+    }
+
+    const Symbol& getFirstRHSSymbol(const Production& prod) const
+    {
+        return prod.at(1);
+    }
+
+    const Symbol& getSecondRHSSymbol(const Production& prod) const
+    {
+        return prod.at(2);
+    }
+
+    void dump() const;
+
+    void dump(std::string fileName) const;
+
+
+    const inline u32_t num_generator()
+    {
+        return newTerminalSubscript++;
+    }
+
+private:
+    SymbolSet<Production> epsilonProds;
+    SymbolMap<Symbol, Productions> singleRHSToProds;
+    SymbolMap<Symbol, Productions> firstRHSToProds;
+    SymbolMap<Symbol, Productions> secondRHSToProds;
+    u32_t newTerminalSubscript;
+};
+
+/**
+ * Worklist with "first in first out" order.
+ * New nodes will be pushed at back and popped from front.
+ * Elements in the list are unique as they're recorded by Set.
+ */
+template<class Data>
+class CFLFIFOWorkList
+{
+    typedef GrammarBase::SymbolSet<Data> DataSet;
+    typedef std::deque<Data> DataDeque;
+public:
+    CFLFIFOWorkList() {}
+
+    ~CFLFIFOWorkList() {}
+
+    inline bool empty() const
+    {
+        return data_list.empty();
+    }
+
+    inline bool find(Data data) const
+    {
+        return (data_set.find(data) == data_set.end() ? false : true);
+    }
+
+    /**
+     * Push a data into the work list.
+     */
+    inline bool push(Data data)
+    {
+        if (data_set.find(data) == data_set.end())
+        {
+            data_list.push_back(data);
+            data_set.insert(data);
+            return true;
+        }
+        else
+            return false;
+    }
+
+    /**
+     * Pop a data from the END of work list.
+     */
+    inline Data pop()
+    {
+        assert(!empty() && "work list is empty");
+        Data data = data_list.front();
+        data_list.pop_front();
+        data_set.erase(data);
+        return data;
+    }
+
+    /*!
+     * Clear all the data
+     */
+    inline void clear()
+    {
+        data_list.clear();
+        data_set.clear();
+    }
+
+private:
+    DataSet data_set;	///< store all data in the work list.
+    DataDeque data_list;	///< work list using std::vector.
+};
+
+}
+#endif /* CFLGrammar_H_ */

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

@@ -112,8 +112,8 @@ public:
         {
             return false;
         }
-        CFLGrammar::Kind copyKind = grammar->strToKind("copy");
-        CFLGrammar::Kind copybarKind = grammar->strToKind("copybar");
+        CFGrammar::Kind copyKind = grammar->strToKind("copy");
+        CFGrammar::Kind copybarKind = grammar->strToKind("copybar");
         solver->pushIntoWorklist(graph->addCFLEdge(graph->getGNode(src),graph->getGNode(dst), copyKind));
         solver->pushIntoWorklist(graph->addCFLEdge(graph->getGNode(dst),graph->getGNode(src), copybarKind));
         return true;

package/SVF-linux/svf/include/CFL/CFLBase.h

@@ -92,7 +92,7 @@ public:
     //@{
     // Grammar
     static double timeOfBuildCFLGrammar;            // Time of building grammarBase from text file
-    static double timeOfNormalizeGrammar;           // Time of normalizing grammarBase to CFLGrammar
+    static double timeOfNormalizeGrammar;           // Time of normalizing grammarBase to CFGrammar
     // Graph
     static double timeOfBuildCFLGraph;              // Time of building CFLGraph
     static double numOfTerminalEdges;               // Number of terminal labeled edges
@@ -109,7 +109,7 @@ protected:
     SVFIR* svfir;
     CFLGraph* graph;
     GrammarBase* grammarBase;
-    CFLGrammar* grammar;
+    CFGrammar* grammar;
     CFLSolver* solver;
 };
 

package/SVF-linux/svf/include/CFL/CFLGramGraphChecker.h

@@ -29,7 +29,7 @@
 #ifndef INCLUDE_CFL_CFLGRAMGRAPHCHECKER_H_
 #define INCLUDE_CFL_CFLGRAMGRAPHCHECKER_H_
 
-#include "CFL/CFLGrammar.h"
+#include "CFL/CFGrammar.h"
 #include "Graphs/CFLGraph.h"
 namespace SVF
 {

package/SVF-linux/svf/include/CFL/CFLGraphBuilder.h

@@ -30,37 +30,43 @@
 #ifndef INCLUDE_CFL_CFLGRAPHBUILDER_H_
 #define INCLUDE_CFL_CFLGRAPHBUILDER_H_
 
-#include "CFL/CFLGrammar.h"
+#include "CFL/CFGrammar.h"
 #include "Graphs/CFLGraph.h"
 #include "Graphs/SVFG.h"
 
 namespace SVF
 {
 
+enum class BuildDirection
+{
+    plain,
+    bidirection,
+};
+
 /**
  * CFLGraphBuilder class is responsible for building CFL (Context-Free Language) graphs
- * from text files or dot files or from memory graph.
+ * from text files, dot files, json file or from memory graph.
  */
 class CFLGraphBuilder
 {
 protected:
-    /// Define Kind(Not contain attribute) and Symbol(May contain attribute) as types derived from CFLGrammar
+    /// Define Kind(Not contain attribute) and Symbol(May contain attribute) as types derived from CFGrammar
     /// to numerically represent label
-    typedef CFLGrammar::Kind Kind;
-    typedef CFLGrammar::Symbol Symbol;
+    typedef CFGrammar::Kind Kind;
+    typedef CFGrammar::Symbol Symbol;
 
     /// Maps to maintain mapping between labels and kinds
     Map<std::string, Kind> labelToKindMap;
     Map<Kind, std::string> kindToLabelMap;
 
     /// Map to maintain attributes associated with each kind
-    Map<CFLGrammar::Kind,  Set<CFLGrammar::Attribute>> kindToAttrsMap;
+    Map<CFGrammar::Kind,  Set<CFGrammar::Attribute>> kindToAttrsMap;
 
     Kind current;
     CFLGraph *cflGraph;
 
     /// Method to add an attribute to a specific kind
-    void addAttribute(CFLGrammar::Kind kind, CFLGrammar::Attribute attribute);
+    void addAttribute(CFGrammar::Kind kind, CFGrammar::Attribute attribute);
 
     /// build label and kind connect from the grammar
     void buildlabelToKindMap(GrammarBase *grammar);
@@ -68,80 +74,23 @@ protected:
     /// add src and dst node from file
     CFLNode* addGNode(u32_t NodeID);
 
+    /// Method to build a CFL graph from a Text file
+    CFLGraph* buildFromText(std::string fileName, GrammarBase *grammar, BuildDirection direction = BuildDirection::plain);
+
+    /// Method to build a CFL graph from a Dot file
+    CFLGraph *buildFromDot(std::string filename, GrammarBase *grammar, BuildDirection direction = BuildDirection::plain);
+
+    /// Method to build a CFL graph from a Json file
+    CFLGraph *buildFromJson(std::string filename, GrammarBase *grammar, BuildDirection direction = BuildDirection::plain);
+
 public:
     /// Method to build a CFL graph by copying nodes and edges from any graph
     /// inherited from GenericGraph
     template<class N, class E>
-    void build(GenericGraph<N,E>* graph, CFLGraph* cflGraph)
-    {
-        for(auto it = graph->begin(); it!= graph->end(); it++)
-        {
-            CFLNode* node = new CFLNode((*it).first);
-            cflGraph->addCFLNode((*it).first, node);
-        }
-        for(auto it = graph->begin(); it!= graph->end(); it++)
-        {
-            N* node = (*it).second;
-            for(E* edge : node->getOutEdges())
-            {
-                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getSrcID()), cflGraph->getGNode(edge->getDstID()), edge->getEdgeKind());
-            }
-        }
-    }
-
-    /// Method to build a bidirectional CFL graph by copying nodes and edges
-    /// from any graph inherited from GenericGraph
-    template<class N, class E>
-    CFLGraph* buildBigraph(GenericGraph<N,E>* graph, Kind startKind, GrammarBase *grammar)
-    {
-        CFLGraph *cflGraph = new CFLGraph(startKind);
-        for(auto pairV : grammar->getTerminals())
-        {
-            if(labelToKindMap.find(pairV.first) == labelToKindMap.end())
-            {
-                labelToKindMap.insert(pairV);
-            }
-            if(kindToLabelMap.find(pairV.second) == kindToLabelMap.end())
-            {
-                kindToLabelMap.insert(make_pair(pairV.second, pairV.first));
-            }
-        }
-        for(auto pairV : grammar->getNonterminals())
-        {
-            if(labelToKindMap.find(pairV.first) == labelToKindMap.end())
-            {
-                labelToKindMap.insert(pairV);
-            }
-            if(kindToLabelMap.find(pairV.second) == kindToLabelMap.end())
-            {
-                kindToLabelMap.insert(make_pair(pairV.second, pairV.first));
-            }
-        }
-        for(auto it = graph->begin(); it!= graph->end(); it++)
-        {
-            CFLNode* node = new CFLNode((*it).first);
-            cflGraph->addCFLNode((*it).first, node);
-        }
-        for(auto it = graph->begin(); it!= graph->end(); it++)
-        {
-            N* node = (*it).second;
-            for(E* edge : node->getOutEdges())
-            {
-                CFLGrammar::Kind edgeLabel = edge->getEdgeKind();
-                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getSrcID()), cflGraph->getGNode(edge->getDstID()), edgeLabel);
-                std::string key = kindToLabelMap[edge->getEdgeKind()];
-                key.append("bar");
-                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), labelToKindMap[key]);
-            }
-        }
-        return cflGraph;
-    }
-
-    /// Method to build a CFL graph from a Dot file
-    CFLGraph *buildFromDot(std::string filename, GrammarBase *grammar);
+    CFLGraph* build(GenericGraph<N,E>* graph, GrammarBase *grammar, BuildDirection direction = BuildDirection::plain);
 
-    /// Method to build a CFL graph from a Text file
-    CFLGraph* buildFromTextFile(std::string fileName, GrammarBase *grammar);
+    /// Method to build a CFL graph from external file
+    CFLGraph* build(std::string fileName, GrammarBase *grammar, BuildDirection direction = BuildDirection::plain);
 
     /// @{
     /// Getter methods for accessing class variables
@@ -159,7 +108,7 @@ public:
     }
 
     /// Returns a reference to the map that associates Kinds with their corresponding attributes
-    Map<CFLGrammar::Kind,  Set<CFLGrammar::Attribute>>& getKindToAttrsMap()
+    Map<CFGrammar::Kind,  Set<CFGrammar::Attribute>>& getKindToAttrsMap()
     {
         return this->kindToAttrsMap;
     }
@@ -183,10 +132,10 @@ private:
     void connectVGep(CFLGraph *cflGraph,  ConstraintGraph *graph, ConstraintNode *src, ConstraintNode *dst, u32_t level, SVFIR* pag);
 
     /// Handles edges, with the exception of the GEP
-    void addBiCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFLGrammar::Kind label);
+    void addBiCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFGrammar::Kind label);
 
     /// Adds bidirectional GEP edges with attributes
-    void addBiGepCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFLGrammar::Attribute attri);
+    void addBiGepCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFGrammar::Attribute attri);
 };
 
 /// VFCFLGraphBuilder: a CFLGraphBuilder specialized for handling value-flow
@@ -205,10 +154,10 @@ private:
     void connectVGep(CFLGraph *cflGraph,  ConstraintGraph *graph, ConstraintNode *src, ConstraintNode *dst, u32_t level, SVFIR* pag);
 
     /// Handles edges, with the exception of the GEP
-    void addBiCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFLGrammar::Kind label);
+    void addBiCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFGrammar::Kind label);
 
     /// Adds bidirectional GEP edges with attributes
-    void addBiGepCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFLGrammar::Attribute attri);
+    void addBiGepCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFGrammar::Attribute attri);
 };
 
 

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

@@ -31,7 +31,7 @@
 #define INCLUDE_CFL_CFLSolver_H_
 
 #include "Graphs/CFLGraph.h"
-#include "CFL/CFLGrammar.h"
+#include "CFL/CFGrammar.h"
 #include "Util/WorkList.h"
 
 using namespace std;
@@ -46,12 +46,12 @@ class CFLSolver
 public:
     /// Define worklist
     typedef FIFOWorkList<const CFLEdge*> WorkList;
-    typedef CFLGrammar::Production Production;
-    typedef CFLGrammar::Symbol Symbol;
+    typedef CFGrammar::Production Production;
+    typedef CFGrammar::Symbol Symbol;
 
     static double numOfChecks;
 
-    CFLSolver(CFLGraph* _graph, CFLGrammar* _grammar): graph(_graph), grammar(_grammar)
+    CFLSolver(CFLGraph* _graph, CFGrammar* _grammar): graph(_graph), grammar(_grammar)
     {
     }
 
@@ -77,7 +77,7 @@ public:
     }
 
     /// Return CFL Grammar
-    inline const CFLGrammar* getGrammar() const
+    inline const CFGrammar* getGrammar() const
     {
         return grammar;
     }
@@ -106,7 +106,7 @@ protected:
 
 protected:
     CFLGraph* graph;
-    CFLGrammar* grammar;
+    CFGrammar* grammar;
     /// Worklist for resolution
     WorkList worklist;
 
@@ -266,7 +266,7 @@ public:
     }
     //@}
 
-    POCRSolver(CFLGraph* _graph, CFLGrammar* _grammar) : CFLSolver(_graph, _grammar)
+    POCRSolver(CFLGraph* _graph, CFGrammar* _grammar) : CFLSolver(_graph, _grammar)
     {
         buildCFLData();
     }
@@ -344,7 +344,7 @@ public:
     void meld_h(NodeID x, TreeNode* uNode, TreeNode* vNode);
 //@}
 public:
-    POCRHybridSolver(CFLGraph* _graph, CFLGrammar* _grammar) : POCRSolver(_graph, _grammar)
+    POCRHybridSolver(CFLGraph* _graph, CFGrammar* _grammar) : POCRSolver(_graph, _grammar)
     {
     }
     /// Destructor

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

@@ -30,7 +30,7 @@
 #ifndef INCLUDE_CFL_GRAMMARBUILDER_H_
 #define INCLUDE_CFL_GRAMMARBUILDER_H_
 
-#include "CFL/CFLGrammar.h"
+#include "CFL/CFGrammar.h"
 
 namespace SVF
 {

package/SVF-linux/svf/include/CFL/grammar/PAGGrammar.txt

@@ -0,0 +1,15 @@
+Start:  
+   V
+Terminal:
+   addr copy store load gep vgep 
+Productions:
+   F -> epsilon | F copy | addr Memflow | F store V load | store Memflow load | F F;
+   Fbar -> epsilon | copybar Fbar | Memflowbar addrbar | loadbar V storebar Fbar | loadbar Memflowbar storebar;
+   V -> Fbar V F | addrbar addr | gepbar_i V gep_i | gepbarpath V gep_0 | gepbar_i F gep_i | gepbar_i Fbar gep_i;
+   copy -> vgep;
+   copybar -> vgepbar;
+   gep_1 -> gep_0 F vgep | gep_0 F gep_1;
+   gepbar_1 -> gepbar_1 Fbar gepbar_0 | vgepbar Fbar gepbar_0;
+   gepbarpath -> gepbar_0 gepbar_0 | gepbarpath gepbar_0;
+   Memflow -> load store | Fbar Memflow | F Memflow Fbar | gep_i Memflow gepbar_i | gepbar_i Memflow gep_i;
+   Memflowbar -> storebar loadbar | Memflowbar F | F Memflowbar Fbar | gep_i Memflowbar gepbar_i | gepbar_i Memflowbar gep_i;

package/SVF-linux/svf/include/CFL/grammar/PEGGrammar.txt

@@ -0,0 +1,11 @@
+Start:  
+   V
+Terminal:
+   addr copy store load gep
+Productions:
+   F -> ( copy M ? ) *;
+   Fbar -> ( M ? copybar ) *;
+   M -> addr V addrbar;
+   V -> Fbar V F | gepbar_i V gep_i | M | epsilon | gepbar_i Memcpy gep_i | gep_i Memcpy gepbar_i | ArrayPath V gep_0;
+   ArrayPath -> gepbar_0 gepbar_0 | ArrayPath gepbar_0;
+   Memcpy -> addrbar V addr | gep_i Memcpy gepbar_i | F Memcpy Fbar;

package/SVF-linux/svf/include/CFL/grammar/VFGGrammar.txt

@@ -0,0 +1,7 @@
+Start:  
+   A
+Terminal:
+   a call ret
+Productions:
+   A -> A A | a | call_i A ret_i | epsilon;
+   Abar -> Abar Abar | abar | retbar_i Abar callbar_i | epsilon; 

package/SVF-linux/svf/include/Graphs/CFLGraph.h

@@ -34,7 +34,7 @@
 #include <iostream>
 #include <string>
 #include <regex>
-#include "CFL/CFLGrammar.h"
+#include "CFL/CFGrammar.h"
 #include "Graphs/GenericGraph.h"
 #include "Graphs/ConsG.h"
 
@@ -155,8 +155,8 @@ typedef GenericGraph<CFLNode,CFLEdge> GenericCFLGraphTy;
 class CFLGraph: public GenericCFLGraphTy
 {
 public:
-    typedef CFLGrammar::Symbol Symbol;
-    typedef CFLGrammar::Kind Kind;
+    typedef CFGrammar::Symbol Symbol;
+    typedef CFGrammar::Kind Kind;
     typedef GenericNode<CFLNode,CFLEdge>::GEdgeSetTy CFLEdgeSet;
     Kind startKind;
 

package/package.json

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