svf-lib 1.0.1375 → 1.0.1376

package/SVF-osx/svf/include/include/Graphs/ICFG.h

@@ -0,0 +1,331 @@
+//===- ICFG.h ----------------------------------------------------------------//
+//
+//                     SVF: Static Value-Flow Analysis
+//
+// Copyright (C) <2013-2018>  <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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * ICFG.h
+ *
+ *  Created on: 11 Sep. 2018
+ *      Author: Yulei
+ */
+
+#ifndef INCLUDE_UTIL_ICFG_H_
+#define INCLUDE_UTIL_ICFG_H_
+
+#include "Graphs/ICFGNode.h"
+#include "Graphs/ICFGEdge.h"
+#include "Util/WorkList.h"
+#include "MemoryModel/SVFLoop.h"
+
+namespace SVF
+{
+
+class PTACallGraph;
+
+/*!
+ * Interprocedural Control-Flow Graph (ICFG)
+ */
+typedef GenericGraph<ICFGNode,ICFGEdge> GenericICFGTy;
+class ICFG : public GenericICFGTy
+{
+
+    friend class ICFGBuilder;
+
+public:
+
+    typedef OrderedMap<NodeID, ICFGNode *> ICFGNodeIDToNodeMapTy;
+    typedef ICFGEdge::ICFGEdgeSetTy ICFGEdgeSetTy;
+    typedef ICFGNodeIDToNodeMapTy::iterator iterator;
+    typedef ICFGNodeIDToNodeMapTy::const_iterator const_iterator;
+
+    typedef Map<const SVFFunction*, FunEntryICFGNode *> FunToFunEntryNodeMapTy;
+    typedef Map<const SVFFunction*, FunExitICFGNode *> FunToFunExitNodeMapTy;
+    typedef Map<const SVFInstruction*, CallICFGNode *> CSToCallNodeMapTy;
+    typedef Map<const SVFInstruction*, RetICFGNode *> CSToRetNodeMapTy;
+    typedef Map<const SVFInstruction*, IntraICFGNode *> InstToBlockNodeMapTy;
+    typedef std::vector<const SVFLoop *> SVFLoopVec;
+    typedef Map<const ICFGNode *, SVFLoopVec> ICFGNodeToSVFLoopVec;
+
+    NodeID totalICFGNode;
+
+private:
+    FunToFunEntryNodeMapTy FunToFunEntryNodeMap; ///< map a function to its FunExitICFGNode
+    FunToFunExitNodeMapTy FunToFunExitNodeMap; ///< map a function to its FunEntryICFGNode
+    CSToCallNodeMapTy CSToCallNodeMap; ///< map a callsite to its CallICFGNode
+    CSToRetNodeMapTy CSToRetNodeMap; ///< map a callsite to its RetICFGNode
+    InstToBlockNodeMapTy InstToBlockNodeMap; ///< map a basic block to its ICFGNode
+    GlobalICFGNode* globalBlockNode; ///< unique basic block for all globals
+    ICFGNodeToSVFLoopVec icfgNodeToSVFLoopVec; ///< map ICFG node to the SVF loops where it resides
+
+
+public:
+    /// Constructor
+    ICFG();
+
+    /// Destructor
+    ~ICFG() override;
+
+    /// Get a ICFG node
+    inline ICFGNode* getICFGNode(NodeID id) const
+    {
+        return getGNode(id);
+    }
+
+    /// Whether has the ICFGNode
+    inline bool hasICFGNode(NodeID id) const
+    {
+        return hasGNode(id);
+    }
+
+    /// Whether we has a SVFG edge
+    //@{
+    ICFGEdge* hasIntraICFGEdge(ICFGNode* src, ICFGNode* dst, ICFGEdge::ICFGEdgeK kind);
+    ICFGEdge* hasInterICFGEdge(ICFGNode* src, ICFGNode* dst, ICFGEdge::ICFGEdgeK kind);
+    ICFGEdge* hasThreadICFGEdge(ICFGNode* src, ICFGNode* dst, ICFGEdge::ICFGEdgeK kind);
+    //@}
+
+    /// Get a SVFG edge according to src and dst
+    ICFGEdge* getICFGEdge(const ICFGNode* src, const ICFGNode* dst, ICFGEdge::ICFGEdgeK kind);
+
+    /// Dump graph into dot file
+    void dump(const std::string& file, bool simple = false);
+
+    /// View graph from the debugger
+    void view();
+
+    /// update ICFG for indirect calls
+    void updateCallGraph(PTACallGraph* callgraph);
+
+    /// Whether node is in a loop
+    inline bool isInLoop(const ICFGNode *node)
+    {
+        auto it = icfgNodeToSVFLoopVec.find(node);
+        return it != icfgNodeToSVFLoopVec.end();
+    }
+
+    /// Whether node is in a loop
+    inline bool isInLoop(const SVFInstruction* inst)
+    {
+        return isInLoop(getICFGNode(inst));
+    }
+
+    /// Insert (node, loop) to icfgNodeToSVFLoopVec
+    inline void addNodeToSVFLoop(const ICFGNode *node, const SVFLoop* loop)
+    {
+        icfgNodeToSVFLoopVec[node].push_back(loop);
+    }
+
+    /// Get loops where a node resides
+    inline SVFLoopVec& getSVFLoops(const ICFGNode *node)
+    {
+        auto it = icfgNodeToSVFLoopVec.find(node);
+        assert(it != icfgNodeToSVFLoopVec.end() && "node not in loop");
+        return it->second;
+    }
+
+protected:
+    /// Remove a SVFG edge
+    inline void removeICFGEdge(ICFGEdge* edge)
+    {
+        edge->getDstNode()->removeIncomingEdge(edge);
+        edge->getSrcNode()->removeOutgoingEdge(edge);
+        delete edge;
+    }
+    /// Remove a ICFGNode
+    inline void removeICFGNode(ICFGNode* node)
+    {
+        removeGNode(node);
+    }
+
+    /// Add control-flow edges for top level pointers
+    //@{
+    ICFGEdge* addIntraEdge(ICFGNode* srcNode, ICFGNode* dstNode);
+    ICFGEdge* addConditionalIntraEdge(ICFGNode* srcNode, ICFGNode* dstNode, const SVFValue* condition, s32_t branchCondVal);
+    ICFGEdge* addCallEdge(ICFGNode* srcNode, ICFGNode* dstNode, const SVFInstruction* cs);
+    ICFGEdge* addRetEdge(ICFGNode* srcNode, ICFGNode* dstNode, const SVFInstruction* cs);
+    //@}
+
+    /// sanitize Intra edges, verify that both nodes belong to the same function.
+    inline void checkIntraEdgeParents(const ICFGNode *srcNode, const ICFGNode *dstNode)
+    {
+        const SVFFunction* srcfun = srcNode->getFun();
+        const SVFFunction* dstfun = dstNode->getFun();
+        if(srcfun != nullptr && dstfun != nullptr)
+        {
+            assert((srcfun == dstfun) && "src and dst nodes of an intra edge should in the same function!" );
+        }
+    }
+
+    /// Add ICFG edge
+    inline bool addICFGEdge(ICFGEdge* edge)
+    {
+        bool added1 = edge->getDstNode()->addIncomingEdge(edge);
+        bool added2 = edge->getSrcNode()->addOutgoingEdge(edge);
+        bool all_added = added1 && added2;
+        assert(all_added && "ICFGEdge not added?");
+        return all_added;
+    }
+
+    /// Add a ICFG node
+    virtual inline void addICFGNode(ICFGNode* node)
+    {
+        addGNode(node->getId(),node);
+    }
+
+public:
+    /// Get a basic block ICFGNode
+    /// TODO:: need to fix the assertions
+    //@{
+    ICFGNode* getICFGNode(const SVFInstruction* inst);
+
+    CallICFGNode* getCallICFGNode(const SVFInstruction* inst);
+
+    RetICFGNode* getRetICFGNode(const SVFInstruction* inst);
+
+    IntraICFGNode* getIntraICFGNode(const SVFInstruction* inst);
+
+    FunEntryICFGNode* getFunEntryICFGNode(const SVFFunction*  fun);
+
+    FunExitICFGNode* getFunExitICFGNode(const SVFFunction*  fun);
+
+    inline GlobalICFGNode* getGlobalICFGNode() const
+    {
+        return globalBlockNode;
+    }
+    inline void addGlobalICFGNode()
+    {
+        globalBlockNode = new GlobalICFGNode(totalICFGNode++);
+        addICFGNode(globalBlockNode);
+    }
+    //@}
+
+private:
+
+    /// Get/Add IntraBlock ICFGNode
+    inline IntraICFGNode* getIntraBlock(const SVFInstruction* inst)
+    {
+        InstToBlockNodeMapTy::const_iterator it = InstToBlockNodeMap.find(inst);
+        if (it == InstToBlockNodeMap.end())
+            return nullptr;
+        return it->second;
+    }
+    inline IntraICFGNode* addIntraBlock(const SVFInstruction* inst)
+    {
+        IntraICFGNode* sNode = new IntraICFGNode(totalICFGNode++,inst);
+        addICFGNode(sNode);
+        InstToBlockNodeMap[inst] = sNode;
+        return sNode;
+    }
+
+    /// Get/Add a function entry node
+    inline FunEntryICFGNode* getFunEntryBlock(const SVFFunction* fun)
+    {
+        FunToFunEntryNodeMapTy::const_iterator it = FunToFunEntryNodeMap.find(fun);
+        if (it == FunToFunEntryNodeMap.end())
+            return nullptr;
+        return it->second;
+    }
+    inline FunEntryICFGNode* addFunEntryBlock(const SVFFunction* fun)
+    {
+        FunEntryICFGNode* sNode = new FunEntryICFGNode(totalICFGNode++,fun);
+        addICFGNode(sNode);
+        FunToFunEntryNodeMap[fun] = sNode;
+        return sNode;
+    }
+
+    /// Get/Add a function exit node
+    inline FunExitICFGNode* getFunExitBlock(const SVFFunction* fun)
+    {
+        FunToFunExitNodeMapTy::const_iterator it = FunToFunExitNodeMap.find(fun);
+        if (it == FunToFunExitNodeMap.end())
+            return nullptr;
+        return it->second;
+    }
+    inline FunExitICFGNode* addFunExitBlock(const SVFFunction* fun)
+    {
+        FunExitICFGNode* sNode = new FunExitICFGNode(totalICFGNode++, fun);
+        addICFGNode(sNode);
+        FunToFunExitNodeMap[fun] = sNode;
+        return sNode;
+    }
+
+    /// Get/Add a call node
+    inline CallICFGNode* addCallBlock(const SVFInstruction* cs)
+    {
+        CallICFGNode* sNode = new CallICFGNode(totalICFGNode++, cs);
+        addICFGNode(sNode);
+        CSToCallNodeMap[cs] = sNode;
+        return sNode;
+    }
+    inline CallICFGNode* getCallBlock(const SVFInstruction* cs)
+    {
+        CSToCallNodeMapTy::const_iterator it = CSToCallNodeMap.find(cs);
+        if (it == CSToCallNodeMap.end())
+            return nullptr;
+        return it->second;
+    }
+
+    /// Get/Add a return node
+    inline RetICFGNode* getRetBlock(const SVFInstruction* cs)
+    {
+        CSToRetNodeMapTy::const_iterator it = CSToRetNodeMap.find(cs);
+        if (it == CSToRetNodeMap.end())
+            return nullptr;
+        return it->second;
+    }
+    inline RetICFGNode* addRetBlock(const SVFInstruction* cs)
+    {
+        CallICFGNode* callBlockNode = getCallICFGNode(cs);
+        RetICFGNode* sNode = new RetICFGNode(totalICFGNode++, cs, callBlockNode);
+        callBlockNode->setRetICFGNode(sNode);
+        addICFGNode(sNode);
+        CSToRetNodeMap[cs] = sNode;
+        return sNode;
+    }
+
+};
+
+} // End namespace SVF
+
+namespace SVF
+{
+/* !
+ * GenericGraphTraits specializations for generic graph algorithms.
+ * Provide graph traits for traversing from a constraint node using standard graph traversals.
+ */
+template<> struct GenericGraphTraits<SVF::ICFGNode*> : public GenericGraphTraits<SVF::GenericNode<SVF::ICFGNode,SVF::ICFGEdge>*  >
+{
+};
+
+/// Inverse GenericGraphTraits specializations for call graph node, it is used for inverse traversal.
+template<>
+struct GenericGraphTraits<Inverse<SVF::ICFGNode *> > : public GenericGraphTraits<Inverse<SVF::GenericNode<SVF::ICFGNode,SVF::ICFGEdge>* > >
+{
+};
+
+template<> struct GenericGraphTraits<SVF::ICFG*> : public GenericGraphTraits<SVF::GenericGraph<SVF::ICFGNode,SVF::ICFGEdge>* >
+{
+    typedef SVF::ICFGNode *NodeRef;
+};
+
+} // End namespace llvm
+
+#endif /* INCLUDE_UTIL_ICFG_H_ */

package/SVF-osx/svf/include/include/Graphs/ICFGEdge.h

@@ -0,0 +1,264 @@
+//===- ICFGEdge.h -- ICFG edge------------------------------------------------//
+//
+//                     SVF: Static Value-Flow Analysis
+//
+// Copyright (C) <2013-2018>  <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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * ICFGEdge.h
+ *
+ *  Created on: Sep 11, 2018
+ *      Author: Yulei Sui
+ */
+
+#ifndef ICFGEdge_H_
+#define ICFGEdge_H_
+
+namespace SVF
+{
+
+class ICFGNode;
+class CallPE;
+class RetPE;
+
+/*!
+ * Interprocedural control-flow and value-flow edge, representing the control- and value-flow dependence between two nodes
+ */
+typedef GenericEdge<ICFGNode> GenericICFGEdgeTy;
+class ICFGEdge : public GenericICFGEdgeTy
+{
+
+public:
+    /// ten types of ICFG edge
+    /// three types of control-flow edges
+    /// seven types of value-flow edges
+    enum ICFGEdgeK
+    {
+        IntraCF,
+        CallCF,
+        RetCF,
+    };
+
+    typedef ICFGEdgeK SVFGEdgeK;
+
+public:
+    /// Constructor
+    ICFGEdge(ICFGNode* s, ICFGNode* d, GEdgeFlag k) : GenericICFGEdgeTy(s,d,k)
+    {
+    }
+    /// Destructor
+    ~ICFGEdge()
+    {
+    }
+
+    /// Get methods of the components
+    //@{
+    inline bool isCFGEdge() const
+    {
+        return getEdgeKind() == IntraCF || getEdgeKind() == CallCF || getEdgeKind() == RetCF;
+    }
+    inline bool isCallCFGEdge() const
+    {
+        return getEdgeKind() == CallCF;
+    }
+    inline bool isRetCFGEdge() const
+    {
+        return getEdgeKind() == RetCF;
+    }
+    inline bool isIntraCFGEdge() const
+    {
+        return getEdgeKind() == IntraCF;
+    }
+    //@}
+    typedef GenericNode<ICFGNode,ICFGEdge>::GEdgeSetTy ICFGEdgeSetTy;
+    typedef ICFGEdgeSetTy SVFGEdgeSetTy;
+    /// Compute the unique edgeFlag value from edge kind and CallSiteID.
+    static inline GEdgeFlag makeEdgeFlagWithInvokeID(GEdgeKind k, CallSiteID cs)
+    {
+        return (cs << EdgeKindMaskBits) | k;
+    }
+
+    /// Overloading operator << for dumping ICFG node ID
+    //@{
+    friend OutStream& operator<< (OutStream &o, const ICFGEdge &edge)
+    {
+        o << edge.toString();
+        return o;
+    }
+    //@}
+
+    virtual const std::string toString() const;
+};
+
+
+/*!
+ * Intra ICFG edge representing control-flows between basic blocks within a function
+ */
+class IntraCFGEdge : public ICFGEdge
+{
+
+public:
+    /// Constructor
+    IntraCFGEdge(ICFGNode* s, ICFGNode* d): ICFGEdge(s,d,IntraCF), conditionVar(nullptr), branchCondVal(0)
+    {
+    }
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const IntraCFGEdge *)
+    {
+        return true;
+    }
+    static inline bool classof(const ICFGEdge *edge)
+    {
+        return edge->getEdgeKind() == IntraCF;
+    }
+    static inline bool classof(const GenericICFGEdgeTy *edge)
+    {
+        return edge->getEdgeKind() == IntraCF;
+    }
+    //@}
+
+    const SVFValue* getCondition() const
+    {
+        return conditionVar;
+    }
+
+    s32_t getSuccessorCondValue() const
+    {
+        assert(getCondition() && "this is not a conditional branch edge");
+        return branchCondVal;
+    }
+
+    void setBranchCondition(const SVFValue* c, s32_t bVal)
+    {
+        conditionVar = c;
+        branchCondVal = bVal;
+    }
+
+    virtual const std::string toString() const;
+
+private:
+    /// conditionVar is a boolean (for if/else) or numeric condition variable (for switch)
+    /// branchCondVal is the value when this condition should hold to execute this CFGEdge.
+    /// e.g., Inst1: br %cmp label 0, label 1,  Inst2 is label 0 and Inst 3 is label 1;
+    /// for edge between Inst1 and Inst 2, the first element is %cmp and second element is 0
+    const SVFValue* conditionVar;
+    s32_t branchCondVal;
+};
+
+/*!
+ * Call ICFG edge representing parameter passing/return from a caller to a callee
+ */
+class CallCFGEdge : public ICFGEdge
+{
+
+private:
+    const SVFInstruction*  cs;
+    std::vector<const CallPE*> callPEs;
+public:
+    /// Constructor
+    CallCFGEdge(ICFGNode* s, ICFGNode* d, const SVFInstruction*  c):
+        ICFGEdge(s,d,CallCF),cs(c)
+    {
+    }
+    /// Return callsite ID
+    inline const SVFInstruction*  getCallSite() const
+    {
+        return cs;
+    }
+    /// Add call parameter edge to this CallCFGEdge
+    inline void addCallPE(const CallPE* callPE)
+    {
+        callPEs.push_back(callPE);
+    }
+    /// Add get parameter edge to this CallCFGEdge
+    inline const std::vector<const CallPE*>& getCallPEs() const
+    {
+        return callPEs;
+    }
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const CallCFGEdge *)
+    {
+        return true;
+    }
+    static inline bool classof(const ICFGEdge *edge)
+    {
+        return edge->getEdgeKind() == CallCF;
+    }
+    static inline bool classof(const GenericICFGEdgeTy *edge)
+    {
+        return edge->getEdgeKind() == CallCF;
+    }
+    //@}
+    virtual const std::string toString() const;
+};
+
+/*!
+ * Return ICFG edge representing parameter/return passing from a callee to a caller
+ */
+class RetCFGEdge : public ICFGEdge
+{
+
+private:
+    const SVFInstruction*  cs;
+    const RetPE* retPE;
+public:
+    /// Constructor
+    RetCFGEdge(ICFGNode* s, ICFGNode* d, const SVFInstruction*  c):
+        ICFGEdge(s,d,RetCF),cs(c),retPE(nullptr)
+    {
+    }
+    /// Return callsite ID
+    inline const SVFInstruction*  getCallSite() const
+    {
+        return cs;
+    }
+    /// Add call parameter edge to this CallCFGEdge
+    inline void addRetPE(const RetPE* ret)
+    {
+        assert(retPE==nullptr && "we can only have one retPE for each RetCFGEdge");
+        retPE = ret;
+    }
+    /// Add get parameter edge to this CallCFGEdge
+    inline const RetPE* getRetPE() const
+    {
+        return retPE;
+    }
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const RetCFGEdge *)
+    {
+        return true;
+    }
+    static inline bool classof(const ICFGEdge *edge)
+    {
+        return edge->getEdgeKind() == RetCF;
+    }
+    static inline bool classof(const GenericICFGEdgeTy *edge)
+    {
+        return edge->getEdgeKind() == RetCF;
+    }
+    //@}
+    virtual const std::string toString() const;
+};
+
+} // End namespace SVF
+
+#endif /* ICFGEdge_H_ */