svf-lib 1.0.1374 → 1.0.1376

package/SVF-osx/svf/include/include/CFL/CFLGraphBuilder.h

@@ -0,0 +1,193 @@
+//===----- 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
+ */
+
+#ifndef INCLUDE_CFL_CFLGRAPHBUILDER_H_
+#define INCLUDE_CFL_CFLGRAPHBUILDER_H_
+
+#include "CFL/CFLGrammar.h"
+#include "Graphs/CFLGraph.h"
+#include "Graphs/SVFG.h"
+
+namespace SVF
+{
+
+/*!
+ * Build CFLGraph from memory graph or dot form
+
+ */
+
+class CFLGraphBuilder
+{
+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;
+    Kind current;
+
+public:
+    /// add attribute to kind2Attribute Map
+    void addAttribute(CFLGrammar::Kind kind, CFLGrammar::Attribute attribute);
+
+    /// 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, Kind startKind, GrammarBase *grammar)
+    {
+        CFLGraph *cflGraph = new CFLGraph(startKind);
+        externMap = true;
+        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())
+            {
+                label2KindMap.insert(pairV);
+            }
+            if(kind2LabelMap.find(pairV.second) == kind2LabelMap.end())
+            {
+                kind2LabelMap.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 = kind2LabelMap[edge->getEdgeKind()];
+                key.append("bar");
+                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), label2KindMap[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);
+
+    Map<std::string, Kind>& getLabel2KindMap()
+    {
+        return this->label2KindMap;
+    }
+
+    Map<Kind, std::string>& getKind2LabelMap()
+    {
+        return this->kind2LabelMap;
+    }
+
+    Map<CFLGrammar::Kind,  Set<CFLGrammar::Attribute>>& getKind2AttrsMap()
+    {
+        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);
+
+    /// Build Bidirectional graph by copying nodes and edges from any graph inherited from GenericGraph
+    /// And transfer Load Store to copy edge and address edge to construct PEG style CFG
+    CFLGraph* buildBiPEGgraph(ConstraintGraph *graph, Kind startKind, GrammarBase *grammar, SVFIR* pag);
+
+private:
+    void connectVGep(CFLGraph *cflGraph,  ConstraintGraph *graph, ConstraintNode *src, ConstraintNode *dst, u32_t level, SVFIR* pag);
+
+    /// Handle edge except for the GEP
+    void addBiCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFLGrammar::Kind label);
+
+    /// Add Bidirectional GEP edge with attribute
+    void addBiGepCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFLGrammar::Attribute attri);
+};
+
+class VFCFLGraphBuilder : public CFLGraphBuilder
+{
+public:
+    /// Build Bidirectional graph by copying nodes and edges from const graph inherited from GenericGraph
+    CFLGraph* buildBigraph(SVFG *graph, Kind startKind, GrammarBase *grammar);
+
+    /// Build Bidirectional graph by copying nodes and edges from any graph inherited from GenericGraph
+    /// And transfer Load Store to copy edge and address edge to construct PEG style CFG
+    CFLGraph* buildBiPEGgraph(ConstraintGraph *graph, Kind startKind, GrammarBase *grammar, SVFIR* pag);
+
+private:
+    void connectVGep(CFLGraph *cflGraph,  ConstraintGraph *graph, ConstraintNode *src, ConstraintNode *dst, u32_t level, SVFIR* pag);
+
+    /// Handle edge except for the GEP
+    void addBiCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFLGrammar::Kind label);
+
+    /// Add Bidirectional GEP edge with attribute
+    void addBiGepCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFLGrammar::Attribute attri);
+};
+
+}// SVF
+
+#endif /* INCLUDE_CFL_CFLGRAPHBUILDER_H_*/

package/SVF-osx/svf/include/include/CFL/CFLSolver.h

@@ -0,0 +1,136 @@
+//===----- 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
+ */
+
+#ifndef INCLUDE_CFL_CFLSolver_H_
+#define INCLUDE_CFL_CFLSolver_H_
+
+#include "Graphs/CFLGraph.h"
+#include "CFL/CFLGrammar.h"
+#include "Util/WorkList.h"
+#include "CFL/CFLData.h"
+
+
+namespace SVF
+{
+
+class CFLSolver
+{
+
+public:
+    /// Define worklist
+    typedef FIFOWorkList<const CFLEdge*> WorkList;
+    typedef CFLGrammar::Production Production;
+    typedef CFLGrammar::Symbol Symbol;
+
+    static double numOfChecks;
+
+    CFLSolver(CFLGraph* _graph, CFLGrammar* _grammar): graph(_graph), grammar(_grammar)
+    {
+    }
+
+    ~CFLSolver()
+    {
+        delete graph;
+        delete grammar;
+    }
+
+    /// Initialize worklist
+    void initialize();
+
+    /// Process CFLEdge
+    void processCFLEdge(const CFLEdge* Y_edge);
+
+    /// Start solving
+    void solve();
+
+    /// Return CFL Graph
+    inline const CFLGraph* getGraph() const
+    {
+        return graph;
+    }
+
+    /// Return CFL Grammar
+    inline const CFLGrammar* getGrammar() const
+    {
+        return grammar;
+    }
+    inline bool pushIntoWorklist(const CFLEdge* item)
+    {
+        return worklist.push(item);
+    }
+    inline bool isWorklistEmpty()
+    {
+        return worklist.empty();
+    }
+
+protected:
+    /// Worklist operations
+    //@{
+    inline const CFLEdge* popFromWorklist()
+    {
+        return worklist.pop();
+    }
+
+    inline bool isInWorklist(const CFLEdge* item)
+    {
+        return worklist.find(item);
+    }
+    //@}
+
+private:
+    CFLGraph* graph;
+    CFLGrammar* grammar;
+    /// Worklist for resolution
+    WorkList worklist;
+
+};
+
+/// Solver Utilize CFLData
+class POCRSolver : public CFLSolver
+{
+    /// Destructor
+    virtual ~POCRSolver()
+    {
+        delete _cflData;
+    }
+
+    CFLData* cflData()
+    {
+        return _cflData;
+    }
+
+    //virtual void initialize();
+
+private:
+    CFLData* _cflData;
+
+};
+}
+
+#endif /* INCLUDE_CFL_CFLSolver_H_*/

package/SVF-osx/svf/include/include/CFL/CFLStat.h

@@ -0,0 +1,67 @@
+//===- CFLStat.h -- CFL statistics--------------------------------------------//
+//
+//                     SVF: Static Value-Flow Analysis
+//
+// Copyright (C) <2013-2017>  <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/>.
+//
+//===----------------------------------------------------------------------===//
+
+
+/*
+ * CFLStat.h
+ *
+ *  Created on: 17/9/2022
+ *      Author: Pei Xu
+ */
+
+#ifndef CFL_CFLSTAT_H_
+#define CFL_CFLSTAT_H_
+
+#include "Util/PTAStat.h"
+#include "CFL/CFLAlias.h"
+#include "CFL/CFLVF.h"
+
+namespace SVF
+{
+
+/*!
+ * Statistics of CFL's analysis
+ */
+class CFLStat : public PTAStat
+{
+private:
+    CFLBase* pta;
+
+public:
+    CFLStat(CFLBase* p);
+
+    virtual ~CFLStat()
+    {
+    }
+
+    virtual void performStat();
+
+    void CFLGraphStat();
+
+    void CFLGrammarStat();
+
+    void CFLSolverStat();
+};
+
+} // End namespace SVF
+
+#endif /* CFL_CFLSTAT_H_ */

package/SVF-osx/svf/include/include/CFL/CFLVF.h

@@ -0,0 +1,65 @@
+//===----- CFLVF.h -- CFL Value-Flow 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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * CFLVF.h
+ *
+ *  Created on: September 5, 2022
+ *      Author: Pei Xu
+ */
+
+#ifndef INCLUDE_CFL_CFLVF_H_
+#define INCLUDE_CFL_CFLVF_H_
+
+
+#include "CFL/CFLBase.h"
+#include "CFL/CFLStat.h"
+#include "SABER/SaberSVFGBuilder.h"
+#include "WPA/Andersen.h"
+
+namespace SVF
+{
+class CFLVF : public CFLBase
+{
+
+public:
+    CFLVF(SVFIR* ir) : CFLBase(ir, PointerAnalysis::CFLFSCS_WPA)
+    {
+    }
+
+    /// Initialize the grammar, graph, solver
+    virtual void initialize();
+
+    /// Print grammar and graph
+    virtual void finalize();
+
+    /// Build CFLGraph via VFG
+    void buildCFLGraph();
+
+private:
+    SaberSVFGBuilder memSSA;
+    SVFG* svfg;
+};
+
+} // End namespace SVF
+
+#endif /* INCLUDE_CFL_CFLVF_H_*/

package/SVF-osx/svf/include/include/CFL/GrammarBuilder.h

@@ -0,0 +1,100 @@
+//===----- GrammarBuilder.h -- CFL Grammar 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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * GrammarBuilder.h
+ *
+ *  Created on: April 26, 2022
+ *      Author: Pei Xu
+ */
+
+#ifndef INCLUDE_CFL_GRAMMARBUILDER_H_
+#define INCLUDE_CFL_GRAMMARBUILDER_H_
+
+#include "CFL/CFLGrammar.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:
+ *      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
+ *      Gep_j -> Gep_i F vgep; // Support variable attribute with variable attribute
+ *      Gep_1 -> Gep_2;      // Support fix number attribute
+ *
+ */
+
+class GrammarBuilder
+{
+private:
+    std::string fileName;
+    GrammarBase *grammar;
+
+    /// Parse start symbol and production from file string
+    const inline std::string parseProductionsString() const;
+
+    /// Parse whole production string to production vector
+    const inline std::vector<std::string> loadWordProductions() const;
+
+    /// Strip front and tail space
+    const inline std::string stripSpace(std::string s) const;
+
+public:
+    GrammarBuilder(std::string fileName): fileName(fileName), grammar(nullptr)
+    {
+        grammar = new GrammarBase();
+    };
+
+    /// Build grammarBase from fileName
+    GrammarBase* build() 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/SVF-osx/svf/include/include/CFL/PEGGrammar.txt

@@ -0,0 +1,11 @@
+Start:  
+   V
+Terminal:
+   addr copy store load gep
+Productions:
+   F -> ( copy M ? ) *;
+   Fbar -> ( M ? copybar ) *;
+   M -> addr V addrbar;
+   V -> Fbar V F | gepbar_i V gep_i | M | epsilon | gepbar_i Memcpy gep_i | gep_i Memcpy gepbar_i | ArrayPath V gep_0;
+   ArrayPath -> gepbar_0 gepbar_0 | ArrayPath gepbar_0;
+   Memcpy -> addrbar V addr | gep_i Memcpy gepbar_i | F Memcpy Fbar;

package/SVF-osx/svf/include/include/CFL/VFG.txt

@@ -0,0 +1,7 @@
+Start:  
+   A
+Terminal:
+   a call ret
+Productions:
+   A -> A A | a | call_i A ret_i | epsilon;
+   Abar -> Abar Abar | abar | retbar_i Abar callbar_i | epsilon;