svf-lib 1.0.1376 → 1.0.1377

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

@@ -1,84 +0,0 @@
-//===----- CFGNormalizer.h -- Context Free Grammar Normalizer--------------//
-//
-//                     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 INCLUDE_CFL_CFGNORMALIZER_H_
-#define INCLUDE_CFL_CFGNORMALIZER_H_
-
-#include "CFLGrammar.h"
-
-namespace SVF
-{
-
-/*!
- *  Generate Normalized Grammar (backus naur form) from a grammarbase (Extended extended Backus–Naur form )
- *
- *  To Do:
- *      Error Notice for ill formed production,
- *      e.g. not end with ';' and '*' not preceding with '()' and extra space before ';'
- *      '|' sign support
- */
-
-class CFGNormalizer
-{
-
-public:
-    CFGNormalizer()
-    {
-    }
-
-    /// Binary Normal Form(BNF) normalization with variable attribute expanded
-    CFLGrammar* normalize(GrammarBase *generalGrammar);
-
-    /// Expand every variable attribute in rawProductions of grammarbase
-    CFLGrammar* fillAttribute(CFLGrammar *grammar, const Map<CFLGrammar::Kind, Set<CFLGrammar::Attribute>>& kind2AttrsMap);
-
-private:
-    /// Add nonterminal to tranfer long rules to binary rules
-    void ebnf_bin(CFLGrammar *grammar);
-
-    void ebnfSignReplace(char sign, CFLGrammar *grammar);
-
-    void barReplace(CFLGrammar *grammar);
-
-    void insertToCFLGrammar(CFLGrammar *grammar, GrammarBase::Production &prod);
-
-    int ebnfBracketMatch(GrammarBase::Production& prod, int i, CFLGrammar *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 getFilledProductions(GrammarBase::Production &prod,const NodeSet& nodeSet, CFLGrammar *grammar, GrammarBase::Productions& normalProds);
-
-    void removeFirstSymbol(CFLGrammar *grammar);
-};
-
-} // End namespace SVF
-
-#endif /* INCLUDE_CFL_CFGNORMALIZER_H_*/

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

@@ -1,176 +0,0 @@
-//===----- 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
- */
-
-#ifndef INCLUDE_CFL_CFLALIAS_H_
-#define INCLUDE_CFL_CFLALIAS_H_
-
-#include "CFL/CFLBase.h"
-#include "CFL/CFLStat.h"
-#include "CFL/CFLData.h"
-#include "CFL/CFLDataBuilder.h"
-
-namespace SVF
-{
-
-class CFLStat;
-
-class CFLAlias : public CFLBase
-{
-
-public:
-    typedef OrderedMap<CallSite, NodeID> CallSite2DummyValPN;
-
-    CFLAlias(SVFIR* ir) : CFLBase(ir, PointerAnalysis::CFLFICI_WPA)
-    {
-    }
-
-    /// Initialize the grammar, graph, solver
-    virtual void initialize();
-
-    /// Print grammar and graph
-    virtual void finalize();
-
-    /// Solving CFL Reachability
-    virtual void solve();
-
-    /// Interface exposed to users of our Alias analysis, given Value infos
-    virtual AliasResult alias(const SVFValue* v1, const SVFValue* v2)
-    {
-        NodeID n1 = svfir->getValueNode(v1);
-        NodeID n2 = svfir->getValueNode(v2);
-        return alias(n1,n2);
-    }
-
-    /// Interface exposed to users of our Alias analysis, given PAGNodeID
-    virtual AliasResult alias(NodeID node1, NodeID node2)
-    {
-        if(graph->hasEdge(graph->getGNode(node1), graph->getGNode(node2), graph->startKind))
-            return AliasResult::MayAlias;
-        else
-            return AliasResult::NoAlias;
-    }
-
-    /// Get points-to targets of a pointer.  V In this context
-    virtual const PointsTo& getCFLPts(NodeID ptr)
-    {
-        /// Check V Dst of ptr.
-        CFLNode *funNode = graph->getGNode(ptr);
-        for(auto outedge = funNode->getOutEdges().begin(); outedge!=funNode->getOutEdges().end(); outedge++)
-        {
-            if((*outedge)->getEdgeKind() == graph->getStartKind())
-            {
-                // Need to Find dst addr src
-                CFLNode *vNode = graph->getGNode((*outedge)->getDstID());
-                addPts(ptr, svfir->getBaseValVar((*outedge)->getDstID()));
-                for(auto inEdge = vNode->getInEdges().begin(); inEdge!=vNode->getInEdges().end(); inEdge++)
-                {
-                    if((*inEdge)->getEdgeKind() == 0)
-                    {
-                        addPts(ptr, (*inEdge)->getSrcID());
-                    }
-                }
-            }
-        }
-        return getPts(ptr);
-    }
-
-    /// Need Original one for virtual table
-
-    /// Add copy edge on constraint graph
-    virtual inline bool addCopyEdge(NodeID src, NodeID dst)
-    {
-        const CFLEdge *edge = graph->hasEdge(graph->getGNode(src),graph->getGNode(dst), 1);
-        if (edge != nullptr )
-        {
-            return false;
-        }
-        CFLGrammar::Kind copyKind = grammar->str2Kind("copy");
-        CFLGrammar::Kind copybarKind = grammar->str2Kind("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;
-    }
-
-    /// 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
-    }
-
-    /// Update call graph for the input indirect callsites
-    virtual bool updateCallGraph(const CallSiteToFunPtrMap& callsites);
-
-    /// On the fly call graph construction
-    virtual void onTheFlyCallGraphSolve(const CallSiteToFunPtrMap& callsites, CallEdgeMap& newEdges);
-
-    /// Connect formal and actual parameters for indirect callsites
-    void connectCaller2CalleeParams(CallSite cs, const SVFFunction* F);
-
-    void heapAllocatorViaIndCall(CallSite cs);
-
-private:
-    CallSite2DummyValPN callsite2DummyValPN;        ///< Map an instruction to a dummy obj which created at an indirect callsite, which invokes a heap allocator
-};
-
-class POCRAlias : public CFLAlias
-{
-public:
-    static double timeOfBuildCFLData;            // Time of building CFLData from CFLGraph
-
-    POCRAlias(SVFIR* ir) : CFLAlias(ir)
-    {
-        if (!_cflData)
-            _cflData = new CFLData();
-    }
-
-    /// Destructor
-    virtual ~POCRAlias()
-    {
-        delete _cflData;
-    }
-
-    CFLData* cflData()
-    {
-        return _cflData;
-    }
-
-    /// Initialize the grammar, graph, CFLData, solver
-    virtual void initialize();
-
-    /// Init CFLData
-    virtual void buildCFLData();
-
-private:
-    /// Graph dataset
-    CFLData* _cflData;
-};
-} // End namespace SVF
-
-#endif /* INCLUDE_CFL_CFLALIAS_H_*/

package/SVF-linux/svf/include/include/CFL/CFLBase.h

@@ -1,115 +0,0 @@
-//===----- CFLBase.h -- CFL Analysis Client Base--------------//
-//
-//                     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/>.
-//
-//===----------------------------------------------------------------------===//
-
-/*
- * CFLBase.h
- *
- *  Created on: Oct 12, 2022
- *      Author: Pei Xu
- */
-
-#ifndef INCLUDE_CFL_CFLBASE_H_
-#define INCLUDE_CFL_CFLBASE_H_
-
-#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"
-#include "SVFIR/SVFType.h"
-
-namespace SVF
-{
-
-class CFLStat;
-
-/// CFL Client Base Class
-class CFLBase : public BVDataPTAImpl
-{
-
-public:
-    CFLBase(SVFIR* ir, PointerAnalysis::PTATY pty) : BVDataPTAImpl(ir, pty), svfir(ir), graph(nullptr), grammar(nullptr), solver(nullptr)
-    {
-    }
-
-    /// Destructor
-    virtual ~CFLBase()
-    {
-        delete solver;
-        delete grammarBase;
-    }
-
-    /// Build Grammar from text file
-    virtual void buildCFLGrammar();
-
-    /// Build CFLGraph based on Option
-    virtual void buildCFLGraph();
-
-    /// Normalize grammar
-    virtual void normalizeCFLGrammar();
-
-    /// Get CFL graph
-    CFLGraph* getCFLGraph();
-
-    /// Count the num of Nonterminal Edges
-    virtual void countSumEdges();
-
-    /// Solving CFL Reachability
-    virtual void solve();
-
-    /// Finalize extra stat info passing
-    virtual void finalize();
-
-    /// Perform analyze (main part of CFLR Analysis)
-    virtual void analyze();
-
-    /// Statistics
-    //@{
-    // Grammar
-    static double timeOfBuildCFLGrammar;            // Time of building grammarBase from text file
-    static double timeOfNormalizeGrammar;           // Time of normalizing grammarBase to CFLGrammar
-    // Graph
-    static double timeOfBuildCFLGraph;              // Time of building CFLGraph
-    static double numOfTerminalEdges;               // Number of terminal labeled edges
-    static double numOfTemporaryNonterminalEdges;   // Number of temporary (ie. X0, X1..) nonterminal labeled edges
-    static double numOfNonterminalEdges;            // Number of nonterminal labeled edges
-    static double numOfStartEdges;                  // Number of start nonterminal labeled edges
-    // Solver
-    static double numOfIteration;                   // Number solving Iteration
-    static double numOfChecks;                  // Number of checks
-    static double timeOfSolving;                    // time of solving CFL Reachability
-    //@}
-
-protected:
-    SVFIR* svfir;
-    CFLGraph* graph;
-    GrammarBase* grammarBase;
-    CFLGrammar* grammar;
-    CFLSolver* solver;
-};
-
-} // End namespace SVF
-
-#endif /* INCLUDE_CFL_CFLBASE_H_*/

package/SVF-linux/svf/include/include/CFL/CFLData.h

@@ -1,316 +0,0 @@
-//===----- CFLData.h -- Context Free Language Reachability Graph Data Structure--------------//
-//
-//                     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/>.
-//
-//===----------------------------------------------------------------------===//
-
-/*
- * CFLData.h
- *
- *  Created on: Nov 22, 2019
- *      Author: Yuxiang Lei
- *
- * The implementation is based on
- * Yuxiang Lei, Yulei Sui, Shuo Ding, and Qirun Zhang.
- * Taming Transitive Redundancy for Context-Free Language Reachability.
- * ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications
- */
-
-#ifndef INCLUDE_CFL_CFGDATA_H_
-#define INCLUDE_CFL_CFGDATA_H_
-
-#include "Util/WorkList.h"
-#include "CFL/CFLGrammar.h"
-
-namespace SVF
-{
-typedef GrammarBase::Symbol Label;
-/*!
- * Adjacency-list graph representation
- */
-class CFLData
-{
-public:
-    typedef std::map<const Label, NodeBS> TypeMap;                  // Label with SparseBitVector of NodeID
-    typedef std::unordered_map<NodeID, TypeMap> DataMap;            // Each Node has a TypeMap
-    typedef typename DataMap::iterator iterator;                    // iterator for each node
-    typedef typename DataMap::const_iterator const_iterator;        // const iterator
-
-protected:
-    DataMap succMap;                                                // succ map for nodes contains Label: Edgeset
-    DataMap predMap;                                                // pred map for nodes contains Label: edgeset
-    const NodeBS emptyData;                                         // ??
-    NodeBS diff;                                                    // ??
-
-    // union/add data
-    //@{
-    inline bool addPred(const NodeID key, const NodeID src, const Label ty)
-    {
-        return predMap[key][ty].test_and_set(src);
-    };
-
-    inline bool addSucc(const NodeID key, const NodeID dst, const Label ty)
-    {
-        return succMap[key][ty].test_and_set(dst);
-    };
-
-    inline bool addPreds(const NodeID key, const NodeBS& data, const Label ty)
-    {
-        if (data.empty())
-            return false;
-        return predMap[key][ty] |= data;                            // union of sparsebitvector (add to LHS)
-    }
-
-    inline bool addSuccs(const NodeID key, const NodeBS& data, const Label ty)
-    {
-        if (data.empty())
-            return false;
-        return succMap[key][ty] |= data;                            // // union of sparsebitvector (add to LHS)
-    }
-    //@}
-
-public:
-    // Constructor
-    CFLData()
-    {}
-
-    // Destructor
-    virtual ~CFLData()
-    {}
-
-    virtual void clear()
-    {
-        succMap.clear();
-        predMap.clear();
-    }
-
-    inline const_iterator begin() const
-    {
-        return succMap.begin();
-    }
-
-    inline const_iterator end() const
-    {
-        return succMap.end();
-    }
-
-    inline iterator begin()
-    {
-        return succMap.begin();
-    }
-
-    inline iterator end()
-    {
-        return succMap.end();
-    }
-
-    inline DataMap& getSuccMap()
-    {
-        return succMap;
-    }
-
-    inline DataMap& getPredMap()
-    {
-        return predMap;
-    }
-
-    inline TypeMap& getSuccMap(const NodeID key)
-    {
-        return succMap[key];
-    }
-
-    inline TypeMap& getPredMap(const NodeID key)
-    {
-        return predMap[key];
-    }
-
-    inline NodeBS& getSuccs(const NodeID key, const Label ty)
-    {
-        return succMap[key][ty];
-    }
-
-    inline NodeBS& getPreds(const NodeID key, const Label ty)
-    {
-        return predMap[key][ty];
-    }
-
-    // Alias data operations
-    //@{
-    inline bool addEdge(const NodeID src, const NodeID dst, const Label ty)
-    {
-        addSucc(src, dst, ty);
-        return addPred(dst, src, ty);
-    }
-
-    /// add edges and return the set of added edges (dst) for src
-    inline NodeBS addEdges(const NodeID src, const NodeBS& dstData, const Label ty)
-    {
-        NodeBS newDsts;
-        if (addSuccs(src, dstData, ty))
-        {
-            for (const NodeID datum: dstData)
-                if (addPred(datum, src, ty))
-                    newDsts.set(datum);
-        }
-        return newDsts;
-    }
-
-    /// add edges and return the set of added edges (src) for dst
-    inline NodeBS addEdges(const NodeBS& srcData, const NodeID dst, const Label ty)
-    {
-        NodeBS newSrcs;
-        if (addPreds(dst, srcData, ty))
-        {
-            for (const NodeID datum: srcData)
-                if (addSucc(datum, dst, ty))
-                    newSrcs.set(datum);
-        }
-        return newSrcs;
-    }
-
-    /// find src -> find src[ty] -> find dst in set
-    inline bool hasEdge(const NodeID src, const NodeID dst, const Label ty)
-    {
-        const_iterator iter1 = succMap.find(src);
-        if (iter1 == succMap.end())
-            return false;
-
-        auto iter2 = iter1->second.find(ty);
-        if (iter2 == iter1->second.end())
-            return false;
-
-        return iter2->second.test(dst);
-    }
-
-    /* This is a dataset version, to be modified to a cflData version */
-    inline void clearEdges(const NodeID key)
-    {
-        succMap[key].clear();
-        predMap[key].clear();
-    }
-    //@}
-};
-
-
-/*!
- * Hybrid graph representation for transitive relations
- */
-class HybridData
-{
-public:
-    struct TreeNode
-    {
-        NodeID id;
-        std::unordered_set<TreeNode*> children;
-
-        TreeNode(NodeID nId) : id(nId)
-        {}
-
-        ~TreeNode()
-        {
-        }
-
-        inline bool operator==(const TreeNode& rhs) const
-        {
-            return id == rhs.id;
-        }
-
-        inline bool operator<(const TreeNode& rhs) const
-        {
-            return id < rhs.id;
-        }
-    };
-
-
-public:
-    Map<NodeID, std::unordered_map<NodeID, TreeNode*>> indMap;   // indMap[v][u] points to node v in tree(u)
-
-    HybridData()
-    {}
-
-    ~HybridData()
-    {
-        for (auto iter1: indMap)
-        {
-            for (auto iter2: iter1.second)
-            {
-                delete iter2.second;
-                iter2.second = NULL;
-            }
-        }
-    }
-
-    bool hasInd(NodeID src, NodeID dst)
-    {
-        auto it = indMap.find(dst);
-        if (it == indMap.end())
-            return false;
-        return (it->second.find(src) != it->second.end());
-    }
-
-    /// Add a node dst to tree(src)
-    TreeNode* addInd(NodeID src, NodeID dst)
-    {
-        auto resIns = indMap[dst].insert(std::make_pair(src, new TreeNode(dst)));
-        if (resIns.second)
-            return resIns.first->second;
-        return nullptr;
-    }
-
-    /// Get the node dst in tree(src)
-    TreeNode* getNode(NodeID src, NodeID dst)
-    {
-        return indMap[dst][src];
-    }
-
-    /// add v into desc(x) as a child of u
-    void insertEdge(TreeNode* u, TreeNode* v)
-    {
-        u->children.insert(v);
-    }
-
-    void addArc(NodeID src, NodeID dst)
-    {
-        if (!hasInd(src, dst))
-        {
-            for (auto iter: indMap[src])
-            {
-                meld(iter.first, getNode(iter.first, src), getNode(dst, dst));
-            }
-        }
-    }
-
-    void meld(NodeID x, TreeNode* uNode, TreeNode* vNode)
-    {
-        TreeNode* newVNode = addInd(x, vNode->id);
-        if (!newVNode)
-            return;
-
-        insertEdge(uNode, newVNode);
-        for (TreeNode* vChild: vNode->children)
-        {
-            meld(x, newVNode, vChild);
-        }
-    }
-};
-
-
-}   // end namespace SVF
-
-#endif