svf-lib 1.0.1374 → 1.0.1376

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

@@ -0,0 +1,523 @@
+//===- ICFGNode.h -- ICFG node------------------------------------------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * ICFGNode.h
+ *
+ *  Created on: Sep 11, 2018
+ *      Author: Yulei
+ */
+
+#ifndef ICFGNODE_H_
+#define ICFGNODE_H_
+
+#include "Util/SVFUtil.h"
+#include "Graphs/GenericGraph.h"
+#include "Graphs/ICFGEdge.h"
+
+namespace SVF
+{
+
+class ICFGNode;
+class RetICFGNode;
+class CallPE;
+class RetPE;
+class SVFStmt;
+class SVFVar;
+class VFGNode;
+
+/*!
+ * Interprocedural control-flow graph node, representing different kinds of program statements
+ * including top-level pointers (ValVar) and address-taken objects (ObjVar)
+ */
+typedef GenericNode<ICFGNode, ICFGEdge> GenericICFGNodeTy;
+
+class ICFGNode : public GenericICFGNodeTy
+{
+
+public:
+    /// 22 kinds of ICFG node
+    /// Gep represents offset edge for field sensitivity
+    enum ICFGNodeK
+    {
+        IntraBlock, FunEntryBlock, FunExitBlock, FunCallBlock, FunRetBlock, GlobalBlock
+    };
+
+    typedef ICFGEdge::ICFGEdgeSetTy::iterator iterator;
+    typedef ICFGEdge::ICFGEdgeSetTy::const_iterator const_iterator;
+    typedef Set<const CallPE *> CallPESet;
+    typedef Set<const RetPE *> RetPESet;
+    typedef std::list<const VFGNode*> VFGNodeList;
+    typedef std::list<const SVFStmt*> SVFStmtList;
+
+public:
+    /// Constructor
+    ICFGNode(NodeID i, ICFGNodeK k) : GenericICFGNodeTy(i, k), fun(nullptr), bb(nullptr)
+    {
+
+    }
+
+    /// Return the function of this ICFGNode
+    virtual const SVFFunction* getFun() const
+    {
+        return fun;
+    }
+
+    /// Return the function of this ICFGNode
+    virtual const SVFBasicBlock* getBB() const
+    {
+        return bb;
+    }
+
+
+    /// Overloading operator << for dumping ICFG node ID
+    //@{
+    friend OutStream &operator<<(OutStream &o, const ICFGNode &node)
+    {
+        o << node.toString();
+        return o;
+    }
+    //@}
+
+    /// Set/Get methods of VFGNodes
+    ///@{
+    inline void addVFGNode(const VFGNode *vfgNode)
+    {
+        VFGNodes.push_back(vfgNode);
+    }
+
+    inline const VFGNodeList& getVFGNodes() const
+    {
+        return VFGNodes;
+    }
+    ///@}
+
+    /// Set/Get methods of VFGNodes
+    ///@{
+    inline void addSVFStmt(const SVFStmt *edge)
+    {
+        pagEdges.push_back(edge);
+    }
+
+    inline const SVFStmtList& getSVFStmts() const
+    {
+        return pagEdges;
+    }
+    ///@}
+
+    virtual const std::string toString() const;
+
+    void dump() const;
+
+protected:
+    const SVFFunction* fun;
+    const SVFBasicBlock* bb;
+    VFGNodeList VFGNodes; //< a list of VFGNodes
+    SVFStmtList pagEdges; //< a list of PAGEdges
+
+};
+
+/*!
+ * Unique ICFG node stands for all global initializations
+ */
+class GlobalICFGNode : public ICFGNode
+{
+
+public:
+    GlobalICFGNode(NodeID id) : ICFGNode(id, GlobalBlock)
+    {
+        bb = nullptr;
+    }
+
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const GlobalICFGNode *)
+    {
+        return true;
+    }
+
+    static inline bool classof(const ICFGNode *node)
+    {
+        return node->getNodeKind() == GlobalBlock;
+    }
+
+    static inline bool classof(const GenericICFGNodeTy *node)
+    {
+        return node->getNodeKind() == GlobalBlock;
+    }
+    //@}
+
+    virtual const std::string toString() const;
+};
+
+/*!
+ * ICFG node stands for a program statement
+ */
+class IntraICFGNode : public ICFGNode
+{
+private:
+    const SVFInstruction *inst;
+
+public:
+    IntraICFGNode(NodeID id, const SVFInstruction *i) : ICFGNode(id, IntraBlock), inst(i)
+    {
+        fun = inst->getFunction();
+        bb = inst->getParent();
+    }
+
+    inline const SVFInstruction *getInst() const
+    {
+        return inst;
+    }
+
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const IntraICFGNode *)
+    {
+        return true;
+    }
+
+    static inline bool classof(const ICFGNode *node)
+    {
+        return node->getNodeKind() == IntraBlock;
+    }
+
+    static inline bool classof(const GenericICFGNodeTy *node)
+    {
+        return node->getNodeKind() == IntraBlock;
+    }
+    //@}
+
+    const std::string toString() const;
+};
+
+class InterICFGNode : public ICFGNode
+{
+
+public:
+    /// Constructor
+    InterICFGNode(NodeID id, ICFGNodeK k) : ICFGNode(id, k)
+    {
+    }
+
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const InterICFGNode *)
+    {
+        return true;
+    }
+
+    static inline bool classof(const ICFGNode *node)
+    {
+        return node->getNodeKind() == FunEntryBlock
+               || node->getNodeKind() == FunExitBlock
+               || node->getNodeKind() == FunCallBlock
+               || node->getNodeKind() == FunRetBlock;
+    }
+
+    static inline bool classof(const GenericICFGNodeTy *node)
+    {
+        return node->getNodeKind() == FunEntryBlock
+               || node->getNodeKind() == FunExitBlock
+               || node->getNodeKind() == FunCallBlock
+               || node->getNodeKind() == FunRetBlock;
+    }
+    //@}
+};
+
+
+/*!
+ * Function entry ICFGNode containing a set of FormalParmVFGNodes of a function
+ */
+class FunEntryICFGNode : public InterICFGNode
+{
+
+public:
+    typedef std::vector<const SVFVar *> FormalParmNodeVec;
+private:
+    FormalParmNodeVec FPNodes;
+public:
+    FunEntryICFGNode(NodeID id, const SVFFunction* f);
+
+    /// Return function
+    inline const SVFFunction* getFun() const
+    {
+        return fun;
+    }
+
+    /// Return the set of formal parameters
+    inline const FormalParmNodeVec &getFormalParms() const
+    {
+        return FPNodes;
+    }
+
+    /// Add formal parameters
+    inline void addFormalParms(const SVFVar *fp)
+    {
+        FPNodes.push_back(fp);
+    }
+
+    ///Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const FunEntryICFGNode *)
+    {
+        return true;
+    }
+
+    static inline bool classof(const InterICFGNode *node)
+    {
+        return node->getNodeKind() == FunEntryBlock;
+    }
+
+    static inline bool classof(const ICFGNode *node)
+    {
+        return node->getNodeKind() == FunEntryBlock;
+    }
+
+    static inline bool classof(const GenericICFGNodeTy *node)
+    {
+        return node->getNodeKind() == FunEntryBlock;
+    }
+    //@}
+
+    const virtual std::string toString() const;
+};
+
+/*!
+ * Function exit ICFGNode containing (at most one) FormalRetVFGNodes of a function
+ */
+class FunExitICFGNode : public InterICFGNode
+{
+
+private:
+    const SVFVar *formalRet;
+public:
+    FunExitICFGNode(NodeID id, const SVFFunction* f);
+
+    /// Return function
+    inline const SVFFunction* getFun() const
+    {
+        return fun;
+    }
+
+    /// Return actual return parameter
+    inline const SVFVar *getFormalRet() const
+    {
+        return formalRet;
+    }
+
+    /// Add actual return parameter
+    inline void addFormalRet(const SVFVar *fr)
+    {
+        formalRet = fr;
+    }
+
+    ///Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const FunEntryICFGNode *)
+    {
+        return true;
+    }
+
+    static inline bool classof(const ICFGNode *node)
+    {
+        return node->getNodeKind() == FunExitBlock;
+    }
+
+    static inline bool classof(const InterICFGNode *node)
+    {
+        return node->getNodeKind() == FunExitBlock;
+    }
+
+    static inline bool classof(const GenericICFGNodeTy *node)
+    {
+        return node->getNodeKind() == FunExitBlock;
+    }
+    //@}
+
+    virtual const std::string toString() const;
+};
+
+/*!
+ * Call ICFGNode containing a set of ActualParmVFGNodes at a callsite
+ */
+class CallICFGNode : public InterICFGNode
+{
+
+public:
+    typedef std::vector<const SVFVar *> ActualParmNodeVec;
+private:
+    const SVFInstruction* cs;
+    const RetICFGNode* ret;
+    ActualParmNodeVec APNodes;
+public:
+    CallICFGNode(NodeID id, const SVFInstruction* c) : InterICFGNode(id, FunCallBlock), cs(c), ret(nullptr)
+    {
+        fun = cs->getFunction();
+        bb = cs->getParent();
+    }
+
+    /// Return callsite
+    inline const SVFInstruction* getCallSite() const
+    {
+        return cs;
+    }
+
+    /// Return callsite
+    inline const RetICFGNode* getRetICFGNode() const
+    {
+        assert(ret && "RetICFGNode not set?");
+        return ret;
+    }
+
+    /// Return callsite
+    inline void setRetICFGNode(const RetICFGNode* r)
+    {
+        ret = r;
+    }
+
+    /// Return callsite
+    inline const SVFFunction* getCaller() const
+    {
+        return cs->getFunction();
+    }
+
+    /// Return Basic Block
+    inline const SVFBasicBlock* getParent() const
+    {
+        return cs->getParent();
+    }
+
+    /// Return true if this is an indirect call
+    inline bool isIndirectCall() const
+    {
+        return nullptr == SVFUtil::getCallee(cs);
+    }
+
+    /// Return the set of actual parameters
+    inline const ActualParmNodeVec &getActualParms() const
+    {
+        return APNodes;
+    }
+
+    /// Add actual parameters
+    inline void addActualParms(const SVFVar *ap)
+    {
+        APNodes.push_back(ap);
+    }
+
+    ///Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const CallICFGNode *)
+    {
+        return true;
+    }
+
+    static inline bool classof(const ICFGNode *node)
+    {
+        return node->getNodeKind() == FunCallBlock;
+    }
+
+    static inline bool classof(const InterICFGNode *node)
+    {
+        return node->getNodeKind() == FunCallBlock;
+    }
+
+    static inline bool classof(const GenericICFGNodeTy *node)
+    {
+        return node->getNodeKind() == FunCallBlock;
+    }
+    //@}
+
+    virtual const std::string toString() const;
+};
+
+
+/*!
+ * Return ICFGNode containing (at most one) ActualRetVFGNode at a callsite
+ */
+class RetICFGNode : public InterICFGNode
+{
+
+private:
+    const SVFInstruction* cs;
+    const SVFVar *actualRet;
+    const CallICFGNode* callBlockNode;
+public:
+    RetICFGNode(NodeID id, const SVFInstruction* c, CallICFGNode* cb) :
+        InterICFGNode(id, FunRetBlock), cs(c), actualRet(nullptr), callBlockNode(cb)
+    {
+        fun = cs->getFunction();
+        bb = cs->getParent();
+    }
+
+    /// Return callsite
+    inline const SVFInstruction* getCallSite() const
+    {
+        return cs;
+    }
+
+    inline const CallICFGNode* getCallICFGNode() const
+    {
+        return callBlockNode;
+    }
+    /// Return actual return parameter
+    inline const SVFVar *getActualRet() const
+    {
+        return actualRet;
+    }
+
+    /// Add actual return parameter
+    inline void addActualRet(const SVFVar *ar)
+    {
+        actualRet = ar;
+    }
+
+    ///Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const RetICFGNode *)
+    {
+        return true;
+    }
+
+    static inline bool classof(const InterICFGNode *node)
+    {
+        return node->getNodeKind() == FunRetBlock;
+    }
+
+    static inline bool classof(const ICFGNode *node)
+    {
+        return node->getNodeKind() == FunRetBlock;
+    }
+
+    static inline bool classof(const GenericICFGNodeTy *node)
+    {
+        return node->getNodeKind() == FunRetBlock;
+    }
+    //@}
+
+    virtual const std::string toString() const;
+};
+
+} // End namespace SVF
+
+#endif /* ICFGNode_H_ */

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

@@ -0,0 +1,164 @@
+//===- ICFGStat.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/>.
+//
+//===----------------------------------------------------------------------===//
+/*
+ * ICFGStat.h
+ *
+ *  Created on: 12Sep.,2018
+ *      Author: yulei
+ */
+
+#ifndef INCLUDE_UTIL_ICFGSTAT_H_
+#define INCLUDE_UTIL_ICFGSTAT_H_
+
+#include "Util/PTAStat.h"
+#include "Graphs/ICFG.h"
+#include <iomanip>
+
+namespace SVF
+{
+
+class ICFGStat : public PTAStat
+{
+
+private:
+    ICFG *icfg;
+    int numOfNodes;
+    int numOfCallNodes;
+    int numOfRetNodes;
+    int numOfEntryNodes;
+    int numOfExitNodes;
+    int numOfIntraNodes;
+
+    int numOfEdges;
+    int numOfCallEdges;
+    int numOfRetEdges;
+    int numOfIntraEdges;
+
+public:
+    typedef Set<const ICFGNode *> ICFGNodeSet;
+
+    ICFGStat(ICFG *cfg) : PTAStat(nullptr), icfg(cfg)
+    {
+        numOfNodes = 0;
+        numOfCallNodes = 0;
+        numOfRetNodes = 0;
+        numOfEntryNodes = 0;
+        numOfExitNodes = 0;
+        numOfIntraNodes = 0;
+
+        numOfEdges = 0;
+        numOfCallEdges = 0;
+        numOfRetEdges = 0;
+        numOfIntraEdges = 0;
+
+    }
+
+    void performStat()
+    {
+
+        countStat();
+
+        PTNumStatMap["ICFGNode"] = numOfNodes;
+        PTNumStatMap["IntraICFGNode"] = numOfIntraNodes;
+        PTNumStatMap["CallICFGNode"] = numOfCallNodes;
+        PTNumStatMap["RetICFGNode"] = numOfRetNodes;
+        PTNumStatMap["FunEntryICFGNode"] = numOfEntryNodes;
+        PTNumStatMap["FunExitICFGNode"] = numOfExitNodes;
+
+        PTNumStatMap["ICFGEdge"] = numOfEdges;
+        PTNumStatMap["CallCFGEdge"] = numOfCallEdges;
+        PTNumStatMap["RetCFGEdge"] = numOfRetEdges;
+        PTNumStatMap["IntraCFGEdge"] = numOfIntraEdges;
+
+        printStat("ICFG Stat");
+    }
+
+    void performStatforIFDS()
+    {
+
+        countStat();
+        PTNumStatMap["ICFGNode(N)"] = numOfNodes;
+        PTNumStatMap["CallICFGNode(Call)"] = numOfCallNodes;
+        PTNumStatMap["ICFGEdge(E)"] = numOfEdges;
+        printStat("IFDS Stat");
+    }
+
+    void countStat()
+    {
+        ICFG::ICFGNodeIDToNodeMapTy::iterator it = icfg->begin();
+        ICFG::ICFGNodeIDToNodeMapTy::iterator eit = icfg->end();
+        for (; it != eit; ++it)
+        {
+            numOfNodes++;
+
+            ICFGNode *node = it->second;
+
+            if (SVFUtil::isa<IntraICFGNode>(node))
+                numOfIntraNodes++;
+            else if (SVFUtil::isa<CallICFGNode>(node))
+                numOfCallNodes++;
+            else if (SVFUtil::isa<RetICFGNode>(node))
+                numOfRetNodes++;
+            else if (SVFUtil::isa<FunEntryICFGNode>(node))
+                numOfEntryNodes++;
+            else if (SVFUtil::isa<FunExitICFGNode>(node))
+                numOfExitNodes++;
+
+
+            ICFGEdge::ICFGEdgeSetTy::iterator edgeIt =
+                it->second->OutEdgeBegin();
+            ICFGEdge::ICFGEdgeSetTy::iterator edgeEit =
+                it->second->OutEdgeEnd();
+            for (; edgeIt != edgeEit; ++edgeIt)
+            {
+                const ICFGEdge *edge = *edgeIt;
+                numOfEdges++;
+                if (edge->isCallCFGEdge())
+                    numOfCallEdges++;
+                else if (edge->isRetCFGEdge())
+                    numOfRetEdges++;
+                else if (edge->isIntraCFGEdge())
+                    numOfIntraEdges++;
+            }
+        }
+    }
+
+    void printStat(std::string statname)
+    {
+
+        SVFUtil::outs() << "\n************ " << statname << " ***************\n";
+        SVFUtil::outs().flags(std::ios::left);
+        unsigned field_width = 20;
+        for(NUMStatMap::iterator it = PTNumStatMap.begin(), eit = PTNumStatMap.end(); it!=eit; ++it)
+        {
+            // format out put with width 20 space
+            SVFUtil::outs() << std::setw(field_width) << it->first << it->second << "\n";
+        }
+        PTNumStatMap.clear();
+        SVFUtil::outs().flush();
+    }
+};
+
+} // End namespace SVF
+
+#endif /* INCLUDE_UTIL_ICFGSTAT_H_ */
+