svf-lib 1.0.1033 → 1.0.1034

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

@@ -11,7 +11,6 @@
 #include "MemoryModel/PointerAnalysisImpl.h"
 #include "DDA/DDAVFSolver.h"
 #include "Util/DPItem.h"
-#include "SVF-FE/DataFlowUtil.h"
 
 namespace SVF
 {
@@ -195,7 +194,6 @@ private:
     ConstSVFGEdgeSet insensitveEdges;///< insensitive call-return edges
     FlowDDA* flowDDA;			///< downgrade to flowDDA if out-of-budget
     DDAClient* _client;			///< DDA client
-    PTACFInfoBuilder loopInfoBuilder; ///< LoopInfo
 };
 
 } // End namespace SVF

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

@@ -11,7 +11,6 @@
 #include "MemoryModel/PointerAnalysisImpl.h"
 #include "Util/DPItem.h"
 #include "DDA/DDAVFSolver.h"
-#include "SVF-FE/DataFlowUtil.h"
 
 namespace SVF
 {
@@ -143,7 +142,6 @@ public:
 
 private:
     DDAClient* _client;				///< DDA client
-    PTACFInfoBuilder loopInfoBuilder; ///< LoopInfo
 };
 
 } // End namespace SVF

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

@@ -33,6 +33,7 @@
 #include "Graphs/ICFGNode.h"
 #include "Graphs/ICFGEdge.h"
 #include "Util/WorkList.h"
+#include "MemoryModel/SVFLoop.h"
 
 namespace SVF
 {
@@ -60,6 +61,8 @@ public:
     typedef Map<const Instruction*, CallICFGNode *> CSToCallNodeMapTy;
     typedef Map<const Instruction*, RetICFGNode *> CSToRetNodeMapTy;
     typedef Map<const Instruction*, IntraICFGNode *> InstToBlockNodeMapTy;
+    typedef std::vector<const SVFLoop *> SVFLoopVec;
+    typedef Map<const ICFGNode *, SVFLoopVec> ICFGNodeToSVFLoopVec;
 
     NodeID totalICFGNode;
 
@@ -70,15 +73,15 @@ private:
     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
-    virtual ~ICFG()
-    {
-    }
+    virtual ~ICFG();
 
     /// Get a ICFG node
     inline ICFGNode* getICFGNode(NodeID id) const
@@ -111,6 +114,33 @@ public:
     /// 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 Instruction *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)

package/SVF-osx/include/MTA/TCT.h

@@ -20,7 +20,6 @@ namespace SVF
 {
 
 class TCTNode;
-class PTALoopInfoBuilder;
 
 
 /*

package/SVF-osx/include/MemoryModel/SVFLoop.h

@@ -0,0 +1,163 @@
+//===- SVFLoop.h -- SVFLoop of SVF ------------------------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * SVFLoop.h
+ *
+ *  Created on: 14, 06, 2022
+ *      Author: Jiawei Wang, Xiao Cheng
+ */
+
+#ifndef SVF_SVFLOOP_H
+#define SVF_SVFLOOP_H
+
+#include "Util/SVFBasicTypes.h"
+
+namespace SVF
+{
+class SVFLoop
+{
+    typedef Set<const ICFGEdge *> ICFGEdgeSet;
+    typedef Set<const ICFGNode *> ICFGNodeSet;
+private:
+    ICFGEdgeSet entryICFGEdges, backICFGEdges, inICFGEdges, outICFGEdges;
+    ICFGNodeSet icfgNodes;
+    u32_t loopBound;
+
+public:
+    SVFLoop(const ICFGNodeSet &_nodes, u32_t _bound) :
+        icfgNodes(_nodes), loopBound(_bound)
+    {
+
+    }
+
+    virtual ~SVFLoop() = default;
+
+    inline ICFGNodeSet::iterator ICFGNodesBegin()
+    {
+        return icfgNodes.begin();
+    }
+
+    inline ICFGNodeSet::iterator ICFGNodesEnd()
+    {
+        return icfgNodes.end();
+    }
+
+    inline bool isInLoop(const ICFGNode *icfgNode) const
+    {
+        return icfgNodes.find(icfgNode) != icfgNodes.end();
+    }
+
+    inline bool isEntryICFGEdge(const ICFGEdge *edge) const
+    {
+        return entryICFGEdges.find(edge) != entryICFGEdges.end();
+    }
+
+    inline bool isBackICFGEdge(const ICFGEdge *edge) const
+    {
+        return backICFGEdges.find(edge) != entryICFGEdges.end();
+    }
+
+    inline bool isInICFGEdge(const ICFGEdge *edge) const
+    {
+        return inICFGEdges.find(edge) != entryICFGEdges.end();
+    }
+
+    inline bool isOutICFGEdge(const ICFGEdge *edge) const
+    {
+        return outICFGEdges.find(edge) != entryICFGEdges.end();
+    }
+
+    inline void addEntryICFGEdge(const ICFGEdge *edge)
+    {
+        entryICFGEdges.insert(edge);
+    }
+
+    inline ICFGEdgeSet::iterator entryICFGEdgesBegin()
+    {
+        return entryICFGEdges.begin();
+    }
+
+    inline ICFGEdgeSet::iterator entryICFGEdgesEnd()
+    {
+        return entryICFGEdges.end();
+    }
+
+    inline void addOutICFGEdge(const ICFGEdge *edge)
+    {
+        outICFGEdges.insert(edge);
+    }
+
+    inline ICFGEdgeSet::iterator outICFGEdgesBegin()
+    {
+        return outICFGEdges.begin();
+    }
+
+    inline ICFGEdgeSet::iterator outICFGEdgesEnd()
+    {
+        return outICFGEdges.end();
+    }
+
+    inline void addBackICFGEdge(const ICFGEdge *edge)
+    {
+        backICFGEdges.insert(edge);
+    }
+
+    inline ICFGEdgeSet::iterator backICFGEdgesBegin()
+    {
+        return backICFGEdges.begin();
+    }
+
+    inline ICFGEdgeSet::iterator backICFGEdgesEnd()
+    {
+        return backICFGEdges.end();
+    }
+
+    inline void addInICFGEdge(const ICFGEdge *edge)
+    {
+        inICFGEdges.insert(edge);
+    }
+
+    inline ICFGEdgeSet::iterator inEdgesBegin()
+    {
+        return inICFGEdges.begin();
+    }
+
+    inline ICFGEdgeSet::iterator inEdgesEnd()
+    {
+        return inICFGEdges.end();
+    }
+
+    inline void setLoopBound(u32_t _bound)
+    {
+        loopBound = _bound;
+    }
+
+    inline u32_t getLoopBound() const
+    {
+        return loopBound;
+    }
+};
+
+}
+
+#endif //SVF_SVFLOOP_H

package/SVF-osx/include/SVF-FE/LLVMLoopAnalysis.h

@@ -0,0 +1,59 @@
+//===- LLVMLoopAnalysis.h -- LoopAnalysis of SVF --------------------//
+//
+//                     SVF: Static Value-Flow Analysis
+//
+// Copyright (C) <2013-2022>  <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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * LLVMLoopAnalysis.h
+ *
+ *  Created on: 14, 06, 2022
+ *      Author: Jiawei Wang, Xiao Cheng
+ */
+
+#ifndef SVF_LLVMLOOPANALYSIS_H
+#define SVF_LLVMLOOPANALYSIS_H
+
+#include "MemoryModel/SVFIR.h"
+#include "MemoryModel/SVFLoop.h"
+
+namespace SVF
+{
+class LLVMLoopAnalysis
+{
+public:
+
+    /// Constructor
+    LLVMLoopAnalysis() = default;;
+
+    /// Destructor
+    virtual ~LLVMLoopAnalysis() = default;
+
+    /// Build llvm loops based on LoopInfo analysis
+    virtual void buildLLVMLoops(SVFModule *mod, std::vector<const Loop *> &llvmLoops);
+
+    /// Start from here
+    virtual void build(ICFG *icfg);
+
+    /// Build SVF loops based on llvm loops
+    virtual void buildSVFLoops(ICFG *icfg, std::vector<const Loop *> &llvmLoops);
+};
+} // end fo SVF
+
+#endif //SVF_LLVMLOOPANALYSIS_H

package/SVF-osx/include/Util/Options.h

@@ -260,6 +260,10 @@ public:
     static const llvm::cl::opt<bool> GraphIsFromDot;
     static const llvm::cl::opt<bool> GrammarIsEBNF;
     static const llvm::cl::opt<bool> FlexSymMap;
+
+    // Loop Analysis
+    static const llvm::cl::opt<bool> LoopAnalysis;
+    static const llvm::cl::opt<unsigned> LoopBound;
 };
 }  // namespace SVF
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-lib",
-  "version": "1.0.1033",
+  "version": "1.0.1034",
   "description": "SVF's npm support",
   "main": "index.js",
   "scripts": {