From d0badbe4b0b25ac95ca54fab490b7ba8a3c5c88e Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Sun, 15 Oct 2023 19:40:09 +0200
Subject: [PATCH 1/7] Add some statistics to the edge functions in IDE

---
 .../phasar/Controller/AnalysisController.h    | 33 ++++++++-
 .../phasar/DataFlow/IfdsIde/EdgeFunction.h    | 72 +++++++++++++++++++
 .../IfdsIde/Solver/FlowEdgeFunctionCache.h    | 29 ++++++++
 .../DataFlow/IfdsIde/Solver/IDESolver.h       | 25 +++++++
 include/phasar/Utils/Timer.h                  | 39 ++++++++++
 include/phasar/Utils/TypeTraits.h             |  4 ++
 .../Problems/IDELinearConstantAnalysis.cpp    | 25 ++++++-
 7 files changed, 225 insertions(+), 2 deletions(-)
 create mode 100644 include/phasar/Utils/Timer.h

diff --git a/include/phasar/Controller/AnalysisController.h b/include/phasar/Controller/AnalysisController.h
index 5ded47b64e..f598c55153 100644
--- a/include/phasar/Controller/AnalysisController.h
+++ b/include/phasar/Controller/AnalysisController.h
@@ -26,14 +26,20 @@
 #include "phasar/PhasarLLVM/TaintConfig/LLVMTaintConfig.h"
 #include "phasar/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchy.h"
 #include "phasar/PhasarLLVM/Utils/DataFlowAnalysisType.h"
+#include "phasar/Utils/ChronoUtils.h"
 #include "phasar/Utils/EnumFlags.h"
 #include "phasar/Utils/IO.h"
 #include "phasar/Utils/Soundness.h"
+#include "phasar/Utils/Timer.h"
 
+#include <optional>
 #include <set>
 #include <string>
 #include <vector>
 
+#include <llvm/Support/TypeName.h>
+#include <llvm/Support/raw_ostream.h>
+
 namespace psr {
 
 class AnalysisController {
@@ -109,7 +115,17 @@ class AnalysisController {
     auto Problem =
         createAnalysisProblem<ProblemTy>(HA, std::forward<ArgTys>(Args)...);
     SolverTy Solver(Problem, &HA.getICFG());
-    Solver.solve();
+    {
+      std::optional<Timer> MeasureTime;
+      if (EmitterOptions &
+          AnalysisControllerEmitterOptions::EmitStatisticsAsText) {
+        MeasureTime.emplace([](hms Elapsed) {
+          llvm::outs() << "Elapsed: " << Elapsed << '\n';
+        });
+      }
+
+      Solver.solve();
+    }
     emitRequestedDataFlowResults(Solver);
   }
 
@@ -127,6 +143,16 @@ class AnalysisController {
 
   LLVMTaintConfig makeTaintConfig();
 
+  template <typename T>
+  void statsEmitter(llvm::raw_ostream &OS, const T &Solver) {
+    OS << "The solver " << llvm::getTypeName<T>()
+       << " does not support statistics output\n";
+  }
+  template <typename T, typename U>
+  void statsEmitter(llvm::raw_ostream &OS, const IDESolver<T, U> &Solver) {
+    Solver.printEdgeFunctionStatistics();
+  }
+
   template <typename T> void emitRequestedDataFlowResults(T &Solver) {
     if (EmitterOptions & AnalysisControllerEmitterOptions::EmitTextReport) {
       if (!ResultDirectory.empty()) {
@@ -163,6 +189,11 @@ class AnalysisController {
       llvm::outs()
           << "Front-end support for 'EmitESGAsDot' to be implemented\n";
     }
+    if (EmitterOptions &
+        AnalysisControllerEmitterOptions::EmitStatisticsAsText) {
+
+      statsEmitter(llvm::outs(), Solver);
+    }
   }
 
 public:
diff --git a/include/phasar/DataFlow/IfdsIde/EdgeFunction.h b/include/phasar/DataFlow/IfdsIde/EdgeFunction.h
index 72f33565ac..1d38883961 100644
--- a/include/phasar/DataFlow/IfdsIde/EdgeFunction.h
+++ b/include/phasar/DataFlow/IfdsIde/EdgeFunction.h
@@ -21,11 +21,15 @@
 #include "llvm/Support/raw_ostream.h"
 
 #include <atomic>
+#include <cstddef>
 #include <ostream>
 #include <tuple>
 #include <type_traits>
 #include <utility>
 
+#include <llvm/ADT/DenseMapInfo.h>
+#include <llvm/ADT/Hashing.h>
+
 namespace psr {
 
 template <typename L> class EdgeFunction;
@@ -404,6 +408,12 @@ class [[clang::trivial_abi]] EdgeFunction final : EdgeFunctionBase {
         FirstEF.EF, SecondEF, FirstEF.VTAndHeapAlloc.getInt());
   }
 
+  [[nodiscard]] bool
+  referenceEquals(const EdgeFunction<L> &Other) const noexcept {
+    return VTAndHeapAlloc.getPointer() == Other.VTAndHeapAlloc.getPointer() &&
+           EF == Other.EF;
+  }
+
   /// Checks for equality of two edge functions. Equality requires exact
   /// type-equality and value-equality based on operator== of the concrete edge
   /// functions that are compared.
@@ -630,6 +640,31 @@ class [[clang::trivial_abi]] EdgeFunction final : EdgeFunctionBase {
     return static_cast<const CachedRefCounted<ConcreteEF> *>(EF)->Cache;
   }
 
+  [[nodiscard]] size_t getHashCode() const noexcept {
+    if (!VTAndHeapAlloc.getOpaqueValue()) {
+      return 0;
+    }
+
+    return VTAndHeapAlloc.getPointer()->getHashCode(
+        EF, VTAndHeapAlloc.getPointer());
+  }
+
+  friend size_t hash_value(const EdgeFunction &EF) noexcept { // NOLINT
+    return EF.getHashCode();
+  }
+
+  static EdgeFunction getEmptyKey() noexcept {
+    return EdgeFunction(nullptr,
+                        {llvm::DenseMapInfo<const VTable *>::getEmptyKey(),
+                         AllocationPolicy::SmallObjectOptimized});
+  }
+
+  static EdgeFunction getTombstoneKey() noexcept {
+    return EdgeFunction(nullptr,
+                        {llvm::DenseMapInfo<const VTable *>::getTombstoneKey(),
+                         AllocationPolicy::SmallObjectOptimized});
+  }
+
 private:
   struct VTable {
     // NOLINTBEGIN(readability-identifier-naming)
@@ -641,6 +676,7 @@ class [[clang::trivial_abi]] EdgeFunction final : EdgeFunctionBase {
     void (*print)(const void *, llvm::raw_ostream &);
     bool (*isConstant)(const void *) noexcept;
     void (*destroy)(const void *, AllocationPolicy) noexcept;
+    size_t (*getHashCode)(const void *, const void *) noexcept;
     // NOLINTEND(readability-identifier-naming)
   };
 
@@ -704,6 +740,16 @@ class [[clang::trivial_abi]] EdgeFunction final : EdgeFunctionBase {
           }
         }
       },
+      [](const void *EF, const void *VT) noexcept -> size_t {
+        if constexpr (is_std_hashable_v<ConcreteEF>) {
+          return std::hash<ConcreteEF>{}(*getPtr<ConcreteEF>(EF));
+        } else if constexpr (is_llvm_hashable_v<ConcreteEF>) {
+          using llvm::hash_value;
+          return hash_value(*getPtr<ConcreteEF>(EF));
+        } else {
+          return llvm::hash_combine(EF, VT);
+        }
+      },
   };
 
   // Utility ctor for (copy) construction. Increments the ref-count if
@@ -729,6 +775,32 @@ class [[clang::trivial_abi]] EdgeFunction final : EdgeFunctionBase {
 
 namespace llvm {
 
+template <typename L> struct DenseMapInfo<psr::EdgeFunction<L>> {
+  static inline auto getEmptyKey() noexcept {
+    return psr::EdgeFunction<L>::getEmptyKey();
+  }
+  static inline auto getTombstoneKey() noexcept {
+    return psr::EdgeFunction<L>::getTombstoneKey();
+  }
+  static inline auto getHashValue(const psr::EdgeFunction<L> &EF) noexcept {
+    return EF.getHashCode();
+  }
+  static inline auto isEqual(const psr::EdgeFunction<L> &EF1,
+                             const psr::EdgeFunction<L> &EF2) noexcept {
+    if (EF1.referenceEquals(EF2)) {
+      return true;
+    }
+    auto Empty = getEmptyKey();
+    auto Tombstone = getTombstoneKey();
+    if (EF1.referenceEquals(Empty) || EF2.referenceEquals(Empty) ||
+        EF1.referenceEquals(Tombstone) || EF2.referenceEquals(Tombstone)) {
+      return false;
+    }
+
+    return EF1 == EF2;
+  }
+};
+
 // LLVM is currently overhauling its casting system. Use the new variant once
 // possible!
 // Note: The new variant (With CastInfo) is not tested yet!
diff --git a/include/phasar/DataFlow/IfdsIde/Solver/FlowEdgeFunctionCache.h b/include/phasar/DataFlow/IfdsIde/Solver/FlowEdgeFunctionCache.h
index b9d89a88ea..4333b9521c 100644
--- a/include/phasar/DataFlow/IfdsIde/Solver/FlowEdgeFunctionCache.h
+++ b/include/phasar/DataFlow/IfdsIde/Solver/FlowEdgeFunctionCache.h
@@ -32,6 +32,9 @@ class Value;
 } // namespace llvm
 
 namespace psr {
+
+enum class EdgeFunctionKind { Normal, Call, Return, CallToReturn, Summary };
+
 template <typename KeyT> class DefaultMapKeyCompressor {
 public:
   using KeyType = KeyT;
@@ -603,6 +606,32 @@ class FlowEdgeFunctionCache {
     }
   }
 
+  template <typename Handler> void foreachCachedEdgeFunction(Handler Fn) const {
+    for (const auto &[Key, NormalFns] : NormalFunctionCache) {
+      for (const auto &[Set, EF] : NormalFns.EdgeFunctionMap) {
+        Fn(EF, EdgeFunctionKind::Normal);
+      }
+    }
+
+    for (const auto &[Key, EF] : CallEdgeFunctionCache) {
+      Fn(EF, EdgeFunctionKind::Call);
+    }
+
+    for (const auto &[Key, EF] : ReturnEdgeFunctionCache) {
+      Fn(EF, EdgeFunctionKind::Return);
+    }
+
+    for (const auto &[Key, CTRFns] : CallToRetEdgeFunctionCache) {
+      for (const auto &[Set, EF] : CTRFns) {
+        Fn(EF, EdgeFunctionKind::CallToReturn);
+      }
+    }
+
+    for (const auto &[Key, EF] : SummaryEdgeFunctionCache) {
+      Fn(EF, EdgeFunctionKind::Summary);
+    }
+  }
+
 private:
   inline EdgeFuncInstKey createEdgeFunctionInstKey(n_t Lhs, n_t Rhs) {
     uint64_t Val = 0;
diff --git a/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h b/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h
index ac730de2a5..363e4c2659 100644
--- a/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h
+++ b/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h
@@ -53,6 +53,8 @@
 #include <unordered_set>
 #include <utility>
 
+#include <llvm/ADT/DenseSet.h>
+
 namespace psr {
 
 /// Solves the given IDETabulationProblem as described in the 1996 paper by
@@ -255,6 +257,29 @@ class IDESolver
                                               std::move(ZeroValue));
   }
 
+  void printEdgeFunctionStatistics(llvm::raw_ostream &OS = llvm::outs()) const {
+    std::array<llvm::DenseSet<EdgeFunction<l_t>>, 5> UniqueEFs{};
+    std::array<size_t, 5> TotalEFCount{};
+    static constexpr std::array<llvm::StringRef, 5> EFKind{
+        "Normal", "Call", "Return", "CallToReturn", "Summary"};
+    // TODO: Cache EFs
+    CachedFlowEdgeFunctions.foreachCachedEdgeFunction(
+        [&UniqueEFs, &TotalEFCount](EdgeFunction<l_t> EF,
+                                    EdgeFunctionKind Kind) {
+          UniqueEFs[int(Kind)].insert(std::move(EF));
+          TotalEFCount[int(Kind)]++;
+        });
+
+    size_t Ctr = 0;
+    for (const auto &[UEF, Count] : llvm::zip(UniqueEFs, TotalEFCount)) {
+      OS << "Kind: " << EFKind[Ctr] << ":\n";
+      Ctr++;
+
+      OS << "  Total # EdgeFunctions: " << Count << '\n';
+      OS << "  Unique EdgeFunctions: " << UEF.size() << '\n';
+    }
+  }
+
 protected:
   /// Lines 13-20 of the algorithm; processing a call site in the caller's
   /// context.
diff --git a/include/phasar/Utils/Timer.h b/include/phasar/Utils/Timer.h
new file mode 100644
index 0000000000..8cf62fe714
--- /dev/null
+++ b/include/phasar/Utils/Timer.h
@@ -0,0 +1,39 @@
+/******************************************************************************
+ * Copyright (c) 2023 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#ifndef PHASAR_UTILS_TIMER_H
+#define PHASAR_UTILS_TIMER_H
+
+#include "phasar/Utils/ChronoUtils.h"
+
+#include "llvm/ADT/FunctionExtras.h"
+
+#include <chrono>
+
+namespace psr {
+class Timer {
+public:
+  Timer(llvm::unique_function<void(psr::hms)> WithElapsed) noexcept
+      : WithElapsed(std::move(WithElapsed)),
+        Start(std::chrono::steady_clock::now()) {}
+
+  ~Timer() {
+    if (WithElapsed) {
+      auto End = std::chrono::steady_clock::now();
+      WithElapsed(hms{End - Start});
+    }
+  }
+
+private:
+  llvm::unique_function<void(psr::hms)> WithElapsed;
+  std::chrono::steady_clock::time_point Start;
+};
+} // namespace psr
+
+#endif // PHASAR_UTILS_TIMER_H
diff --git a/include/phasar/Utils/TypeTraits.h b/include/phasar/Utils/TypeTraits.h
index 77bcfa36ae..f70f5edd92 100644
--- a/include/phasar/Utils/TypeTraits.h
+++ b/include/phasar/Utils/TypeTraits.h
@@ -105,6 +105,10 @@ struct is_llvm_hashable : std::false_type {}; // NOLINT
 template <typename T>
 struct is_llvm_hashable<T, decltype(hash_value(std::declval<T>()))> // NOLINT
     : std::true_type {};
+template <typename T>
+struct is_llvm_hashable<T,
+                        decltype(llvm::hash_value(std::declval<T>()))> // NOLINT
+    : std::true_type {};
 
 template <template <typename> typename Base, typename Derived>
 class template_arg {
diff --git a/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IDELinearConstantAnalysis.cpp b/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IDELinearConstantAnalysis.cpp
index a8aa6e8240..cb87e27052 100644
--- a/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IDELinearConstantAnalysis.cpp
+++ b/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IDELinearConstantAnalysis.cpp
@@ -22,6 +22,7 @@
 #include "phasar/PhasarLLVM/Utils/LLVMIRToSrc.h"
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
 #include "phasar/Utils/Logger.h"
+#include "phasar/Utils/TypeTraits.h"
 #include "phasar/Utils/Utilities.h"
 
 #include "llvm/ADT/STLExtras.h"
@@ -43,6 +44,8 @@
 #include <memory>
 #include <utility>
 
+#include <llvm/ADT/Hashing.h>
+
 namespace psr {
 
 namespace lca {
@@ -66,7 +69,20 @@ struct LCAEdgeFunctionComposer : EdgeFunctionComposer<l_t> {
   }
 };
 
-using GenConstant = ConstantEdgeFunction<l_t>;
+auto hash_value(const LCAEdgeFunctionComposer &EF) noexcept {
+  return llvm::hash_combine(EF.First, EF.Second);
+}
+
+static_assert(is_llvm_hashable_v<LCAEdgeFunctionComposer>);
+
+struct GenConstant : ConstantEdgeFunction<l_t> {};
+
+llvm::hash_code hash_value(const GenConstant &EF) noexcept {
+  return llvm::hash_value(EF.Value);
+}
+
+using TTT = decltype(hash_value(std::declval<GenConstant>()));
+static_assert(is_llvm_hashable_v<GenConstant>);
 
 /**
  * The following binary operations are computed:
@@ -253,6 +269,13 @@ struct BinOp {
     return OS;
   }
 };
+
+auto hash_value(const BinOp &EF) noexcept {
+  return llvm::hash_combine(EF.Op, EF.Lop, EF.Rop, EF.CurrNode);
+}
+
+static_assert(is_llvm_hashable_v<BinOp>);
+
 } // namespace lca
 
 IDELinearConstantAnalysis::IDELinearConstantAnalysis(

From 862b2b8e045d581535ecd7feada9d75226b401c4 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabian.schiebel@iem.fraunhofer.de>
Date: Sun, 15 Oct 2023 21:09:21 +0200
Subject: [PATCH 2/7] Make more of AnalysisController internal and reduce
 dependencies

---
 .../phasar/Controller/AnalysisController.h    | 203 +-----------
 .../DataFlow/IfdsIde/Solver/IDESolver.h       |   3 +-
 include/phasar/Utils/Timer.h                  |  14 +-
 lib/Controller/AnalysisController.cpp         | 292 +++++++++---------
 lib/Controller/AnalysisControllerInternal.h   | 119 +++++++
 .../AnalysisControllerInternalIDE.h           |  62 ++++
 .../AnalysisControllerInternalMono.h          |  45 +++
 .../AnalysisControllerXIDECSTDIOTS.cpp        |  11 +-
 lib/Controller/AnalysisControllerXIDEIIA.cpp  |  12 +-
 .../AnalysisControllerXIDELinearConst.cpp     |  12 +-
 .../AnalysisControllerXIDEOpenSSLTS.cpp       |  11 +-
 .../AnalysisControllerXIDESolverTest.cpp      |  12 +-
 .../AnalysisControllerXIDEXTaint.cpp          |  14 +-
 .../AnalysisControllerXIFDSConst.cpp          |  11 +-
 .../AnalysisControllerXIFDSFieldSensTaint.cpp |  15 +-
 .../AnalysisControllerXIFDSSolverTest.cpp     |  12 +-
 .../AnalysisControllerXIFDSTaint.cpp          |  13 +-
 .../AnalysisControllerXIFDSType.cpp           |  11 +-
 .../AnalysisControllerXIFDSUninit.cpp         |  12 +-
 ...AnalysisControllerXInterMonoSolverTest.cpp |  12 +-
 .../AnalysisControllerXInterMonoTaint.cpp     |  15 +-
 ...alysisControllerXIntraMonoFullConstant.cpp |  13 +-
 ...AnalysisControllerXIntraMonoSolverTest.cpp |  12 +-
 23 files changed, 505 insertions(+), 431 deletions(-)
 create mode 100644 lib/Controller/AnalysisControllerInternal.h
 create mode 100644 lib/Controller/AnalysisControllerInternalIDE.h
 create mode 100644 lib/Controller/AnalysisControllerInternalMono.h

diff --git a/include/phasar/Controller/AnalysisController.h b/include/phasar/Controller/AnalysisController.h
index f598c55153..7b9e132c4b 100644
--- a/include/phasar/Controller/AnalysisController.h
+++ b/include/phasar/Controller/AnalysisController.h
@@ -13,190 +13,27 @@
 #include "phasar/AnalysisStrategy/Strategies.h"
 #include "phasar/Controller/AnalysisControllerEmitterOptions.h"
 #include "phasar/DataFlow/IfdsIde/IFDSIDESolverConfig.h"
-#include "phasar/DataFlow/IfdsIde/Solver/IDESolver.h"
-#include "phasar/DataFlow/IfdsIde/Solver/IFDSSolver.h"
-#include "phasar/DataFlow/IfdsIde/SolverResults.h"
-#include "phasar/DataFlow/Mono/Solver/InterMonoSolver.h"
-#include "phasar/DataFlow/Mono/Solver/IntraMonoSolver.h"
-#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h"
-#include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
 #include "phasar/PhasarLLVM/HelperAnalyses.h"
-#include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
-#include "phasar/PhasarLLVM/SimpleAnalysisConstructor.h"
-#include "phasar/PhasarLLVM/TaintConfig/LLVMTaintConfig.h"
-#include "phasar/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchy.h"
 #include "phasar/PhasarLLVM/Utils/DataFlowAnalysisType.h"
-#include "phasar/Utils/ChronoUtils.h"
-#include "phasar/Utils/EnumFlags.h"
-#include "phasar/Utils/IO.h"
-#include "phasar/Utils/Soundness.h"
-#include "phasar/Utils/Timer.h"
-
-#include <optional>
-#include <set>
-#include <string>
-#include <vector>
-
-#include <llvm/Support/TypeName.h>
-#include <llvm/Support/raw_ostream.h>
 
+#include <filesystem>
 namespace psr {
 
 class AnalysisController {
-private:
-  HelperAnalyses &HA;
-  std::vector<DataFlowAnalysisType> DataFlowAnalyses;
-  std::vector<std::string> AnalysisConfigs;
-  std::vector<std::string> EntryPoints;
-  [[maybe_unused]] AnalysisStrategy Strategy;
-  AnalysisControllerEmitterOptions EmitterOptions =
-      AnalysisControllerEmitterOptions::None;
-  std::string ProjectID;
-  std::filesystem::path ResultDirectory;
-  IFDSIDESolverConfig SolverConfig;
-
-  ///
-  /// \brief The maximum length of the CallStrings used in the InterMonoSolver
-  ///
-  static const unsigned K = 3;
-
-  void executeDemandDriven();
-
-  void executeIncremental();
-
-  void executeModuleWise();
-
-  void executeVariational();
-
-  void executeWholeProgram();
-
-  void emitRequestedHelperAnalysisResults();
-
-  void executeIFDSUninitVar();
-  void executeIFDSConst();
-  void executeIFDSTaint();
-  void executeIFDSType();
-  void executeIFDSSolverTest();
-  void executeIFDSFieldSensTaint();
-  void executeIDEXTaint();
-  void executeIDEOpenSSLTS();
-  void executeIDECSTDIOTS();
-  void executeIDELinearConst();
-  void executeIDESolverTest();
-  void executeIDEIIA();
-  void executeIntraMonoFullConstant();
-  void executeIntraMonoSolverTest();
-  void executeInterMonoSolverTest();
-  void executeInterMonoTaint();
-
-  template <typename SolverTy, typename ProblemTy, typename... ArgTys>
-  void executeMonoAnalysis(ArgTys &&...Args) {
-    auto Problem =
-        createAnalysisProblem<ProblemTy>(HA, std::forward<ArgTys>(Args)...);
-    SolverTy Solver(Problem);
-    Solver.solve();
-    emitRequestedDataFlowResults(Solver);
-  }
-
-  template <typename ProblemTy, typename... ArgTys>
-  void executeIntraMonoAnalysis(ArgTys &&...Args) {
-    executeMonoAnalysis<IntraMonoSolver_P<ProblemTy>, ProblemTy>(
-        std::forward<ArgTys>(Args)...);
-  }
-
-  template <typename ProblemTy, typename... ArgTys>
-  void executeInterMonoAnalysis(ArgTys &&...Args) {
-    executeMonoAnalysis<InterMonoSolver_P<ProblemTy, 3>, ProblemTy>(
-        std::forward<ArgTys>(Args)...);
-  }
-
-  template <typename SolverTy, typename ProblemTy, typename... ArgTys>
-  void executeIfdsIdeAnalysis(ArgTys &&...Args) {
-    auto Problem =
-        createAnalysisProblem<ProblemTy>(HA, std::forward<ArgTys>(Args)...);
-    SolverTy Solver(Problem, &HA.getICFG());
-    {
-      std::optional<Timer> MeasureTime;
-      if (EmitterOptions &
-          AnalysisControllerEmitterOptions::EmitStatisticsAsText) {
-        MeasureTime.emplace([](hms Elapsed) {
-          llvm::outs() << "Elapsed: " << Elapsed << '\n';
-        });
-      }
-
-      Solver.solve();
-    }
-    emitRequestedDataFlowResults(Solver);
-  }
-
-  template <typename ProblemTy, typename... ArgTys>
-  void executeIFDSAnalysis(ArgTys &&...Args) {
-    executeIfdsIdeAnalysis<IFDSSolver_P<ProblemTy>, ProblemTy>(
-        std::forward<ArgTys>(Args)...);
-  }
-
-  template <typename ProblemTy, typename... ArgTys>
-  void executeIDEAnalysis(ArgTys &&...Args) {
-    executeIfdsIdeAnalysis<IDESolver_P<ProblemTy>, ProblemTy>(
-        std::forward<ArgTys>(Args)...);
-  }
-
-  LLVMTaintConfig makeTaintConfig();
-
-  template <typename T>
-  void statsEmitter(llvm::raw_ostream &OS, const T &Solver) {
-    OS << "The solver " << llvm::getTypeName<T>()
-       << " does not support statistics output\n";
-  }
-  template <typename T, typename U>
-  void statsEmitter(llvm::raw_ostream &OS, const IDESolver<T, U> &Solver) {
-    Solver.printEdgeFunctionStatistics();
-  }
-
-  template <typename T> void emitRequestedDataFlowResults(T &Solver) {
-    if (EmitterOptions & AnalysisControllerEmitterOptions::EmitTextReport) {
-      if (!ResultDirectory.empty()) {
-        if (auto OFS =
-                openFileStream(ResultDirectory.string() + "/psr-report.txt")) {
-          Solver.emitTextReport(*OFS);
-        }
-      } else {
-        Solver.emitTextReport(llvm::outs());
-      }
-    }
-    if (EmitterOptions &
-        AnalysisControllerEmitterOptions::EmitGraphicalReport) {
-      if (!ResultDirectory.empty()) {
-        if (auto OFS =
-                openFileStream(ResultDirectory.string() + "/psr-report.html")) {
-          Solver.emitGraphicalReport(*OFS);
-        }
-      } else {
-        Solver.emitGraphicalReport(llvm::outs());
-      }
-    }
-    if (EmitterOptions & AnalysisControllerEmitterOptions::EmitRawResults) {
-      if (!ResultDirectory.empty()) {
-        if (auto OFS = openFileStream(ResultDirectory.string() +
-                                      "/psr-raw-results.txt")) {
-          Solver.dumpResults(*OFS);
-        }
-      } else {
-        Solver.dumpResults(llvm::outs());
-      }
-    }
-    if (EmitterOptions & AnalysisControllerEmitterOptions::EmitESGAsDot) {
-      llvm::outs()
-          << "Front-end support for 'EmitESGAsDot' to be implemented\n";
-    }
-    if (EmitterOptions &
-        AnalysisControllerEmitterOptions::EmitStatisticsAsText) {
-
-      statsEmitter(llvm::outs(), Solver);
-    }
-  }
-
 public:
+  struct ControllerData {
+    HelperAnalyses *HA{};
+    std::vector<DataFlowAnalysisType> DataFlowAnalyses;
+    std::vector<std::string> AnalysisConfigs;
+    std::vector<std::string> EntryPoints;
+    [[maybe_unused]] AnalysisStrategy Strategy;
+    AnalysisControllerEmitterOptions EmitterOptions =
+        AnalysisControllerEmitterOptions::None;
+    std::string ProjectID;
+    std::filesystem::path ResultDirectory;
+    IFDSIDESolverConfig SolverConfig{};
+  };
+
   explicit AnalysisController(
       HelperAnalyses &HA, std::vector<DataFlowAnalysisType> DataFlowAnalyses,
       std::vector<std::string> AnalysisConfigs,
@@ -206,21 +43,15 @@ class AnalysisController {
       std::string ProjectID = "default-phasar-project",
       std::string OutDirectory = "");
 
-  ~AnalysisController() = default;
-
-  AnalysisController(const AnalysisController &) = delete;
-  AnalysisController(AnalysisController &&) = delete;
-  AnalysisController &operator=(const AnalysisController &) = delete;
-  AnalysisController &operator=(const AnalysisController &&) = delete;
-
-  void executeAs(AnalysisStrategy Strategy);
-
   static constexpr bool
   needsToEmitPTA(AnalysisControllerEmitterOptions EmitterOptions) {
     return (EmitterOptions & AnalysisControllerEmitterOptions::EmitPTAAsDot) ||
            (EmitterOptions & AnalysisControllerEmitterOptions::EmitPTAAsJson) ||
            (EmitterOptions & AnalysisControllerEmitterOptions::EmitPTAAsText);
   }
+
+private:
+  ControllerData Data;
 };
 
 } // namespace psr
diff --git a/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h b/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h
index 363e4c2659..9377a611ae 100644
--- a/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h
+++ b/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h
@@ -39,6 +39,7 @@
 #include "phasar/Utils/Table.h"
 #include "phasar/Utils/Utilities.h"
 
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/raw_ostream.h"
 
@@ -53,8 +54,6 @@
 #include <unordered_set>
 #include <utility>
 
-#include <llvm/ADT/DenseSet.h>
-
 namespace psr {
 
 /// Solves the given IDETabulationProblem as described in the 1996 paper by
diff --git a/include/phasar/Utils/Timer.h b/include/phasar/Utils/Timer.h
index 8cf62fe714..f485aa0cba 100644
--- a/include/phasar/Utils/Timer.h
+++ b/include/phasar/Utils/Timer.h
@@ -10,8 +10,6 @@
 #ifndef PHASAR_UTILS_TIMER_H
 #define PHASAR_UTILS_TIMER_H
 
-#include "phasar/Utils/ChronoUtils.h"
-
 #include "llvm/ADT/FunctionExtras.h"
 
 #include <chrono>
@@ -19,19 +17,25 @@
 namespace psr {
 class Timer {
 public:
-  Timer(llvm::unique_function<void(psr::hms)> WithElapsed) noexcept
+  Timer(llvm::unique_function<void(std::chrono::nanoseconds)>
+            WithElapsed) noexcept
       : WithElapsed(std::move(WithElapsed)),
         Start(std::chrono::steady_clock::now()) {}
 
+  Timer(Timer &&) noexcept = default;
+  Timer &operator=(Timer &&) noexcept = default;
+  Timer(const Timer &) = delete;
+  Timer &operator=(const Timer &) = delete;
+
   ~Timer() {
     if (WithElapsed) {
       auto End = std::chrono::steady_clock::now();
-      WithElapsed(hms{End - Start});
+      WithElapsed(End - Start);
     }
   }
 
 private:
-  llvm::unique_function<void(psr::hms)> WithElapsed;
+  llvm::unique_function<void(std::chrono::nanoseconds)> WithElapsed;
   std::chrono::steady_clock::time_point Start;
 };
 } // namespace psr
diff --git a/lib/Controller/AnalysisController.cpp b/lib/Controller/AnalysisController.cpp
index 1341319a08..4266e4cfc5 100644
--- a/lib/Controller/AnalysisController.cpp
+++ b/lib/Controller/AnalysisController.cpp
@@ -9,136 +9,18 @@
 
 #include "phasar/Controller/AnalysisController.h"
 
-#include "phasar/AnalysisStrategy/Strategies.h"
-#include "phasar/Controller/AnalysisControllerEmitterOptions.h"
-#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h"
-#include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
-#include "phasar/PhasarLLVM/HelperAnalyses.h"
 #include "phasar/PhasarLLVM/Passes/GeneralStatisticsAnalysis.h"
-#include "phasar/PhasarLLVM/Utils/DataFlowAnalysisType.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchy.h"
 #include "phasar/Utils/NlohmannLogging.h"
-#include "phasar/Utils/Utilities.h"
 
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/Support/ErrorHandling.h"
-
-#include <cassert>
-#include <filesystem>
-#include <functional>
-#include <set>
-#include <utility>
+#include "AnalysisControllerInternal.h"
 
 namespace psr {
 
-AnalysisController::AnalysisController(
-    HelperAnalyses &HA, std::vector<DataFlowAnalysisType> DataFlowAnalyses,
-    std::vector<std::string> AnalysisConfigs,
-    std::vector<std::string> EntryPoints, AnalysisStrategy Strategy,
-    AnalysisControllerEmitterOptions EmitterOptions,
-    IFDSIDESolverConfig SolverConfig, std::string ProjectID,
-    std::string OutDirectory)
-    : HA(HA), DataFlowAnalyses(std::move(DataFlowAnalyses)),
-      AnalysisConfigs(std::move(AnalysisConfigs)),
-      EntryPoints(std::move(EntryPoints)), Strategy(Strategy),
-      EmitterOptions(EmitterOptions), ProjectID(std::move(ProjectID)),
-      ResultDirectory(std::move(OutDirectory)), SolverConfig(SolverConfig) {
-  if (!ResultDirectory.empty()) {
-    // create directory for results
-    ResultDirectory /= this->ProjectID + "-" + createTimeStamp();
-    std::filesystem::create_directory(ResultDirectory);
-  }
-  emitRequestedHelperAnalysisResults();
-  executeAs(Strategy);
-}
-
-void AnalysisController::executeAs(AnalysisStrategy Strategy) {
-  switch (Strategy) {
-  case AnalysisStrategy::None:
-    return;
-  case AnalysisStrategy::DemandDriven:
-  case AnalysisStrategy::Incremental:
-  case AnalysisStrategy::ModuleWise:
-  case AnalysisStrategy::Variational:
-    llvm::report_fatal_error("AnalysisStrategy not supported, yet!");
-    return;
-  case AnalysisStrategy::WholeProgram:
-    executeWholeProgram();
-    return;
-  }
-  llvm_unreachable(
-      "All AnalysisStrategy variants should be handled in the switch above!");
-}
-
-void AnalysisController::executeDemandDriven() {}
-
-void AnalysisController::executeIncremental() {}
-
-void AnalysisController::executeModuleWise() {}
-
-void AnalysisController::executeVariational() {}
-
-void AnalysisController::executeWholeProgram() {
-  for (auto DataFlowAnalysis : DataFlowAnalyses) {
-    switch (DataFlowAnalysis) {
-    case DataFlowAnalysisType::None:
-      continue;
-    case DataFlowAnalysisType::IFDSUninitializedVariables:
-      executeIFDSUninitVar();
-      continue;
-    case DataFlowAnalysisType::IFDSConstAnalysis:
-      executeIFDSConst();
-      continue;
-    case DataFlowAnalysisType::IFDSTaintAnalysis:
-      executeIFDSTaint();
-      continue;
-    case DataFlowAnalysisType::IDEExtendedTaintAnalysis:
-      executeIDEXTaint();
-      continue;
-    case DataFlowAnalysisType::IDEOpenSSLTypeStateAnalysis:
-      executeIDEOpenSSLTS();
-      continue;
-    case DataFlowAnalysisType::IDECSTDIOTypeStateAnalysis:
-      executeIDECSTDIOTS();
-      continue;
-    case DataFlowAnalysisType::IFDSTypeAnalysis:
-      executeIFDSType();
-      continue;
-    case DataFlowAnalysisType::IFDSSolverTest:
-      executeIFDSSolverTest();
-      continue;
-    case DataFlowAnalysisType::IFDSFieldSensTaintAnalysis:
-      executeIFDSFieldSensTaint();
-      continue;
-    case DataFlowAnalysisType::IDELinearConstantAnalysis:
-      executeIDELinearConst();
-      continue;
-    case DataFlowAnalysisType::IDESolverTest:
-      executeIDESolverTest();
-      continue;
-    case DataFlowAnalysisType::IDEInstInteractionAnalysis:
-      executeIDEIIA();
-      continue;
-    case DataFlowAnalysisType::IntraMonoFullConstantPropagation:
-      executeIntraMonoFullConstant();
-      continue;
-    case DataFlowAnalysisType::IntraMonoSolverTest:
-      executeIntraMonoSolverTest();
-      continue;
-    case DataFlowAnalysisType::InterMonoSolverTest:
-      executeInterMonoSolverTest();
-      continue;
-    case DataFlowAnalysisType::InterMonoTaintAnalysis:
-      executeInterMonoTaint();
-      continue;
-    }
-
-    llvm_unreachable("All possible DataFlowAnalysisType variants should be "
-                     "handled in the switch above!");
-  }
-}
-
-void AnalysisController::emitRequestedHelperAnalysisResults() {
-  auto WithResultFileOrStdout = [this](const auto &FileName, auto Callback) {
+static void
+emitRequestedHelperAnalysisResults(AnalysisController::ControllerData &Data) {
+  auto WithResultFileOrStdout = [&ResultDirectory = Data.ResultDirectory](
+                                    const auto &FileName, auto Callback) {
     if (!ResultDirectory.empty()) {
       if (auto OFS = openFileStream(ResultDirectory.string() + FileName)) {
         Callback(*OFS);
@@ -148,46 +30,49 @@ void AnalysisController::emitRequestedHelperAnalysisResults() {
     }
   };
 
+  auto EmitterOptions = Data.EmitterOptions;
+  auto &HA = *Data.HA;
+
   if (EmitterOptions & AnalysisControllerEmitterOptions::EmitIR) {
-    WithResultFileOrStdout("/psr-preprocess-ir.ll", [this](auto &OS) {
+    WithResultFileOrStdout("/psr-preprocess-ir.ll", [&HA](auto &OS) {
       HA.getProjectIRDB().emitPreprocessedIR(OS);
     });
   }
   if (EmitterOptions & AnalysisControllerEmitterOptions::EmitTHAsText) {
     WithResultFileOrStdout(
-        "/psr-th.txt", [this](auto &OS) { HA.getTypeHierarchy().print(OS); });
+        "/psr-th.txt", [&HA](auto &OS) { HA.getTypeHierarchy().print(OS); });
   }
   if (EmitterOptions & AnalysisControllerEmitterOptions::EmitTHAsDot) {
-    WithResultFileOrStdout("/psr-th.dot", [this](auto &OS) {
+    WithResultFileOrStdout("/psr-th.dot", [&HA](auto &OS) {
       HA.getTypeHierarchy().printAsDot(OS);
     });
   }
   if (EmitterOptions & AnalysisControllerEmitterOptions::EmitTHAsJson) {
-    WithResultFileOrStdout("/psr-th.json", [this](auto &OS) {
+    WithResultFileOrStdout("/psr-th.json", [&HA](auto &OS) {
       HA.getTypeHierarchy().printAsJson(OS);
     });
   }
   if (EmitterOptions & AnalysisControllerEmitterOptions::EmitPTAAsText) {
     WithResultFileOrStdout("/psr-pta.txt",
-                           [this](auto &OS) { HA.getAliasInfo().print(OS); });
+                           [&HA](auto &OS) { HA.getAliasInfo().print(OS); });
   }
   if (EmitterOptions & AnalysisControllerEmitterOptions::EmitPTAAsDot) {
     WithResultFileOrStdout("/psr-pta.dot",
-                           [this](auto &OS) { HA.getAliasInfo().print(OS); });
+                           [&HA](auto &OS) { HA.getAliasInfo().print(OS); });
   }
   if (EmitterOptions & AnalysisControllerEmitterOptions::EmitPTAAsJson) {
-    WithResultFileOrStdout("/psr-pta.json", [this](auto &OS) {
+    WithResultFileOrStdout("/psr-pta.json", [&HA](auto &OS) {
       HA.getAliasInfo().printAsJson(OS);
     });
   }
 
   if (EmitterOptions & AnalysisControllerEmitterOptions::EmitCGAsDot) {
     WithResultFileOrStdout("/psr-cg.txt",
-                           [this](auto &OS) { HA.getICFG().print(OS); });
+                           [&HA](auto &OS) { HA.getICFG().print(OS); });
   }
   if (EmitterOptions & AnalysisControllerEmitterOptions::EmitCGAsJson) {
-    WithResultFileOrStdout(
-        "/psr-cg.json", [this](auto &OS) { OS << HA.getICFG().getAsJson(); });
+    WithResultFileOrStdout("/psr-cg.json",
+                           [&HA](auto &OS) { OS << HA.getICFG().getAsJson(); });
   }
 
   if (EmitterOptions &
@@ -211,13 +96,144 @@ void AnalysisController::emitRequestedHelperAnalysisResults() {
   }
 }
 
-LLVMTaintConfig AnalysisController::makeTaintConfig() {
+static void executeDemandDriven(AnalysisController::ControllerData & /*Data*/) {
+  llvm::report_fatal_error(
+      "AnalysisStrategy 'demand-driven' not supported, yet!");
+}
+static void executeIncremental(AnalysisController::ControllerData & /*Data*/) {
+  llvm::report_fatal_error(
+      "AnalysisStrategy 'incremental' not supported, yet!");
+}
+static void executeModuleWise(AnalysisController::ControllerData & /*Data*/) {
+  llvm::report_fatal_error(
+      "AnalysisStrategy 'module-wise' not supported, yet!");
+}
+static void executeVariational(AnalysisController::ControllerData & /*Data*/) {
+  llvm::report_fatal_error(
+      "AnalysisStrategy 'variational' not supported, yet!");
+}
+
+static void executeWholeProgram(AnalysisController::ControllerData &Data) {
+  for (auto DataFlowAnalysis : Data.DataFlowAnalyses) {
+    using namespace controller;
+    switch (DataFlowAnalysis) {
+    case DataFlowAnalysisType::None:
+      continue;
+    case DataFlowAnalysisType::IFDSUninitializedVariables:
+      executeIFDSUninitVar(Data);
+      continue;
+    case DataFlowAnalysisType::IFDSConstAnalysis:
+      executeIFDSConst(Data);
+      continue;
+    case DataFlowAnalysisType::IFDSTaintAnalysis:
+      executeIFDSTaint(Data);
+      continue;
+    case DataFlowAnalysisType::IDEExtendedTaintAnalysis:
+      executeIDEXTaint(Data);
+      continue;
+    case DataFlowAnalysisType::IDEOpenSSLTypeStateAnalysis:
+      executeIDEOpenSSLTS(Data);
+      continue;
+    case DataFlowAnalysisType::IDECSTDIOTypeStateAnalysis:
+      executeIDECSTDIOTS(Data);
+      continue;
+    case DataFlowAnalysisType::IFDSTypeAnalysis:
+      executeIFDSType(Data);
+      continue;
+    case DataFlowAnalysisType::IFDSSolverTest:
+      executeIFDSSolverTest(Data);
+      continue;
+    case DataFlowAnalysisType::IFDSFieldSensTaintAnalysis:
+      executeIFDSFieldSensTaint(Data);
+      continue;
+    case DataFlowAnalysisType::IDELinearConstantAnalysis:
+      executeIDELinearConst(Data);
+      continue;
+    case DataFlowAnalysisType::IDESolverTest:
+      executeIDESolverTest(Data);
+      continue;
+    case DataFlowAnalysisType::IDEInstInteractionAnalysis:
+      executeIDEIIA(Data);
+      continue;
+    case DataFlowAnalysisType::IntraMonoFullConstantPropagation:
+      executeIntraMonoFullConstant(Data);
+      continue;
+    case DataFlowAnalysisType::IntraMonoSolverTest:
+      executeIntraMonoSolverTest(Data);
+      continue;
+    case DataFlowAnalysisType::InterMonoSolverTest:
+      executeInterMonoSolverTest(Data);
+      continue;
+    case DataFlowAnalysisType::InterMonoTaintAnalysis:
+      executeInterMonoTaint(Data);
+      continue;
+    }
+
+    llvm_unreachable("All possible DataFlowAnalysisType variants should be "
+                     "handled in the switch above!");
+  }
+}
+
+static void executeAs(AnalysisController::ControllerData &Data,
+                      AnalysisStrategy Strategy) {
+  switch (Strategy) {
+  case AnalysisStrategy::None:
+    return;
+  case AnalysisStrategy::DemandDriven:
+    executeDemandDriven(Data);
+    return;
+  case AnalysisStrategy::Incremental:
+    executeIncremental(Data);
+    return;
+  case AnalysisStrategy::ModuleWise:
+    executeModuleWise(Data);
+    return;
+  case AnalysisStrategy::Variational:
+    executeVariational(Data);
+    return;
+  case AnalysisStrategy::WholeProgram:
+    executeWholeProgram(Data);
+    return;
+  }
+  llvm_unreachable(
+      "All AnalysisStrategy variants should be handled in the switch above!");
+}
+
+AnalysisController::AnalysisController(
+    HelperAnalyses &HA, std::vector<DataFlowAnalysisType> DataFlowAnalyses,
+    std::vector<std::string> AnalysisConfigs,
+    std::vector<std::string> EntryPoints, AnalysisStrategy Strategy,
+    AnalysisControllerEmitterOptions EmitterOptions,
+    IFDSIDESolverConfig SolverConfig, std::string ProjectID,
+    std::string OutDirectory)
+    : Data{
+          &HA,
+          std::move(DataFlowAnalyses),
+          std::move(AnalysisConfigs),
+          std::move(EntryPoints),
+          Strategy,
+          EmitterOptions,
+          std::move(ProjectID),
+          std::move(OutDirectory),
+          SolverConfig,
+      } {
+  if (!Data.ResultDirectory.empty()) {
+    // create directory for results
+    Data.ResultDirectory /= Data.ProjectID + "-" + createTimeStamp();
+    std::filesystem::create_directory(Data.ResultDirectory);
+  }
+  emitRequestedHelperAnalysisResults(Data);
+  executeAs(Data, Strategy);
+}
+
+LLVMTaintConfig
+controller::makeTaintConfig(AnalysisController::ControllerData &Data) {
   std::string AnalysisConfigPath =
-      !AnalysisConfigs.empty() ? AnalysisConfigs[0] : "";
+      !Data.AnalysisConfigs.empty() ? Data.AnalysisConfigs[0] : "";
   return !AnalysisConfigPath.empty()
-             ? LLVMTaintConfig(HA.getProjectIRDB(),
+             ? LLVMTaintConfig(Data.HA->getProjectIRDB(),
                                parseTaintConfig(AnalysisConfigPath))
-             : LLVMTaintConfig(HA.getProjectIRDB());
+             : LLVMTaintConfig(Data.HA->getProjectIRDB());
 }
 
 } // namespace psr
diff --git a/lib/Controller/AnalysisControllerInternal.h b/lib/Controller/AnalysisControllerInternal.h
new file mode 100644
index 0000000000..f907800f78
--- /dev/null
+++ b/lib/Controller/AnalysisControllerInternal.h
@@ -0,0 +1,119 @@
+/******************************************************************************
+ * Copyright (c) 2023 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#ifndef PHASAR_CONTROLLER_ANALYSISCONTROLLERINTERNAL_H
+#define PHASAR_CONTROLLER_ANALYSISCONTROLLERINTERNAL_H
+
+#include "phasar/Controller/AnalysisController.h"
+#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h"
+#include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
+#include "phasar/PhasarLLVM/SimpleAnalysisConstructor.h"
+#include "phasar/PhasarLLVM/TaintConfig/LLVMTaintConfig.h"
+#include "phasar/Utils/ChronoUtils.h"
+#include "phasar/Utils/IO.h"
+#include "phasar/Utils/Timer.h"
+
+#include "llvm/Support/Compiler.h"
+
+namespace psr::controller {
+
+LLVM_LIBRARY_VISIBILITY void
+executeIFDSUninitVar(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIFDSConst(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIFDSTaint(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIFDSType(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIFDSSolverTest(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIFDSFieldSensTaint(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIDEXTaint(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIDEOpenSSLTS(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIDECSTDIOTS(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIDELinearConst(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIDESolverTest(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIDEIIA(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIntraMonoFullConstant(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeIntraMonoSolverTest(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeInterMonoSolverTest(AnalysisController::ControllerData &Data);
+LLVM_LIBRARY_VISIBILITY void
+executeInterMonoTaint(AnalysisController::ControllerData &Data);
+
+///
+/// \brief The maximum length of the CallStrings used in the InterMonoSolver
+///
+static constexpr unsigned K = 3;
+
+[[nodiscard]] LLVM_LIBRARY_VISIBILITY LLVMTaintConfig
+makeTaintConfig(AnalysisController::ControllerData &Data);
+
+template <typename T>
+static void statsEmitter(llvm::raw_ostream & /*OS*/, const T & /*Solver*/) {}
+
+template <typename T>
+static void
+emitRequestedDataFlowResults(AnalysisController::ControllerData &Data,
+                             T &Solver) {
+  auto EmitterOptions = Data.EmitterOptions;
+  const auto &ResultDirectory = Data.ResultDirectory;
+
+  if (EmitterOptions & AnalysisControllerEmitterOptions::EmitTextReport) {
+    if (!ResultDirectory.empty()) {
+      if (auto OFS =
+              openFileStream(ResultDirectory.string() + "/psr-report.txt")) {
+        Solver.emitTextReport(*OFS);
+      }
+    } else {
+      Solver.emitTextReport(llvm::outs());
+    }
+  }
+  if (EmitterOptions & AnalysisControllerEmitterOptions::EmitGraphicalReport) {
+    if (!ResultDirectory.empty()) {
+      if (auto OFS =
+              openFileStream(ResultDirectory.string() + "/psr-report.html")) {
+        Solver.emitGraphicalReport(*OFS);
+      }
+    } else {
+      Solver.emitGraphicalReport(llvm::outs());
+    }
+  }
+  if (EmitterOptions & AnalysisControllerEmitterOptions::EmitRawResults) {
+    if (!ResultDirectory.empty()) {
+      if (auto OFS = openFileStream(ResultDirectory.string() +
+                                    "/psr-raw-results.txt")) {
+        Solver.dumpResults(*OFS);
+      }
+    } else {
+      Solver.dumpResults(llvm::outs());
+    }
+  }
+  if (EmitterOptions & AnalysisControllerEmitterOptions::EmitESGAsDot) {
+    llvm::outs() << "Front-end support for 'EmitESGAsDot' to be implemented\n";
+  }
+  if (EmitterOptions & AnalysisControllerEmitterOptions::EmitStatisticsAsText) {
+
+    statsEmitter(llvm::outs(), Solver);
+  }
+}
+
+} // namespace psr::controller
+
+#endif // PHASAR_CONTROLLER_ANALYSISCONTROLLERINTERNAL_H
diff --git a/lib/Controller/AnalysisControllerInternalIDE.h b/lib/Controller/AnalysisControllerInternalIDE.h
new file mode 100644
index 0000000000..fa758bbb68
--- /dev/null
+++ b/lib/Controller/AnalysisControllerInternalIDE.h
@@ -0,0 +1,62 @@
+/******************************************************************************
+ * Copyright (c) 2023 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#ifndef PHASAR_CONTROLLER_ANALYSISCONTROLLERINTERNALIDE_H
+#define PHASAR_CONTROLLER_ANALYSISCONTROLLERINTERNALIDE_H
+
+#include "phasar/DataFlow/IfdsIde/Solver/IDESolver.h"
+#include "phasar/DataFlow/IfdsIde/Solver/IFDSSolver.h"
+
+#include "AnalysisControllerInternal.h"
+
+namespace psr::controller {
+
+template <typename T, typename U>
+static void statsEmitter(llvm::raw_ostream &OS, const IDESolver<T, U> &Solver) {
+  OS << "\nEdgeFunction Statistics:\n";
+  Solver.printEdgeFunctionStatistics(OS);
+}
+
+template <typename SolverTy, typename ProblemTy, typename... ArgTys>
+static void executeIfdsIdeAnalysis(AnalysisController::ControllerData &Data,
+                                   ArgTys &&...Args) {
+  auto Problem =
+      createAnalysisProblem<ProblemTy>(*Data.HA, std::forward<ArgTys>(Args)...);
+  SolverTy Solver(Problem, &Data.HA->getICFG());
+  {
+    std::optional<Timer> MeasureTime;
+    if (Data.EmitterOptions &
+        AnalysisControllerEmitterOptions::EmitStatisticsAsText) {
+      MeasureTime.emplace([](auto Elapsed) {
+        llvm::outs() << "Elapsed: " << hms{Elapsed} << '\n';
+      });
+    }
+
+    Solver.solve();
+  }
+  emitRequestedDataFlowResults(Data, Solver);
+}
+
+template <typename ProblemTy, typename... ArgTys>
+static void executeIFDSAnalysis(AnalysisController::ControllerData &Data,
+                                ArgTys &&...Args) {
+  executeIfdsIdeAnalysis<IFDSSolver_P<ProblemTy>, ProblemTy>(
+      Data, std::forward<ArgTys>(Args)...);
+}
+
+template <typename ProblemTy, typename... ArgTys>
+static void executeIDEAnalysis(AnalysisController::ControllerData &Data,
+                               ArgTys &&...Args) {
+  executeIfdsIdeAnalysis<IDESolver_P<ProblemTy>, ProblemTy>(
+      Data, std::forward<ArgTys>(Args)...);
+}
+
+} // namespace psr::controller
+
+#endif // PHASAR_CONTROLLER_ANALYSISCONTROLLERINTERNALMONO_H
diff --git a/lib/Controller/AnalysisControllerInternalMono.h b/lib/Controller/AnalysisControllerInternalMono.h
new file mode 100644
index 0000000000..e688789318
--- /dev/null
+++ b/lib/Controller/AnalysisControllerInternalMono.h
@@ -0,0 +1,45 @@
+/******************************************************************************
+ * Copyright (c) 2023 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#ifndef PHASAR_CONTROLLER_ANALYSISCONTROLLERINTERNALMONO_H
+#define PHASAR_CONTROLLER_ANALYSISCONTROLLERINTERNALMONO_H
+
+#include "phasar/DataFlow/Mono/Solver/InterMonoSolver.h"
+#include "phasar/DataFlow/Mono/Solver/IntraMonoSolver.h"
+
+#include "AnalysisControllerInternal.h"
+
+namespace psr::controller {
+
+template <typename SolverTy, typename ProblemTy, typename... ArgTys>
+static void executeMonoAnalysis(AnalysisController::ControllerData &Data,
+                                ArgTys &&...Args) {
+  auto Problem =
+      createAnalysisProblem<ProblemTy>(*Data.HA, std::forward<ArgTys>(Args)...);
+  SolverTy Solver(Problem);
+  Solver.solve();
+  emitRequestedDataFlowResults(Data, Solver);
+}
+
+template <typename ProblemTy, typename... ArgTys>
+static void executeIntraMonoAnalysis(AnalysisController::ControllerData &Data,
+                                     ArgTys &&...Args) {
+  executeMonoAnalysis<IntraMonoSolver_P<ProblemTy>, ProblemTy>(
+      Data, std::forward<ArgTys>(Args)...);
+}
+
+template <typename ProblemTy, typename... ArgTys>
+static void executeInterMonoAnalysis(AnalysisController::ControllerData &Data,
+                                     ArgTys &&...Args) {
+  executeMonoAnalysis<InterMonoSolver_P<ProblemTy, K>, ProblemTy>(
+      Data, std::forward<ArgTys>(Args)...);
+}
+} // namespace psr::controller
+
+#endif // PHASAR_CONTROLLER_ANALYSISCONTROLLERINTERNALMONO_H
diff --git a/lib/Controller/AnalysisControllerXIDECSTDIOTS.cpp b/lib/Controller/AnalysisControllerXIDECSTDIOTS.cpp
index 59bd165343..f6c268ae8b 100644
--- a/lib/Controller/AnalysisControllerXIDECSTDIOTS.cpp
+++ b/lib/Controller/AnalysisControllerXIDECSTDIOTS.cpp
@@ -7,16 +7,15 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IDETypeStateAnalysis.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/TypeStateDescriptions/CSTDFILEIOTypeStateDescription.h"
 
-namespace psr {
+#include "AnalysisControllerInternalIDE.h"
 
-void AnalysisController::executeIDECSTDIOTS() {
+using namespace psr;
+
+void controller::executeIDECSTDIOTS(AnalysisController::ControllerData &Data) {
   CSTDFILEIOTypeStateDescription TSDesc;
   executeIDEAnalysis<IDETypeStateAnalysis<CSTDFILEIOTypeStateDescription>>(
-      &TSDesc, EntryPoints);
+      Data, &TSDesc, Data.EntryPoints);
 }
-
-} // namespace psr
diff --git a/lib/Controller/AnalysisControllerXIDEIIA.cpp b/lib/Controller/AnalysisControllerXIDEIIA.cpp
index 17b053f16b..e44f08422e 100644
--- a/lib/Controller/AnalysisControllerXIDEIIA.cpp
+++ b/lib/Controller/AnalysisControllerXIDEIIA.cpp
@@ -7,16 +7,17 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IDEInstInteractionAnalysis.h"
 
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/Support/Casting.h"
 
-namespace psr {
+#include "AnalysisControllerInternalIDE.h"
 
-void AnalysisController::executeIDEIIA() {
+using namespace psr;
+
+void controller::executeIDEIIA(AnalysisController::ControllerData &Data) {
   // use Phasar's instruction ids as testing labels
   auto Generator =
       [](std::variant<const llvm::Instruction *, const llvm::GlobalVariable *>
@@ -38,7 +39,6 @@ void AnalysisController::executeIDEIIA() {
         Current);
   };
 
-  executeIDEAnalysis<IDEInstInteractionAnalysis>(EntryPoints, Generator);
+  executeIDEAnalysis<IDEInstInteractionAnalysis>(Data, Data.EntryPoints,
+                                                 Generator);
 }
-
-} // namespace psr
diff --git a/lib/Controller/AnalysisControllerXIDELinearConst.cpp b/lib/Controller/AnalysisControllerXIDELinearConst.cpp
index 7f62100865..1e794814f1 100644
--- a/lib/Controller/AnalysisControllerXIDELinearConst.cpp
+++ b/lib/Controller/AnalysisControllerXIDELinearConst.cpp
@@ -7,13 +7,13 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IDELinearConstantAnalysis.h"
 
-namespace psr {
+#include "AnalysisControllerInternalIDE.h"
 
-void AnalysisController::executeIDELinearConst() {
-  executeIDEAnalysis<IDELinearConstantAnalysis>(EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeIDELinearConst(
+    AnalysisController::ControllerData &Data) {
+  executeIDEAnalysis<IDELinearConstantAnalysis>(Data, Data.EntryPoints);
+}
diff --git a/lib/Controller/AnalysisControllerXIDEOpenSSLTS.cpp b/lib/Controller/AnalysisControllerXIDEOpenSSLTS.cpp
index 6c6dba3b45..f45029770f 100644
--- a/lib/Controller/AnalysisControllerXIDEOpenSSLTS.cpp
+++ b/lib/Controller/AnalysisControllerXIDEOpenSSLTS.cpp
@@ -7,16 +7,15 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IDETypeStateAnalysis.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/TypeStateDescriptions/OpenSSLEVPKDFDescription.h"
 
-namespace psr {
+#include "AnalysisControllerInternalIDE.h"
 
-void AnalysisController::executeIDEOpenSSLTS() {
+using namespace psr;
+
+void controller::executeIDEOpenSSLTS(AnalysisController::ControllerData &Data) {
   OpenSSLEVPKDFDescription TSDesc;
   executeIDEAnalysis<IDETypeStateAnalysis<OpenSSLEVPKDFDescription>>(
-      &TSDesc, EntryPoints);
+      Data, &TSDesc, Data.EntryPoints);
 }
-
-} // namespace psr
diff --git a/lib/Controller/AnalysisControllerXIDESolverTest.cpp b/lib/Controller/AnalysisControllerXIDESolverTest.cpp
index 5c840dc502..719207aa39 100644
--- a/lib/Controller/AnalysisControllerXIDESolverTest.cpp
+++ b/lib/Controller/AnalysisControllerXIDESolverTest.cpp
@@ -7,13 +7,13 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IDESolverTest.h"
 
-namespace psr {
+#include "AnalysisControllerInternalIDE.h"
 
-void AnalysisController::executeIDESolverTest() {
-  executeIDEAnalysis<IDESolverTest>(EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeIDESolverTest(
+    AnalysisController::ControllerData &Data) {
+  executeIDEAnalysis<IDESolverTest>(Data, Data.EntryPoints);
+}
diff --git a/lib/Controller/AnalysisControllerXIDEXTaint.cpp b/lib/Controller/AnalysisControllerXIDEXTaint.cpp
index 8813c0ff77..8929394573 100644
--- a/lib/Controller/AnalysisControllerXIDEXTaint.cpp
+++ b/lib/Controller/AnalysisControllerXIDEXTaint.cpp
@@ -7,14 +7,14 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IDEExtendedTaintAnalysis.h"
 
-namespace psr {
+#include "AnalysisControllerInternalIDE.h"
 
-void AnalysisController::executeIDEXTaint() {
-  auto Config = makeTaintConfig();
-  executeIDEAnalysis<IDEExtendedTaintAnalysis<>>(Config, EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeIDEXTaint(AnalysisController::ControllerData &Data) {
+  auto Config = makeTaintConfig(Data);
+  executeIDEAnalysis<IDEExtendedTaintAnalysis<>>(Data, Config,
+                                                 Data.EntryPoints);
+}
diff --git a/lib/Controller/AnalysisControllerXIFDSConst.cpp b/lib/Controller/AnalysisControllerXIFDSConst.cpp
index 0dfc6c724c..0393c29509 100644
--- a/lib/Controller/AnalysisControllerXIFDSConst.cpp
+++ b/lib/Controller/AnalysisControllerXIFDSConst.cpp
@@ -7,13 +7,12 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSConstAnalysis.h"
 
-namespace psr {
+#include "AnalysisControllerInternalIDE.h"
 
-void AnalysisController::executeIFDSConst() {
-  executeIFDSAnalysis<IFDSConstAnalysis>(EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeIFDSConst(AnalysisController::ControllerData &Data) {
+  executeIFDSAnalysis<IFDSConstAnalysis>(Data, Data.EntryPoints);
+}
diff --git a/lib/Controller/AnalysisControllerXIFDSFieldSensTaint.cpp b/lib/Controller/AnalysisControllerXIFDSFieldSensTaint.cpp
index 0042d94006..6e50cd4f19 100644
--- a/lib/Controller/AnalysisControllerXIFDSFieldSensTaint.cpp
+++ b/lib/Controller/AnalysisControllerXIFDSFieldSensTaint.cpp
@@ -7,14 +7,15 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSFieldSensTaintAnalysis.h"
 
-namespace psr {
+#include "AnalysisControllerInternalIDE.h"
 
-void AnalysisController::executeIFDSFieldSensTaint() {
-  auto Config = makeTaintConfig();
-  executeIFDSAnalysis<IFDSFieldSensTaintAnalysis>(&Config, EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeIFDSFieldSensTaint(
+    AnalysisController::ControllerData &Data) {
+  auto Config = makeTaintConfig(Data);
+  executeIFDSAnalysis<IFDSFieldSensTaintAnalysis>(Data, &Config,
+                                                  Data.EntryPoints);
+}
diff --git a/lib/Controller/AnalysisControllerXIFDSSolverTest.cpp b/lib/Controller/AnalysisControllerXIFDSSolverTest.cpp
index ff45656e25..08f8c26898 100644
--- a/lib/Controller/AnalysisControllerXIFDSSolverTest.cpp
+++ b/lib/Controller/AnalysisControllerXIFDSSolverTest.cpp
@@ -7,13 +7,13 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSSolverTest.h"
 
-namespace psr {
+#include "AnalysisControllerInternalIDE.h"
 
-void AnalysisController::executeIFDSSolverTest() {
-  executeIFDSAnalysis<IFDSSolverTest>(EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeIFDSSolverTest(
+    AnalysisController::ControllerData &Data) {
+  executeIFDSAnalysis<IFDSSolverTest>(Data, Data.EntryPoints);
+}
diff --git a/lib/Controller/AnalysisControllerXIFDSTaint.cpp b/lib/Controller/AnalysisControllerXIFDSTaint.cpp
index 49fe79caa0..a94abca60d 100644
--- a/lib/Controller/AnalysisControllerXIFDSTaint.cpp
+++ b/lib/Controller/AnalysisControllerXIFDSTaint.cpp
@@ -7,14 +7,13 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSTaintAnalysis.h"
 
-namespace psr {
+#include "AnalysisControllerInternalIDE.h"
 
-void AnalysisController::executeIFDSTaint() {
-  auto Config = makeTaintConfig();
-  executeIFDSAnalysis<IFDSTaintAnalysis>(&Config, EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeIFDSTaint(AnalysisController::ControllerData &Data) {
+  auto Config = makeTaintConfig(Data);
+  executeIFDSAnalysis<IFDSTaintAnalysis>(Data, &Config, Data.EntryPoints);
+}
diff --git a/lib/Controller/AnalysisControllerXIFDSType.cpp b/lib/Controller/AnalysisControllerXIFDSType.cpp
index 2c90d8536a..e5a56d531c 100644
--- a/lib/Controller/AnalysisControllerXIFDSType.cpp
+++ b/lib/Controller/AnalysisControllerXIFDSType.cpp
@@ -7,13 +7,12 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSTypeAnalysis.h"
 
-namespace psr {
+#include "AnalysisControllerInternalIDE.h"
 
-void AnalysisController::executeIFDSType() {
-  executeIFDSAnalysis<IFDSTypeAnalysis>(EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeIFDSType(AnalysisController::ControllerData &Data) {
+  executeIFDSAnalysis<IFDSTypeAnalysis>(Data, Data.EntryPoints);
+}
diff --git a/lib/Controller/AnalysisControllerXIFDSUninit.cpp b/lib/Controller/AnalysisControllerXIFDSUninit.cpp
index 1e1772f761..db66cfef1d 100644
--- a/lib/Controller/AnalysisControllerXIFDSUninit.cpp
+++ b/lib/Controller/AnalysisControllerXIFDSUninit.cpp
@@ -7,13 +7,13 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSUninitializedVariables.h"
 
-namespace psr {
+#include "AnalysisControllerInternalIDE.h"
 
-void AnalysisController::executeIFDSUninitVar() {
-  executeIFDSAnalysis<IFDSUninitializedVariables>(EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeIFDSUninitVar(
+    AnalysisController::ControllerData &Data) {
+  executeIFDSAnalysis<IFDSUninitializedVariables>(Data, Data.EntryPoints);
+}
diff --git a/lib/Controller/AnalysisControllerXInterMonoSolverTest.cpp b/lib/Controller/AnalysisControllerXInterMonoSolverTest.cpp
index f6de335f44..17ad61168d 100644
--- a/lib/Controller/AnalysisControllerXInterMonoSolverTest.cpp
+++ b/lib/Controller/AnalysisControllerXInterMonoSolverTest.cpp
@@ -7,13 +7,13 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/Mono/Problems/InterMonoSolverTest.h"
 
-namespace psr {
+#include "AnalysisControllerInternalMono.h"
 
-void AnalysisController::executeInterMonoSolverTest() {
-  executeInterMonoAnalysis<InterMonoSolverTest>(EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeInterMonoSolverTest(
+    AnalysisController::ControllerData &Data) {
+  executeInterMonoAnalysis<InterMonoSolverTest>(Data, Data.EntryPoints);
+}
diff --git a/lib/Controller/AnalysisControllerXInterMonoTaint.cpp b/lib/Controller/AnalysisControllerXInterMonoTaint.cpp
index 2f9a6cbea0..cc24440e1e 100644
--- a/lib/Controller/AnalysisControllerXInterMonoTaint.cpp
+++ b/lib/Controller/AnalysisControllerXInterMonoTaint.cpp
@@ -7,14 +7,15 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/Mono/Problems/InterMonoTaintAnalysis.h"
 
-namespace psr {
+#include "AnalysisControllerInternalMono.h"
 
-void AnalysisController::executeInterMonoTaint() {
-  auto Config = makeTaintConfig();
-  executeInterMonoAnalysis<InterMonoTaintAnalysis>(Config, EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeInterMonoTaint(
+    AnalysisController::ControllerData &Data) {
+  auto Config = makeTaintConfig(Data);
+  executeInterMonoAnalysis<InterMonoTaintAnalysis>(Data, Config,
+                                                   Data.EntryPoints);
+}
diff --git a/lib/Controller/AnalysisControllerXIntraMonoFullConstant.cpp b/lib/Controller/AnalysisControllerXIntraMonoFullConstant.cpp
index 50013234f8..65a95b338b 100644
--- a/lib/Controller/AnalysisControllerXIntraMonoFullConstant.cpp
+++ b/lib/Controller/AnalysisControllerXIntraMonoFullConstant.cpp
@@ -7,13 +7,14 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/Mono/Problems/IntraMonoFullConstantPropagation.h"
 
-namespace psr {
+#include "AnalysisControllerInternalMono.h"
 
-void AnalysisController::executeIntraMonoFullConstant() {
-  executeIntraMonoAnalysis<IntraMonoFullConstantPropagation>(EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeIntraMonoFullConstant(
+    AnalysisController::ControllerData &Data) {
+  executeIntraMonoAnalysis<IntraMonoFullConstantPropagation>(Data,
+                                                             Data.EntryPoints);
+}
diff --git a/lib/Controller/AnalysisControllerXIntraMonoSolverTest.cpp b/lib/Controller/AnalysisControllerXIntraMonoSolverTest.cpp
index c3b61cf7ec..557d5899d6 100644
--- a/lib/Controller/AnalysisControllerXIntraMonoSolverTest.cpp
+++ b/lib/Controller/AnalysisControllerXIntraMonoSolverTest.cpp
@@ -7,13 +7,13 @@
  *     Martin Mory and others
  *****************************************************************************/
 
-#include "phasar/Controller/AnalysisController.h"
 #include "phasar/PhasarLLVM/DataFlow/Mono/Problems/IntraMonoSolverTest.h"
 
-namespace psr {
+#include "AnalysisControllerInternalMono.h"
 
-void AnalysisController::executeIntraMonoSolverTest() {
-  executeIntraMonoAnalysis<IntraMonoSolverTest>(EntryPoints);
-}
+using namespace psr;
 
-} // namespace psr
+void controller::executeIntraMonoSolverTest(
+    AnalysisController::ControllerData &Data) {
+  executeIntraMonoAnalysis<IntraMonoSolverTest>(Data, Data.EntryPoints);
+}

From edcf9c3ac6ee76fd9b30793a2d2854a74a93dc42 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabian.schiebel@iem.fraunhofer.de>
Date: Tue, 17 Oct 2023 17:50:07 +0200
Subject: [PATCH 3/7] More stats (WIP)

---
 .../phasar/DataFlow/IfdsIde/EdgeFunction.h    | 25 ++++++++++++++++---
 .../DataFlow/IfdsIde/EdgeFunctionUtils.h      |  2 ++
 .../DataFlow/IfdsIde/Solver/IDESolver.h       | 12 +++++++--
 include/phasar/Utils/TypeTraits.h             |  8 ++++++
 lib/Controller/AnalysisControllerInternal.h   |  6 +++++
 5 files changed, 47 insertions(+), 6 deletions(-)

diff --git a/include/phasar/DataFlow/IfdsIde/EdgeFunction.h b/include/phasar/DataFlow/IfdsIde/EdgeFunction.h
index 1d38883961..9fbe871095 100644
--- a/include/phasar/DataFlow/IfdsIde/EdgeFunction.h
+++ b/include/phasar/DataFlow/IfdsIde/EdgeFunction.h
@@ -14,6 +14,8 @@
 #include "phasar/Utils/ByRef.h"
 #include "phasar/Utils/TypeTraits.h"
 
+#include "llvm/ADT/DenseMapInfo.h"
+#include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/TypeName.h"
@@ -27,9 +29,6 @@
 #include <type_traits>
 #include <utility>
 
-#include <llvm/ADT/DenseMapInfo.h>
-#include <llvm/ADT/Hashing.h>
-
 namespace psr {
 
 template <typename L> class EdgeFunction;
@@ -77,12 +76,13 @@ class EdgeFunctionBase {
                        alignof(ConcreteEF) <= alignof(void *) &&
                        std::is_trivially_copyable_v<ConcreteEF>;
 
-protected:
   enum class AllocationPolicy {
     SmallObjectOptimized,
     DefaultHeapAllocated,
     CustomHeapAllocated,
   };
+
+protected:
   struct RefCountedBase {
     mutable std::atomic_size_t Rc = 0;
   };
@@ -619,6 +619,10 @@ class [[clang::trivial_abi]] EdgeFunction final : EdgeFunctionBase {
     return VTAndHeapAlloc.getInt() == AllocationPolicy::CustomHeapAllocated;
   }
 
+  [[nodiscard]] auto getAllocationPolicy() const noexcept {
+    return VTAndHeapAlloc.getInt();
+  }
+
   /// Gets an opaque identifier for this edge function. Only meant for
   /// comparisons of object-identity. Do not dereference!
   [[nodiscard]] const void *getOpaqueValue() const noexcept { return EF; }
@@ -649,6 +653,11 @@ class [[clang::trivial_abi]] EdgeFunction final : EdgeFunctionBase {
         EF, VTAndHeapAlloc.getPointer());
   }
 
+  [[nodiscard]] auto depth() noexcept {
+    assert(!!*this && "depth() called on nullptr!");
+    return VTAndHeapAlloc.getPointer()->depth(EF);
+  }
+
   friend size_t hash_value(const EdgeFunction &EF) noexcept { // NOLINT
     return EF.getHashCode();
   }
@@ -677,6 +686,7 @@ class [[clang::trivial_abi]] EdgeFunction final : EdgeFunctionBase {
     bool (*isConstant)(const void *) noexcept;
     void (*destroy)(const void *, AllocationPolicy) noexcept;
     size_t (*getHashCode)(const void *, const void *) noexcept;
+    size_t (*depth)(const void *) noexcept;
     // NOLINTEND(readability-identifier-naming)
   };
 
@@ -750,6 +760,13 @@ class [[clang::trivial_abi]] EdgeFunction final : EdgeFunctionBase {
           return llvm::hash_combine(EF, VT);
         }
       },
+      [](const void *EF) noexcept -> size_t {
+        if constexpr (HasDepth<ConcreteEF>) {
+          return getPtr<ConcreteEF>(EF)->depth();
+        } else {
+          return 1;
+        }
+      },
   };
 
   // Utility ctor for (copy) construction. Increments the ref-count if
diff --git a/include/phasar/DataFlow/IfdsIde/EdgeFunctionUtils.h b/include/phasar/DataFlow/IfdsIde/EdgeFunctionUtils.h
index 018a7849fe..8b96373035 100644
--- a/include/phasar/DataFlow/IfdsIde/EdgeFunctionUtils.h
+++ b/include/phasar/DataFlow/IfdsIde/EdgeFunctionUtils.h
@@ -265,6 +265,8 @@ template <typename L> struct EdgeFunctionComposer {
     return LHS.First == RHS.First && LHS.Second == RHS.Second;
   }
 
+  size_t depth() noexcept { return First.depth() + Second.depth(); }
+
   // -- data members
 
   EdgeFunction<l_t> First{};
diff --git a/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h b/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h
index 9377a611ae..9233fc0489 100644
--- a/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h
+++ b/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h
@@ -261,12 +261,16 @@ class IDESolver
     std::array<size_t, 5> TotalEFCount{};
     static constexpr std::array<llvm::StringRef, 5> EFKind{
         "Normal", "Call", "Return", "CallToReturn", "Summary"};
+
+    std::array<size_t, 3> PerAllocCount{};
+    static constexpr std::array<llvm::StringRef, 3> AllocKind{
+        "SmallObjectOptimized", "DefaultHeapAllocated", "CustomHeapAllocated"};
     // TODO: Cache EFs
     CachedFlowEdgeFunctions.foreachCachedEdgeFunction(
-        [&UniqueEFs, &TotalEFCount](EdgeFunction<l_t> EF,
-                                    EdgeFunctionKind Kind) {
+        [&](EdgeFunction<l_t> EF, EdgeFunctionKind Kind) {
           UniqueEFs[int(Kind)].insert(std::move(EF));
           TotalEFCount[int(Kind)]++;
+          PerAllocCount[int(EF.getAllocationPolicy())]++;
         });
 
     size_t Ctr = 0;
@@ -277,6 +281,10 @@ class IDESolver
       OS << "  Total # EdgeFunctions: " << Count << '\n';
       OS << "  Unique EdgeFunctions: " << UEF.size() << '\n';
     }
+
+    for (auto [Count, Kind] : llvm::zip(PerAllocCount, AllocKind)) {
+      OS << Kind << ": " << Count << '\n';
+    }
   }
 
 protected:
diff --git a/include/phasar/Utils/TypeTraits.h b/include/phasar/Utils/TypeTraits.h
index f70f5edd92..6d554c8e47 100644
--- a/include/phasar/Utils/TypeTraits.h
+++ b/include/phasar/Utils/TypeTraits.h
@@ -151,6 +151,11 @@ struct AreEqualityComparable<T, U,
                              decltype(std::declval<T>() == std::declval<U>())>
     : std::true_type {};
 
+template <typename T, typename = size_t> struct HasDepth : std::false_type {};
+template <typename T>
+struct HasDepth<T, decltype(std::declval<const T &>().depth())>
+    : std::true_type {};
+
 } // namespace detail
 
 template <typename T>
@@ -213,6 +218,9 @@ constexpr bool is_crtp_base_of_v = // NOLINT
 template <typename T>
 static inline constexpr bool HasIsConstant = detail::HasIsConstant<T>::value;
 
+template <typename T>
+static inline constexpr bool HasDepth = detail::HasDepth<T>::value;
+
 template <typename T>
 static inline constexpr bool IsEqualityComparable =
     detail::IsEqualityComparable<T>::value;
diff --git a/lib/Controller/AnalysisControllerInternal.h b/lib/Controller/AnalysisControllerInternal.h
index f907800f78..8a736e3a11 100644
--- a/lib/Controller/AnalysisControllerInternal.h
+++ b/lib/Controller/AnalysisControllerInternal.h
@@ -22,6 +22,10 @@
 
 #include "llvm/Support/Compiler.h"
 
+namespace psr {
+template <typename T, typename U> class IDESolver;
+} // namespace psr
+
 namespace psr::controller {
 
 LLVM_LIBRARY_VISIBILITY void
@@ -67,6 +71,8 @@ makeTaintConfig(AnalysisController::ControllerData &Data);
 
 template <typename T>
 static void statsEmitter(llvm::raw_ostream & /*OS*/, const T & /*Solver*/) {}
+template <typename T, typename U>
+static void statsEmitter(llvm::raw_ostream &OS, const IDESolver<T, U> &Solver);
 
 template <typename T>
 static void

From 6679d3304d8c07eeb94797bb5fc4430178af5527 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabian.schiebel@iem.fraunhofer.de>
Date: Wed, 6 Dec 2023 17:11:05 +0100
Subject: [PATCH 4/7] EF Stats object

---
 .../phasar/DataFlow/IfdsIde/EdgeFunction.h    | 12 ++--
 .../DataFlow/IfdsIde/EdgeFunctionStats.h      | 72 +++++++++++++++++++
 .../DataFlow/IfdsIde/Solver/IDESolver.h       | 33 ++++-----
 lib/Utils/EdgeFunctionStats.cpp               | 26 +++++++
 4 files changed, 118 insertions(+), 25 deletions(-)
 create mode 100644 include/phasar/DataFlow/IfdsIde/EdgeFunctionStats.h
 create mode 100644 lib/Utils/EdgeFunctionStats.cpp

diff --git a/include/phasar/DataFlow/IfdsIde/EdgeFunction.h b/include/phasar/DataFlow/IfdsIde/EdgeFunction.h
index 9fbe871095..65f5e62011 100644
--- a/include/phasar/DataFlow/IfdsIde/EdgeFunction.h
+++ b/include/phasar/DataFlow/IfdsIde/EdgeFunction.h
@@ -68,6 +68,12 @@ concept IsEdgeFunction = requires(const T &EF, const EdgeFunction<typename T::l_
 
 #endif
 
+enum class EdgeFunctionAllocationPolicy {
+  SmallObjectOptimized,
+  DefaultHeapAllocated,
+  CustomHeapAllocated,
+};
+
 class EdgeFunctionBase {
 public:
   template <typename ConcreteEF>
@@ -76,11 +82,7 @@ class EdgeFunctionBase {
                        alignof(ConcreteEF) <= alignof(void *) &&
                        std::is_trivially_copyable_v<ConcreteEF>;
 
-  enum class AllocationPolicy {
-    SmallObjectOptimized,
-    DefaultHeapAllocated,
-    CustomHeapAllocated,
-  };
+  using AllocationPolicy = EdgeFunctionAllocationPolicy;
 
 protected:
   struct RefCountedBase {
diff --git a/include/phasar/DataFlow/IfdsIde/EdgeFunctionStats.h b/include/phasar/DataFlow/IfdsIde/EdgeFunctionStats.h
new file mode 100644
index 0000000000..5ff6a84647
--- /dev/null
+++ b/include/phasar/DataFlow/IfdsIde/EdgeFunctionStats.h
@@ -0,0 +1,72 @@
+/******************************************************************************
+ * Copyright (c) 2023 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#ifndef PHASAR_DATAFLOW_IFDSIDE_EDGEFUNCTIONSTATS_H
+#define PHASAR_DATAFLOW_IFDSIDE_EDGEFUNCTIONSTATS_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include <array>
+#include <cstddef>
+#include <numeric>
+
+namespace psr {
+enum class EdgeFunctionKind;
+enum class EdgeFunctionAllocationPolicy;
+
+namespace detail {
+struct EdgeFunctionStatsData {
+  static constexpr size_t NumEFKinds = 5;
+  static constexpr size_t NumAllocPolicies = 3;
+
+  std::array<size_t, NumEFKinds> UniqueEFCount{};
+  std::array<size_t, NumEFKinds> TotalEFCount{};
+  std::array<size_t, NumAllocPolicies> PerAllocCount{};
+};
+} // namespace detail
+
+class EdgeFunctionStats : public detail::EdgeFunctionStatsData {
+public:
+  [[nodiscard]] size_t getNumUniqueEFs() const noexcept {
+    return std::reduce(UniqueEFCount.begin(), UniqueEFCount.end());
+  }
+  [[nodiscard]] size_t getNumUniqueEFs(EdgeFunctionKind Kind) const noexcept {
+    assert(size_t(Kind) < NumEFKinds);
+    return UniqueEFCount[size_t(Kind)]; // NOLINT
+  }
+
+  [[nodiscard]] size_t getNumEFs() const noexcept {
+    return std::reduce(TotalEFCount.begin(), TotalEFCount.end());
+  }
+  [[nodiscard]] size_t getNumEFs(EdgeFunctionKind Kind) const noexcept {
+    assert(size_t(Kind) < NumEFKinds);
+    return TotalEFCount[size_t(Kind)]; // NOLINT
+  }
+
+  [[nodiscard]] size_t getNumEFsPerAllocationPolicy(
+      EdgeFunctionAllocationPolicy Policy) const noexcept {
+    assert(size_t(Policy) < NumAllocPolicies);
+    return PerAllocCount[size_t(Policy)]; // NOLINT
+  }
+
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+                                       const EdgeFunctionStats &S);
+
+private:
+  template <typename AnalysisDomainTy, typename Container>
+  friend class IDESolver;
+
+  constexpr EdgeFunctionStats(
+      const detail::EdgeFunctionStatsData &Data) noexcept
+      : detail::EdgeFunctionStatsData(Data) {}
+};
+} // namespace psr
+
+#endif // PHASAR_DATAFLOW_IFDSIDE_EDGEFUNCTIONSTATS_H
diff --git a/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h b/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h
index 9233fc0489..6534a2fa02 100644
--- a/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h
+++ b/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h
@@ -20,6 +20,7 @@
 #include "phasar/Config/Configuration.h"
 #include "phasar/DB/ProjectIRDBBase.h"
 #include "phasar/DataFlow/IfdsIde/EdgeFunction.h"
+#include "phasar/DataFlow/IfdsIde/EdgeFunctionStats.h"
 #include "phasar/DataFlow/IfdsIde/EdgeFunctionUtils.h"
 #include "phasar/DataFlow/IfdsIde/EdgeFunctions.h"
 #include "phasar/DataFlow/IfdsIde/FlowFunctions.h"
@@ -256,35 +257,27 @@ class IDESolver
                                               std::move(ZeroValue));
   }
 
-  void printEdgeFunctionStatistics(llvm::raw_ostream &OS = llvm::outs()) const {
-    std::array<llvm::DenseSet<EdgeFunction<l_t>>, 5> UniqueEFs{};
-    std::array<size_t, 5> TotalEFCount{};
-    static constexpr std::array<llvm::StringRef, 5> EFKind{
-        "Normal", "Call", "Return", "CallToReturn", "Summary"};
+  [[nodiscard]] EdgeFunctionStats getEdgeFunctionStatistics() const {
+    detail::EdgeFunctionStatsData Stats{};
 
-    std::array<size_t, 3> PerAllocCount{};
-    static constexpr std::array<llvm::StringRef, 3> AllocKind{
-        "SmallObjectOptimized", "DefaultHeapAllocated", "CustomHeapAllocated"};
+    std::array<llvm::DenseSet<EdgeFunction<l_t>>, 5> UniqueEFs{};
     // TODO: Cache EFs
     CachedFlowEdgeFunctions.foreachCachedEdgeFunction(
         [&](EdgeFunction<l_t> EF, EdgeFunctionKind Kind) {
           UniqueEFs[int(Kind)].insert(std::move(EF));
-          TotalEFCount[int(Kind)]++;
-          PerAllocCount[int(EF.getAllocationPolicy())]++;
+          Stats.TotalEFCount[int(Kind)]++;
+          Stats.PerAllocCount[int(EF.getAllocationPolicy())]++;
         });
 
-    size_t Ctr = 0;
-    for (const auto &[UEF, Count] : llvm::zip(UniqueEFs, TotalEFCount)) {
-      OS << "Kind: " << EFKind[Ctr] << ":\n";
-      Ctr++;
-
-      OS << "  Total # EdgeFunctions: " << Count << '\n';
-      OS << "  Unique EdgeFunctions: " << UEF.size() << '\n';
+    for (size_t I = 0, End = UniqueEFs.size(); I != End; ++I) {
+      Stats.UniqueEFCount[I] = UniqueEFs[I].size(); // NOLINT
     }
 
-    for (auto [Count, Kind] : llvm::zip(PerAllocCount, AllocKind)) {
-      OS << Kind << ": " << Count << '\n';
-    }
+    return Stats;
+  }
+
+  void printEdgeFunctionStatistics(llvm::raw_ostream &OS = llvm::outs()) const {
+    OS << getEdgeFunctionStatistics() << '\n';
   }
 
 protected:
diff --git a/lib/Utils/EdgeFunctionStats.cpp b/lib/Utils/EdgeFunctionStats.cpp
new file mode 100644
index 0000000000..4beb5d9b43
--- /dev/null
+++ b/lib/Utils/EdgeFunctionStats.cpp
@@ -0,0 +1,26 @@
+#include "phasar/DataFlow/IfdsIde/EdgeFunctionStats.h"
+
+#include "llvm/ADT/STLExtras.h"
+
+llvm::raw_ostream &psr::operator<<(llvm::raw_ostream &OS,
+                                   const EdgeFunctionStats &S) {
+  static constexpr std::array<llvm::StringRef, 5> EFKind{
+      "Normal", "Call", "Return", "CallToReturn", "Summary"};
+  static constexpr std::array<llvm::StringRef, 3> AllocKind{
+      "SmallObjectOptimized", "DefaultHeapAllocated", "CustomHeapAllocated"};
+
+  size_t Ctr = 0;
+  for (const auto &[UEF, Count] : llvm::zip(S.UniqueEFCount, S.TotalEFCount)) {
+    OS << "Kind: " << EFKind[Ctr] << ":\n";
+    Ctr++;
+
+    OS << "  Total # EdgeFunctions: " << Count << '\n';
+    OS << "  Unique EdgeFunctions: " << UEF << '\n';
+  }
+
+  for (auto [Count, Kind] : llvm::zip(S.PerAllocCount, AllocKind)) {
+    OS << Kind << ": " << Count << '\n';
+  }
+
+  return OS;
+}

From a565f4fac3ed98c15c806000718d142d184f311a Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabian.schiebel@iem.fraunhofer.de>
Date: Thu, 7 Dec 2023 10:13:51 +0100
Subject: [PATCH 5/7] More EF stats + add some JF stats

---
 .../phasar/DataFlow/IfdsIde/EdgeFunction.h    |  2 +-
 .../DataFlow/IfdsIde/EdgeFunctionStats.h      | 12 +++
 .../DataFlow/IfdsIde/EdgeFunctionUtils.h      |  7 +-
 .../DataFlow/IfdsIde/Solver/IDESolver.h       | 78 ++++++++++++++++---
 .../DataFlow/IfdsIde/Solver/JumpFunctions.h   | 13 ++++
 .../Problems/IDELinearConstantAnalysis.cpp    |  1 -
 lib/Utils/EdgeFunctionStats.cpp               | 33 +++++++-
 7 files changed, 129 insertions(+), 17 deletions(-)

diff --git a/include/phasar/DataFlow/IfdsIde/EdgeFunction.h b/include/phasar/DataFlow/IfdsIde/EdgeFunction.h
index 65f5e62011..cf1eae3f58 100644
--- a/include/phasar/DataFlow/IfdsIde/EdgeFunction.h
+++ b/include/phasar/DataFlow/IfdsIde/EdgeFunction.h
@@ -655,7 +655,7 @@ class [[clang::trivial_abi]] EdgeFunction final : EdgeFunctionBase {
         EF, VTAndHeapAlloc.getPointer());
   }
 
-  [[nodiscard]] auto depth() noexcept {
+  [[nodiscard]] auto depth() const noexcept {
     assert(!!*this && "depth() called on nullptr!");
     return VTAndHeapAlloc.getPointer()->depth(EF);
   }
diff --git a/include/phasar/DataFlow/IfdsIde/EdgeFunctionStats.h b/include/phasar/DataFlow/IfdsIde/EdgeFunctionStats.h
index 5ff6a84647..448188b48b 100644
--- a/include/phasar/DataFlow/IfdsIde/EdgeFunctionStats.h
+++ b/include/phasar/DataFlow/IfdsIde/EdgeFunctionStats.h
@@ -29,6 +29,18 @@ struct EdgeFunctionStatsData {
   std::array<size_t, NumEFKinds> UniqueEFCount{};
   std::array<size_t, NumEFKinds> TotalEFCount{};
   std::array<size_t, NumAllocPolicies> PerAllocCount{};
+  size_t MaxDepth{};
+  double AvgDepth{};
+  double AvgUniqueDepth{};
+
+  size_t TotalNumJF{};
+  size_t UniqueNumJF{};
+  size_t NumJFObjects{};
+  size_t MaxJFDepth{};
+  double AvgJFDepth{};
+  double AvgUniqueJFDepth{};
+  double AvgJFObjDepth{};
+  std::array<size_t, NumAllocPolicies> PerAllocJFCount{};
 };
 } // namespace detail
 
diff --git a/include/phasar/DataFlow/IfdsIde/EdgeFunctionUtils.h b/include/phasar/DataFlow/IfdsIde/EdgeFunctionUtils.h
index 8b96373035..de9db609a6 100644
--- a/include/phasar/DataFlow/IfdsIde/EdgeFunctionUtils.h
+++ b/include/phasar/DataFlow/IfdsIde/EdgeFunctionUtils.h
@@ -13,6 +13,7 @@
 #include "phasar/DataFlow/IfdsIde/EdgeFunction.h"
 #include "phasar/Utils/ByRef.h"
 #include "phasar/Utils/JoinLattice.h"
+#include "phasar/Utils/TypeTraits.h"
 
 #include "llvm/ADT/ArrayRef.h"
 
@@ -265,7 +266,9 @@ template <typename L> struct EdgeFunctionComposer {
     return LHS.First == RHS.First && LHS.Second == RHS.Second;
   }
 
-  size_t depth() noexcept { return First.depth() + Second.depth(); }
+  [[nodiscard]] size_t depth() const noexcept {
+    return First.depth() + Second.depth();
+  }
 
   // -- data members
 
@@ -273,6 +276,8 @@ template <typename L> struct EdgeFunctionComposer {
   EdgeFunction<l_t> Second{};
 };
 
+static_assert(HasDepth<EdgeFunctionComposer<int>>);
+
 template <typename L, uint8_t N> struct JoinEdgeFunction {
   using l_t = L;
   using JLattice = JoinLatticeTraits<L>;
diff --git a/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h b/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h
index 6534a2fa02..365e999e0d 100644
--- a/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h
+++ b/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h
@@ -260,19 +260,77 @@ class IDESolver
   [[nodiscard]] EdgeFunctionStats getEdgeFunctionStatistics() const {
     detail::EdgeFunctionStatsData Stats{};
 
-    std::array<llvm::DenseSet<EdgeFunction<l_t>>, 5> UniqueEFs{};
-    // TODO: Cache EFs
-    CachedFlowEdgeFunctions.foreachCachedEdgeFunction(
-        [&](EdgeFunction<l_t> EF, EdgeFunctionKind Kind) {
-          UniqueEFs[int(Kind)].insert(std::move(EF));
-          Stats.TotalEFCount[int(Kind)]++;
-          Stats.PerAllocCount[int(EF.getAllocationPolicy())]++;
-        });
+    // Cached Edge Functions
+    {
+
+      std::array<llvm::DenseSet<EdgeFunction<l_t>>, 5> UniqueEFs{};
+      size_t TotalDepth = 0;
+      size_t TotalUniqueDepth = 0;
+      size_t TotalNumEF = 0;
+      // TODO: Cache EFs
+      CachedFlowEdgeFunctions.foreachCachedEdgeFunction(
+          [&](EdgeFunction<l_t> EF, EdgeFunctionKind Kind) {
+            ++TotalNumEF;
+            auto Depth = EF.depth();
+            TotalDepth += Depth;
+            if (Depth > Stats.MaxDepth) {
+              Stats.MaxDepth = Depth;
+            }
 
-    for (size_t I = 0, End = UniqueEFs.size(); I != End; ++I) {
-      Stats.UniqueEFCount[I] = UniqueEFs[I].size(); // NOLINT
+            if (UniqueEFs[int(Kind)].insert(std::move(EF)).second) {
+              TotalUniqueDepth += Depth;
+            }
+            Stats.TotalEFCount[int(Kind)]++;
+            Stats.PerAllocCount[int(EF.getAllocationPolicy())]++;
+          });
+
+      size_t TotalUniqueNumEF = 0;
+      for (size_t I = 0, End = UniqueEFs.size(); I != End; ++I) {
+        Stats.UniqueEFCount[I] = UniqueEFs[I].size(); // NOLINT
+        TotalUniqueNumEF += UniqueEFs[I].size();
+      }
+
+      Stats.AvgDepth = double(TotalDepth) / double(TotalNumEF);
+      Stats.AvgUniqueDepth =
+          double(TotalUniqueDepth) / double(TotalUniqueNumEF);
     }
 
+    // Jump Functions
+    {
+
+      llvm::DenseSet<EdgeFunction<l_t>> UniqueJumpFns;
+      llvm::DenseSet<const void *> AllocatedJumpFns;
+      size_t TotalDepth = 0;
+      size_t TotalUniqueDepth = 0;
+      size_t TotalAllocDepth = 0;
+
+      JumpFn->foreachEdgeFunction([&](EdgeFunction<l_t> JF) {
+        ++Stats.TotalNumJF;
+        auto Depth = JF.depth();
+        TotalDepth += Depth;
+        if (Depth > Stats.MaxJFDepth) {
+          Stats.MaxJFDepth = Depth;
+        }
+
+        if (AllocatedJumpFns.insert(JF.getOpaqueValue()).second) {
+          TotalAllocDepth += Depth;
+        }
+
+        Stats.PerAllocJFCount[int(JF.getAllocationPolicy())]++;
+
+        if (UniqueJumpFns.insert(std::move(JF)).second) {
+          TotalUniqueDepth += Depth;
+        }
+      });
+
+      Stats.UniqueNumJF = UniqueJumpFns.size();
+      Stats.NumJFObjects = AllocatedJumpFns.size();
+      Stats.AvgJFDepth = double(TotalDepth) / double(Stats.TotalNumJF);
+      Stats.AvgUniqueJFDepth =
+          double(TotalUniqueDepth) / double(Stats.UniqueNumJF);
+      Stats.AvgJFObjDepth =
+          double(TotalAllocDepth) / double(Stats.NumJFObjects);
+    }
     return Stats;
   }
 
diff --git a/include/phasar/DataFlow/IfdsIde/Solver/JumpFunctions.h b/include/phasar/DataFlow/IfdsIde/Solver/JumpFunctions.h
index 0a9bcb3274..85a80fe604 100644
--- a/include/phasar/DataFlow/IfdsIde/Solver/JumpFunctions.h
+++ b/include/phasar/DataFlow/IfdsIde/Solver/JumpFunctions.h
@@ -18,6 +18,7 @@
 #define PHASAR_DATAFLOW_IFDSIDE_SOLVER_JUMPFUNCTIONS_H
 
 #include "phasar/DataFlow/IfdsIde/EdgeFunctionUtils.h"
+#include "phasar/Utils/ByRef.h"
 #include "phasar/Utils/Logger.h"
 #include "phasar/Utils/Table.h"
 
@@ -157,6 +158,18 @@ template <typename AnalysisDomainTy, typename Container> class JumpFunctions {
     return NonEmptyLookupByTargetNode[Target];
   }
 
+  template <typename HandlerFn>
+  void foreachEdgeFunction(HandlerFn Handler) const {
+    NonEmptyForwardLookup.foreachCell(
+        [Handler = std::move(Handler)](ByConstRef<d_t> /*Row*/,
+                                       ByConstRef<n_t> /*Col*/,
+                                       const auto &TargetFactAndEF) {
+          for (const auto &[TargetFact, EF] : TargetFactAndEF) {
+            std::invoke(Handler, EF);
+          }
+        });
+  }
+
   /**
    * Removes a jump function. The source statement is implicit.
    * @see PathEdge
diff --git a/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IDELinearConstantAnalysis.cpp b/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IDELinearConstantAnalysis.cpp
index cb87e27052..68926b7d12 100644
--- a/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IDELinearConstantAnalysis.cpp
+++ b/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IDELinearConstantAnalysis.cpp
@@ -236,7 +236,6 @@ struct BinOp {
     }
 
     // TODO: Optimize Binop::composeWith(BinOp)
-
     return LCAEdgeFunctionComposer{This, SecondFunction};
   }
 
diff --git a/lib/Utils/EdgeFunctionStats.cpp b/lib/Utils/EdgeFunctionStats.cpp
index 4beb5d9b43..141db21517 100644
--- a/lib/Utils/EdgeFunctionStats.cpp
+++ b/lib/Utils/EdgeFunctionStats.cpp
@@ -1,6 +1,7 @@
 #include "phasar/DataFlow/IfdsIde/EdgeFunctionStats.h"
 
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/Format.h"
 
 llvm::raw_ostream &psr::operator<<(llvm::raw_ostream &OS,
                                    const EdgeFunctionStats &S) {
@@ -9,18 +10,42 @@ llvm::raw_ostream &psr::operator<<(llvm::raw_ostream &OS,
   static constexpr std::array<llvm::StringRef, 3> AllocKind{
       "SmallObjectOptimized", "DefaultHeapAllocated", "CustomHeapAllocated"};
 
+  OS << "Cached Edge Functions:\n";
+
   size_t Ctr = 0;
   for (const auto &[UEF, Count] : llvm::zip(S.UniqueEFCount, S.TotalEFCount)) {
-    OS << "Kind: " << EFKind[Ctr] << ":\n";
+    OS << "  Kind: " << EFKind[Ctr] << ":\n";
     Ctr++;
 
-    OS << "  Total # EdgeFunctions: " << Count << '\n';
-    OS << "  Unique EdgeFunctions: " << UEF << '\n';
+    OS << "    Total #EdgeFunctions:\t" << Count << '\n';
+    OS << "    Unique EdgeFunctions:\t" << UEF << '\n';
   }
 
+  OS << "  AllocationPolicy:\n";
   for (auto [Count, Kind] : llvm::zip(S.PerAllocCount, AllocKind)) {
-    OS << Kind << ": " << Count << '\n';
+    OS << "    " << Kind << ":\t" << Count << '\n';
+  }
+
+  OS << "  Depth:\n";
+  OS << "    Max Depth:\t\t\t" << S.MaxDepth << '\n';
+  OS << "    Avg Depth:\t\t\t" << llvm::format("%g\n", S.AvgDepth);
+  OS << "    Avg Unique Depth:\t\t" << llvm::format("%g\n", S.AvgUniqueDepth);
+
+  OS << "Jump Functions:\n";
+  OS << "  Total #JumpFunctions:\t\t" << S.TotalNumJF << '\n';
+  OS << "  Unique JumpFunctions:\t\t" << S.UniqueNumJF << '\n';
+  OS << "  JumpFunctions Objects:\t" << S.NumJFObjects << '\n';
+
+  OS << "  AllocationPolicy:\n";
+  for (auto [Count, Kind] : llvm::zip(S.PerAllocJFCount, AllocKind)) {
+    OS << "    " << Kind << ":\t" << Count << '\n';
   }
 
+  OS << "  Depth:\n";
+  OS << "    Max Depth:\t\t\t" << S.MaxJFDepth << '\n';
+  OS << "    Avg Depth:\t\t\t" << llvm::format("%g\n", S.AvgJFDepth);
+  OS << "    Avg Unique Depth:\t\t" << llvm::format("%g\n", S.AvgUniqueJFDepth);
+  OS << "    Avg JF Object Depth:\t" << llvm::format("%g\n", S.AvgJFObjDepth);
+
   return OS;
 }

From c521f2fa1dff94c33ac7da00ab52e5cc46996f1e Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabian.schiebel@iem.fraunhofer.de>
Date: Fri, 2 Feb 2024 16:34:15 +0100
Subject: [PATCH 6/7] Apply some review comments

---
 .../IfdsIde/Solver/FlowEdgeFunctionCache.h    |  1 +
 .../DataFlow/IfdsIde/Solver/IDESolver.h       | 49 +++++++++----------
 include/phasar/Utils/Average.h                | 33 +++++++++++++
 .../Problems/IDELinearConstantAnalysis.cpp    |  3 +-
 lib/Utils/EdgeFunctionStats.cpp               | 14 +++---
 5 files changed, 63 insertions(+), 37 deletions(-)
 create mode 100644 include/phasar/Utils/Average.h

diff --git a/include/phasar/DataFlow/IfdsIde/Solver/FlowEdgeFunctionCache.h b/include/phasar/DataFlow/IfdsIde/Solver/FlowEdgeFunctionCache.h
index 4333b9521c..68a4279578 100644
--- a/include/phasar/DataFlow/IfdsIde/Solver/FlowEdgeFunctionCache.h
+++ b/include/phasar/DataFlow/IfdsIde/Solver/FlowEdgeFunctionCache.h
@@ -34,6 +34,7 @@ class Value;
 namespace psr {
 
 enum class EdgeFunctionKind { Normal, Call, Return, CallToReturn, Summary };
+static constexpr size_t EdgeFunctionKindCount = 5;
 
 template <typename KeyT> class DefaultMapKeyCompressor {
 public:
diff --git a/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h b/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h
index 30f86ab5ba..2f03ac7048 100644
--- a/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h
+++ b/include/phasar/DataFlow/IfdsIde/Solver/IDESolver.h
@@ -34,6 +34,7 @@
 #include "phasar/DataFlow/IfdsIde/Solver/PathEdge.h"
 #include "phasar/DataFlow/IfdsIde/SolverResults.h"
 #include "phasar/Domain/AnalysisDomain.h"
+#include "phasar/Utils/Average.h"
 #include "phasar/Utils/DOTGraph.h"
 #include "phasar/Utils/JoinLattice.h"
 #include "phasar/Utils/Logger.h"
@@ -263,26 +264,24 @@ class IDESolver
 
     // Cached Edge Functions
     {
-
-      std::array<llvm::DenseSet<EdgeFunction<l_t>>, 5> UniqueEFs{};
-      size_t TotalDepth = 0;
-      size_t TotalUniqueDepth = 0;
-      size_t TotalNumEF = 0;
+      std::array<llvm::DenseSet<EdgeFunction<l_t>>, EdgeFunctionKindCount>
+          UniqueEFs{};
+      Sampler DepthSampler{};
+      Sampler UniqueDepthSampler{};
       // TODO: Cache EFs
       CachedFlowEdgeFunctions.foreachCachedEdgeFunction(
           [&](EdgeFunction<l_t> EF, EdgeFunctionKind Kind) {
-            ++TotalNumEF;
             auto Depth = EF.depth();
-            TotalDepth += Depth;
+            DepthSampler.addSample(Depth);
             if (Depth > Stats.MaxDepth) {
               Stats.MaxDepth = Depth;
             }
 
-            if (UniqueEFs[int(Kind)].insert(std::move(EF)).second) {
-              TotalUniqueDepth += Depth;
+            if (UniqueEFs[size_t(Kind)].insert(std::move(EF)).second) {
+              UniqueDepthSampler.addSample(Depth);
             }
-            Stats.TotalEFCount[int(Kind)]++;
-            Stats.PerAllocCount[int(EF.getAllocationPolicy())]++;
+            Stats.TotalEFCount[size_t(Kind)]++;
+            Stats.PerAllocCount[size_t(EF.getAllocationPolicy())]++;
           });
 
       size_t TotalUniqueNumEF = 0;
@@ -291,46 +290,42 @@ class IDESolver
         TotalUniqueNumEF += UniqueEFs[I].size();
       }
 
-      Stats.AvgDepth = double(TotalDepth) / double(TotalNumEF);
-      Stats.AvgUniqueDepth =
-          double(TotalUniqueDepth) / double(TotalUniqueNumEF);
+      Stats.AvgDepth = DepthSampler.getAverage();
+      Stats.AvgUniqueDepth = UniqueDepthSampler.getAverage();
     }
 
     // Jump Functions
     {
-
       llvm::DenseSet<EdgeFunction<l_t>> UniqueJumpFns;
       llvm::DenseSet<const void *> AllocatedJumpFns;
-      size_t TotalDepth = 0;
-      size_t TotalUniqueDepth = 0;
-      size_t TotalAllocDepth = 0;
+      Sampler DepthSampler{};
+      Sampler UniqueDepthSampler{};
+      Sampler AllocDepthSampler{};
 
       JumpFn->foreachEdgeFunction([&](EdgeFunction<l_t> JF) {
         ++Stats.TotalNumJF;
         auto Depth = JF.depth();
-        TotalDepth += Depth;
+        DepthSampler.addSample(Depth);
         if (Depth > Stats.MaxJFDepth) {
           Stats.MaxJFDepth = Depth;
         }
 
         if (AllocatedJumpFns.insert(JF.getOpaqueValue()).second) {
-          TotalAllocDepth += Depth;
+          AllocDepthSampler.addSample(Depth);
         }
 
-        Stats.PerAllocJFCount[int(JF.getAllocationPolicy())]++;
+        Stats.PerAllocJFCount[size_t(JF.getAllocationPolicy())]++;
 
         if (UniqueJumpFns.insert(std::move(JF)).second) {
-          TotalUniqueDepth += Depth;
+          UniqueDepthSampler.addSample(Depth);
         }
       });
 
       Stats.UniqueNumJF = UniqueJumpFns.size();
       Stats.NumJFObjects = AllocatedJumpFns.size();
-      Stats.AvgJFDepth = double(TotalDepth) / double(Stats.TotalNumJF);
-      Stats.AvgUniqueJFDepth =
-          double(TotalUniqueDepth) / double(Stats.UniqueNumJF);
-      Stats.AvgJFObjDepth =
-          double(TotalAllocDepth) / double(Stats.NumJFObjects);
+      Stats.AvgJFDepth = DepthSampler.getAverage();
+      Stats.AvgUniqueJFDepth = UniqueDepthSampler.getAverage();
+      Stats.AvgJFObjDepth = AllocDepthSampler.getAverage();
     }
     return Stats;
   }
diff --git a/include/phasar/Utils/Average.h b/include/phasar/Utils/Average.h
new file mode 100644
index 0000000000..c6e54f0901
--- /dev/null
+++ b/include/phasar/Utils/Average.h
@@ -0,0 +1,33 @@
+/******************************************************************************
+ * Copyright (c) 2024 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel
+ *****************************************************************************/
+
+#ifndef PHASAR_UTILS_AVERAGE_H
+#define PHASAR_UTILS_AVERAGE_H
+
+#include <cstddef>
+
+namespace psr {
+
+struct Sampler {
+  size_t Count{};
+  double Curr{};
+
+  constexpr void addSample(size_t Sample) noexcept {
+    Curr += (double(Sample) - Curr) / double(++Count);
+  }
+
+  [[nodiscard]] constexpr double getAverage() const noexcept { return Curr; }
+  [[nodiscard]] constexpr size_t getNumSamples() const noexcept {
+    return Count;
+  }
+};
+
+} // namespace psr
+
+#endif // PHASAR_UTILS_AVERAGE_H
diff --git a/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IDELinearConstantAnalysis.cpp b/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IDELinearConstantAnalysis.cpp
index 68926b7d12..1836e070fc 100644
--- a/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IDELinearConstantAnalysis.cpp
+++ b/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IDELinearConstantAnalysis.cpp
@@ -25,6 +25,7 @@
 #include "phasar/Utils/TypeTraits.h"
 #include "phasar/Utils/Utilities.h"
 
+#include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/IR/AbstractCallSite.h"
 #include "llvm/IR/Constants.h"
@@ -44,8 +45,6 @@
 #include <memory>
 #include <utility>
 
-#include <llvm/ADT/Hashing.h>
-
 namespace psr {
 
 namespace lca {
diff --git a/lib/Utils/EdgeFunctionStats.cpp b/lib/Utils/EdgeFunctionStats.cpp
index 141db21517..56b85bc501 100644
--- a/lib/Utils/EdgeFunctionStats.cpp
+++ b/lib/Utils/EdgeFunctionStats.cpp
@@ -5,18 +5,16 @@
 
 llvm::raw_ostream &psr::operator<<(llvm::raw_ostream &OS,
                                    const EdgeFunctionStats &S) {
-  static constexpr std::array<llvm::StringRef, 5> EFKind{
-      "Normal", "Call", "Return", "CallToReturn", "Summary"};
-  static constexpr std::array<llvm::StringRef, 3> AllocKind{
+  static constexpr auto EFKind = {"Normal", "Call", "Return", "CallToReturn",
+                                  "Summary"};
+  static constexpr auto AllocKind = {
       "SmallObjectOptimized", "DefaultHeapAllocated", "CustomHeapAllocated"};
 
   OS << "Cached Edge Functions:\n";
 
-  size_t Ctr = 0;
-  for (const auto &[UEF, Count] : llvm::zip(S.UniqueEFCount, S.TotalEFCount)) {
-    OS << "  Kind: " << EFKind[Ctr] << ":\n";
-    Ctr++;
-
+  for (const auto &[UEF, Count, EFK] :
+       llvm::zip(S.UniqueEFCount, S.TotalEFCount, EFKind)) {
+    OS << "  Kind: " << EFK << ":\n";
     OS << "    Total #EdgeFunctions:\t" << Count << '\n';
     OS << "    Unique EdgeFunctions:\t" << UEF << '\n';
   }

From 3182d1aeddfad46a5b0b12c3204184117a1ec627 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabian.schiebel@iem.fraunhofer.de>
Date: Mon, 5 Feb 2024 09:15:20 +0100
Subject: [PATCH 7/7] More review fixes

---
 .../phasar/DataFlow/IfdsIde/EdgeFunction.h    | 20 ++++++++++---------
 .../IfdsIde/Solver/FlowEdgeFunctionCache.h    | 10 +++++-----
 2 files changed, 16 insertions(+), 14 deletions(-)

diff --git a/include/phasar/DataFlow/IfdsIde/EdgeFunction.h b/include/phasar/DataFlow/IfdsIde/EdgeFunction.h
index cf1eae3f58..7f8e98df88 100644
--- a/include/phasar/DataFlow/IfdsIde/EdgeFunction.h
+++ b/include/phasar/DataFlow/IfdsIde/EdgeFunction.h
@@ -332,7 +332,7 @@ class [[clang::trivial_abi]] EdgeFunction final : EdgeFunctionBase {
   /// details.
   ///
   [[nodiscard]] l_t computeTarget(ByConstRef<l_t> Source) const {
-    assert(!!*this && "computeTarget() called on nullptr!");
+    assert(isValid() && "computeTarget() called on nullptr!");
     return VTAndHeapAlloc.getPointer()->computeTarget(EF, Source);
   }
 
@@ -363,8 +363,8 @@ class [[clang::trivial_abi]] EdgeFunction final : EdgeFunctionBase {
   /// SecondEF.computeTarget(FirstEF.computeTarget(x)).
   [[nodiscard]] static EdgeFunction compose(const EdgeFunction &FirstEF,
                                             const EdgeFunction &SecondEF) {
-    assert(!!FirstEF && "compose() called on LHS nullptr!");
-    assert(!!SecondEF && "compose() called on RHS nullptr!");
+    assert(FirstEF.isValid() && "compose() called on LHS nullptr!");
+    assert(SecondEF.isValid() && "compose() called on RHS nullptr!");
     return FirstEF.VTAndHeapAlloc.getPointer()->compose(
         FirstEF.EF, SecondEF, FirstEF.VTAndHeapAlloc.getInt());
   }
@@ -404,8 +404,8 @@ class [[clang::trivial_abi]] EdgeFunction final : EdgeFunctionBase {
   /// connected with the value-lattice on l_t
   [[nodiscard]] static EdgeFunction join(const EdgeFunction &FirstEF,
                                          const EdgeFunction &SecondEF) {
-    assert(!!FirstEF && "join() called on LHS nullptr!");
-    assert(!!SecondEF && "join() called on RHS nullptr!");
+    assert(FirstEF.isValid() && "join() called on LHS nullptr!");
+    assert(SecondEF.isValid() && "join() called on RHS nullptr!");
     return FirstEF.VTAndHeapAlloc.getPointer()->join(
         FirstEF.EF, SecondEF, FirstEF.VTAndHeapAlloc.getInt());
   }
@@ -558,15 +558,17 @@ class [[clang::trivial_abi]] EdgeFunction final : EdgeFunctionBase {
   /// Allows for better optimizations in compose and join and should be
   /// provided, whehever this knowledge is available.
   [[nodiscard]] bool isConstant() const noexcept {
-    assert(!!*this && "isConstant() called on nullptr!");
+    assert(isValid() && "isConstant() called on nullptr!");
     return VTAndHeapAlloc.getPointer()->isConstant(EF);
   }
 
-  /// Performs a null-check. True, iff thie edge function is not null.
-  [[nodiscard]] explicit operator bool() const noexcept {
+  [[nodiscard]] bool isValid() const noexcept {
     return VTAndHeapAlloc.getOpaqueValue();
   }
 
+  /// Performs a null-check. True, iff thie edge function is not null.
+  [[nodiscard]] explicit operator bool() const noexcept { return isValid(); }
+
   /// Performs a runtime-typecheck. True, if the concrete type of the held edge
   /// function *exactly* equals ConcreteEF.
   ///
@@ -656,7 +658,7 @@ class [[clang::trivial_abi]] EdgeFunction final : EdgeFunctionBase {
   }
 
   [[nodiscard]] auto depth() const noexcept {
-    assert(!!*this && "depth() called on nullptr!");
+    assert(isValid() && "depth() called on nullptr!");
     return VTAndHeapAlloc.getPointer()->depth(EF);
   }
 
diff --git a/include/phasar/DataFlow/IfdsIde/Solver/FlowEdgeFunctionCache.h b/include/phasar/DataFlow/IfdsIde/Solver/FlowEdgeFunctionCache.h
index 68a4279578..637eaa083c 100644
--- a/include/phasar/DataFlow/IfdsIde/Solver/FlowEdgeFunctionCache.h
+++ b/include/phasar/DataFlow/IfdsIde/Solver/FlowEdgeFunctionCache.h
@@ -610,26 +610,26 @@ class FlowEdgeFunctionCache {
   template <typename Handler> void foreachCachedEdgeFunction(Handler Fn) const {
     for (const auto &[Key, NormalFns] : NormalFunctionCache) {
       for (const auto &[Set, EF] : NormalFns.EdgeFunctionMap) {
-        Fn(EF, EdgeFunctionKind::Normal);
+        std::invoke(Fn, EF, EdgeFunctionKind::Normal);
       }
     }
 
     for (const auto &[Key, EF] : CallEdgeFunctionCache) {
-      Fn(EF, EdgeFunctionKind::Call);
+      std::invoke(Fn, EF, EdgeFunctionKind::Call);
     }
 
     for (const auto &[Key, EF] : ReturnEdgeFunctionCache) {
-      Fn(EF, EdgeFunctionKind::Return);
+      std::invoke(Fn, EF, EdgeFunctionKind::Return);
     }
 
     for (const auto &[Key, CTRFns] : CallToRetEdgeFunctionCache) {
       for (const auto &[Set, EF] : CTRFns) {
-        Fn(EF, EdgeFunctionKind::CallToReturn);
+        std::invoke(Fn, EF, EdgeFunctionKind::CallToReturn);
       }
     }
 
     for (const auto &[Key, EF] : SummaryEdgeFunctionCache) {
-      Fn(EF, EdgeFunctionKind::Summary);
+      std::invoke(Fn, EF, EdgeFunctionKind::Summary);
     }
   }