svf-lib 1.0.2682 → 1.0.2684

package/SVF-linux-x86_64/include/MTA/MTASlicer.h

@@ -24,14 +24,6 @@
  * MTASlicer.h
  *
  *      Author: Jiawei Yang
- *
- * The program slicers of "Multi-Stage On-Demand Program Slicing for Modular
- * Analysis of Multi-Threaded Programs" (ISSTA 2026): a shared MTASlicerBase plus
- * three concrete slicers.
- *   - MultiStageSlicer   : ILA (sync + dual + call) slice for the thread-aware analysis
- *   (its FSPTA stage: data-dependence slice over the thread-aware VFG_pre)
- *   - SingleSlicer: one unified slice combining all three dependence kinds, shared
- *                   by both ILA and FSPTA (the single-pass baseline, MSli §3/§5.4)
  */
 
 #ifndef MTA_MTASLICER_H
@@ -48,15 +40,11 @@
 #include "Graphs/ThreadCallGraph.h"
 #include "Graphs/ICFG.h"
 #include "Graphs/ICFGNode.h"
-#include <fstream>
+#include <deque>
 #include "Graphs/ICFGEdge.h"
 #include "Graphs/CallGraph.h"
 #include "Util/WorkList.h"
 #include <memory>
-#include <set>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
 #include <vector>
 #include <utility>
 
@@ -68,6 +56,20 @@ class SVFG;
 class VFGNode;          // SVFGNode is a typedef for VFGNode
 class PointerAnalysis;
 
+struct ValueFlowSlice
+{
+    OrderedSet<const SVFGNode*> svfgNodes;
+    OrderedSet<const ICFGNode*> icfgNodes;
+
+    NodeBS nodeIds() const
+    {
+        NodeBS ids;
+        for (const SVFGNode* node : svfgNodes)
+            ids.set(node->getId());
+        return ids;
+    }
+};
+
 
 //===----------------------------------------------------------------------===//
 // SlicedTCT - the Thread-Create-Tree rebuilt over a SlicedThreadCallGraphView.
@@ -80,16 +82,15 @@ class PointerAnalysis;
 class SlicedTCT : public TCT
 {
 public:
-    /// @param p PointerAnalysis (the shared Andersen pre-analysis)
+    /// @param pointerAnalysis the shared Andersen pre-analysis
     /// @param slicedView SlicedSVFIRView containing a SlicedThreadCallGraphView
-    /// @param maxContextLen Max context length (0 = use Options::MaxContextLen())
-    SlicedTCT(PointerAnalysis* p, const SlicedSVFIRView* slicedView, u32_t maxContextLen = 0);
+    /// @param contextLimit maximum context length for the main analysis
+    static std::unique_ptr<SlicedTCT> create(
+        PointerAnalysis& pointerAnalysis, const SlicedSVFIRView& slicedView,
+        u32_t contextLimit);
 
     ~SlicedTCT() override = default;
 
-    /// Override pushCxt to use the custom maxContextLen
-    void pushCxt(CallStrCxt& cxt, const CallICFGNode* call, const FunObjVar* callee) override;
-
 protected:
     void build() override;
     void markRelProcs() override;
@@ -98,11 +99,12 @@ protected:
     void handleCallRelation(CxtThreadProc& ctp, const CallGraphEdge* cgEdge, const CallICFGNode* cs) override;
 
 private:
-    void collectEntryFunInCallGraph() override;
+    SlicedTCT(PointerAnalysis& pointerAnalysis,
+              const SlicedSVFIRView& slicedView, u32_t contextLimit);
 
-    const SlicedThreadCallGraphView* tcgView; // ThreadCallGraph view (from the sliced view)
-    u32_t maxContextLen; // 0 means use Options::MaxContextLen()
+    void collectEntryFunInCallGraph() override;
 
+    const SlicedThreadCallGraphView& tcgView;
     bool isKeptNode(const CallGraphNode* node) const;
     bool isKeptEdge(const CallGraphEdge* edge) const;
     void getKeptForkSites(std::vector<const ICFGNode*>& out) const;
@@ -119,62 +121,61 @@ private:
 class MTASlicerBase
 {
 public:
-    MTASlicerBase(SVFIR* svfIr, AndersenBase* pta, MHP* mhp,
-                  LockAnalysis* lockAnalysis, SVFG* vfg = nullptr);
-    virtual ~MTASlicerBase();
+    MTASlicerBase(SVFIR* svfir, AndersenBase* pta, MHP* mhp,
+                  LockAnalysis* lockAnalysis, SVFG* svfg = nullptr);
 
 protected:
-    SVFIR* svfIr;
+    SVFIR* svfir;
     AndersenBase* pta;
     MHP* mhp;
     LockAnalysis* lockAnalysis;
     CallGraph* callGraph;
-    SVFG* vfg;   ///< thread-aware VFG_pre (PTA/Single slicers; null for MTA)
+    SVFG* svfg;   ///< thread-aware VFG_pre (PTA/Single slicers; null for MTA)
 
     // === Data flow analysis helper ===
-    /**
-     * Paper-faithful (§4.3) data-dependence slice over the thread-aware SVFG
-     * (VFG_pre): seed from the value-flow nodes of the given statements and
-     * backward-traverse every value-flow edge -- direct (top-level def-use),
-     * indirect (address-taken / MemSSA def-use), and thread-aware interference.
-     * Returns the kept ICFG nodes. This is the single dependence model used
-     * by the FSPTA stage.
-     */
-    OrderedSet<const ICFGNode*> sliceDataDependenceOverVFG(
-        const OrderedSet<const SVFStmt*>& seeds, SVFG* vfg);
-
     /// The SVFG-node granularity of the data-dependence slice above: the set of
     /// VFG nodes reachable backward from the seeds. ThreadVF(VFG'_pre) is exactly
     /// the thread-aware edges whose *both* endpoints lie in this set, so ILA
     /// slicing uses it to restrict the [THREAD-VF] sources to surviving edges.
     OrderedSet<const VFGNode*> computeDataDependenceSVFGNodes(
-        const OrderedSet<const SVFStmt*>& seeds, SVFG* vfg);
+        const OrderedSet<const SVFStmt*>& seeds, SVFG* svfg);
+
+    static void enqueueSVFGNode(const SVFGNode* node,
+                                OrderedSet<const SVFGNode*>& visited,
+                                std::deque<const SVFGNode*>& worklist);
 
     /// Project the retained VFG nodes (plus the seeds) onto their ICFG nodes.
     OrderedSet<const ICFGNode*> svfgNodesToICFGNodes(
         const OrderedSet<const VFGNode*>& nodes, const OrderedSet<const SVFStmt*>& seeds);
 
     // === Thread analysis helpers ===
-    OrderedSet<const SVFStmt*> getDependentThreadCreate(const SVFStmt* stmt);
+    OrderedSet<const CallICFGNode*> getDependentThreadCreate(const ICFGNode* node);
     OrderedSet<const TCTNode*> getTCTNodeSetFromNode(const ICFGNode* node);
 
     // === Lock analysis helpers ===
     OrderedSet<const ICFGNode*> getLockSet(const ICFGNode* node);
-    OrderedSet<const CallICFGNode*> collectPthreadStatements(const OrderedSet<const SVFStmt*>& vulnerableStmts);
-    OrderedSet<const CallICFGNode*> collectMutexStatements(const OrderedSet<const SVFStmt*>& vulnerableStmts);
+    OrderedSet<const CallICFGNode*> collectPthreadStatements(
+        const OrderedSet<const ICFGNode*>& sourceNodes);
+    OrderedSet<const CallICFGNode*> collectMutexStatements(
+        const OrderedSet<const ICFGNode*>& sourceNodes);
 
     // === Common slicing helpers ===
     /**
      * Collect common pthread and mutex statements (shared by PTA and MTA slicing).
-     * @param vulnerableStatements Set of vulnerable statements
+     * @param sourceNodes Complete ILA source set ([INIT] union [THREAD-VF])
      * @return Pair of (pthreadCallNodes, mutexCallNodes)
      */
     std::pair<OrderedSet<const CallICFGNode*>, OrderedSet<const CallICFGNode*>>
-            collectCommonThreadStatements(const OrderedSet<const SVFStmt*>& vulnerableStatements);
+            collectCommonThreadStatements(const OrderedSet<const ICFGNode*>& sourceNodes);
 
-    // === ICFG analysis helpers ===
-    OrderedSet<const ICFGNode*> buildBackwardICFGNodeSet(const OrderedSet<const ICFGNode*>& vulnerableNodes);
+    /// Add synchronization primitives and the control-flow anchors required by
+    /// the sliced MHP/lock analyses.
+    void addSynchronizationDependencies(
+        const OrderedSet<const CallICFGNode*>& pthreadCallNodes,
+        const OrderedSet<const CallICFGNode*>& mutexCallNodes,
+        OrderedSet<const ICFGNode*>& retainedNodes);
 
+    // === ICFG analysis helpers ===
     /**
      * Call-dependence expansion (used by MultiStageSlicer): take the
      * kept functions of the given nodes, close upward over the call graph
@@ -185,20 +186,13 @@ protected:
      */
     OrderedSet<const ICFGNode*> expandCallDependence(const OrderedSet<const ICFGNode*>& nodes);
 
-    /**
-     * Perform dual slicing (temporal slicing): filter statements based on control flow and parallel execution.
-     * This is shared by both PTA and MTA slicing.
-     * @param slicedNodes Set of statements from statement-level slicing
-     * @return Set of ICFG nodes in the dual slice
-     */
-    OrderedSet<const ICFGNode*> runDualSlicing(
-        const OrderedSet<const ICFGNode*>& slicedNodes);
 };
 
 /**
- * MultiStageSlicer - the multi-stage (differential) slicer of MSli: one class,
- * two stages sharing one memoised data-dependence closure over VFG_pre.
- *   Stage 1 (ILA):  runILASlicing  -- synchronization/dual slicing + function
+ * MultiStageSlicer - the multi-stage (differential) slicer of MSli. The
+ * pre-candidate closure scopes ILA queries and the Main-TVF overlay; the final
+ * closure is recomputed over that refined main graph.
+ *   Stage 1 (ILA):  runILASlicing  -- synchronization slicing + function
  *                                     expansion, feeding the sliced MHP/lock.
  *   Stage 2 (FSPTA): runPTASlicing -- backward data-dependence slice feeding
  *                                     the sliced flow-sensitive solve.
@@ -207,11 +201,11 @@ protected:
 class MultiStageSlicer : public MTASlicerBase
 {
 public:
-    MultiStageSlicer(SVFIR* svfIr, AndersenBase* pta, MHP* mhp,
-                     LockAnalysis* lockAnalysis, SVFG* vfg = nullptr);
+    MultiStageSlicer(SVFIR* svfir, AndersenBase* pta, MHP* mhp,
+                     LockAnalysis* lockAnalysis, SVFG* svfg = nullptr);
 
     /**
-     * Stage 1: the ILA slice (dual slicing + function expansion for the IRView).
+     * Stage 1: the ILA slice (synchronization + function expansion for the IRView).
      * @param vulnerableStatements Set of vulnerable statements to start slicing from
      *        (the [INIT] rule: pre-analysis race statements).
      * @param threadVFSources Extra ILA slicing sources from the [THREAD-VF] rule
@@ -225,24 +219,24 @@ public:
         const OrderedSet<const ICFGNode*>& threadVFSources = {});
 
     /**
-     * Stage 2: the FSPTA slice (backward data dependence over the thread-aware
-     * VFG_pre; node set only, no function expansion).
+     * Stage 2: the FSPTA slice (backward data dependence over the refined main
+     * value-flow graph; node set only, no function expansion).
      */
-    OrderedSet<const ICFGNode*> runPTASlicing(
-        const OrderedSet<const SVFStmt*>& vulnerableStatements);
+    ValueFlowSlice runPTASlicing(
+        const OrderedSet<const SVFStmt*>& vulnerableStatements,
+        SVFG* refinedMainVFG);
 
-    /**
-     * The FSPTA data-dependence slice at SVFG-node granularity (memoised). The
-     * ILA stage queries this first, to restrict the [THREAD-VF] sources to
-     * ThreadVF(VFG'_pre); runPTASlicing reuses the same set, so the backward
-     * closure over VFG_pre is computed once and shared across both stages.
-     */
-    const OrderedSet<const VFGNode*>& getRetainedSVFGNodes(
+    /// Compute the pre-candidate slice used to restrict [THREAD-VF] sources and
+    /// scope construction of the refined main overlay.
+    void computePreCandidateSlice(
         const OrderedSet<const SVFStmt*>& vulnerableStatements);
 
+    /// Return the pre-candidate slice after computePreCandidateSlice().
+    const ValueFlowSlice& getPreCandidateSlice() const;
+
 private:
-    OrderedSet<const VFGNode*> retainedSVFGNodes; ///< memoised data-dependence slice
-    bool retainedComputed = false;
+    ValueFlowSlice preCandidateSlice;
+    bool preCandidateComputed = false;
 };
 
 /**
@@ -252,21 +246,21 @@ private:
  * graph). Both ILA and FSPTA run on this single slice, so V_ILA, V_PTA subset
  * V_Single. Used by the differential-slicing ablation (-mta-slicing-single).
  *
- * Iteratively applies data dependence (over the thread-aware VFG_pre) and call
- * dependence until convergence, then a single dual-slicing pass.
+ * Iteratively applies synchronization, data, and call dependence over the
+ * thread-aware VFG_pre until convergence.
  */
 class SingleSlicer : public MTASlicerBase
 {
 public:
-    SingleSlicer(SVFIR* svfIr, AndersenBase* pta, MHP* mhp,
-                 LockAnalysis* lockAnalysis, SVFG* vfg = nullptr);
+    SingleSlicer(SVFIR* svfir, AndersenBase* pta, MHP* mhp,
+                 LockAnalysis* lockAnalysis, SVFG* svfg = nullptr);
 
     /**
      * Perform unified slicing combining synchronization, data, and call dependence.
      * @param vulnerableStatements Set of vulnerable statements to start slicing from
-     * @return Set of ICFG nodes in the slice (including call/ret and entry/exit nodes)
+     * @return Exact SVFG data slice plus its synchronization/call-complete ICFG view
      */
-    OrderedSet<const ICFGNode*> runSlicing(
+    ValueFlowSlice runSlicing(
         const OrderedSet<const SVFStmt*>& vulnerableStatements);
 };
 

package/SVF-linux-x86_64/include/MTA/MTAStat.h

@@ -31,11 +31,63 @@
 #define MTASTAT_H_
 
 #include "Util/PTAStat.h"
+#include "Util/Options.h"
+#include "Util/SVFUtil.h"
+
+#include <chrono>
+#include <iomanip>
+#include <sstream>
 
 namespace SVF
 {
 
-class Instruction;
+/// MTA's phase and slice reports are opt-in. PStat itself defaults to true in
+/// SVF, so its value alone does not indicate that the user requested -stat.
+inline bool isMTAStatEnabled()
+{
+    return Options::PStat.isSet() && Options::PStat();
+}
+
+class ScopedPhaseTimer
+{
+public:
+    explicit ScopedPhaseTimer(const char* phaseName)
+        : name(phaseName), enabled(isMTAStatEnabled()),
+          start(enabled ? std::chrono::steady_clock::now()
+                : std::chrono::steady_clock::time_point())
+    {
+        if (enabled)
+        {
+            SVFUtil::outs() << "[TIMER] Phase: " << name << " - started\n";
+            SVFUtil::outs().flush();
+        }
+    }
+
+    ~ScopedPhaseTimer()
+    {
+        if (!enabled)
+            return;
+
+        const auto end = std::chrono::steady_clock::now();
+        const double milliseconds =
+            std::chrono::duration_cast<std::chrono::duration<double, std::milli>>(
+                end - start).count();
+        std::ostringstream elapsed;
+        elapsed << std::fixed << std::setprecision(2) << milliseconds << " ms";
+        if (milliseconds >= 1000.0)
+            elapsed << " (" << std::fixed << std::setprecision(2)
+                    << (milliseconds / 1000.0) << " s)";
+        SVFUtil::outs() << "[TIMER] Phase: " << name << " - finished in "
+                        << elapsed.str() << "\n";
+        SVFUtil::outs().flush();
+    }
+
+private:
+    const char* name;
+    const bool enabled;
+    std::chrono::steady_clock::time_point start;
+};
+
 class ThreadCallGraph;
 class TCT;
 class MHP;
@@ -48,18 +100,14 @@ class MTAStat : public PTAStat
 {
 
 public:
-    typedef Set<const Instruction*> InstSet;
-
     /// Constructor
-    MTAStat():PTAStat(nullptr),TCTTime(0),MHPTime(0),AnnotationTime(0)
+    MTAStat() : PTAStat(nullptr), TCTTime(0), MHPTime(0), AnnotationTime(0)
     {
     }
     /// Statistics for thread call graph
     void performThreadCallGraphStat(ThreadCallGraph* tcg);
     /// Statistics for thread creation tree
     void performTCTStat(TCT* tct);
-    /// Statistics for annotation
-    //void performAnnotationStat(MTAAnnotator* anno);
 
     double TCTTime;
     double MHPTime;

package/SVF-linux-x86_64/include/MTA/TCT.h

@@ -30,6 +30,7 @@
 #ifndef TCTNodeDetector_H_
 #define TCTNodeDetector_H_
 
+#include <memory>
 #include <vector>
 
 #include "MemoryModel/PointerAnalysis.h"
@@ -183,8 +184,13 @@ public:
     typedef SCCDetection<CallGraph*> ThreadCallGraphSCC;
     typedef Set<const ICFGNode*> DummyForkSiteSet;
 
-    /// Constructor
-    TCT(PointerAnalysis* p);
+    /// Construct and build a TCT with the command-line context bound.
+    static std::unique_ptr<TCT> create(PointerAnalysis* p);
+
+    /// Construct and build a TCT with an explicit context bound. Analyses that
+    /// require a phase-specific bound must pass it here rather than mutating
+    /// the process-global option.
+    static std::unique_ptr<TCT> create(PointerAnalysis* p, u32_t contextLimit);
 
     /// Destructor
     virtual ~TCT();
@@ -444,8 +450,13 @@ public:
     void print() const;
 
 protected:
+    /// Initialize common TCT state. Factory functions invoke build() only after
+    /// the complete concrete object has been constructed.
+    TCT(PointerAnalysis* p, u32_t contextLimit);
+
     ThreadCallGraph* tcg;
     PointerAnalysis* pta;
+    const u32_t contextLimit;
     u32_t TCTNodeNum;
     u32_t TCTEdgeNum;
     u32_t MaxCxtSize;
@@ -478,26 +489,6 @@ protected:
     /// Build TCT
     virtual void build();
 
-    /// Free the built graph and clear all bookkeeping so build() can run again from
-    /// a clean state (SlicedTCT rebuilds the tree over a sliced view).
-    void reset()
-    {
-        destroy();
-        IDToNodeMap.clear();
-        ctpToNodeMap.clear();
-        ctToForkCxtsMap.clear();
-        ctToRoutineFunMap.clear();
-        candidateFuncSet.clear();
-        entryFuncSet.clear();
-        joinSiteToLoopMap.clear();
-        inRecurJoinSites.clear();
-        ctpList.clear();
-        visitedCTPs.clear();
-        TCTNodeNum = 0;
-        TCTEdgeNum = 0;
-        MaxCxtSize = 0;
-    }
-
     /// Mark relevant procedures that are backward reachable from any fork/join site
     //@{
     virtual void markRelProcs();

package/SVF-linux-x86_64/include/SVF-LLVM/GEPTypeBridgeIterator.h

@@ -92,8 +92,8 @@ public:
 #endif
     }
 
-    // non-standard operators, these may not need be bridged but seems it's
-    // prudent to do so...
+// non-standard operators, these may not need be bridged but seems it's
+// prudent to do so...
     Type* operator->() const
     {
         return operator*();

package/SVF-linux-x86_64/include/SVF-LLVM/ObjTypeInference.h

@@ -99,7 +99,7 @@ private:
     const Type *fwInferObjType(const Value *var);
 
     /// backward collect all possible allocation sites (stack, static, heap) of var
-    Set<const Value *>& bwfindAllocOfVar(const Value *var);
+    Set<const Value *>& bwFindAllocOfVar(const Value *var);
 
     /// is allocation (stack, static, heap)
     bool isAlloc(const SVF::Value *val);

package/SVF-linux-x86_64/include/Util/Options.h

@@ -258,11 +258,9 @@ public:
     static const Option<bool> DumpMTAGraphs;
 
     /// MTA slicing: slice before the FSAM main analysis (false = whole-program baseline), Default: true
-    static const Option<bool> EnableSlicing;
+    static const Option<bool> MTAEnableSlicing;
     /// MTA slicing: one unified slice for ILA + FSPTA (single-pass baseline), Default: false
-    static const Option<bool> SlicingSingle;
-    /// MTA slicing: dump intermediate dot graphs (ICFG/TCG/SVFG/...), Default: false
-    static const Option<bool> SlicedDumpDot;
+    static const Option<bool> MTASingleStageSlicing;
     /// if the access index of gepstmt is unknown, skip it, Default: false
     static const Option<bool> GepUnknownIdx;
     static const Option<bool> RunUncallFuncs;

package/SVF-linux-x86_64/include/Util/SparseBitVector.h

@@ -1130,7 +1130,7 @@ public:
         return (First.index() * ElementSize) + First.find_first();
     }
 
-    // Return the last set bit in the bitmap.  Return -1 if no bits are set.
+// Return the last set bit in the bitmap.  Return -1 if no bits are set.
     int find_last() const
     {
         if (Elements.empty())
@@ -1139,7 +1139,7 @@ public:
         return (Last.index() * ElementSize) + Last.find_last();
     }
 
-    // Return true if the SparseBitVector is empty
+// Return true if the SparseBitVector is empty
     bool empty() const
     {
         return Elements.empty();

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

@@ -503,6 +503,11 @@ template<> struct GenericGraphTraits<SVF::CallGraph*> : public GenericGraphTrait
 {
     typedef SVF::CallGraphNode*NodeRef;
 
+    static const SVF::CallGraphNode* getRawNode(const SVF::CallGraphNode* n)
+    {
+        return n;
+    }
+
     // Graph-intrinsic queries shared with the sliced-view specialisation
     // (GenericGraphTraits<const SlicedThreadCallGraphView*>).
     //@{
@@ -514,10 +519,36 @@ template<> struct GenericGraphTraits<SVF::CallGraph*> : public GenericGraphTrait
         for (SVF::CallGraphEdge* e : n->getInEdges())
             out.push_back(e);
     }
-    /// The CallGraph object whose nodes an analysis over this graph scans.
-    static const SVF::CallGraph* getCallGraph(const SVF::CallGraph* g)
+    static void getOutEdges(const SVF::CallGraph*, const SVF::CallGraphNode* n,
+                            std::vector<const SVF::CallGraphEdge*>& out)
+    {
+        out.clear();
+        for (SVF::CallGraphEdge* e : n->getOutEdges())
+            out.push_back(e);
+    }
+    static void getDirectCalls(const SVF::CallGraph*, const SVF::CallGraphEdge* e,
+                               std::vector<const SVF::CallICFGNode*>& out)
+    {
+        out.assign(e->getDirectCalls().begin(), e->getDirectCalls().end());
+    }
+    static void getIndirectCalls(const SVF::CallGraph*, const SVF::CallGraphEdge* e,
+                                 std::vector<const SVF::CallICFGNode*>& out)
+    {
+        out.assign(e->getIndirectCalls().begin(), e->getIndirectCalls().end());
+    }
+    static bool containsCallSite(const SVF::CallGraph*,
+                                 const SVF::CallGraphEdge* e,
+                                 const SVF::CallICFGNode* callSite)
+    {
+        return e->getDirectCalls().count(callSite) ||
+               e->getIndirectCalls().count(callSite);
+    }
+    static void getCallees(SVF::CallGraph* g,
+                           const SVF::CallICFGNode* callSite,
+                           SVF::CallGraph::FunctionSet& callees)
     {
-        return g;
+        callees.clear();
+        g->getCallees(callSite, callees);
     }
     //@}
 };

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

@@ -309,6 +309,12 @@ template<> struct GenericGraphTraits<SVF::ICFG*> : public GenericGraphTraits<SVF
     {
         return fun->getEntryBlock()->front();
     }
+    /// Exit node of fun under the whole ICFG.
+    static const SVF::ICFGNode* getFunExit(SVF::ICFG* graph,
+                                           const SVF::FunObjVar* fun)
+    {
+        return graph->getFunExitICFGNode(fun);
+    }
     /// Nodes of fun contained in this graph (whole ICFG: all of them).
     static void getFunICFGNodes(SVF::ICFG*, const SVF::FunObjVar* fun,
                                 std::vector<const SVF::ICFGNode*>& out)

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

@@ -500,6 +500,7 @@ namespace SVF
 template<> struct GenericGraphTraits<SVF::SVFG*> : public GenericGraphTraits<SVF::GenericGraph<SVF::SVFGNode,SVF::SVFGEdge>* >
 {
     typedef SVF::SVFGNode *NodeRef;
+    static constexpr bool isFilteredGraph = false;
 
     /// Whether n belongs to this graph (the whole SVFG contains every node).
     /// Mirrored by GenericGraphTraits<const SlicedSVFGView*>, so a solver
@@ -508,6 +509,11 @@ template<> struct GenericGraphTraits<SVF::SVFG*> : public GenericGraphTraits<SVF
     {
         return true;
     }
+
+    static bool containsEdge(SVF::SVFG*, const SVF::SVFGEdge*)
+    {
+        return true;
+    }
 };
 
 } // End namespace llvm