SolverConfig Parametrization

include/phasar/Controller/AnalysisController.h

@@ -20,6 +20,7 @@
 #include "phasar/DB/ProjectIRDB.h"
 #include "phasar/PhasarLLVM/AnalysisStrategy/Strategies.h"
 #include "phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h"
+#include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/IFDSIDESolverConfig.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMBasedPointsToAnalysis.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMPointsToSet.h"
 #include "phasar/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchy.h"
@@ -62,6 +63,7 @@ class AnalysisController {
   std::string ProjectID;
   std::string OutDirectory;
   boost::filesystem::path ResultDirectory;
+  IFDSIDESolverConfig SolverConfig;
   [[maybe_unused]] Soundness SoundnessLevel;
   [[maybe_unused]] bool AutoGlobalSupport;
 
@@ -122,6 +124,7 @@ class AnalysisController {
                      const std::set<std::string> &EntryPoints,
                      AnalysisStrategy Strategy,
                      AnalysisControllerEmitterOptions EmitterOptions,
+                     IFDSIDESolverConfig SolverConfig,
                      const std::string &ProjectID = "default-phasar-project",
                      const std::string &OutDirectory = "");
 

include/phasar/PhasarLLVM/AnalysisStrategy/WholeProgramAnalysis.h

@@ -19,6 +19,8 @@
 
 #include "phasar/DB/ProjectIRDB.h"
 #include "phasar/PhasarLLVM/AnalysisStrategy/AnalysisSetup.h"
+#include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/IFDSIDESolverConfig.h"
+#include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Solver/IDESolver.h"
 
 namespace psr {
 
@@ -51,7 +53,7 @@ class WholeProgramAnalysis {
   Solver DataFlowSolver;
 
 public:
-  WholeProgramAnalysis(ProjectIRDB &IRDB,
+  WholeProgramAnalysis(IFDSIDESolverConfig SolverConfig, ProjectIRDB &IRDB,
                        std::set<std::string> EntryPoints = {},
                        PointerAnalysisTy *PointerInfo = nullptr,
                        CallGraphAnalysisTy *CallGraph = nullptr,
@@ -70,12 +72,17 @@ class WholeProgramAnalysis {
                       : std::unique_ptr<CallGraphAnalysisTy>(CallGraph)),
         EntryPoints(EntryPoints),
         ProblemDesc(&IRDB, TypeHierarchy, CallGraph, PointerInfo, EntryPoints),
-        DataFlowSolver(ProblemDesc) {}
+        DataFlowSolver(ProblemDesc) {
+    if constexpr (has_setIFDSIDESolverConfig_v<ProblemDescription>) {
+      ProblemDesc.setIFDSIDESolverConfig(SolverConfig);
+    }
+  }
 
   template <typename T = ProblemDescription,
             typename = typename std::enable_if_t<!std::is_same_v<
                 typename T::ConfigurationTy, HasNoConfigurationType>>>
-  WholeProgramAnalysis(ProjectIRDB &IRDB, ConfigurationTy *Config,
+  WholeProgramAnalysis(IFDSIDESolverConfig SolverConfig, ProjectIRDB &IRDB,
+                       ConfigurationTy *Config,
                        std::set<std::string> EntryPoints = {},
                        PointerAnalysisTy *PointerInfo = nullptr,
                        CallGraphAnalysisTy *CallGraph = nullptr,
@@ -95,12 +102,17 @@ class WholeProgramAnalysis {
         EntryPoints(EntryPoints), Config(Config),
         ProblemDesc(&IRDB, TypeHierarchy, CallGraph, PointerInfo, *Config,
                     EntryPoints),
-        DataFlowSolver(ProblemDesc) {}
+        DataFlowSolver(ProblemDesc) {
+    if constexpr (has_setIFDSIDESolverConfig_v<ProblemDescription>) {
+      ProblemDesc.setIFDSIDESolverConfig(SolverConfig);
+    }
+  }
 
   template <typename T = ProblemDescription,
             typename = typename std::enable_if_t<!std::is_same_v<
                 typename T::ConfigurationTy, HasNoConfigurationType>>>
-  WholeProgramAnalysis(ProjectIRDB &IRDB, std::string ConfigPath,
+  WholeProgramAnalysis(IFDSIDESolverConfig SolverConfig, ProjectIRDB &IRDB,
+                       std::string ConfigPath,
                        std::set<std::string> EntryPoints = {},
                        PointerAnalysisTy *PointerInfo = nullptr,
                        CallGraphAnalysisTy *CallGraph = nullptr,
@@ -121,7 +133,11 @@ class WholeProgramAnalysis {
         OwnsConfig(true), ConfigPath(ConfigPath),
         ProblemDesc(&IRDB, TypeHierarchy, CallGraph, PointerInfo, *Config,
                     EntryPoints),
-        DataFlowSolver(ProblemDesc) {}
+        DataFlowSolver(ProblemDesc) {
+    if constexpr (has_setIFDSIDESolverConfig_v<ProblemDescription>) {
+      ProblemDesc.setIFDSIDESolverConfig(SolverConfig);
+    }
+  }
 
   WholeProgramAnalysis(const WholeProgramAnalysis &) = delete;
   WholeProgramAnalysis(WholeProgramAnalysis &&) = delete;

include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/IFDSIDESolverConfig.h

@@ -22,7 +22,6 @@
 #include "phasar/Config/Configuration.h"
 #include "phasar/Utils/EnumFlags.h"
 #include "phasar/Utils/Logger.h"
-#include "phasar/Utils/Utilities.h"
 
 namespace psr {
 
@@ -39,13 +38,14 @@ enum class SolverConfigOptions : uint32_t {
 };
 
 struct IFDSIDESolverConfig {
-  IFDSIDESolverConfig();
-  IFDSIDESolverConfig(SolverConfigOptions Options);
+  IFDSIDESolverConfig() noexcept = default;
+  IFDSIDESolverConfig(SolverConfigOptions Options) noexcept;
   ~IFDSIDESolverConfig() = default;
-  IFDSIDESolverConfig(const IFDSIDESolverConfig &) = default;
-  IFDSIDESolverConfig &operator=(const IFDSIDESolverConfig &) = default;
-  IFDSIDESolverConfig(IFDSIDESolverConfig &&) = default;
-  IFDSIDESolverConfig &operator=(IFDSIDESolverConfig &&) = default;
+  IFDSIDESolverConfig(const IFDSIDESolverConfig &) noexcept = default;
+  IFDSIDESolverConfig &
+  operator=(const IFDSIDESolverConfig &) noexcept = default;
+  IFDSIDESolverConfig(IFDSIDESolverConfig &&) noexcept = default;
+  IFDSIDESolverConfig &operator=(IFDSIDESolverConfig &&) noexcept = default;
 
   [[nodiscard]] bool followReturnsPastSeeds() const;
   [[nodiscard]] bool autoAddZero() const;
@@ -61,6 +61,8 @@ struct IFDSIDESolverConfig {
   void setEmitESG(bool Set = true);
   void setComputePersistedSummaries(bool Set = true);
 
+  void setConfig(SolverConfigOptions Opt);
+
   friend std::ostream &operator<<(std::ostream &OS,
                                   const IFDSIDESolverConfig &SC);
 

include/phasar/Utils/TypeTraits.h

@@ -15,6 +15,8 @@
 #include <type_traits>
 #include <variant>
 
+#include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/IFDSIDESolverConfig.h"
+
 #include "llvm/Support/raw_ostream.h"
 
 namespace psr {
@@ -75,6 +77,13 @@ template <typename T>
 struct is_llvm_hashable<T, decltype(hash_value(std::declval<T>()))> // NOLINT
     : std::true_type {};
 
+template <typename T, typename = void>
+struct has_setIFDSIDESolverConfig : std::false_type {};
+template <typename T>
+struct has_setIFDSIDESolverConfig<
+    T, decltype(std::declval<T>().setIFDSIDESolverConfig(
+           std::declval<IFDSIDESolverConfig>()))> : std::true_type {};
+
 } // namespace detail
 
 template <typename T>
@@ -111,6 +120,10 @@ template <typename T>
 constexpr bool is_llvm_hashable_v = // NOLINT
     detail::is_llvm_hashable<T>::value;
 
+template <typename T>
+constexpr bool has_setIFDSIDESolverConfig_v = // NOLINT
+    detail::has_setIFDSIDESolverConfig<T>::value;
+
 template <typename T> struct is_variant : std::false_type {}; // NOLINT
 
 template <typename... Args>

include/phasar/Utils/Utilities.h

@@ -197,41 +197,48 @@ It remove_by_index(It First, EndIt Last, IdxIt FirstIndex, IdxEndIt LastIndex) {
   if (FirstIndex == LastIndex || First == Last) {
     return Last;
   }
-  First = std::next(First, *FirstIndex);
-  if (First == Last) {
-    return First;
-  }
-
-  auto CurrIdx = *FirstIndex;
 
   if constexpr (std::is_same_v<It, EndIt> &&
                 std::is_same_v<
                     std::random_access_iterator_tag,
                     typename std::iterator_traits<It>::iterator_category>) {
-    size_t GapSize = 1;
-    auto Curr = First + 1;
+    /// Random-access version inspired from
+    /// "https://codereview.stackexchange.com/a/207056" and slightly changed
 
+    auto Bounds = size_t(std::distance(First, Last));
+    auto Out = std::next(First, *FirstIndex);
+    auto In = std::next(Out);
     while (++FirstIndex != LastIndex) {
-      auto Offset = *FirstIndex - CurrIdx - 1;
-      if (Offset >= std::distance(Curr, Last)) {
+      auto CurrIdx = *FirstIndex;
+      if (*std::prev(FirstIndex) + 1 == CurrIdx) {
+        ++In;
+        continue;
+      }
+      if (LLVM_UNLIKELY(CurrIdx >= Bounds)) {
         break;
       }
-      First = std::move(Curr, Curr + Offset, First); // NOLINT
-      CurrIdx = *FirstIndex;
-      Curr = First + ++GapSize;
-    }
 
-    return std::move(Curr, Last, First); // NOLINT
-  }
-  for (auto I = First; I != Last; ++CurrIdx, ++I) {
-    if (CurrIdx != *FirstIndex) {
-      *First++ = std::move(*I);
-      if (++FirstIndex == LastIndex) {
-        return std::move(std::next(I), Last, First);
+      auto Tar = std::next(First, CurrIdx);
+      Out = std::move(In, Tar, Out);
+      In = std::next(Tar);
+    }
+    return std::move(In, Last, Out);
+  } else {
+    auto CurrIdx = *FirstIndex;
+    First = std::next(First, CurrIdx);
+    if (First == Last) {
+      return First;
+    }
+    for (auto I = First; I != Last; ++CurrIdx, ++I) {
+      if (CurrIdx != *FirstIndex) {
+        *First++ = std::move(*I);
+        if (++FirstIndex == LastIndex) {
+          return std::move(std::next(I), Last, First);
+        }
       }
     }
+    return First;
   }
-  return First;
 }
 
 template <typename Container, typename IdxIt,