svf-lib 1.0.1376 → 1.0.1377

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

@@ -1,452 +0,0 @@
-//===- PointerAnalysis.h -- Base class of pointer analyses--------------------//
-//
-//                     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/>.
-//
-//===----------------------------------------------------------------------===//
-
-/*
- * PointerAnalysis.h
- *
- *  Created on: Nov 12, 2013
- *      Author: Yulei Sui
- */
-
-#ifndef POINTERANALYSIS_H_
-#define POINTERANALYSIS_H_
-
-#include <unistd.h>
-#include <signal.h>
-
-#include "SVFIR/SVFIR.h"
-#include "MemoryModel/ConditionalPT.h"
-#include "MemoryModel/AbstractPointsToDS.h"
-#include "MemoryModel/MutablePointsToDS.h"
-#include "MemoryModel/PersistentPointsToDS.h"
-#include "Graphs/PTACallGraph.h"
-#include "Graphs/CHG.h"
-#include "Util/SCC.h"
-#include "MemoryModel/PointsTo.h"
-
-namespace SVF
-{
-
-class CommonCHGraph;
-
-class TypeSystem;
-class SVFModule;
-class ICFG;
-class PTAStat;
-/*
- * Pointer Analysis Base Class
- */
-class PointerAnalysis
-{
-
-public:
-    /// Pointer analysis type list
-    enum PTATY
-    {
-        // Whole program analysis
-        Andersen_BASE,		///< Base Andersen PTA
-        Andersen_WPA,		///< Andersen PTA
-        AndersenSCD_WPA,    ///< Selective cycle detection andersen-style WPA
-        AndersenSFR_WPA,    ///< Stride-based field representation
-        AndersenWaveDiff_WPA,	///< Diff wave propagation andersen-style WPA
-        Steensgaard_WPA,      ///< Steensgaard PTA
-        CSCallString_WPA,	///< Call string based context sensitive WPA
-        CSSummary_WPA,		///< Summary based context sensitive WPA
-        FSDATAFLOW_WPA,	///< Traditional Dataflow-based flow sensitive WPA
-        FSSPARSE_WPA,		///< Sparse flow sensitive WPA
-        VFS_WPA,		///< Versioned sparse flow-sensitive WPA
-        FSCS_WPA,			///< Flow-, context- 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
-        FieldS_DDA,		///< Field sensitive DDA
-        FlowS_DDA,		///< Flow sensitive DDA
-        PathS_DDA,		///< Guarded value-flow DDA
-        Cxt_DDA,		///< context sensitive DDA
-
-
-        Default_PTA		///< default pta without any analysis
-    };
-
-    /// Implementation type: BVDataPTAImpl or CondPTAImpl.
-    enum PTAImplTy
-    {
-        BaseImpl,   ///< Represents PointerAnalaysis.
-        BVDataImpl, ///< Represents BVDataPTAImpl.
-        CondImpl,   ///< Represents CondPTAImpl.
-    };
-
-    /// Indirect call edges type, map a callsite to a set of callees
-    //@{
-    typedef Set<const CallICFGNode*> CallSiteSet;
-    typedef SVFIR::CallSiteToFunPtrMap CallSiteToFunPtrMap;
-    typedef Set<const SVFFunction*> FunctionSet;
-    typedef OrderedMap<const CallICFGNode*, FunctionSet> CallEdgeMap;
-    typedef SCCDetection<PTACallGraph*> CallGraphSCC;
-    typedef Set<const SVFGlobalValue*> VTableSet;
-    typedef Set<const SVFFunction*> VFunSet;
-    //@}
-
-    static const std::string aliasTestMayAlias;
-    static const std::string aliasTestMayAliasMangled;
-    static const std::string aliasTestNoAlias;
-    static const std::string aliasTestNoAliasMangled;
-    static const std::string aliasTestPartialAlias;
-    static const std::string aliasTestPartialAliasMangled;
-    static const std::string aliasTestMustAlias;
-    static const std::string aliasTestMustAliasMangled;
-    static const std::string aliasTestFailMayAlias;
-    static const std::string aliasTestFailMayAliasMangled;
-    static const std::string aliasTestFailNoAlias;
-    static const std::string aliasTestFailNoAliasMangled;
-
-private:
-    /// Release the memory
-    void destroy();
-
-protected:
-
-    /// User input flags
-    //@{
-    /// Flag for printing the statistic results
-    bool print_stat;
-    /// Flag for validating points-to/alias results
-    bool alias_validation;
-    /// Flag for iteration budget for on-the-fly statistics
-    u32_t OnTheFlyIterBudgetForStat;
-    //@}
-
-    /// SVFIR
-    static SVFIR* pag;
-    /// Module
-    SVFModule* svfMod;
-    /// Pointer analysis Type
-    PTATY ptaTy;
-    /// PTA implementation type.
-    PTAImplTy ptaImplTy;
-    /// Statistics
-    PTAStat* stat;
-    /// Call graph used for pointer analysis
-    PTACallGraph* ptaCallGraph;
-    /// SCC for CallGraph
-    CallGraphSCC* callGraphSCC;
-    /// Interprocedural control-flow graph
-    ICFG* icfg;
-    /// CHGraph
-    CommonCHGraph *chgraph;
-    /// TypeSystem
-    TypeSystem *typeSystem;
-
-public:
-    /// Get ICFG
-    inline ICFG* getICFG() const
-    {
-        return pag->getICFG();
-    }
-    /// Return number of resolved indirect call edges
-    inline u32_t getNumOfResolvedIndCallEdge() const
-    {
-        return getPTACallGraph()->getNumOfResolvedIndCallEdge();
-    }
-    /// Return call graph
-    inline PTACallGraph* getPTACallGraph() const
-    {
-        return ptaCallGraph;
-    }
-    /// Return call graph SCC
-    inline CallGraphSCC* getCallGraphSCC() const
-    {
-        return callGraphSCC;
-    }
-
-    /// Constructor
-    PointerAnalysis(SVFIR* pag, PTATY ty = Default_PTA, bool alias_check = true);
-
-    /// Type of pointer analysis
-    inline PTATY getAnalysisTy() const
-    {
-        return ptaTy;
-    }
-
-    /// Return implementation type of the pointer analysis.
-    inline PTAImplTy getImplTy() const
-    {
-        return ptaImplTy;
-    }
-
-    /// Get/set SVFIR
-    ///@{
-    inline SVFIR* getPAG() const
-    {
-        return pag;
-    }
-    //@}
-
-    /// Get PTA stat
-    inline PTAStat* getStat() const
-    {
-        return stat;
-    }
-    /// Module
-    inline SVFModule* getModule() const
-    {
-        return svfMod;
-    }
-    /// Get all Valid Pointers for resolution
-    inline OrderedNodeSet& getAllValidPtrs()
-    {
-        return pag->getAllValidPtrs();
-    }
-
-    /// Destructor
-    virtual ~PointerAnalysis();
-
-    /// Initialization of a pointer analysis, including building symbol table and SVFIR etc.
-    virtual void initialize();
-
-    /// Finalization of a pointer analysis, including checking alias correctness
-    virtual void finalize();
-
-    /// Start Analysis here (main part of pointer analysis). It needs to be implemented in child class
-    virtual void analyze() = 0;
-
-    /// Compute points-to results on-demand, overridden by derived classes
-    virtual void computeDDAPts(NodeID) {}
-
-    /// Interface exposed to users of our pointer analysis, given Value infos
-    virtual AliasResult alias(const SVFValue* V1,
-                              const SVFValue* V2) = 0;
-
-    /// Interface exposed to users of our pointer analysis, given PAGNodeID
-    virtual AliasResult alias(NodeID node1, NodeID node2) = 0;
-
-    /// Get points-to targets of a pointer. It needs to be implemented in child class
-    virtual const PointsTo& getPts(NodeID ptr) = 0;
-
-    /// Given an object, get all the nodes having whose pointsto contains the object.
-    /// Similar to getPts, this also needs to be implemented in child classes.
-    virtual const NodeSet& getRevPts(NodeID nodeId) = 0;
-
-    /// Print targets of a function pointer
-    void printIndCSTargets(const CallICFGNode* cs, const FunctionSet& targets);
-
-    // Debug purpose
-    //@{
-    virtual void dumpTopLevelPtsTo() {}
-    virtual void dumpAllPts() {}
-    virtual void dumpCPts() {}
-    virtual void dumpPts(NodeID ptr, const PointsTo& pts);
-    void printIndCSTargets();
-    void dumpAllTypes();
-    //@}
-
-protected:
-    /// Return all indirect callsites
-    inline const CallSiteToFunPtrMap& getIndirectCallsites() const
-    {
-        return pag->getIndirectCallsites();
-    }
-    /// Return function pointer PAGNode at a callsite cs
-    inline NodeID getFunPtr(const CallICFGNode* cs) const
-    {
-        return pag->getFunPtr(cs);
-    }
-    /// Alias check functions to verify correctness of pointer analysis
-    //@{
-    virtual void validateTests();
-    virtual void validateSuccessTests(std::string fun);
-    virtual void validateExpectedFailureTests(std::string fun);
-    //@}
-
-    /// Reset all object node as field-sensitive.
-    void resetObjFieldSensitive();
-
-public:
-    /// Dump the statistics
-    void dumpStat();
-
-    /// Determine whether a points-to contains a black hole or constant node
-    //@{
-    inline bool containBlackHoleNode(const PointsTo& pts)
-    {
-        return pts.test(pag->getBlackHoleNode());
-    }
-    inline bool containConstantNode(const PointsTo& pts)
-    {
-        return pts.test(pag->getConstantNode());
-    }
-    virtual inline bool isBlkObjOrConstantObj(NodeID ptd) const
-    {
-        return pag->isBlkObjOrConstantObj(ptd);
-    }
-    inline bool isNonPointerObj(NodeID ptd) const
-    {
-        return pag->isNonPointerObj(ptd);
-    }
-    //@}
-
-    /// Whether this object is heap or array
-    //@{
-    inline bool isHeapMemObj(NodeID id) const
-    {
-        const MemObj* mem = pag->getObject(id);
-        assert(mem && "memory object is null??");
-        return mem->isHeap();
-    }
-
-    inline bool isArrayMemObj(NodeID id) const
-    {
-        const MemObj* mem = pag->getObject(id);
-        assert(mem && "memory object is null??");
-        return mem->isArray();
-    }
-    //@}
-
-    /// For field-sensitivity
-    ///@{
-    inline bool isFIObjNode(NodeID id) const
-    {
-        return (SVFUtil::isa<FIObjVar>(pag->getGNode(id)));
-    }
-    inline NodeID getBaseObjVar(NodeID id)
-    {
-        return pag->getBaseObjVar(id);
-    }
-    inline NodeID getFIObjVar(NodeID id)
-    {
-        return pag->getFIObjVar(id);
-    }
-    inline NodeID getGepObjVar(NodeID id, const LocationSet& ls)
-    {
-        return pag->getGepObjVar(id,ls);
-    }
-    virtual inline const NodeBS& getAllFieldsObjVars(NodeID id)
-    {
-        return pag->getAllFieldsObjVars(id);
-    }
-    inline void setObjFieldInsensitive(NodeID id)
-    {
-        MemObj* mem =  const_cast<MemObj*>(pag->getBaseObj(id));
-        mem->setFieldInsensitive();
-    }
-    inline bool isFieldInsensitive(NodeID id) const
-    {
-        const MemObj* mem =  pag->getBaseObj(id);
-        return mem->isFieldInsensitive();
-    }
-    ///@}
-
-    /// Whether print statistics
-    inline bool printStat()
-    {
-        return print_stat;
-    }
-
-    /// Whether print statistics
-    inline void disablePrintStat()
-    {
-        print_stat = false;
-    }
-
-    /// Get callees from an indirect callsite
-    //@{
-    inline CallEdgeMap& getIndCallMap()
-    {
-        return getPTACallGraph()->getIndCallMap();
-    }
-    inline bool hasIndCSCallees(const CallICFGNode* cs) const
-    {
-        return getPTACallGraph()->hasIndCSCallees(cs);
-    }
-    inline const FunctionSet& getIndCSCallees(const CallICFGNode* cs) const
-    {
-        return getPTACallGraph()->getIndCSCallees(cs);
-    }
-    //@}
-
-    /// Resolve indirect call edges
-    virtual void resolveIndCalls(const CallICFGNode* cs, const PointsTo& target, CallEdgeMap& newEdges);
-    /// Match arguments for callsite at caller and callee
-    bool matchArgs(const CallICFGNode* cs, const SVFFunction* callee);
-
-    /// CallGraph SCC related methods
-    //@{
-    /// CallGraph SCC detection
-    inline void callGraphSCCDetection()
-    {
-        if(callGraphSCC==nullptr)
-            callGraphSCC = new CallGraphSCC(ptaCallGraph);
-
-        callGraphSCC->find();
-    }
-    /// Get SCC rep node of a SVFG node.
-    inline NodeID getCallGraphSCCRepNode(NodeID id) const
-    {
-        return callGraphSCC->repNode(id);
-    }
-    /// Return TRUE if this edge is inside a CallGraph SCC, i.e., src node and dst node are in the same SCC on the SVFG.
-    inline bool inSameCallGraphSCC(const SVFFunction* fun1,const SVFFunction* fun2)
-    {
-        const PTACallGraphNode* src = ptaCallGraph->getCallGraphNode(fun1);
-        const PTACallGraphNode* dst = ptaCallGraph->getCallGraphNode(fun2);
-        return (getCallGraphSCCRepNode(src->getId()) == getCallGraphSCCRepNode(dst->getId()));
-    }
-    inline bool isInRecursion(const SVFFunction* fun) const
-    {
-        return callGraphSCC->isInCycle(ptaCallGraph->getCallGraphNode(fun)->getId());
-    }
-    /// Whether a local variable is in function recursions
-    bool isLocalVarInRecursiveFun(NodeID id) const;
-    //@}
-
-    /// Return PTA name
-    virtual const std::string PTAName() const
-    {
-        return "Pointer Analysis";
-    }
-
-    /// get CHGraph
-    CommonCHGraph *getCHGraph() const
-    {
-        return chgraph;
-    }
-
-    void getVFnsFromCHA(const CallICFGNode* cs, VFunSet &vfns);
-    void getVFnsFromPts(const CallICFGNode* cs, const PointsTo &target, VFunSet &vfns);
-    void connectVCallToVFns(const CallICFGNode* cs, const VFunSet &vfns, CallEdgeMap& newEdges);
-    virtual void resolveCPPIndCalls(const CallICFGNode* cs,
-                                    const PointsTo& target,
-                                    CallEdgeMap& newEdges);
-
-    /// get TypeSystem
-    const TypeSystem *getTypeSystem() const
-    {
-        return typeSystem;
-    }
-};
-
-} // End namespace SVF
-
-#endif /* POINTERANALYSIS_H_ */