svf-lib 1.0.1612 → 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
 {