Reorder Analysis Dependencies (#530)

* Swap ordering of IDE- and IFDS tabulation problem

* Adapt analysis problems to new tabulation problem (WIP)

* Continue adapting the IFDS/IDE problems to the new tabulation problem

* Complete rewriting

* Replace boost::trim with llvm::StringRef::trim

* Update myphasartool and re-sync use-phasar-as-library/myphasartool

* Vector EntryPoints

* pre-commit

* pre-commit

* make edge function overrides in IFDSTabulationProblem final, consistent with conceptual property, forbidding IFDS problem to override anything related to the edge domain

* dummy commit

* Revert "dummy commit"

This reverts commit edd65ec.

Co-authored-by: Martin Mory <mmo@mail.upb.de>
Co-authored-by: Martin Mory <linuxfan91@googlemail.com>

Author: 3 people

include/phasar/Controller/AnalysisController.h

@@ -10,14 +10,15 @@
 #ifndef PHASAR_CONTROLLER_ANALYSISCONTROLLER_H
 #define PHASAR_CONTROLLER_ANALYSISCONTROLLER_H
 
+#include "phasar/Controller/AnalysisControllerEmitterOptions.h"
 #include "phasar/DB/LLVMProjectIRDB.h"
+#include "phasar/PhasarLLVM/AnalysisStrategy/HelperAnalyses.h"
 #include "phasar/PhasarLLVM/AnalysisStrategy/Strategies.h"
-#include "phasar/PhasarLLVM/AnalysisStrategy/WholeProgramAnalysis.h"
 #include "phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h"
-#include "phasar/PhasarLLVM/ControlFlow/Resolver/CallGraphAnalysisType.h"
 #include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/IFDSIDESolverConfig.h"
 #include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Solver/IDESolver.h"
 #include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Solver/IFDSSolver.h"
+#include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Solver/SolverResults.h"
 #include "phasar/PhasarLLVM/DataFlowSolver/Mono/Solver/InterMonoSolver.h"
 #include "phasar/PhasarLLVM/DataFlowSolver/Mono/Solver/IntraMonoSolver.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMBasedPointsToAnalysis.h"
@@ -35,31 +36,9 @@
 
 namespace psr {
 
-enum class AnalysisControllerEmitterOptions : uint32_t {
-  None = 0,
-  EmitIR = (1 << 0),
-  EmitRawResults = (1 << 1),
-  EmitTextReport = (1 << 2),
-  EmitGraphicalReport = (1 << 3),
-  EmitESGAsDot = (1 << 4),
-  EmitTHAsText = (1 << 5),
-  EmitTHAsDot = (1 << 6),
-  EmitTHAsJson = (1 << 7),
-  // EmitCGAsText = (1 << 8),
-  EmitCGAsDot = (1 << 9),
-  // EmitCGAsJson = (1 << 10),
-  EmitPTAAsText = (1 << 11),
-  EmitPTAAsDot = (1 << 12),
-  EmitPTAAsJson = (1 << 13),
-  EmitStatisticsAsJson = (1 << 14),
-};
-
 class AnalysisController {
 private:
-  LLVMProjectIRDB &IRDB;
-  LLVMTypeHierarchy TH;
-  LLVMPointsToSet PT;
-  LLVMBasedICFG ICF;
+  HelperAnalyses &HA;
   std::vector<DataFlowAnalysisType> DataFlowAnalyses;
   std::vector<std::string> AnalysisConfigs;
   std::vector<std::string> EntryPoints;
@@ -69,8 +48,6 @@ class AnalysisController {
   std::string ProjectID;
   std::filesystem::path ResultDirectory;
   IFDSIDESolverConfig SolverConfig;
-  [[maybe_unused]] Soundness SoundnessLevel;
-  [[maybe_unused]] bool AutoGlobalSupport;
 
   ///
   /// \brief The maximum length of the CallStrings used in the InterMonoSolver
@@ -106,79 +83,64 @@ class AnalysisController {
   void executeInterMonoSolverTest();
   void executeInterMonoTaint();
 
-  template <typename AnalysisTy, bool WithConfig = false>
-  void executeIntraMonoAnalysis() {
-    executeAnalysis<IntraMonoSolver_P<AnalysisTy>, AnalysisTy, WithConfig>();
+  template <typename ProblemTy>
+  void executeIntraMonoAnalysis(ProblemTy &Problem) {
+    IntraMonoSolver Solver(Problem);
+    Solver.solve();
+    emitRequestedDataFlowResults(Solver);
   }
 
-  template <typename AnalysisTy, bool WithConfig = false>
-  void executeInterMonoAnalysis() {
-    executeAnalysis<InterMonoSolver_P<AnalysisTy, 3>, AnalysisTy, WithConfig>();
+  template <typename ProblemTy>
+  void executeInterMonoAnalysis(ProblemTy &Problem) {
+    InterMonoSolver_P<ProblemTy, 3> Solver(Problem);
+    Solver.solve();
+    emitRequestedDataFlowResults(Solver);
   }
 
-  template <typename AnalysisTy, bool WithConfig = false>
-  void executeIFDSAnalysis() {
-    executeAnalysis<IFDSSolver_P<AnalysisTy>, AnalysisTy, WithConfig>();
+  template <typename ProblemTy> void executeIFDSAnalysis(ProblemTy &Problem) {
+    IFDSSolver Solver(Problem, &HA.getICFG());
+    Solver.solve();
+    emitRequestedDataFlowResults(Solver);
   }
 
-  template <typename AnalysisTy, bool WithConfig = false>
-  void executeIDEAnalysis() {
-    executeAnalysis<IDESolver_P<AnalysisTy>, AnalysisTy, WithConfig>();
+  template <typename ProblemTy> void executeIDEAnalysis(ProblemTy &Problem) {
+    IDESolver Solver(Problem, &HA.getICFG());
+    Solver.solve();
+    emitRequestedDataFlowResults(Solver);
   }
 
-  template <class Solver_P, typename AnalysisTy, bool WithConfig>
-  void executeAnalysis() {
-    if constexpr (WithConfig) {
-      std::string AnalysisConfigPath =
-          !AnalysisConfigs.empty() ? AnalysisConfigs[0] : "";
-      auto Config =
-          !AnalysisConfigPath.empty()
-              ? TaintConfig(IRDB, parseTaintConfig(AnalysisConfigPath))
-              : TaintConfig(IRDB);
-      WholeProgramAnalysis<Solver_P, AnalysisTy> WPA(
-          SolverConfig, IRDB, &Config, EntryPoints, &PT, &ICF, &TH);
-      WPA.solve();
-      emitRequestedDataFlowResults(WPA);
-      WPA.releaseAllHelperAnalyses();
-    } else {
-      WholeProgramAnalysis<Solver_P, AnalysisTy> WPA(
-          SolverConfig, IRDB, EntryPoints, &PT, &ICF, &TH);
-      WPA.solve();
-      emitRequestedDataFlowResults(WPA);
-      WPA.releaseAllHelperAnalyses();
-    }
-  }
+  TaintConfig makeTaintConfig();
 
-  template <typename T> void emitRequestedDataFlowResults(T &WPA) {
+  template <typename T> void emitRequestedDataFlowResults(T &Solver) {
     if (EmitterOptions & AnalysisControllerEmitterOptions::EmitTextReport) {
       if (!ResultDirectory.empty()) {
         if (auto OFS =
                 openFileStream(ResultDirectory.string() + "/psr-report.txt")) {
-          WPA.emitTextReport(*OFS);
+          Solver.emitTextReport(*OFS);
         }
       } else {
-        WPA.emitTextReport(llvm::outs());
+        Solver.emitTextReport(llvm::outs());
       }
     }
     if (EmitterOptions &
         AnalysisControllerEmitterOptions::EmitGraphicalReport) {
       if (!ResultDirectory.empty()) {
         if (auto OFS =
                 openFileStream(ResultDirectory.string() + "/psr-report.html")) {
-          WPA.emitGraphicalReport(*OFS);
+          Solver.emitGraphicalReport(*OFS);
         }
       } else {
-        WPA.emitGraphicalReport(llvm::outs());
+        Solver.emitGraphicalReport(llvm::outs());
       }
     }
     if (EmitterOptions & AnalysisControllerEmitterOptions::EmitRawResults) {
       if (!ResultDirectory.empty()) {
         if (auto OFS = openFileStream(ResultDirectory.string() +
                                       "/psr-raw-results.txt")) {
-          WPA.dumpResults(*OFS);
+          Solver.dumpResults(*OFS);
         }
       } else {
-        WPA.dumpResults(llvm::outs());
+        Solver.dumpResults(llvm::outs());
       }
     }
     if (EmitterOptions & AnalysisControllerEmitterOptions::EmitESGAsDot) {
@@ -188,18 +150,14 @@ class AnalysisController {
   }
 
 public:
-  AnalysisController(LLVMProjectIRDB &IRDB,
-                     std::vector<DataFlowAnalysisType> DataFlowAnalyses,
-                     std::vector<std::string> AnalysisConfigs,
-                     PointerAnalysisType PTATy, CallGraphAnalysisType CGTy,
-                     Soundness SoundnessLevel, bool AutoGlobalSupport,
-                     std::vector<std::string> EntryPoints,
-                     AnalysisStrategy Strategy,
-                     AnalysisControllerEmitterOptions EmitterOptions,
-                     IFDSIDESolverConfig SolverConfig,
-                     const std::string &ProjectID = "default-phasar-project",
-                     std::filesystem::path OutDirectory = {},
-                     const nlohmann::json &PrecomputedPointsToInfo = {});
+  explicit AnalysisController(
+      HelperAnalyses &HA, std::vector<DataFlowAnalysisType> DataFlowAnalyses,
+      std::vector<std::string> AnalysisConfigs,
+      std::vector<std::string> EntryPoints, AnalysisStrategy Strategy,
+      AnalysisControllerEmitterOptions EmitterOptions,
+      IFDSIDESolverConfig SolverConfig,
+      const std::string &ProjectID = "default-phasar-project",
+      const std::string &OutDirectory = "");
 
   ~AnalysisController() = default;
 
@@ -209,6 +167,13 @@ class AnalysisController {
   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);
+  }
 };
 
 } // namespace psr

include/phasar/Controller/AnalysisControllerEmitterOptions.h

@@ -0,0 +1,35 @@
+/******************************************************************************
+ * Copyright (c) 2022 Philipp Schubert.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Philipp Schubert and others
+ *****************************************************************************/
+
+#ifndef PHASAR_CONTROLLER_ANALYSISCONTROLLEREMITTEROPTIONS_H
+#define PHASAR_CONTROLLER_ANALYSISCONTROLLEREMITTEROPTIONS_H
+
+namespace psr {
+enum class AnalysisControllerEmitterOptions {
+  None = 0,
+  EmitIR = (1 << 0),
+  EmitRawResults = (1 << 1),
+  EmitTextReport = (1 << 2),
+  EmitGraphicalReport = (1 << 3),
+  EmitESGAsDot = (1 << 4),
+  EmitTHAsText = (1 << 5),
+  EmitTHAsDot = (1 << 6),
+  EmitTHAsJson = (1 << 7),
+  EmitCGAsText = (1 << 8),
+  EmitCGAsDot = (1 << 9),
+  EmitCGAsJson = (1 << 10),
+  EmitPTAAsText = (1 << 11),
+  EmitPTAAsDot = (1 << 12),
+  EmitPTAAsJson = (1 << 13),
+  EmitStatisticsAsText = (1 << 14),
+  EmitStatisticsAsJson = (1 << 15),
+};
+} // namespace psr
+
+#endif // PHASAR_CONTROLLER_ANALYSISCONTROLLEREMITTEROPTIONS_H

include/phasar/PhasarLLVM/AnalysisStrategy/HelperAnalyses.h

@@ -0,0 +1,69 @@
+/******************************************************************************
+ * Copyright (c) 2022 Philipp Schubert.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel, Philipp Schubert and others
+ *****************************************************************************/
+
+#ifndef PHASAR_PHASARLLVM_ANALYSISSTRATEGY_HELPERANALYSES_H_
+#define PHASAR_PHASARLLVM_ANALYSISSTRATEGY_HELPERANALYSES_H_
+
+#include "phasar/PhasarLLVM/AnalysisStrategy/HelperAnalysisConfig.h"
+
+#include "nlohmann/json.hpp"
+
+#include <memory>
+#include <optional>
+#include <set>
+#include <vector>
+
+namespace psr {
+class LLVMProjectIRDB;
+class LLVMTypeHierarchy;
+class LLVMBasedICFG;
+class LLVMPointsToInfo;
+
+class HelperAnalyses { // NOLINT(cppcoreguidelines-special-member-functions)
+public:
+  explicit HelperAnalyses(std::string IRFile,
+                          std::optional<nlohmann::json> PrecomputedPTS,
+                          PointerAnalysisType PTATy, bool AllowLazyPTS,
+                          std::vector<std::string> EntryPoints,
+                          CallGraphAnalysisType CGTy, Soundness SoundnessLevel,
+                          bool AutoGlobalSupport);
+
+  explicit HelperAnalyses(std::string IRFile,
+                          std::vector<std::string> EntryPoints,
+                          HelperAnalysisConfig Config = {});
+  ~HelperAnalyses();
+
+  LLVMProjectIRDB &getProjectIRDB();
+  LLVMPointsToInfo &getPointsToInfo();
+  LLVMTypeHierarchy &getTypeHierarchy();
+  LLVMBasedICFG &getICFG();
+
+private:
+  std::unique_ptr<LLVMProjectIRDB> IRDB;
+  std::unique_ptr<LLVMPointsToInfo> PT;
+  std::unique_ptr<LLVMTypeHierarchy> TH;
+  std::unique_ptr<LLVMBasedICFG> ICF;
+
+  // IRDB
+  std::string IRFile;
+
+  // PTS
+  std::optional<nlohmann::json> PrecomputedPTS;
+  PointerAnalysisType PTATy{};
+  bool AllowLazyPTS{};
+
+  // ICF
+  std::vector<std::string> EntryPoints;
+  CallGraphAnalysisType CGTy{};
+  Soundness SoundnessLevel{};
+  bool AutoGlobalSupport{};
+};
+} // namespace psr
+
+#endif // PHASAR_PHASARLLVM_ANALYSISSTRATEGY_HELPERANALYSES_H_

include/phasar/PhasarLLVM/AnalysisStrategy/HelperAnalysisConfig.h

@@ -0,0 +1,32 @@
+/******************************************************************************
+ * Copyright (c) 2022 Philipp Schubert.
+ * 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_PHASARLLVM_ANALYSISSTRATEGY_HELPERANALYSISCONFIG_H
+#define PHASAR_PHASARLLVM_ANALYSISSTRATEGY_HELPERANALYSISCONFIG_H
+
+#include "phasar/PhasarLLVM/ControlFlow/Resolver/CallGraphAnalysisType.h"
+#include "phasar/PhasarLLVM/Pointer/PointerAnalysisType.h"
+
+#include "nlohmann/json.hpp"
+#include "phasar/Utils/Soundness.h"
+
+#include <optional>
+
+namespace psr {
+struct HelperAnalysisConfig {
+  std::optional<nlohmann::json> PrecomputedPTS = std::nullopt;
+  PointerAnalysisType PTATy = PointerAnalysisType::CFLAnders;
+  CallGraphAnalysisType CGTy = CallGraphAnalysisType::OTF;
+  Soundness SoundnessLevel = Soundness::Soundy;
+  bool AutoGlobalSupport = true;
+  bool AllowLazyPTS = true;
+};
+} // namespace psr
+
+#endif // PHASAR_PHASARLLVM_ANALYSISSTRATEGY_HELPERANALYSISCONFIG_H