svf-lib 1.0.733 → 1.0.737

package/SVF-linux/include/DDA/ContextDDA.h

@@ -28,7 +28,7 @@ class ContextDDA : public CondPTAImpl<ContextCond>, public DDAVFSolver<CxtVar,Cx
 
 public:
     /// Constructor
-    ContextDDA(PAG* _pag, DDAClient* client);
+    ContextDDA(SVFIR* _pag, DDAClient* client);
 
     /// Destructor
     virtual ~ContextDDA();

package/SVF-linux/include/DDA/DDAClient.h

@@ -11,7 +11,7 @@
 #ifndef DDACLIENT_H_
 #define DDACLIENT_H_
 
-#include "Graphs/PAG.h"
+#include "MemoryModel/SVFIR.h"
 #include "MemoryModel/PointerAnalysisImpl.h"
 #include "Graphs/SVFG.h"
 #include "Util/BasicTypes.h"
@@ -32,7 +32,7 @@ public:
     virtual inline void initialise(SVFModule*) {}
 
     /// Collect candidate pointers for query.
-    virtual inline OrderedNodeSet& collectCandidateQueries(PAG* p)
+    virtual inline OrderedNodeSet& collectCandidateQueries(SVFIR* p)
     {
         setPAG(p);
         if (solveAll)
@@ -52,8 +52,8 @@ public:
 
     /// Call back used by DDAVFSolver.
     virtual inline void handleStatement(const SVFGNode*, NodeID) {}
-    /// Set PAG graph.
-    inline void setPAG(PAG* g)
+    /// Set SVFIR graph.
+    inline void setPAG(SVFIR* g)
     {
         pag = g;
     }
@@ -81,11 +81,11 @@ public:
 protected:
     void addCandidate(NodeID id)
     {
-        if (pag->isValidTopLevelPtr(pag->getPAGNode(id)))
+        if (pag->isValidTopLevelPtr(pag->getGNode(id)))
             candidateQueries.insert(id);
     }
 
-    PAG*   pag;					///< PAG graph used by current DDA analysis
+    SVFIR*   pag;					///< SVFIR graph used by current DDA analysis
     SVFModule* module;		///< LLVM module
     NodeID curPtr;				///< current pointer being queried
     OrderedNodeSet candidateQueries;	///< store all candidate pointers to be queried
@@ -109,7 +109,7 @@ public:
     ~FunptrDDAClient() {}
 
     /// Only collect function pointers as query candidates.
-    virtual OrderedNodeSet& collectCandidateQueries(PAG* p);
+    virtual OrderedNodeSet& collectCandidateQueries(SVFIR* p);
     virtual void performStat(PointerAnalysis* pta);
 };
 
@@ -128,7 +128,7 @@ public:
     ~AliasDDAClient() {}
 
     /// Only collect function pointers as query candidates.
-    virtual OrderedNodeSet& collectCandidateQueries(PAG* pag);
+    virtual OrderedNodeSet& collectCandidateQueries(SVFIR* pag);
 
     virtual void performStat(PointerAnalysis* pta);
 

package/SVF-linux/include/DDA/DDAVFSolver.h

@@ -29,7 +29,7 @@ public:
     typedef SCCDetection<SVFG*> SVFGSCC;
     typedef SCCDetection<PTACallGraph*> CallGraphSCC;
     typedef PTACallGraphEdge::CallInstSet CallInstSet;
-    typedef PAG::CallSiteSet CallSiteSet;
+    typedef SVFIR::CallSiteSet CallSiteSet;
     typedef OrderedSet<DPIm> DPTItemSet;
     typedef OrderedMap<DPIm, CPtSet> DPImToCPtSetMap;
     typedef OrderedMap<DPIm,CVar> DPMToCVarMap;
@@ -287,7 +287,7 @@ protected:
     }
 
     /// Build SVFG
-    virtual inline void buildSVFG(PAG* pag)
+    virtual inline void buildSVFG(SVFIR* pag)
     {
         _ander = AndersenWaveDiff::createAndersenWaveDiff(pag);
         _svfg = svfgBuilder.buildPTROnlySVFGWithoutOPT(_ander);
@@ -473,7 +473,7 @@ protected:
             {
                 NodeID funPtr = _pag->getFunPtr(cbn);
                 DPIm funPtrDpm(dpm);
-                funPtrDpm.setLocVar(getSVFG()->getDefSVFGNode(_pag->getPAGNode(funPtr)),funPtr);
+                funPtrDpm.setLocVar(getSVFG()->getDefSVFGNode(_pag->getGNode(funPtr)),funPtr);
                 findPT(funPtrDpm);
             }
         }
@@ -486,7 +486,7 @@ protected:
             {
                 NodeID funPtr = _pag->getFunPtr(*it);
                 DPIm funPtrDpm(dpm);
-                funPtrDpm.setLocVar(getSVFG()->getDefSVFGNode(_pag->getPAGNode(funPtr)),funPtr);
+                funPtrDpm.setLocVar(getSVFG()->getDefSVFGNode(_pag->getGNode(funPtr)),funPtr);
                 findPT(funPtrDpm);
             }
         }
@@ -750,7 +750,7 @@ protected:
     }
 
     bool outOfBudgetQuery;			///< Whether the current query is out of step limits
-    PAG* _pag;						///< PAG
+    SVFIR* _pag;						///< SVFIR
     SVFG* _svfg;					///< SVFG
     AndersenWaveDiff* _ander;		///< Andersen's analysis
     NodeBS candidateQueries;		///< candidate pointers;

package/SVF-linux/include/DDA/FlowDDA.h

@@ -30,7 +30,7 @@ public:
     typedef BVDataPTAImpl::CallEdgeMap	CallEdgeMap;
     typedef BVDataPTAImpl::FunctionSet	FunctionSet;
     /// Constructor
-    FlowDDA(PAG* _pag, DDAClient* client): BVDataPTAImpl(_pag, PointerAnalysis::FlowS_DDA),
+    FlowDDA(SVFIR* _pag, DDAClient* client): BVDataPTAImpl(_pag, PointerAnalysis::FlowS_DDA),
         DDAVFSolver<NodeID,PointsTo,LocDPItem>(),
         _client(client)
     {

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

@@ -0,0 +1,351 @@
+//===----- CHG.h -- Base class of pointer analyses ---------------------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * CHG.h (previously CHA.h)
+ *
+ *  Created on: Apr 13, 2016
+ *      Author: Xiaokang Fan
+ * 
+ * Created on: Aug 24, 2019
+ *      Author: Mohamad Barbar
+ */
+
+#ifndef CHA_H_
+#define CHA_H_
+
+#include "Util/SVFModule.h"
+#include "Graphs/GenericGraph.h"
+#include "Util/WorkList.h"
+
+namespace SVF
+{
+
+class SVFModule;
+class CHNode;
+
+typedef Set<const GlobalValue*> VTableSet;
+typedef Set<const SVFFunction*> VFunSet;
+
+/// Common base for class hierarchy graph. Only implements what PointerAnalysis needs.
+class CommonCHGraph
+{
+public:
+    virtual ~CommonCHGraph() { };
+    enum CHGKind
+    {
+        Standard,
+        DI
+    };
+
+    virtual bool csHasVFnsBasedonCHA(CallSite cs) = 0;
+    virtual const VFunSet &getCSVFsBasedonCHA(CallSite cs) = 0;
+    virtual bool csHasVtblsBasedonCHA(CallSite cs) = 0;
+    virtual const VTableSet &getCSVtblsBasedonCHA(CallSite cs) = 0;
+    virtual void getVFnsFromVtbls(CallSite cs, const VTableSet &vtbls, VFunSet &virtualFunctions) = 0;
+
+    CHGKind getKind(void) const
+    {
+        return kind;
+    }
+
+protected:
+    CHGKind kind;
+};
+
+
+typedef GenericEdge<CHNode> GenericCHEdgeTy;
+class CHEdge: public GenericCHEdgeTy
+{
+public:
+    typedef enum
+    {
+        INHERITANCE = 0x1, // inheritance relation
+        INSTANTCE = 0x2 // template-instance relation
+    } CHEDGETYPE;
+
+    typedef GenericNode<CHNode,CHEdge>::GEdgeSetTy CHEdgeSetTy;
+
+    CHEdge(CHNode *s, CHNode *d, CHEDGETYPE et, GEdgeFlag k = 0):
+        GenericCHEdgeTy(s,d,k)
+    {
+        edgeType = et;
+    }
+
+    CHEDGETYPE getEdgeType() const
+    {
+        return edgeType;
+    }
+
+private:
+    CHEDGETYPE edgeType;
+};
+
+typedef GenericNode<CHNode,CHEdge> GenericCHNodeTy;
+class CHNode: public GenericCHNodeTy
+{
+public:
+    typedef enum
+    {
+        PURE_ABSTRACT = 0x1, // pure virtual abstract class
+        MULTI_INHERITANCE = 0x2, // multi inheritance class
+        TEMPLATE = 0x04 // template class
+    } CLASSATTR;
+
+    typedef std::vector<const SVFFunction*> FuncVector;
+
+    CHNode (const std::string name, NodeID i = 0, GNodeK k = 0):
+        GenericCHNodeTy(i, k), vtable(nullptr), className(name), flags(0)
+    {
+    }
+    ~CHNode()
+    {
+    }
+    std::string getName() const
+    {
+        return className;
+    }
+    /// Flags
+    //@{
+    inline void setFlag(CLASSATTR mask)
+    {
+        flags |= mask;
+    }
+    inline bool hasFlag(CLASSATTR mask) const
+    {
+        return (flags & mask) == mask;
+    }
+    //@}
+
+    /// Attribute
+    //@{
+    inline void setPureAbstract()
+    {
+        setFlag(PURE_ABSTRACT);
+    }
+    inline void setMultiInheritance()
+    {
+        setFlag(MULTI_INHERITANCE);
+    }
+    inline void setTemplate()
+    {
+        setFlag(TEMPLATE);
+    }
+    inline bool isPureAbstract() const
+    {
+        return hasFlag(PURE_ABSTRACT);
+    }
+    inline bool isMultiInheritance() const
+    {
+        return hasFlag(MULTI_INHERITANCE);
+    }
+    inline bool isTemplate() const
+    {
+        return hasFlag(TEMPLATE);
+    }
+    //@}
+
+    void addVirtualFunctionVector(FuncVector vfuncvec)
+    {
+        virtualFunctionVectors.push_back(vfuncvec);
+    }
+    const std::vector<FuncVector> &getVirtualFunctionVectors() const
+    {
+        return virtualFunctionVectors;
+    }
+    void getVirtualFunctions(u32_t idx, FuncVector &virtualFunctions) const;
+
+    const GlobalValue *getVTable() const
+    {
+        return vtable;
+    }
+
+    void setVTable(const GlobalValue *vtbl)
+    {
+        vtable = vtbl;
+    }
+
+private:
+    const GlobalValue* vtable;
+    std::string className;
+    size_t flags;
+    /*
+     * virtual functions inherited from different classes are separately stored
+     * to model different vtables inherited from different fathers.
+     *
+     * Example:
+     * class C: public A, public B
+     * vtableC = {Af1, Af2, ..., inttoptr, Bg1, Bg2, ...} ("inttoptr"
+     * instruction works as the delimiter for separating virtual functions
+     * inherited from different classes)
+     *
+     * virtualFunctionVectors = {{Af1, Af2, ...}, {Bg1, Bg2, ...}}
+     */
+    std::vector<FuncVector> virtualFunctionVectors;
+};
+
+/// class hierarchy graph
+typedef GenericGraph<CHNode,CHEdge> GenericCHGraphTy;
+class CHGraph: public CommonCHGraph, public GenericCHGraphTy
+{
+friend class CHGBuilder;
+
+public:
+    typedef Set<const CHNode*> CHNodeSetTy;
+    typedef FIFOWorkList<const CHNode*> WorkList;
+    typedef Map<std::string, CHNodeSetTy> NameToCHNodesMap;
+    typedef Map<CallSite, CHNodeSetTy> CallSiteToCHNodesMap;
+    typedef Map<CallSite, VTableSet> CallSiteToVTableSetMap;
+    typedef Map<CallSite, VFunSet> CallSiteToVFunSetMap;
+
+    typedef enum
+    {
+        CONSTRUCTOR = 0x1, // connect node based on constructor
+        DESTRUCTOR = 0x2 // connect node based on destructor
+    } RELATIONTYPE;
+
+    CHGraph(SVFModule* svfModule): svfMod(svfModule), classNum(0), vfID(0), buildingCHGTime(0)
+    {
+        this->kind = Standard;
+    }
+    ~CHGraph() override = default;
+
+    void addEdge(const std::string className,
+                 const std::string baseClassName,
+                 CHEdge::CHEDGETYPE edgeType);
+    CHNode *getNode(const std::string name) const;
+    void getVFnsFromVtbls(CallSite cs, const VTableSet &vtbls, VFunSet &virtualFunctions) override;
+    void dump(const std::string& filename);
+    void view();
+    void printCH();
+
+    inline s32_t getVirtualFunctionID(const SVFFunction* vfn) const
+    {
+        Map<const SVFFunction*, s32_t>::const_iterator it =
+            virtualFunctionToIDMap.find(vfn);
+        if (it != virtualFunctionToIDMap.end())
+            return it->second;
+        else
+            return -1;
+    }
+    inline const SVFFunction* getVirtualFunctionBasedonID(s32_t id) const
+    {
+        Map<const SVFFunction*, s32_t>::const_iterator it, eit;
+        for (it = virtualFunctionToIDMap.begin(), eit =
+                    virtualFunctionToIDMap.end(); it != eit; ++it)
+        {
+            if (it->second == id)
+                return it->first;
+        }
+        return nullptr;
+    }
+
+    inline void addInstances(const std::string templateName, CHNode* node)
+    {
+        NameToCHNodesMap::iterator it = templateNameToInstancesMap.find(
+                                            templateName);
+        if (it != templateNameToInstancesMap.end())
+            it->second.insert(node);
+        else
+            templateNameToInstancesMap[templateName].insert(node);
+    }
+    inline const CHNodeSetTy &getDescendants(const std::string className)
+    {
+        return classNameToDescendantsMap[className];
+    }
+    inline const CHNodeSetTy &getInstances(const std::string className)
+    {
+        return templateNameToInstancesMap[className];
+    }
+
+    inline bool csHasVtblsBasedonCHA(CallSite cs) override
+    {
+        CallSiteToVTableSetMap::const_iterator it = csToCHAVtblsMap.find(cs);
+        return it != csToCHAVtblsMap.end();
+    }
+    inline bool csHasVFnsBasedonCHA(CallSite cs) override
+    {
+        CallSiteToVFunSetMap::const_iterator it = csToCHAVFnsMap.find(cs);
+        return it != csToCHAVFnsMap.end();
+    }
+    inline const VTableSet &getCSVtblsBasedonCHA(CallSite cs) override
+    {
+        CallSiteToVTableSetMap::const_iterator it = csToCHAVtblsMap.find(cs);
+        assert(it != csToCHAVtblsMap.end() && "cs does not have vtabls based on CHA.");
+        return it->second;
+    }
+    inline const VFunSet &getCSVFsBasedonCHA(CallSite cs) override
+    {
+        CallSiteToVFunSetMap::const_iterator it = csToCHAVFnsMap.find(cs);
+        assert(it != csToCHAVFnsMap.end() && "cs does not have vfns based on CHA.");
+        return it->second;
+    }
+
+    static inline bool classof(const CommonCHGraph *chg)
+    {
+        return chg->getKind() == Standard;
+    }
+
+
+private:
+    SVFModule* svfMod;
+    u32_t classNum;
+    s32_t vfID;
+    double buildingCHGTime;
+    Map<std::string, CHNode *> classNameToNodeMap;
+    NameToCHNodesMap classNameToDescendantsMap;
+    NameToCHNodesMap classNameToAncestorsMap;
+    NameToCHNodesMap classNameToInstAndDescsMap;
+    NameToCHNodesMap templateNameToInstancesMap;
+    CallSiteToCHNodesMap csToClassesMap;
+
+    Map<const SVFFunction*, s32_t> virtualFunctionToIDMap;
+    CallSiteToVTableSetMap csToCHAVtblsMap;
+    CallSiteToVFunSetMap csToCHAVFnsMap;
+};
+
+} // End namespace SVF
+
+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::CHNode*> : public GraphTraits<SVF::GenericNode<SVF::CHNode,SVF::CHEdge>*  >
+{
+};
+
+/// Inverse GraphTraits specializations for call graph node, it is used for inverse traversal.
+template<>
+struct GraphTraits<Inverse<SVF::CHNode*> > : public GraphTraits<Inverse<SVF::GenericNode<SVF::CHNode,SVF::CHEdge>* > >
+{
+};
+
+template<> struct GraphTraits<SVF::CHGraph*> : public GraphTraits<SVF::GenericGraph<SVF::CHNode,SVF::CHEdge>* >
+{
+    typedef SVF::CHNode *NodeRef;
+};
+
+} // End namespace llvm
+
+#endif /* CHA_H_ */

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

@@ -52,7 +52,7 @@ public:
     typedef FIFOWorkList<NodeID> WorkList;
 
 protected:
-    PAG*pag;
+    SVFIR*pag;
     NodeToRepMap nodeToRepMap;
     NodeToSubsMap nodeToSubsMap;
     WorkList nodesToBeCollapsed;
@@ -92,7 +92,7 @@ protected:
 
 public:
     /// Constructor
-    ConstraintGraph(PAG* p): pag(p), edgeIndex(0)
+    ConstraintGraph(SVFIR* p): pag(p), edgeIndex(0)
     {
         buildCG();
     }
@@ -172,7 +172,7 @@ public:
         }
     }
 
-    ///Add a PAG edge into Edge map
+    ///Add a SVFIR edge into Edge map
     //@{
     /// Add Address edge
     AddrCGEdge* addAddrCGEdge(NodeID src, NodeID dst);
@@ -187,7 +187,7 @@ public:
     StoreCGEdge* addStoreCGEdge(NodeID src, NodeID dst);
     //@}
 
-    ///Get PAG edge
+    ///Get SVFIR edge
     //@{
     /// Get Address edges
     inline ConstraintEdge::ConstraintEdgeSetTy& getAddrCGEdges()
@@ -296,9 +296,9 @@ public:
         return false;
     }
 
-    /// Wrappers for invoking PAG methods
+    /// Wrappers for invoking SVFIR methods
     //@{
-    inline const PAG::CallSiteToFunPtrMap& getIndirectCallsites() const
+    inline const SVFIR::CallSiteToFunPtrMap& getIndirectCallsites() const
     {
         return pag->getIndirectCallsites();
     }

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

@@ -30,7 +30,7 @@
 #ifndef CONSGEDGE_H_
 #define CONSGEDGE_H_
 
-#include "Graphs/PAG.h"
+#include "MemoryModel/SVFIR.h"
 #include "Util/WorkList.h"
 
 #include <map>
@@ -42,7 +42,7 @@ namespace SVF
 class ConstraintNode;
 /*!
  * Self-defined edge for constraint resolution
- * including add/remove/re-target, but all the operations do not affect original PAG Edges
+ * including add/remove/re-target, but all the operations do not affect original SVFIR Edges
  */
 typedef GenericEdge<ConstraintNode> GenericConsEdgeTy;
 class ConstraintEdge : public GenericConsEdgeTy

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

@@ -101,7 +101,7 @@ public:
     }
     //@}
 
-    /// Direct and Indirect PAG edges
+    /// Direct and Indirect SVFIR edges
     inline bool isdirectEdge(ConstraintEdge::ConstraintEdgeK kind)
     {
         return (kind == ConstraintEdge::Copy || kind == ConstraintEdge::NormalGep || kind == ConstraintEdge::VariantGep );

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

@@ -10,15 +10,15 @@
 #ifndef EXTERNALPAG_H_
 #define EXTERNALPAG_H_
 
-#include "Graphs/PAGNode.h"
+#include "MemoryModel/SVFVariables.h"
 
 extern llvm::cl::list<std::string> DumpPAGFunctions;
 
 namespace SVF
 {
 
-/// Represents the PAG of a function loaded externally (i.e. from file).
-/// It's purpose is to be attached to the main PAG (almost) seamlessly.
+/// Represents the SVFIR of a function loaded externally (i.e. from file).
+/// It's purpose is to be attached to the main SVFIR (almost) seamlessly.
 class ExternalPAG
 {
 private:
@@ -28,17 +28,17 @@ private:
             functionToExternalPAGEntries;
     static Map<const SVFFunction*, PAGNode *> functionToExternalPAGReturns;
 
-    /// Name of the function this external PAG represents.
+    /// Name of the function this external SVFIR represents.
     std::string functionName;
 
-    /// Value nodes in this external PAG, represented by NodeIDs
-    /// because we will rebuild these nodes in the main PAG.
+    /// Value nodes in this external SVFIR, represented by NodeIDs
+    /// because we will rebuild these nodes in the main SVFIR.
     NodeSet valueNodes;
-    /// Object nodes in this external PAG, represented by NodeIDs
-    /// because we will rebuild these nodes in the main PAG.
+    /// Object nodes in this external SVFIR, represented by NodeIDs
+    /// because we will rebuild these nodes in the main SVFIR.
     NodeSet objectNodes;
-    /// Edges in this external PAG, represented by the parts of an Edge because
-    /// we will rebuild these edges in the main PAG.
+    /// Edges in this external SVFIR, represented by the parts of an Edge because
+    /// we will rebuild these edges in the main SVFIR.
     OrderedSet<std::tuple<NodeID, NodeID, std::string, int>> edges;
 
     // Special nodes.
@@ -82,15 +82,15 @@ public:
     ~ExternalPAG() {}
 
     /// Parses command line arguments and attaches external PAGs to main
-    /// PAG.
+    /// SVFIR.
     static void initialise(SVFModule* svfModule);
 
-    /// Connects callsite if a external PAG implementing the relevant function
+    /// Connects callsite if a external SVFIR implementing the relevant function
     /// has been added.
     /// Returns true on success, false otherwise.
     static bool connectCallsiteToExternalPAG(CallSite *cs);
 
-    /// Whether an external PAG implementing function exists.
+    /// Whether an external SVFIR implementing function exists.
     static bool hasExternalPAG(const SVFFunction* function);
 
     /// Dump individual PAGs of specified functions. Currently to outs().
@@ -136,7 +136,7 @@ public:
     }
 
     /// Adds (creates new equivalents) all the nodes and edges of this extpag to
-    /// the main PAG. function is used as a key for future lookups.
+    /// the main SVFIR. function is used as a key for future lookups.
     /// Returns true on success, false otherwise (incl. if it already exists).
     bool addExternalPAG(const SVFFunction* function);
 

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

@@ -108,7 +108,7 @@ public:
         }
     } equalGEdge;
 
-    inline bool operator==(const GenericEdge<NodeType>* rhs) const
+    virtual inline bool operator==(const GenericEdge<NodeType>* rhs) const
     {
         return (rhs->edgeFlag == this->edgeFlag && rhs->getSrcID() == this->getSrcID()
                 && rhs->getDstID() == this->getDstID());