svf-tools 1.0.804 → 1.0.805

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.804",
+  "version": "1.0.805",
   "description": "* <b>[TypeClone](https://github.com/SVF-tools/SVF/wiki/TypeClone) published in our [ECOOP paper](https://yuleisui.github.io/publications/ecoop20.pdf) is now available in SVF </b> * <b>SVF now uses a single script for its build. Just type [`source ./build.sh`](https://github.com/SVF-tools/SVF/blob/master/build.sh) in your terminal, that's it!</b> * <b>SVF now supports LLVM-10.0.0! </b> * <b>We thank [bsauce](https://github.com/bsauce) for writing a user manual of SVF ([link1](https://www.jianshu.com/p/068a08ec749c) and [link2](https://www.jianshu.com/p/777c30d4240e)) in Chinese </b> * <b>SVF now supports LLVM-9.0.0 (Thank [Byoungyoung Lee](https://github.com/SVF-tools/SVF/issues/142) for his help!). </b> * <b>SVF now supports a set of [field-sensitive pointer analyses](https://yuleisui.github.io/publications/sas2019a.pdf). </b> * <b>[Use SVF as an external lib](https://github.com/SVF-tools/SVF/wiki/Using-SVF-as-a-lib-in-your-own-tool) for your own project (Contributed by [Hongxu Chen](https://github.com/HongxuChen)). </b> * <b>SVF now supports LLVM-7.0.0. </b> * <b>SVF now supports Docker. [Try SVF in Docker](https://github.com/SVF-tools/SVF/wiki/Try-SVF-in-Docker)! </b> * <b>SVF now supports [LLVM-6.0.0](https://github.com/svf-tools/SVF/pull/38) (Contributed by [Jack Anthony](https://github.com/jackanth)). </b> * <b>SVF now supports [LLVM-4.0.0](https://github.com/svf-tools/SVF/pull/23) (Contributed by Jared Carlson. Thank [Jared](https://github.com/jcarlson23) and [Will](https://github.com/dtzWill) for their in-depth [discussions](https://github.com/svf-tools/SVF/pull/18) about updating SVF!) </b> * <b>SVF now supports analysis for C++ programs.</b> <br />",
   "main": "index.js",
   "scripts": {

package/svf/lib/Util/CFBasicBlockGBuilder.cpp

@@ -31,29 +31,37 @@
 namespace SVF
 {
 
+/**
+ * Initialize Control Flow Basic Block Graph (CFBasicBlockG) nodes based on the provided Interprocedural Control Flow Graph (ICFG).
+ *
+ * @param icfg The Interprocedural Control Flow Graph (ICFG) to initialize from.
+ * @param bbToNodes A map that associates each SVFBasicBlock with a vector of CFBasicBlockNode objects.
+ */
 void CFBasicBlockGBuilder::initCFBasicBlockGNodes(ICFG *icfg,
         Map<const SVFBasicBlock *, std::vector<CFBasicBlockNode *>> &bbToNodes)
 {
-    for (const auto &node: *icfg)
+    for (const auto &node : *icfg)
     {
         CFBasicBlockNode *pNode;
         if (const SVFBasicBlock *bb = node.second->getBB())
         {
             if (const CallICFGNode *callNode = SVFUtil::dyn_cast<CallICFGNode>(node.second))
             {
+                // Create a new CFBasicBlockNode for the CallICFGNode
                 pNode = new CFBasicBlockNode({callNode});
                 bbToNodes[bb].push_back(pNode);
                 _CFBasicBlockG->addCFBBNode(pNode);
 
+                // Create a new CFBasicBlockNode for the corresponding RetICFGNode
                 auto *retNode = new CFBasicBlockNode({callNode->getRetICFGNode()});
                 bbToNodes[bb].push_back(retNode);
                 _CFBasicBlockG->addCFBBNode(retNode);
-
             }
             else if (!SVFUtil::isa<RetICFGNode>(node.second))
             {
                 if (bbToNodes.find(bb) == bbToNodes.end())
                 {
+                    // Create a new CFBasicBlockNode for the non-CallICFGNode
                     pNode = new CFBasicBlockNode({node.second});
                     bbToNodes[node.second->getBB()] = {pNode};
                     _CFBasicBlockG->addCFBBNode(pNode);
@@ -63,10 +71,12 @@ void CFBasicBlockGBuilder::initCFBasicBlockGNodes(ICFG *icfg,
                     pNode = bbToNodes[node.second->getBB()].back();
                     if (!SVFUtil::isa<RetICFGNode>(pNode->getICFGNodes()[0]))
                     {
+                        // Add the non-CallICFGNode to the existing CFBasicBlockNode
                         pNode->addNode(node.second);
                     }
                     else
                     {
+                        // Create a new CFBasicBlockNode for the non-CallICFGNode
                         pNode = new CFBasicBlockNode({node.second});
                         bbToNodes[node.second->getBB()].push_back(pNode);
                         _CFBasicBlockG->addCFBBNode(pNode);
@@ -77,39 +87,62 @@ void CFBasicBlockGBuilder::initCFBasicBlockGNodes(ICFG *icfg,
     }
 }
 
+
+/**
+ * Add inter-BasicBlock edges to the Control Flow Basic Block Graph (CFBasicBlockG) based on the provided Interprocedural Control Flow Graph (ICFG).
+ *
+ * @param icfg The Interprocedural Control Flow Graph (ICFG) to extract edges from.
+ * @param bbToNodes A map that associates each SVFBasicBlock with a vector of CFBasicBlockNode objects.
+ */
 void CFBasicBlockGBuilder::addInterBBEdge(ICFG *icfg,
         Map<const SVFBasicBlock *, std::vector<CFBasicBlockNode *>> &bbToNodes)
 {
-    // connect inter-BB BBNodes
-    for (const auto &node: *icfg)
+    // Connect inter-BB BBNodes
+    for (const auto &node : *icfg)
     {
-        for (const auto &succ: node.second->getOutEdges())
+        for (const auto &succ : node.second->getOutEdges())
         {
-            const SVFFunction *node_fun = node.second->getFun();
-            const SVFFunction *succ_fun = succ->getDstNode()->getFun();
-            const SVFBasicBlock *node_bb = node.second->getBB();
-            const SVFBasicBlock *succ_bb = succ->getDstNode()->getBB();
-            if (node_fun == succ_fun)
+            // Check if it's an intraCFGEdge in case of recursive functions
+            // if recursive functions, node_fun == succ_fun but they are different call context
+            // edges related to recursive functions would be added in addInterProceduralEdge()
+            if (succ->isIntraCFGEdge())
             {
-                if (node_bb != succ_bb)
+                const SVFFunction *node_fun = node.second->getFun();
+                const SVFFunction *succ_fun = succ->getDstNode()->getFun();
+                const SVFBasicBlock *node_bb = node.second->getBB();
+                const SVFBasicBlock *succ_bb = succ->getDstNode()->getBB();
+                if (node_fun == succ_fun)
                 {
-                    CFBasicBlockEdge *pEdge = new CFBasicBlockEdge(bbToNodes[node_bb].back(),
+                    if (node_bb != succ_bb)
+                    {
+                        // Create a new CFBasicBlockEdge connecting the last node of the source BB
+                        // and the first node of the destination BB
+                        CFBasicBlockEdge *pEdge = new CFBasicBlockEdge(
+                            bbToNodes[node_bb].back(),
                             bbToNodes[succ_bb].front(), succ);
-                    _CFBasicBlockG->addCFBBEdge(pEdge);
+                        _CFBasicBlockG->addCFBBEdge(pEdge);
+                    }
                 }
             }
         }
     }
 }
 
+/**
+ * Add intra-BasicBlock edges to the Control Flow Basic Block Graph (CFBasicBlockG) based on the provided Interprocedural Control Flow Graph (ICFG).
+ *
+ * @param icfg The Interprocedural Control Flow Graph (ICFG) to extract edges from.
+ * @param bbToNodes A map that associates each SVFBasicBlock with a vector of CFBasicBlockNode objects.
+ */
 void CFBasicBlockGBuilder::addIntraBBEdge(ICFG *icfg,
         Map<const SVFBasicBlock *, std::vector<CFBasicBlockNode *>> &bbToNodes)
 {
-    // connect intra-BB BBNodes
-    for (const auto &bbNodes: bbToNodes)
+    // Connect intra-BB BBNodes
+    for (const auto &bbNodes : bbToNodes)
     {
         for (u32_t i = 0; i < bbNodes.second.size() - 1; ++i)
         {
+            // Check if an intraCFGEdge exists between the last node of the source BB and the first node of the destination BB
             if (ICFGEdge *icfgEdge = icfg->getICFGEdge(
                                          const_cast<ICFGNode *>(bbNodes.second[i]->getICFGNodes().back()),
                                          const_cast<ICFGNode *>(bbNodes.second[i + 1]->getICFGNodes().front()),
@@ -120,24 +153,30 @@ void CFBasicBlockGBuilder::addIntraBBEdge(ICFG *icfg,
             }
             else
             {
-                // no intra-procedural edge, maybe ext api
+                // No intra-procedural edge found, possibly an external API call
             }
         }
     }
 }
 
+/**
+ * Add inter-procedural edges between CFBasicBlockNodes based on the provided Interprocedural Control Flow Graph (ICFG).
+ *
+ * @param icfg The Interprocedural Control Flow Graph (ICFG) to extract edges from.
+ * @param bbToNodes A map that associates each SVFBasicBlock with a vector of CFBasicBlockNode objects.
+ */
 void CFBasicBlockGBuilder::addInterProceduralEdge(ICFG *icfg,
         Map<const SVFBasicBlock *, std::vector<CFBasicBlockNode *>> &bbToNodes)
 {
-    // connect inter-procedural BBNodes
-    for (const auto &bbNodes: bbToNodes)
+    // Connect inter-procedural BBNodes
+    for (const auto &bbNodes : bbToNodes)
     {
         for (u32_t i = 0; i < bbNodes.second.size(); ++i)
         {
             if (const CallICFGNode *callICFGNode = SVFUtil::dyn_cast<CallICFGNode>(
                     bbNodes.second[i]->getICFGNodes().front()))
             {
-                for (const auto &icfgEdge: callICFGNode->getOutEdges())
+                for (const auto &icfgEdge : callICFGNode->getOutEdges())
                 {
                     if (const CallCFGEdge *callEdge = SVFUtil::dyn_cast<CallCFGEdge>(icfgEdge))
                     {
@@ -151,7 +190,7 @@ void CFBasicBlockGBuilder::addInterProceduralEdge(ICFG *icfg,
             else if (const RetICFGNode *retICFGNode = SVFUtil::dyn_cast<RetICFGNode>(
                          bbNodes.second[i]->getICFGNodes().front()))
             {
-                for (const auto &icfgEdge: retICFGNode->getInEdges())
+                for (const auto &icfgEdge : retICFGNode->getInEdges())
                 {
                     if (const RetCFGEdge *retEdge = SVFUtil::dyn_cast<RetCFGEdge>(icfgEdge))
                     {
@@ -164,20 +203,26 @@ void CFBasicBlockGBuilder::addInterProceduralEdge(ICFG *icfg,
             }
             else
             {
-                // other nodes are intra-procedural
+                // Other nodes are intra-procedural
             }
         }
     }
 }
 
-void CFBasicBlockGBuilder::build(ICFG* icfg)
+/**
+ * Build the Control Flow Basic Block Graph (CFBasicBlockG) based on the provided Interprocedural Control Flow Graph (ICFG).
+ *
+ * @param icfg The Interprocedural Control Flow Graph (ICFG) to extract control flow information from.
+ */
+void CFBasicBlockGBuilder::build(ICFG *icfg)
 {
     _CFBasicBlockG = new CFBasicBlockGraph();
-    Map<const SVFBasicBlock*, std::vector<CFBasicBlockNode*>> bbToNodes;
+    Map<const SVFBasicBlock *, std::vector<CFBasicBlockNode *>> bbToNodes;
 
     initCFBasicBlockGNodes(icfg, bbToNodes);
     addInterBBEdge(icfg, bbToNodes);
     addIntraBBEdge(icfg, bbToNodes);
     addInterProceduralEdge(icfg, bbToNodes);
 }
+
 }