svf-lib 1.0.2319 → 1.0.2321

package/SVF-osx/Release-build/include/SVF/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 Affero 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 Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero 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 CallGraph;
+
+/*!
+ * Interprocedural Control-Flow Graph (ICFG)
+ */
+typedef GenericGraph<ICFGNode,ICFGEdge> GenericICFGTy;
+class ICFG : public GenericICFGTy
+{
+    friend class ICFGBuilder;
+    friend class SVFIRWriter;
+    friend class SVFIRReader;
+    friend class ICFGSimplification;
+
+public:
+
+    typedef OrderedMap<NodeID, ICFGNode *> ICFGNodeIDToNodeMapTy;
+    typedef ICFGEdge::ICFGEdgeSetTy ICFGEdgeSetTy;
+    typedef ICFGNodeIDToNodeMapTy::iterator iterator;
+    typedef ICFGNodeIDToNodeMapTy::const_iterator const_iterator;
+
+    typedef Map<const FunObjVar*, FunEntryICFGNode *> FunToFunEntryNodeMapTy;
+    typedef Map<const FunObjVar*, FunExitICFGNode *> FunToFunExitNodeMapTy;
+    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
+    GlobalICFGNode* globalBlockNode; ///< unique basic block for all globals
+    ICFGNodeToSVFLoopVec icfgNodeToSVFLoopVec; ///< map ICFG node to the SVF loops where it resides
+
+    Map<const ICFGNode*, std::vector<const ICFGNode*>> _subNodes; ///<map a node(1st node of basicblock) to its subnodes
+    Map<const ICFGNode*, const ICFGNode*> _repNode; ///<map a subnode to its representative node(1st node of basicblock)
+
+
+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(CallGraph* callgraph);
+
+    /// Whether node is in a loop
+    inline bool isInLoop(const ICFGNode *node)
+    {
+        auto it = icfgNodeToSVFLoopVec.find(node);
+        return it != icfgNodeToSVFLoopVec.end();
+    }
+
+    /// 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;
+    }
+
+    inline const ICFGNodeToSVFLoopVec& getIcfgNodeToSVFLoopVec() const
+    {
+        return icfgNodeToSVFLoopVec;
+    }
+
+protected:
+    /// Add intraprocedural and interprocedural control-flow edges.
+    //@{
+    ICFGEdge* addIntraEdge(ICFGNode* srcNode, ICFGNode* dstNode);
+    ICFGEdge* addConditionalIntraEdge(ICFGNode* srcNode, ICFGNode* dstNode, s64_t branchCondVal);
+    ICFGEdge* addCallEdge(ICFGNode* srcNode, ICFGNode* dstNode);
+    ICFGEdge* addRetEdge(ICFGNode* srcNode, ICFGNode* dstNode);
+    //@}
+    /// Remove a ICFG 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);
+    }
+
+    /// sanitize Intra edges, verify that both nodes belong to the same function.
+    inline void checkIntraEdgeParents(const ICFGNode *srcNode, const ICFGNode *dstNode)
+    {
+        const FunObjVar* srcfun = srcNode->getFun();
+        const FunObjVar* dstfun = dstNode->getFun();
+        if(srcfun != nullptr && dstfun != nullptr)
+        {
+            assert((srcfun == dstfun) && "src and dst nodes of an intra edge should in the same function!" );
+        }
+    }
+
+    virtual inline IntraICFGNode* addIntraICFGNode(const SVFBasicBlock* bb, bool isRet)
+    {
+        IntraICFGNode* intraIcfgNode =
+            new IntraICFGNode(totalICFGNode++, bb, isRet);
+        addICFGNode(intraIcfgNode);
+        return intraIcfgNode;
+    }
+
+    virtual inline CallICFGNode* addCallICFGNode(
+        const SVFBasicBlock* bb, const SVFType* ty,
+        const FunObjVar* calledFunc, bool isVararg, bool isvcall,
+        s32_t vcallIdx, const std::string& funNameOfVcall)
+    {
+
+        CallICFGNode* callICFGNode =
+            new CallICFGNode(totalICFGNode++, bb, ty, calledFunc, isVararg,
+                             isvcall, vcallIdx, funNameOfVcall);
+        addICFGNode(callICFGNode);
+        return callICFGNode;
+    }
+
+    virtual inline RetICFGNode* addRetICFGNode(CallICFGNode* call)
+    {
+        RetICFGNode* retICFGNode = new RetICFGNode(totalICFGNode++, call);
+        call->setRetICFGNode(retICFGNode);
+        addICFGNode(retICFGNode);
+        return retICFGNode;
+    }
+
+    virtual inline FunEntryICFGNode* addFunEntryICFGNode(const FunObjVar* svfFunc)
+    {
+        FunEntryICFGNode* sNode = new FunEntryICFGNode(totalICFGNode++,svfFunc);
+        addICFGNode(sNode);
+        return FunToFunEntryNodeMap[svfFunc] = sNode;
+    }
+
+    virtual inline FunExitICFGNode* addFunExitICFGNode(const FunObjVar* svfFunc)
+    {
+        FunExitICFGNode* sNode = new FunExitICFGNode(totalICFGNode++, svfFunc);
+        addICFGNode(sNode);
+        return FunToFunExitNodeMap[svfFunc] = sNode;
+    }
+
+    /// Add a ICFG node
+    virtual inline void addICFGNode(ICFGNode* node)
+    {
+        addGNode(node->getId(),node);
+        _repNode[node] = node;
+        _subNodes[node].push_back(node);
+    }
+
+public:
+    /// Get a basic block ICFGNode
+    /// TODO:: need to fix the assertions
+    //@{
+
+
+    FunEntryICFGNode* getFunEntryICFGNode(const FunObjVar*  fun);
+
+    FunExitICFGNode* getFunExitICFGNode(const FunObjVar*  fun);
+
+    inline GlobalICFGNode* getGlobalICFGNode() const
+    {
+        return globalBlockNode;
+    }
+
+    const std::vector<const ICFGNode*>& getSubNodes(const ICFGNode* node) const
+    {
+        return _subNodes.at(node);
+    }
+
+    const ICFGNode* getRepNode(const ICFGNode* node) const
+    {
+        return _repNode.at(node);
+    }
+
+
+    void updateSubAndRep(const ICFGNode* rep, const ICFGNode* sub)
+    {
+        addSubNode(rep, sub);
+        updateRepNode(rep, sub);
+    }
+    //@}
+
+private:
+    /// when ICFG is simplified, SubNode would merge repNode, then update the map
+    void addSubNode(const ICFGNode* rep, const ICFGNode* sub)
+    {
+        std::vector<const ICFGNode*>& subNodes = _subNodes[sub];
+        if(std::find(subNodes.begin(), subNodes.end(), rep) == subNodes.end())
+        {
+            subNodes.push_back(rep);
+        }
+    }
+
+    /// when ICFG is simplified, some node would be removed, this map records the removed node to its rep node
+    void updateRepNode(const ICFGNode* rep, const ICFGNode* sub)
+    {
+        _repNode[rep] = sub;
+    }
+
+    /// Add ICFG edge, only used by addIntraEdge, addCallEdge, addRetEdge etc.
+    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;
+    }
+
+    /// Get/Add a function entry node
+    inline FunEntryICFGNode* getFunEntryBlock(const FunObjVar* fun)
+    {
+        FunToFunEntryNodeMapTy::const_iterator it = FunToFunEntryNodeMap.find(fun);
+        if (it == FunToFunEntryNodeMap.end())
+            return nullptr;
+        return it->second;
+    }
+
+    /// Get/Add a function exit node
+    inline FunExitICFGNode* getFunExitBlock(const FunObjVar* fun)
+    {
+        FunToFunExitNodeMapTy::const_iterator it = FunToFunExitNodeMap.find(fun);
+        if (it == FunToFunExitNodeMap.end())
+            return nullptr;
+        return it->second;
+    }
+
+};
+
+} // 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/Release-build/include/SVF/Graphs/ICFGEdge.h

@@ -0,0 +1,281 @@
+//===- 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 Affero 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 Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero 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
+{
+    friend class SVFIRWriter;
+    friend class SVFIRReader;
+
+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
+{
+    friend class SVFIRWriter;
+    friend class SVFIRReader;
+    friend class ICFG;
+    friend class SVFIRBuilder;
+
+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 SVFVar* getCondition() const
+    {
+        return conditionVar;
+    }
+
+    s64_t getSuccessorCondValue() const
+    {
+        assert(getCondition() && "this is not a conditional branch edge");
+        return branchCondVal;
+    }
+
+    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: label 0
+    ///       Inst3: label 1;
+    /// for edge between Inst1 and Inst 2, the first element is %cmp and
+    /// the second element is 0
+    const SVFVar* conditionVar;
+    s64_t branchCondVal;
+
+    inline void setConditionVar(const SVFVar* c)
+    {
+        conditionVar = c;
+    }
+
+    inline void setBranchCondVal(s64_t bVal)
+    {
+        branchCondVal = bVal;
+    }
+};
+
+/*!
+ * Call ICFG edge representing parameter passing/return from a caller to a callee
+ */
+class CallCFGEdge : public ICFGEdge
+{
+    friend class SVFIRWriter;
+    friend class SVFIRReader;
+
+private:
+    std::vector<const CallPE*> callPEs;
+
+public:
+    /// Constructor
+    CallCFGEdge(ICFGNode* s, ICFGNode* d)
+        : ICFGEdge(s, d, CallCF)
+    {
+    }
+    /// Add call parameter edge to this CallCFGEdge
+    inline void addCallPE(const CallPE* callPE)
+    {
+        callPEs.push_back(callPE);
+    }
+    /// Return call ICFGNode at the callsite
+    inline const CallICFGNode* getCallSite() const
+    {
+        assert(SVFUtil::isa<CallICFGNode>(getSrcNode()) && "not a CallICFGNode?");
+        return SVFUtil::cast<CallICFGNode>(getSrcNode());
+    }
+    /// 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
+{
+    friend class SVFIRWriter;
+    friend class SVFIRReader;
+
+private:
+    const RetPE* retPE;
+
+public:
+    /// Constructor
+    RetCFGEdge(ICFGNode* s, ICFGNode* d)
+        : ICFGEdge(s, d, RetCF), retPE(nullptr)
+    {
+    }
+    /// Add call parameter edge to this CallCFGEdge
+    inline void addRetPE(const RetPE* ret)
+    {
+        assert(!retPE && "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;
+    }
+    /// Return call ICFGNode at the callsite
+    const CallICFGNode* getCallSite() const;
+
+    /// 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_ */