svf-tools 1.0.752 → 1.0.754

package/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/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/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/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/svf/lib/CFL/CFGNormalizer.cpp

@@ -39,9 +39,9 @@
 
 using namespace SVF;
 
-CFLGrammar* CFGNormalizer::normalize(GrammarBase *generalGrammar)
+CFGrammar* CFGNormalizer::normalize(GrammarBase *generalGrammar)
 {
-    CFLGrammar *grammar = new CFLGrammar();
+    CFGrammar *grammar = new CFGrammar();
     grammar->setStartKind(generalGrammar->getStartKind());
     grammar->setTerminals(generalGrammar->getTerminals());
     grammar->setNonterminals(generalGrammar->getNonterminals());
@@ -59,7 +59,7 @@ CFLGrammar* CFGNormalizer::normalize(GrammarBase *generalGrammar)
 }
 
 
-CFLGrammar* CFGNormalizer::fillAttribute(CFLGrammar *grammar, const Map<CFLGrammar::Kind, Set<CFLGrammar::Attribute>>& kindToAttrsMap)
+CFGrammar* CFGNormalizer::fillAttribute(CFGrammar *grammar, const Map<CFGrammar::Kind, Set<CFGrammar::Attribute>>& kindToAttrsMap)
 {
     NodeSet nodeSet = {};
     for (auto pair: kindToAttrsMap)
@@ -89,7 +89,7 @@ CFLGrammar* CFGNormalizer::fillAttribute(CFLGrammar *grammar, const Map<CFLGramm
     return grammar;
 }
 
-void CFGNormalizer::ebnf_bin(CFLGrammar *grammar)
+void CFGNormalizer::ebnf_bin(CFGrammar *grammar)
 {
     GrammarBase::SymbolMap<GrammarBase::Symbol, GrammarBase::Productions> new_grammar = {};
     std::string tempStr = "";
@@ -221,7 +221,7 @@ void CFGNormalizer::ebnf_bin(CFLGrammar *grammar)
 ///and expand to productions set
 ///e.g Xi -> Y Zi with Xi i = 0, 1, Yi i = 0,2
 ///Will get {X0 -> Y Z0, X1 -> Y Z1, X2 -> Y Z2}
-void CFGNormalizer::getFilledProductions(GrammarBase::Production &prod, const NodeSet& nodeSet, CFLGrammar *grammar,  GrammarBase::Productions& normalProds)
+void CFGNormalizer::getFilledProductions(GrammarBase::Production &prod, const NodeSet& nodeSet, CFGrammar *grammar,  GrammarBase::Productions& normalProds)
 {
     normalProds.clear();
     CFLFIFOWorkList<GrammarBase::Production> worklist;
@@ -279,7 +279,7 @@ void CFGNormalizer::getFilledProductions(GrammarBase::Production &prod, const No
     }
 }
 
-int CFGNormalizer::ebnfBracketMatch(GrammarBase::Production &prod, int i, CFLGrammar *grammar)
+int CFGNormalizer::ebnfBracketMatch(GrammarBase::Production &prod, int i, CFGrammar *grammar)
 {
     int index = i;
     while (index >= 0)
@@ -293,7 +293,7 @@ int CFGNormalizer::ebnfBracketMatch(GrammarBase::Production &prod, int i, CFLGra
     return 0;
 }
 
-void CFGNormalizer::barReplace(CFLGrammar *grammar)
+void CFGNormalizer::barReplace(CFGrammar *grammar)
 {
     for (auto &symbolToProductionsPair : grammar->getRawProductions())
     {
@@ -323,7 +323,7 @@ void CFGNormalizer::barReplace(CFLGrammar *grammar)
     }
 }
 
-void CFGNormalizer::ebnfSignReplace(char sign, CFLGrammar *grammar)
+void CFGNormalizer::ebnfSignReplace(char sign, CFGrammar *grammar)
 {
     /// Replace Sign Group With tempNonterminal 'X'
     /// And load the replace in newProductions
@@ -435,7 +435,7 @@ void CFGNormalizer::ebnfSignReplace(char sign, CFLGrammar *grammar)
     }
 }
 
-void CFGNormalizer::strTrans(std::string LHS, CFLGrammar *grammar, GrammarBase::Production& normalProd)
+void CFGNormalizer::strTrans(std::string LHS, CFGrammar *grammar, GrammarBase::Production& normalProd)
 {
     std::smatch matches;
     std::regex LHSReg("\\s*(.*)");
@@ -471,7 +471,7 @@ GrammarBase::Symbol CFGNormalizer::check_head(GrammarBase::SymbolMap<GrammarBase
 }
 
 /// Based on prod size to add on suitable member field of grammar
-void CFGNormalizer::insertToCFLGrammar(CFLGrammar *grammar, GrammarBase::Production &prod)
+void CFGNormalizer::insertToCFLGrammar(CFGrammar *grammar, GrammarBase::Production &prod)
 {
     if (prod.size() == 2)
     {
@@ -494,7 +494,7 @@ void CFGNormalizer::insertToCFLGrammar(CFLGrammar *grammar, GrammarBase::Product
     }
 }
 
-void CFGNormalizer::removeFirstSymbol(CFLGrammar *grammar)
+void CFGNormalizer::removeFirstSymbol(CFGrammar *grammar)
 {
     // Remove First Terminal
     for(auto head : grammar->getRawProductions())

package/svf/lib/CFL/{CFLGrammar.cpp → CFGrammar.cpp}

@@ -1,4 +1,4 @@
-//===----- CFLGrammar.cpp -- Context-free grammar --------------------------//
+//===----- CFGrammar.cpp -- Context-free grammar --------------------------//
 //
 //                     SVF: Static Value-Flow Analysis
 //
@@ -21,13 +21,13 @@
 //===----------------------------------------------------------------------===//
 
 /*
- * CFLGrammar.cpp
+ * CFGrammar.cpp
  *
  *  Created on: March 5, 2022
  *      Author: Yulei Sui
  */
 
-#include "CFL/CFLGrammar.h"
+#include "CFL/CFGrammar.h"
 #include "Util/SVFUtil.h"
 #include <string>
 #include <iostream>
@@ -333,22 +333,22 @@ void GrammarBase::insertAttribute(Kind kind, Attribute attribute)
     }
     else
     {
-        Set<CFLGrammar::Attribute> attrs {attribute};
+        Set<CFGrammar::Attribute> attrs {attribute};
         kindToAttrsMap.insert(make_pair(kind, attrs));
     }
 }
 
-CFLGrammar::CFLGrammar()
+CFGrammar::CFGrammar()
 {
     newTerminalSubscript = 0;
 }
 
-void CFLGrammar::dump() const
+void CFGrammar::dump() const
 {
     dump("Normailized_Grammar.txt");
 }
 
-void CFLGrammar::dump(std::string fileName) const
+void CFGrammar::dump(std::string fileName) const
 {
     std::ofstream gramFile(fileName);
     gramFile << "Start Kind:\n";

package/svf/lib/CFL/CFLBase.cpp

@@ -50,12 +50,13 @@ void CFLBase::checkParameter()
 {
     // Check for valid grammar file before parsing other options
     std::string filename = Options::GrammarFilename();
-    bool cflfile = (filename.rfind("CFLGrammar.txt") == filename.length() - std::string("CFLGrammar.txt").length());
+    bool pagfile = (filename.rfind("PAGGrammar.txt") == filename.length() - std::string("PAGGrammar.txt").length());
     bool pegfile = (filename.rfind("PEGGrammar.txt") == filename.length() - std::string("PEGGrammar.txt").length());
-    if (!Options::Customized()  && !(cflfile || pegfile))
+    bool vfgfile = (filename.rfind("VFGGrammar.txt") == filename.length() - std::string("VFGGrammar.txt").length());
+    if (!Options::Customized()  && !(pagfile || pegfile || vfgfile))
     {
         SVFUtil::errs() << "Invalid alias grammar file: " << Options::GrammarFilename() << "\n"
-                        << "Please use a file that ends with either 'CFLGrammar.txt' or 'PEGGrammar.txt', "
+                        << "Please use a file that ends with either 'CFGrammar.txt' or 'PEGGrammar.txt', "
                         << "or use the -customized flag to allow custom grammar files.\n";
         assert(false && "grammar loading failed!");  // exit with error
     }
@@ -91,14 +92,7 @@ void CFLBase::buildCFLGraph()
         delete consCG;
     }
     else
-    {
-        std::string fileName = Options::CFLGraph();
-        bool dotfile = (fileName.rfind(".dot") == fileName.length() - std::string("dot").length());
-        if (dotfile)
-            graph = cflGraphBuilder.buildFromDot(Options::CFLGraph(), grammarBase);
-        else
-            graph = cflGraphBuilder.buildFromTextFile(Options::CFLGraph(), grammarBase);
-    }
+        graph = cflGraphBuilder.build(Options::CFLGraph(), grammarBase);
     // Check CFL Graph and Grammar are accordance with grammar
     CFLGramGraphChecker cflChecker = CFLGramGraphChecker();
     cflChecker.check(grammarBase, &cflGraphBuilder, graph);