svf-lib 1.0.1004 → 1.0.1007

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

@@ -53,19 +53,30 @@ public:
 
     /// Start Normalize (BIN Only)
     // TODO: Add different Combination Transformation Option
+
+    /// Normalization without attribute expanded
     CFLGrammar* normalize(GrammarBase *generalGrammar);
-private:
 
+    /// Fill Every attribute in CFL grammar
+    CFLGrammar* fillAttribute(CFLGrammar *grammar, Map<CFLGrammar::Kind, Set<CFLGrammar::Attribute>> *kind2AttrMap);
+
+private:
+    /// Add nonterminal to tranfer long rules to binary rules
     void ebnf_bin(GrammarBase *generalGrammar, CFLGrammar *grammar);
 
     void ebnf_sign_replace(char sign, GrammarBase* generalGrammar, CFLGrammar *grammar);
 
+    void insertToCFLGrammar(CFLGrammar *grammar, Production &prod);
+
     int ebnf_bracket_match(Production& prod, int i, CFLGrammar *grammar) ;
 
+    int check_head(Map<Symbol, Productions>& grammar, Production& rule);
+
     Production strTrans(std::string strPro, CFLGrammar *grammar);
 
-    int check_head(Map<Symbol, Productions>& grammar, Production& rule);
+    Production getFilledProd(Production &prod, CFLGrammar::Attribute attribute, CFLGrammar *grammar);
 
+    Productions getFilledProductions(Production &prod, Map<CFLGrammar::Kind,  Set<CFLGrammar::Attribute>> *kind2AttriMap, CFLGrammar *grammar);
 };
 
 } // End namespace SVF

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

@@ -31,6 +31,8 @@
 #include "CFL/CFLSolver.h"
 #include "CFL/CFGNormalizer.h"
 #include "CFL/GrammarBuilder.h"
+#include "CFL/CFLGraphBuilder.h"
+#include "CFL/CFLGramGraphChecker.h"
 #include "MemoryModel/PointerAnalysis.h"
 #include "Graphs/ConsG.h"
 #include "Util/Options.h"
@@ -57,39 +59,40 @@ public:
     /// 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();
+        GrammarBuilder gReader = GrammarBuilder(Options::GrammarFilename);
+        CFGNormalizer normalizer = CFGNormalizer();
+        CFLGraphBuilder cflGraphBuilder = CFLGraphBuilder();
+        CFLGramGraphChecker cflChecker = CFLGramGraphChecker();
+        /// Assume Read From Const Graph, associate label symbol is hard coded
         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}};
+            PointerAnalysis::initialize();
+            Map<std::string, SVF::CFLGraph::Symbol> ConstMap =  {{"Addr",0}, {"Copy", 1},{"Store", 2},{"Load", 3},{"Gep_i", 4},{"Vgep", 5},{"Addrbar",6}, {"Copybar", 7},{"Storebar", 8},{"Loadbar", 9},{"Gepbar_i", 10},{"Vgepbar", 11}};
+            GrammarBase *generalGrammar = gReader.build(ConstMap);
             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");
+            graph = cflGraphBuilder.buildBigraph(consCG);
+            cflChecker.check(generalGrammar, graph);
+            grammar = normalizer.normalize(generalGrammar);
+            cflChecker.check(grammar, graph);
             delete consCG;
-            GrammarBase *generalGrammar = gReader->build(&ConstMap);
-            grammar = normalizer->normalize(generalGrammar);
-            graph->setMap(&grammar->terminals, &grammar->nonterminals);
+            delete generalGrammar;
+            grammar->dump();
         }
         else
         {
-            GrammarBase *generalGrammar = gReader->build();
-            grammar = normalizer->normalize(generalGrammar);
-            graph->setMap(&grammar->terminals, &grammar->nonterminals);
-            graph->buildFromDot(Options::InputFilename);
+            GrammarBase *generalGrammar = gReader.build();
+            graph = cflGraphBuilder.buildFromDot(Options::InputFilename, generalGrammar);
+            cflChecker.check(generalGrammar, graph);
+            grammar = normalizer.normalize(generalGrammar);
+            cflChecker.check(grammar, graph);
+            delete generalGrammar;
         }
-        graph->startSymbol = grammar->startSymbol;
         solver = new CFLSolver(graph, grammar);
         solver->solve();
-        graph->dump("map");
-        PointerAnalysis::finalize();
+        if (Options::GraphIsFromDot == false)
+        {
+            PointerAnalysis::finalize();
+        }
     }
 
     /// Interface exposed to users of our pointer analysis, given Value infos
@@ -103,7 +106,6 @@ public:
     /// 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

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

@@ -0,0 +1,64 @@
+//===----- CFLGramGraphChecker.h -- CFL Checker for Grammar and Graph alignment --------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * CFLGramGraphChecker.h
+ *
+ *  Created on: May 23, 2022
+ *      Author: Pei Xu
+ */
+
+#include "CFL/CFLGrammar.h"
+#include "Graphs/CFLGraph.h"
+namespace SVF
+{
+
+class CFLGramGraphChecker
+{
+public:
+    void check(GrammarBase *grammar, CFLGraph *graph)
+    {
+        /// Check all the symbol in grammar in graph With the same label
+        for(auto pairV : grammar->terminals)
+        {
+            if (graph->label2SymMap.find(pairV.first) != graph->label2SymMap.end())
+            {
+                assert(graph->label2SymMap[pairV.first] == pairV.second);
+            }
+        }
+
+        for(auto pairV : grammar->nonterminals)
+        {
+            if (graph->label2SymMap.find(pairV.first) != graph->label2SymMap.end())
+            {
+                assert(graph->label2SymMap[pairV.first] == pairV.second);
+            }
+        }
+
+        /// Get Kind2Attr Map from Graph to Grammar
+        grammar->kind2AttrMap = graph->kind2AttrMap;
+        graph->startSymbol = grammar->startSymbol;
+    }
+};
+
+}// SVF
+

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

@@ -32,49 +32,101 @@
 
 namespace SVF
 {
-
 class GrammarBase
 {
 public:
     typedef u32_t Symbol;
     typedef std::vector<Symbol> Production;
     typedef Set<Production> Productions;
+    typedef u32_t Attribute;
+    typedef u32_t Kind;
     Map<std::string, Symbol> terminals;
     Map<std::string, Symbol> nonterminals;
+    Symbol startSymbol;
+    Symbol totalSymbol;
+    Map<Symbol, Productions> rawProductions;
+    Set<Symbol> attributeSymbol;
+    Map<Kind,  Set<Attribute>> kind2AttrMap;
 
     Symbol str2Sym(std::string str) const;
 
     std::string sym2Str(Symbol sym) const;
 
+    std::string sym2StrDump(Symbol sym) const;
+
     Symbol getSymbol(const Production& prod, u32_t pos)
     {
         return prod.at(pos);
     }
 
+    inline Set<Symbol>& getAttrSyms()
+    {
+        return this->attributeSymbol;
+    }
+
     Symbol insertTerminalSymbol(std::string strLit);
     Symbol insertNonTerminalSymbol(std::string strLit);
+    void insertAttribute(Symbol s);
+
+    inline static Kind getSymKind(Symbol sym)
+    {
+        return (EdgeKindMask & sym);
+    }
+
+    inline static Attribute getSymAttribute(Symbol sym)
+    {
+        return (sym >> EdgeKindMaskBits);
+    }
+
+    inline static Kind getAttributedKind(Attribute attribute, Kind kind)
+    {
+        return ((attribute << EdgeKindMaskBits)| kind );
+    }
+
+protected:
+    static constexpr unsigned char EdgeKindMaskBits = 8;  ///< We use the lower 8 bits to denote edge kind
+    static constexpr u64_t EdgeKindMask = (~0ULL) >> (64 - EdgeKindMaskBits);
 
-    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
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const CFLGrammar *)
+    {
+        return true;
+    }
+
+    static inline bool classof(const GrammarBase *node)
+    {
+        return true;
+    }
+
+    Productions& getEpsilonProds()
     {
         return epsilonProds;
     }
 
+    Map<Symbol, Productions>& getSingleRHS2Prods()
+    {
+        return singleRHS2Prods;
+    }
+
+    Map<Symbol, Productions>& getFirstRHS2Prods()
+    {
+        return firstRHS2Prods;
+    }
+
+    Map<Symbol, Productions>& getSecondRHS2Prods()
+    {
+        return secondRHS2Prods;
+    }
+
     const bool hasProdsFromFirstRHS(Symbol sym) const
     {
         auto it = firstRHS2Prods.find(sym);
@@ -103,7 +155,7 @@ public:
     const Productions& getProdsFromFirstRHS(Symbol sym) const
     {
         auto it = firstRHS2Prods.find(sym);
-        assert(it!=firstRHS2Prods.end() && "production (X -> sym Y) not found for sym!!");
+        assert(it!=firstRHS2Prods.end() && "production (X -> sym Y ) not found for sym!!");
         return it->second;
     }
 
@@ -114,28 +166,36 @@ public:
         return it->second;
     }
 
-    Symbol getLHSSymbol(const Production& prod)
+
+    const Symbol& getLHSSymbol(const Production& prod)
     {
         return prod.at(0);
     }
 
-    Symbol getFirstRHSSymbol(const Production& prod)
+    const Symbol& getFirstRHSSymbol(const Production& prod)
     {
         return prod.at(1);
     }
 
-    Symbol getSecondRHSSymbol(const Production& prod)
+    const Symbol& getSecondRHSSymbol(const Production& prod)
     {
         return prod.at(2);
     }
 
-    inline int num_generator()
+    void dump();
+
+    const inline int num_generator()
     {
         return newTerminalSubscript++;
     }
 
+private:
+    Set<Production> epsilonProds;
+    Map<Symbol, Productions> singleRHS2Prods;
+    Map<Symbol, Productions> firstRHS2Prods;
+    Map<Symbol, Productions> secondRHS2Prods;
+    Symbol newTerminalSubscript;
 };
 
-
 }
 #endif /* CFLGrammar_H_ */

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

@@ -0,0 +1,11 @@
+Start:  
+   V
+Productions:
+   F -> ( Copy ) *;
+   F -> ( Store V Load ) *;
+   Fbar -> ( Copybar ) *;
+   Fbar -> ( Loadbar V Storebar ) *;
+   V -> Fbar V F;
+   V -> Gepbar_i V Gep_i;
+   V -> Addrbar Addr;
+   V -> epsilon;

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

@@ -0,0 +1,114 @@
+//===----- CFLGraphBuilder.h -- CFL Graph 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 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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * CFLGraphBuilder.h
+ *
+ *  Created on: May 22, 2022
+ *      Author: Pei Xu
+ */
+
+#include "CFL/CFLGrammar.h"
+#include "Graphs/CFLGraph.h"
+namespace SVF
+{
+
+/*!
+ * Build CFLGraph from memory graph or dot form
+
+ */
+
+class CFLGraphBuilder
+{
+public:
+    /// Build 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());
+            }
+        }
+    }
+
+    /// Build Bidirectional graph by copying nodes and edges from any graph inherited from GenericGraph
+    template<class N, class E>
+    CFLGraph* buildBigraph(GenericGraph<N,E>* graph)
+    {
+        CFLGraph *cflGraph = new CFLGraph();
+        Map<std::string, SVF::CFLGraph::Symbol> ConstMap =  {{"Addr",0}, {"Copy", 1},{"Store", 2},{"Load", 3},{"Gep_i", 4},{"Vgep", 5},{"Addrbar",6}, {"Copybar", 7},{"Storebar", 8},{"Loadbar", 9},{"Gepbar_i", 10},{"Vgepbar", 11}};
+        cflGraph->setMap(ConstMap);
+        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();
+                // Need to get the offset from the Const Edge
+                // The offset present edge is only from Normal Gep CG at moment
+                if(NormalGepCGEdge::classof(edge))
+                {
+                    NormalGepCGEdge *nGepEdge = SVFUtil::dyn_cast<NormalGepCGEdge>(edge);
+                    CFLGrammar::Attribute offset =  nGepEdge->getConstantFieldIdx();
+                    cflGraph->addAttribute(edgeLabel, offset);
+                    edgeLabel = CFLGrammar::getAttributedKind(offset, edgeLabel);
+                    cflGraph->addCFLEdge(cflGraph->getGNode(edge->getSrcID()), cflGraph->getGNode(edge->getDstID()), edgeLabel);
+                    std::string key = cflGraph->sym2LabelMap[edge->getEdgeKind()];
+                    key.pop_back();
+                    key.pop_back();    // _i standsfor attribute variable should place at last
+                    key.append("bar_i");   // for example Gep_i should be Gepbar_i, not Gep_ibar
+                    cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), CFLGrammar::getAttributedKind(offset, cflGraph->label2SymMap[key]));
+                    cflGraph->addAttribute(cflGraph->label2SymMap[key], offset);
+                }
+                else
+                {
+                    cflGraph->addCFLEdge(cflGraph->getGNode(edge->getSrcID()), cflGraph->getGNode(edge->getDstID()), edgeLabel);
+                    std::string key = cflGraph->sym2LabelMap[edge->getEdgeKind()];
+                    key.append("bar");
+                    cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), cflGraph->label2SymMap[key]);
+                }
+            }
+        }
+        return cflGraph;
+    }
+    /// Build graph from file
+    void build(std::string filename, CFLGraph* cflGraph);
+
+    /// Build graph from Dot
+    CFLGraph *buildFromDot(std::string filename, GrammarBase *grammar);
+};
+}// SVF
+

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

@@ -1,4 +1,4 @@
-//===----- CFGNormalizer.h -- CFL Alias Analysis Client--------------//
+//===----- GrammarBuilder.h -- CFL Grammar Builder--------------//
 //
 //                     SVF: Static Value-Flow Analysis
 //
@@ -30,7 +30,6 @@
 
 #include "CFL/CFLGrammar.h"
 #include "Graphs/CFLGraph.h"
-
 namespace SVF
 {
 
@@ -51,6 +50,19 @@ namespace SVF
 
 class GrammarBuilder
 {
+private:
+    /// Load whole file content to string
+    const inline std::string loadFileString() const;
+
+    /// Parse start symbol and production from file string
+    const inline std::string parseProduction() const;
+
+    /// Parse whole production string to production vector
+    const inline std::vector<std::string> loadWordProductions() const;
+
+    /// Strip frond and tail space
+    const inline std::string stripSpace(std::string s) const;
+
 public:
     std::string fileName;
     GrammarBase *grammar;
@@ -60,9 +72,9 @@ public:
         grammar = new GrammarBase();
     };
 
-    GrammarBase* build();
+    GrammarBase* build() const;
 
-    GrammarBase* build(Map<std::string, SVF::CFLGraph::Symbol> *preMap);
+    GrammarBase* build(Map<std::string, SVF::CFLGraph::Symbol> &preMap) const;
 };
 
 } // SVF

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

@@ -36,6 +36,7 @@
 #include <regex>
 #include "CFL/CFLGrammar.h"
 #include "Graphs/GenericGraph.h"
+#include "Graphs/ConsG.h"
 
 namespace SVF
 {
@@ -51,6 +52,11 @@ public:
     {
     }
     ~CFLEdge() override = default;
+
+    inline GEdgeKind getEdgeKind() const
+    {
+        return this->getEdgeKindWithoutMask();
+    }
 };
 
 
@@ -70,64 +76,20 @@ typedef GenericGraph<CFLNode,CFLEdge> GenericCFLGraphTy;
 class CFLGraph: public GenericCFLGraphTy
 {
 public:
-    typedef u32_t Symbol;
+    typedef CFLGrammar::Symbol Symbol;
     typedef GenericNode<CFLNode,CFLEdge>::GEdgeSetTy CFLEdgeSet;
     Map<std::string, Symbol> label2SymMap;
+    Map<Symbol, std::string> sym2LabelMap;
     Symbol startSymbol;
+    Map<CFLGrammar::Kind,  Set<CFLGrammar::Attribute>> kind2AttrMap;
+    bool externMap;
+    Symbol current;
 
     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);
@@ -138,19 +100,30 @@ public:
 
     void view();
 
-    /// Build graph from file
-    void build(std::string filename);
-
-    /// Build graph from Dot
-    void buildFromDot(std::string filename);
-
+    void setMap(Map<std::string, Symbol> &labelMap);
     /// Set label2Sym from External
-    void setMap(Map<std::string, Symbol>* terminals, Map<std::string, Symbol>* nonterminals);
+    void setMap(GrammarBase *grammar);
+
+    /// add attribute to kind2Attribute Map
+    void addAttribute(CFLGrammar::Kind kind, CFLGrammar::Attribute attribute)
+    {
+        if(kind2AttrMap.find(kind) == kind2AttrMap.end())
+        {
+            Set<CFLGrammar::Attribute> attrs {attribute};
+            kind2AttrMap.insert(make_pair(kind, attrs));
+        }
+        else
+        {
+            if(kind2AttrMap[kind].find(attribute) == kind2AttrMap[kind].end())
+            {
+                kind2AttrMap[kind].insert(attribute);
+            }
+        }
+    }
 
 private:
     CFLEdgeSet cflEdgeSet;
-    Symbol current;
-    bool externMap;
+
 };
 
 }

package/SVF-linux/include/Graphs/GenericGraph.h

@@ -82,6 +82,10 @@ public:
     {
         return (EdgeKindMask & edgeFlag);
     }
+    inline GEdgeKind getEdgeKindWithoutMask() const
+    {
+        return edgeFlag;
+    }
     NodeType* getSrcNode() const
     {
         return src;