svf-tools 1.0.477 → 1.0.480

package/include/CFL/CFLGrammar.h

@@ -28,20 +28,155 @@
  */
 #ifndef CFLGrammar_H_
 #define CFLGrammar_H_
-#include "Util/BasicTypes.h"
+#include "Util/SVFBasicTypes.h"
 
 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;
+    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()
+        {
+            u32_t num = 0;
+            num += this->variableAttribute << 24;
+            num += this->attribute << 8;
+            num += this->kind;
+            return num;
+        }
+
+        /// Conversion of u64_t
+        operator u64_t()
+        {
+            u64_t num = 0;
+            num += this->variableAttribute << 24;
+            num += this->attribute << 8;
+            num += this->kind;
+            return num;
+        }
+
+        operator s64_t() const
+        {
+            s64_t num = 0;
+            num += this->variableAttribute << 24;
+            num += this->attribute << 8;
+            num += this->kind;
+            return num;
+        }
+
+        bool operator<(const Symbol& rhs)
+        {
+            return this->kind < rhs.kind;
+        }
+
+        void operator=(const int& 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;
+        }
+
+        void operator=(const Kind& kind)
+        {
+            this->kind = kind;
+        }
+
+        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 int& i)
+        {
+            return ((this->kind == (EdgeKindMask & i)) && (this->attribute == (i >> EdgeKindMaskBits)) && (this->variableAttribute == (i >> AttributedKindMaskBits)));
+        }
+
+        bool operator==(const Kind& k) const
+        {
+            return (this->kind == k);
+        }
+
+        bool operator==(const Kind& k)
+        {
+            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));
+        }
+    };
+
 
-    inline Map<std::string, Kind>& getNonterminals()
+    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;
     }
@@ -61,7 +196,7 @@ public:
         this->terminals = terminals;
     }
 
-    inline Map<Symbol, Productions>& getRawProductions()
+    inline SymbolMap<Symbol, Productions>& getRawProductions()
     {
         return this->rawProductions;
     }
@@ -91,7 +226,11 @@ public:
         this->totalKind = totalKind;
     }
 
-    void setRawProductions(Map<Symbol, Productions>& rawProductions);
+    std::string extractKindStrFromSymbolStr(const std::string symbolStr) const;
+
+    std::string extractAttributeStrFromSymbolStr(const std::string symbolStr) const;
+
+    void setRawProductions(SymbolMap<Symbol, Productions>& rawProductions);
 
     void setKind2AttrsMap(const Map<Kind,  Set<Attribute>>& kind2AttrsMap);
 
@@ -99,6 +238,8 @@ public:
 
     Kind str2Kind(std::string str) const;
 
+    Symbol str2Symbol(const std::string str) const;
+
     std::string kind2Str(Kind kind) const;
 
     std::string sym2StrDump(Symbol sym) const;
@@ -108,41 +249,46 @@ public:
         return prod.at(pos);
     }
 
-    inline const Set<Symbol>& getAttrSyms() const
+    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);
-    Kind insertNonTerminalKind(std::string strLit);
-    void insertAttribute(Kind kind, Attribute a);
 
-    inline static Kind getSymKind(Symbol sym)
-    {
-        return (EdgeKindMask & sym);
-    }
+    Symbol insertSymbol(std::string strLit);
 
-    inline static Attribute getSymAttribute(Symbol sym)
-    {
-        return (sym >> EdgeKindMaskBits);
-    }
+    Symbol insertNonTerminalSymbol(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:
-    Set<Kind> attributeKinds;
-    Map<Kind,  Set<Attribute>> kind2AttrsMap;
-    Map<Symbol, Productions> rawProductions;
-    Kind totalKind;
     Map<std::string, Kind> nonterminals;
     Map<std::string, Kind> terminals;
+    Set<Kind> attributeKinds;
+    Map<Kind,  Set<Attribute>> kind2AttrsMap;
+    SymbolMap<Symbol, Productions> rawProductions;
+    u32_t totalKind;
 };
 
 class CFLGrammar : public GrammarBase
@@ -168,17 +314,17 @@ public:
         return epsilonProds;
     }
 
-    Map<Symbol, Productions>& getSingleRHS2Prods()
+    SymbolMap<Symbol, Productions>& getSingleRHS2Prods()
     {
         return singleRHS2Prods;
     }
 
-    Map<Symbol, Productions>& getFirstRHS2Prods()
+    SymbolMap<Symbol, Productions>& getFirstRHS2Prods()
     {
         return firstRHS2Prods;
     }
 
-    Map<Symbol, Productions>& getSecondRHS2Prods()
+    SymbolMap<Symbol, Productions>& getSecondRHS2Prods()
     {
         return secondRHS2Prods;
     }
@@ -240,17 +386,86 @@ public:
 
     void dump() const;
 
+    void dump(std::string fileName) const;
+
+
     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;
+    SymbolSet<Production> epsilonProds;
+    SymbolMap<Symbol, Productions> singleRHS2Prods;
+    SymbolMap<Symbol, Productions> firstRHS2Prods;
+    SymbolMap<Symbol, Productions> secondRHS2Prods;
+    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.
 };
 
 }

package/include/CFL/CFLGrammar.txt

@@ -1,19 +1,17 @@
 Start:  
-   V
+   V 
+Terminal:
+   Addr Copy Store Load Gep Vgep 
 Productions:
-   F -> Addr;
-   F -> Addr ( Copy ) *;
-   F -> Addr ( Store V Load ) *;
-   F -> ( Copy ) *;
-   F -> ( Store V Load ) *;
-   Fbar -> Addrbar;
-   Fbar -> Addrbar ( Copybar ) *;
-   Fbar -> Addrbar ( Loadbar V Storebar ) *;
-   Fbar -> ( Copybar ) *;
-   Fbar -> ( Loadbar V Storebar ) *;
+   F -> epsilon;
+   F -> F Copy;
+   F -> F Store V Load;
+   Gepbar_j -> Vgepbar Fbar Gepbar_i; 
+   Fbar -> epsilon;
+   Fbar -> Copybar Fbar;
+   Fbar -> Loadbar V Storebar Fbar;
    V -> Fbar V F;
-   V -> Gepbar_i V Gep_i;
    V -> Addrbar Addr;
-   V -> epsilon;
-
-   
+   V -> Gepbar_i V Gep_i;
+   Gep_j -> Gep_i F Vgep;
+   

package/include/CFL/CFLGraphBuilder.h

@@ -39,14 +39,14 @@ namespace SVF
 
 class CFLGraphBuilder
 {
-private:
+protected:
     typedef CFLGrammar::Kind Kind;
     typedef CFLGrammar::Symbol Symbol;
     Map<std::string, Kind> label2KindMap;
     Map<Kind, std::string> kind2LabelMap;
     Map<CFLGrammar::Kind,  Set<CFLGrammar::Attribute>> kind2AttrsMap;
     bool externMap;
-    Symbol current;
+    Kind current;
 
 public:
     /// add attribute to kind2Attribute Map
@@ -73,12 +73,22 @@ public:
 
     /// 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, Kind startKind)
+    CFLGraph* buildBigraph(GenericGraph<N,E>* graph, Kind startKind, GrammarBase *grammar)
     {
         CFLGraph *cflGraph = new CFLGraph(startKind);
-        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}};
         externMap = true;
-        for(auto pairV : ConstMap)
+        for(auto pairV : grammar->getTerminals())
+        {
+            if(label2KindMap.find(pairV.first) == label2KindMap.end())
+            {
+                label2KindMap.insert(pairV);
+            }
+            if(kind2LabelMap.find(pairV.second) == kind2LabelMap.end())
+            {
+                kind2LabelMap.insert(make_pair(pairV.second, pairV.first));
+            }
+        }
+        for(auto pairV : grammar->getNonterminals())
         {
             if(label2KindMap.find(pairV.first) == label2KindMap.end())
             {
@@ -100,29 +110,10 @@ public:
             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 attr =  nGepEdge->getConstantFieldIdx();
-                    addAttribute(edgeLabel, attr);
-                    edgeLabel = CFLGrammar::getAttributedKind(attr, edgeLabel);
-                    cflGraph->addCFLEdge(cflGraph->getGNode(edge->getSrcID()), cflGraph->getGNode(edge->getDstID()), edgeLabel);
-                    std::string key = kind2LabelMap[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(attr, label2KindMap[key]));
-                    addAttribute(label2KindMap[key], attr);
-                }
-                else
-                {
-                    cflGraph->addCFLEdge(cflGraph->getGNode(edge->getSrcID()), cflGraph->getGNode(edge->getDstID()), edgeLabel);
-                    std::string key = kind2LabelMap[edge->getEdgeKind()];
-                    key.append("bar");
-                    cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), label2KindMap[key]);
-                }
+                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getSrcID()), cflGraph->getGNode(edge->getDstID()), edgeLabel);
+                std::string key = kind2LabelMap[edge->getEdgeKind()];
+                key.append("bar");
+                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), label2KindMap[key]);
             }
         }
         return cflGraph;
@@ -147,8 +138,15 @@ public:
     {
         return this->kind2AttrsMap;
     }
+};
 
-
+class AliasCFLGraphBuilder : public CFLGraphBuilder
+{
+public:
+    /// Build Bidirectional graph by copying nodes and edges from const graph inherited from GenericGraph
+    CFLGraph* buildBigraph(ConstraintGraph *graph, Kind startKind, GrammarBase *grammar);
 };
+
 }// SVF
 
+

package/include/CFL/GrammarBuilder.h

@@ -27,54 +27,74 @@
  *      Author: Pei Xu
  */
 
+#ifndef INCLUDE_CFL_GRAMMARBUILDER_H_
+#define INCLUDE_CFL_GRAMMARBUILDER_H_
 
 #include "CFL/CFLGrammar.h"
-#include "Graphs/CFLGraph.h"
+
 namespace SVF
 {
 
-/*!
+/**
  * Build Grammar from a user specified grammar text
+ *
+ * Symbol Format:
+ *      <kind> [bar] [ _alpha | _number ]
+ *      kind: any nonspace string start with alphabet, epsilon stand for empty string
+ *      bar: stand for reverse edge
+ *      alpha: any single alpha
+ *      number: any number
+ *      start with capital: nonterminal
+ *      start with noncapital: terminal
+ *
+ * Production Format:
+ *      <symbol> -> <symbol> *;
+ *      LHS and RHS, Seperate by '->', symbol seperate by ' ', end by ';'
+ *      support '*', '?', '(', ')'
+ *
  * Input Format:
- *      Start:              // Special string 'epsilon' for empty RHS
+ *      Start:
  *      M                   // Specify Start Symbol in Second Line
+ *      Terminal:
+ *      Addr Copy Store Load Gep Vgep // Specify the order of terminal Addr->0, Copy->1 ..
  *      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.
+ *      Gep_j -> Gep_i F vgep; // Support variable attribute with variable attribute
+ *      Gep_1 -> Gep_2;      // Support fix number attribute
+ *
  */
 
 class GrammarBuilder
 {
 private:
-    /// Load whole file content to string
-    const inline std::string loadFileString() const;
+    std::string fileName;
+    GrammarBase *grammar;
 
     /// Parse start symbol and production from file string
-    const inline std::string parseProduction() const;
+    const inline std::string parseProductionsString() const;
 
     /// Parse whole production string to production vector
     const inline std::vector<std::string> loadWordProductions() const;
 
-    /// Strip frond and tail space
+    /// Strip front and tail space
     const inline std::string stripSpace(std::string s) const;
 
 public:
-    std::string fileName;
-    GrammarBase *grammar;
-
     GrammarBuilder(std::string fileName): fileName(fileName), grammar(nullptr)
     {
         grammar = new GrammarBase();
     };
 
+    /// Build grammarBase from fileName
     GrammarBase* build() const;
 
-    GrammarBase* build(Map<std::string, SVF::CFLGraph::Symbol> &preMap) const;
+    /// Build grammarBase from fileName with preset str2KindMap
+    GrammarBase* build(Map<std::string, SVF::GrammarBase::Symbol> &preMap) const;
 };
 
 } // SVF
+
+#endif /* INCLUDE_CFL_GRAMMARBUILDER_H_ */

package/include/Graphs/CFLGraph.h

@@ -57,6 +57,16 @@ public:
     {
         return this->getEdgeKindWithoutMask();
     }
+
+    inline GEdgeKind getEdgeKindWithMask() const
+    {
+        return (EdgeKindMask & this->getEdgeKindWithoutMask());
+    }
+
+    inline GEdgeKind getEdgeAttri() const
+    {
+        return (getEdgeKind() >> this->EdgeKindMaskBits);
+    }
 };
 
 
@@ -87,6 +97,8 @@ public:
     }
     ~CFLGraph() override = default;
 
+    Kind getStartKind() const;
+
     virtual void addCFLNode(NodeID id, CFLNode* node);
 
     virtual const CFLEdge* addCFLEdge(CFLNode* src, CFLNode* dst, CFLEdge::GEdgeFlag label);

package/include/Graphs/ConsGEdge.h

@@ -308,6 +308,7 @@ public:
     {
         return ls.accumulateConstantFieldIdx();
     }
+
 };
 
 /*!

package/include/SVF-FE/CallGraphBuilder.h

@@ -28,8 +28,8 @@
  *      Author: Yulei Sui
  */
 
-#ifndef INCLUDE_UTIL_CALLGRAPHBUILDER_H_
-#define INCLUDE_UTIL_CALLGRAPHBUILDER_H_
+#ifndef INCLUDE_SVF_FE_CALLGRAPHBUILDER_H_
+#define INCLUDE_SVF_FE_CALLGRAPHBUILDER_H_
 
 #include "Graphs/PTACallGraph.h"
 #include "Graphs/ThreadCallGraph.h"