svf-lib 1.0.981 → 1.0.984

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

@@ -0,0 +1,70 @@
+//===----- CFGNormalizer.h -- CFL Alias Analysis Client--------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * CFGNormalizer.h
+ *
+ *  Created on: April 19 , 2022
+ *      Author: Pei Xu
+ */
+
+#ifndef CFGNormalizer_H_
+#define CFGNormalizer_H_
+
+#include "CFLGrammar.h"
+
+namespace SVF{
+
+/*!
+ *  Normalize Grammar from a grammarbase
+ */
+
+class CFGNormalizer {
+
+public:
+    typedef u32_t Symbol;
+    typedef std::vector<Symbol> Production;
+    typedef Set<Production> Productions;
+
+    CFGNormalizer(){
+    }
+
+    /// Start Normalize (BIN Only)
+    // TODO: Add different Combination Transformation Option
+    CFLGrammar* normalize(GrammarBase *generalGrammar);
+private:
+
+    void ebnf_bin(GrammarBase *generalGrammar, CFLGrammar *grammar);
+
+    void ebnf_sign_replace(char sign, GrammarBase* generalGrammar, CFLGrammar *grammar);
+
+    int ebnf_bracket_match(Production& prod, int i, CFLGrammar *grammar) ;
+
+    Production strTrans(std::string strPro, CFLGrammar *grammar);
+
+    int check_head(Map<Symbol, Productions>& grammar, Production& rule);
+
+};
+
+} // End namespace SVF
+
+#endif /* CFGNormalizer_H_*/

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

@@ -0,0 +1,124 @@
+//===----- CFLAlias.h -- CFL Alias Analysis Client--------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * CFLAlias.h
+ *
+ *  Created on: March 5, 2022
+ *      Author: Yulei Sui
+ */
+
+
+#include "CFL/CFLSolver.h"
+#include "CFL/CFGNormalizer.h"
+#include "CFL/GrammarBuilder.h"
+#include "MemoryModel/PointerAnalysis.h"
+#include "Graphs/ConsG.h"
+#include "Util/Options.h"
+
+namespace SVF{
+
+class CFLAlias : public PointerAnalysis{
+
+public:
+    CFLAlias(SVFIR* ir) : PointerAnalysis(ir, PointerAnalysis::CFLFICI_WPA), svfir(ir), graph(nullptr), grammar(nullptr), solver(nullptr){
+    }
+
+    /// Destructor
+    virtual ~CFLAlias(){
+        delete graph;
+        delete grammar;
+        delete solver;
+    }
+
+    /// 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();
+        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}};
+            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");
+            delete consCG;
+            GrammarBase *generalGrammar = gReader->build(&ConstMap);
+            grammar = normalizer->normalize(generalGrammar);
+            graph->setMap(&grammar->terminals, &grammar->nonterminals);
+        }
+        else {
+            GrammarBase *generalGrammar = gReader->build();
+            grammar = normalizer->normalize(generalGrammar);
+            graph->setMap(&grammar->terminals, &grammar->nonterminals);
+            graph->buildFromDot(Options::InputFilename);     
+        }
+        graph->startSymbol = grammar->startSymbol;
+        solver = new CFLSolver(graph, grammar);
+        solver->solve();
+        graph->dump("map");
+        PointerAnalysis::finalize();
+    }
+
+    /// Interface exposed to users of our pointer analysis, given Value infos
+    virtual AliasResult alias(const Value* v1, const Value* v2) {
+        NodeID n1 = svfir->getValueNode(v1);
+        NodeID n2 = svfir->getValueNode(v2);
+        return alias(n1,n2);
+    }
+
+    /// 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
+            return AliasResult::NoAlias;
+    }
+
+    /// Get points-to targets of a pointer.
+    virtual const PointsTo& getPts(NodeID ptr) {
+        /// Check Outgoing edge Dst of ptr
+        //PointsTo * ps;
+        abort(); // to be implemented
+    }
+
+    /// Given an object, get all the nodes having whose pointsto contains the object
+    virtual const NodeSet& getRevPts(NodeID nodeId) {
+        /// Check Outgoing flowtobar edge dst of ptr
+        abort(); // to be implemented
+    }
+
+private:
+    SVFIR* svfir;
+    CFLGraph* graph;
+    CFLGrammar* grammar;
+    CFLSolver *solver;
+};
+
+}

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

@@ -0,0 +1,127 @@
+//===----- CFLGrammar.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 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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * CFLGrammar.h
+ *
+ *  Created on: March 5, 2022
+ *      Author: Yulei Sui
+ */
+#ifndef CFLGrammar_H_
+#define CFLGrammar_H_  
+#include "Util/BasicTypes.h"
+
+namespace SVF{
+
+class GrammarBase{
+public:
+    typedef u32_t Symbol;
+    typedef std::vector<Symbol> Production;
+    typedef Set<Production> Productions;
+    Map<std::string, Symbol> terminals;
+    Map<std::string, Symbol> nonterminals;
+
+    Symbol str2Sym(std::string str) const;
+    
+    std::string sym2Str(Symbol sym) const;
+
+    Symbol getSymbol(const Production& prod, u32_t pos){
+        return prod.at(pos);
+    }
+
+    Symbol insertTerminalSymbol(std::string strLit);
+    Symbol insertNonTerminalSymbol(std::string strLit);
+
+    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{
+        return epsilonProds;
+    }
+
+    const bool hasProdsFromFirstRHS(Symbol sym) const{
+        auto it = firstRHS2Prods.find(sym);
+        return it!=firstRHS2Prods.end();
+    }
+
+    const bool hasProdsFromSingleRHS(Symbol sym) const{
+        auto it = singleRHS2Prods.find(sym);
+        return it!=singleRHS2Prods.end();
+    }
+
+    const bool hasProdsFromSecondRHS(Symbol sym) const{
+        auto it = secondRHS2Prods.find(sym);
+        return it!=secondRHS2Prods.end();
+    }
+
+    const Productions& getProdsFromSingleRHS(Symbol sym) const{
+        auto it = singleRHS2Prods.find(sym);
+        assert(it!=singleRHS2Prods.end() && "production (X -> sym) not found for sym!!");
+        return it->second;
+    }
+
+    const Productions& getProdsFromFirstRHS(Symbol sym) const{
+        auto it = firstRHS2Prods.find(sym);
+        assert(it!=firstRHS2Prods.end() && "production (X -> sym Y) not found for sym!!");
+        return it->second;
+    }
+
+    const Productions& getProdsFromSecondRHS(Symbol sym) const{
+        auto it = secondRHS2Prods.find(sym);
+        assert(it!=secondRHS2Prods.end() && "production (X -> Y sym) not found for sym!!");
+        return it->second;
+    }
+
+    Symbol getLHSSymbol(const Production& prod){
+        return prod.at(0);
+    }
+
+    Symbol getFirstRHSSymbol(const Production& prod){
+        return prod.at(1);
+    }
+
+    Symbol getSecondRHSSymbol(const Production& prod){
+        return prod.at(2);
+    }
+
+    inline int num_generator()
+    {
+        return newTerminalSubscript++;
+    }
+
+};
+
+
+}
+#endif /* CFLGrammar_H_ */

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

@@ -0,0 +1,94 @@
+//===----- CFLSolver.h -- Context-free language reachability solver--------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * CFLSolver.h
+ *
+ *  Created on: March 5, 2022
+ *      Author: Yulei Sui
+ */
+
+#include "Graphs/CFLGraph.h"
+#include "CFL/CFLGrammar.h"
+#include "Util/WorkList.h"
+
+
+namespace SVF{
+
+class CFLSolver{
+
+public:
+    /// Define worklist
+    typedef FIFOWorkList<const CFLEdge*> WorkList;
+    typedef CFLGrammar::Production Production;
+    typedef CFLGrammar::Symbol Symbol;
+
+    CFLSolver(CFLGraph* _graph, CFLGrammar* _grammar): graph(_graph), grammar(_grammar)
+    {
+    }
+
+    ~CFLSolver()
+    {
+    }
+
+    /// Start solving
+    void solve();
+
+    /// Return CFL Graph
+    inline const CFLGraph* getGraph() const {
+        return graph;
+    }
+
+    /// Return CFL Grammar
+    inline const CFLGrammar* getGrammar() const {
+        return grammar;
+    }
+
+protected:
+    /// Worklist operations
+    //@{
+    inline const CFLEdge* popFromWorklist()
+    {
+        return worklist.pop();
+    }
+    inline bool pushIntoWorklist(const CFLEdge* item)
+    {
+        return worklist.push(item);
+    }
+    inline bool isWorklistEmpty()
+    {
+        return worklist.empty();
+    }
+    inline bool isInWorklist(const CFLEdge* item)
+    {
+        return worklist.find(item);
+    }
+    //@}
+
+private: 
+    CFLGraph* graph;
+    CFLGrammar* grammar;
+    /// Worklist for resolution
+    WorkList worklist;
+};
+
+}

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

@@ -0,0 +1,65 @@
+//===----- CFGNormalizer.h -- CFL Alias Analysis Client--------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * GrammarBuilder.h
+ *
+ *  Created on: April 26, 2022
+ *      Author: Pei Xu
+ */
+
+
+#include "CFL/CFLGrammar.h"
+#include "Graphs/CFLGraph.h"
+
+namespace SVF{
+
+/*!
+ * Build Grammar from a user specified grammar text
+ * Input Format:
+ *      Start:              // Special string 'epsilon' for empty RHS
+ *      M                   // Specify Start Symbol in Second Line 
+ *      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. 
+ */
+
+class GrammarBuilder{
+public:
+    std::string fileName;
+    GrammarBase *grammar;
+
+    GrammarBuilder(std::string fileName): fileName(fileName), grammar(nullptr){
+        grammar = new GrammarBase();
+    };
+
+    GrammarBase* build(); 
+
+    GrammarBase* build(Map<std::string, SVF::CFLGraph::Symbol> *preMap);
+};
+
+} // SVF 

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

@@ -0,0 +1,175 @@
+//===----- CFLGraph.h -- Graph for context-free language reachability analysis --//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * CFLGraph.h
+ *
+ *  Created on: March 5, 2022
+ *      Author: Yulei Sui
+ */
+
+#ifndef CFLG_H_
+#define CFLG_H_
+
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <regex>
+#include "CFL/CFLGrammar.h"
+#include "Graphs/GenericGraph.h"
+
+namespace SVF
+{
+class CFLNode;
+
+typedef GenericEdge<CFLNode> GenericCFLEdgeTy;
+
+class CFLEdge: public GenericCFLEdgeTy
+{
+public:
+    CFLEdge(CFLNode *s, CFLNode *d, GEdgeFlag k = 0):
+        GenericCFLEdgeTy(s,d,k)
+    {
+    }
+    ~CFLEdge() override = default;
+};
+
+
+typedef GenericNode<CFLNode,CFLEdge> GenericCFLNodeTy;
+class CFLNode: public GenericCFLNodeTy
+{
+public:
+    CFLNode (NodeID i = 0, GNodeK k = 0):
+        GenericCFLNodeTy(i, k)
+    {
+    }
+    ~CFLNode() override = default;
+};
+
+/// Edge-labeled graph for CFL Reachability analysis
+typedef GenericGraph<CFLNode,CFLEdge> GenericCFLGraphTy;
+class CFLGraph: public GenericCFLGraphTy
+{
+public:
+    typedef u32_t Symbol;
+    typedef GenericNode<CFLNode,CFLEdge>::GEdgeSetTy CFLEdgeSet;
+    Map<std::string, Symbol> label2SymMap;
+    Symbol startSymbol;
+
+    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);
+
+    virtual const CFLEdge* hasEdge(CFLNode* src, CFLNode* dst, CFLEdge::GEdgeFlag label);
+
+    void dump(const std::string& filename);
+
+    void view();
+
+    /// Build graph from file
+    void build(std::string filename);
+    
+    /// Build graph from Dot
+    void buildFromDot(std::string filename);
+
+    /// Set label2Sym from External
+    void setMap(Map<std::string, Symbol>* terminals, Map<std::string, Symbol>* nonterminals);
+
+private:
+    CFLEdgeSet cflEdgeSet;
+    Symbol current;
+    bool externMap;
+};
+
+}
+
+namespace llvm
+{
+/* !
+ * GraphTraits specializations for generic graph algorithms.
+ * Provide graph traits for traversing from a constraint node using standard graph traversals.
+ */
+template<> struct GraphTraits<SVF::CFLNode*> : public GraphTraits<SVF::GenericNode<SVF::CFLNode,SVF::CFLEdge>*  >
+{
+};
+
+/// Inverse GraphTraits specializations for call graph node, it is used for inverse traversal.
+template<>
+struct GraphTraits<Inverse<SVF::CFLNode *> > : public GraphTraits<Inverse<SVF::GenericNode<SVF::CFLNode,SVF::CFLEdge>* > >
+{
+};
+
+template<> struct GraphTraits<SVF::CFLGraph*> : public GraphTraits<SVF::GenericGraph<SVF::CFLNode,SVF::CFLEdge>* >
+{
+    typedef SVF::CFLNode *NodeRef;
+};
+
+} // End namespace llvm
+
+#endif /* CFLG_H_ */

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

@@ -53,7 +53,7 @@ public:
 
 protected:
     SVFStmt::KindToSVFStmtMapTy KindToSVFStmtSetMap;  // < SVFIR edge map containing all PAGEdges
-    SVFStmt::KindToSVFStmtMapTy KindToPTASVFStmtSetMap;  // < SVFIR edge map containing only pointer-related edges, i.e, both RHS and RHS are of pointer type
+    SVFStmt::KindToSVFStmtMapTy KindToPTASVFStmtSetMap;  // < SVFIR edge map containing only pointer-related edges, i.e, both LHS and RHS are of pointer type
     bool fromFile; ///< Whether the SVFIR is built according to user specified data from a txt file
     NodeID nodeNumAfterPAGBuild; // initial node number after building SVFIR, excluding later added nodes, e.g., gepobj nodes
     u32_t totalPTAPAGEdge;

package/SVF-linux/include/MemoryModel/PointerAnalysis.h

@@ -79,9 +79,9 @@ public:
         FSTBHC_WPA,		///< Sparse flow-sensitive type-based heap cloning WPA
         VFS_WPA,		///< Versioned sparse flow-sensitive WPA
         FSCS_WPA,			///< Flow-, context- sensitive WPA
-        FSCSPS_WPA,		///< Flow-, context-, path- sensitive WPA
-        ADAPTFSCS_WPA,		///< Adaptive Flow-, context-, sensitive WPA
-        ADAPTFSCSPS_WPA,	///< Adaptive Flow-, context-, path- sensitive WPA
+        CFLFICI_WPA,		///< Flow-, context-, insensitive CFL-reachability-based analysis
+        CFLFSCI_WPA,		///< Flow-insensitive, context-sensitive  CFL-reachability-based analysis
+        CFLFSCS_WPA,	///< Flow-, context-, CFL-reachability-based analysis
         TypeCPP_WPA, ///<  Type-based analysis for C++
 
         // Demand driven analysis