svf-lib 1.0.1892 → 1.0.1893

package/SVF-linux/Release-build/include/AE/Svfexe/AbstractExecution.h

@@ -27,20 +27,24 @@
 //
 // Created by Jiawei Wang on 2024/1/10.
 //
-#include <exception>
-#include <string>
-#include "AE/Svfexe/SVFIR2ItvExeState.h"
-#include "Util/WorkList.h"
-#include "MSSA/SVFGBuilder.h"
+
+#include "Util/SVFBugReport.h"
 #include "AE/Core/ICFGWTO.h"
 #include "WPA/Andersen.h"
-#include "Util/SVFBugReport.h"
+#include "AE/Svfexe/SVFIR2ItvExeState.h"
 
 namespace SVF
 {
 class AbstractExecution;
 class AEStat;
 class AEAPI;
+class IntervalValue;
+class ExeState;
+
+template<typename T> class FILOWorkList;
+
+
+
 
 
 enum class AEKind
@@ -118,7 +122,7 @@ public:
 
     virtual void initExtAPI();
 
-    virtual void runOnModule(SVFIR* svfModule);
+    virtual void runOnModule(ICFG* icfg);
 
     /// Destructor
     virtual ~AbstractExecution();
@@ -276,13 +280,12 @@ private:
     Map<const ICFGNode*, IntervalExeState> _postES;
     std::string _moduleName;
 
+
 };
 
 class AEAPI
 {
 public:
-
-    typedef ExeState::Addrs Addrs;
     enum ExtAPIType { UNCLASSIFIED, MEMCPY, MEMSET, STRCPY, STRCAT };
     static bool classof(const AEAPI* api)
     {
@@ -430,5 +433,6 @@ protected:
 
     Set<const CallICFGNode*> _checkpoints;
     Set<std::string> _checkpoint_names;
+
 };
 }

package/SVF-linux/Release-build/include/AE/Svfexe/ICFGSimplification.h

@@ -0,0 +1,46 @@
+//===- ICFGSimplification.h -- Simplify ICFG----------------------------------//
+//
+//                     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 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/>.
+//
+// The implementation is based on
+// Xiao Cheng, Jiawei Wang and Yulei Sui. Precise Sparse Abstract Execution via Cross-Domain Interaction.
+// 46th International Conference on Software Engineering. (ICSE24)
+//===----------------------------------------------------------------------===//
+
+
+//
+// Created by Jiawei Wang on 2024/2/25.
+//
+#include "Graphs/ICFG.h"
+#include "AE/Svfexe/SVFIR2ItvExeState.h"
+
+
+namespace SVF
+{
+
+class ICFGSimplification
+{
+public:
+    ICFGSimplification() = default;
+
+    virtual ~ICFGSimplification() = default;
+
+    static void mergeAdjacentNodes(ICFG* icfg);
+};
+}

package/SVF-linux/Release-build/include/Graphs/ICFG.h

@@ -49,6 +49,7 @@ class ICFG : public GenericICFGTy
     friend class ICFGBuilder;
     friend class SVFIRWriter;
     friend class SVFIRReader;
+    friend class ICFGSimplification;
 
 public:
 
@@ -76,6 +77,9 @@ private:
     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
@@ -148,27 +152,27 @@ public:
     }
 
 protected:
-    /// Remove a SVFG edge
+    /// Add intraprocedural and interprocedural control-flow edges.
+    //@{
+    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);
+    //@}
+    /// 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);
     }
 
-    /// 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)
     {
@@ -180,20 +184,12 @@ protected:
         }
     }
 
-    /// 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);
+        _repNode[node] = node;
+        _subNodes[node].push_back(node);
     }
 
 public:
@@ -221,9 +217,51 @@ public:
         globalBlockNode = new GlobalICFGNode(totalICFGNode++);
         addICFGNode(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 IntraBlock ICFGNode
     inline IntraICFGNode* getIntraBlock(const SVFInstruction* inst)

package/SVF-linux/Release-build/include/Util/Options.h

@@ -272,6 +272,8 @@ public:
     /// if the access index of gepstmt is unknown, skip it, Default: false
     static const Option<bool> GepUnknownIdx;
     static const Option<bool> RunUncallFuncs;
+
+    static const Option<bool> ICFGMergeAdjacentNodes;
 };
 }  // namespace SVF
 

package/package.json

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