Refactor AnalysisPrinter to take a llvm::raw_ostream& in onFinalize() and provide a sensible default for LLVM-based analyses.

Fixes missing emit-text-report output in phasar-cli

Author: fabianbs96

include/phasar/DataFlow/IfdsIde/IDETabulationProblem.h

@@ -18,13 +18,17 @@
 #include "phasar/DataFlow/IfdsIde/IFDSIDESolverConfig.h"
 #include "phasar/DataFlow/IfdsIde/InitialSeeds.h"
 #include "phasar/DataFlow/IfdsIde/Solver/GenericSolverResults.h"
-#include "phasar/DataFlow/IfdsIde/SolverResults.h"
+#include "phasar/Utils/DefaultAnalysisPrinterSelector.h"
 #include "phasar/Utils/JoinLattice.h"
+#include "phasar/Utils/MaybeUniquePtr.h"
 #include "phasar/Utils/NullAnalysisPrinter.h"
 #include "phasar/Utils/SemiRing.h"
 #include "phasar/Utils/Soundness.h"
 
+#include "llvm/Support/raw_ostream.h"
+
 #include <cassert>
+#include <memory>
 #include <optional>
 #include <set>
 #include <string>
@@ -96,20 +100,28 @@ class IDETabulationProblem : public FlowFunctions<AnalysisDomainTy, Container>,
           ZeroValue) noexcept(std::is_nothrow_move_constructible_v<d_t>)
       : IRDB(IRDB), EntryPoints(std::move(EntryPoints)),
         ZeroValue(std::move(ZeroValue)),
-        Printer(NullAnalysisPrinter<AnalysisDomainTy>::getInstance()) {
+        Printer(std::make_unique<typename DefaultAnalysisPrinterSelector<
+                    AnalysisDomainTy>::type>()) {
     assert(IRDB != nullptr);
   }
 
-  void setAnalysisPrinter(AnalysisPrinterBase<AnalysisDomainTy> *P) {
+  IDETabulationProblem(IDETabulationProblem &&) noexcept = default;
+  IDETabulationProblem &operator=(IDETabulationProblem &&) noexcept = default;
+
+  IDETabulationProblem(const IDETabulationProblem &) = delete;
+  IDETabulationProblem &operator=(const IDETabulationProblem &) = delete;
+
+  ~IDETabulationProblem() override = default;
+
+  void
+  setAnalysisPrinter(MaybeUniquePtr<AnalysisPrinterBase<AnalysisDomainTy>> P) {
     if (P) {
-      Printer = P;
+      Printer = std::move(P);
     } else {
       Printer = NullAnalysisPrinter<AnalysisDomainTy>::getInstance();
     }
   }
 
-  ~IDETabulationProblem() override = default;
-
   /// Checks if the given data-flow fact is the special tautological lambda (or
   /// zero) fact.
   [[nodiscard]] virtual bool isZeroValue(d_t FlowFact) const noexcept {
@@ -148,7 +160,7 @@ class IDETabulationProblem : public FlowFunctions<AnalysisDomainTy, Container>,
   virtual void
   emitTextReport([[maybe_unused]] GenericSolverResults<n_t, d_t, l_t> Results,
                  llvm::raw_ostream &OS = llvm::outs()) {
-    OS << "No text report available!\n";
+    Printer->onFinalize(OS);
   }
 
   /// Generates a graphical report, e.g. in html or other markup languages, of
@@ -163,7 +175,9 @@ class IDETabulationProblem : public FlowFunctions<AnalysisDomainTy, Container>,
   /// the level of soundness is ignored. Otherwise, true.
   virtual bool setSoundness(Soundness /*S*/) { return false; }
 
-  const ProjectIRDBBase<db_t> *getProjectIRDB() const noexcept { return IRDB; }
+  [[nodiscard]] const ProjectIRDBBase<db_t> *getProjectIRDB() const noexcept {
+    return IRDB;
+  }
 
 protected:
   typename FlowFunctions<AnalysisDomainTy, Container>::FlowFunctionPtrType
@@ -172,6 +186,19 @@ class IDETabulationProblem : public FlowFunctions<AnalysisDomainTy, Container>,
         std::move(FactToGenerate), getZeroValue());
   }
 
+  template <typename L = l_t>
+  std::enable_if_t<!std::is_same_v<std::decay_t<L>, psr::BinaryDomain>>
+  onResult(n_t Instr, d_t DfFact, l_t LatticeElement,
+           DataFlowAnalysisType AnalysisType) {
+    Printer->onResult(Instr, std::move(DfFact), std::move(LatticeElement),
+                      AnalysisType);
+  }
+  template <typename L = l_t>
+  std::enable_if_t<std::is_same_v<std::decay_t<L>, psr::BinaryDomain>>
+  onResult(n_t Instr, d_t DfFact, DataFlowAnalysisType AnalysisType) {
+    Printer->onResult(Instr, std::move(DfFact), AnalysisType);
+  }
+
   /// Seeds that just start with ZeroValue and bottomElement() at the starting
   /// points of each EntryPoint function.
   /// Takes the __ALL__ EntryPoint into account.
@@ -196,7 +223,7 @@ class IDETabulationProblem : public FlowFunctions<AnalysisDomainTy, Container>,
 
   [[maybe_unused]] Soundness SF = Soundness::Soundy;
 
-  AnalysisPrinterBase<AnalysisDomainTy> *Printer;
+  MaybeUniquePtr<AnalysisPrinterBase<AnalysisDomainTy>> Printer;
 };
 
 } // namespace psr

include/phasar/DataFlow/IfdsIde/IFDSTabulationProblem.h

@@ -59,6 +59,13 @@ class IFDSTabulationProblem
                                  std::vector<std::string> EntryPoints,
                                  d_t ZeroValue)
       : Base(IRDB, std::move(EntryPoints), std::move(ZeroValue)) {}
+
+  IFDSTabulationProblem(IFDSTabulationProblem &&) noexcept = default;
+  IFDSTabulationProblem &operator=(IFDSTabulationProblem &&) noexcept = default;
+
+  IFDSTabulationProblem(const IFDSTabulationProblem &) = delete;
+  IFDSTabulationProblem &operator=(const IFDSTabulationProblem &) = delete;
+
   ~IFDSTabulationProblem() override = default;
 
   EdgeFunction<l_t> getNormalEdgeFunction(n_t /*Curr*/, d_t /*CurrNode*/,

include/phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IDETypeStateAnalysis.h

@@ -54,6 +54,14 @@ class IDETypeStateAnalysisBase
 public:
   virtual ~IDETypeStateAnalysisBase() = default;
 
+  IDETypeStateAnalysisBase(IDETypeStateAnalysisBase &&) noexcept = default;
+  IDETypeStateAnalysisBase &
+  operator=(IDETypeStateAnalysisBase &&) noexcept = default;
+
+  IDETypeStateAnalysisBase(const IDETypeStateAnalysisBase &) = delete;
+  IDETypeStateAnalysisBase &
+  operator=(const IDETypeStateAnalysisBase &) noexcept = delete;
+
 protected:
   IDETypeStateAnalysisBase(LLVMAliasInfoRef PT) noexcept : PT(PT) {}
 
@@ -195,8 +203,7 @@ class IDETypeStateAnalysis
     }
 
     [[no_unique_address]] std::conditional_t<HasJoinLatticeTraits<l_t>,
-                                             EmptyType, l_t>
-        BotElement{};
+                                             EmptyType, l_t> BotElement{};
 
     static EdgeFunction<l_t> join(EdgeFunctionRef<TSEdgeFunctionComposer> This,
                                   const EdgeFunction<l_t> &OtherFunction) {
@@ -348,8 +355,6 @@ class IDETypeStateAnalysis
     assert(PT);
   }
 
-  ~IDETypeStateAnalysis() override = default;
-
   // start formulating our analysis by specifying the parts required for IFDS
 
   FlowFunctionPtrType getNormalFlowFunction(n_t Curr, n_t Succ) override {
@@ -513,40 +518,27 @@ class IDETypeStateAnalysis
 
   void emitTextReport(GenericSolverResults<n_t, d_t, l_t> SR,
                       llvm::raw_ostream &OS = llvm::outs()) override {
-    LLVMBasedCFG CFG;
+
     for (const auto &F : this->IRDB->getAllFunctions()) {
       for (const auto &BB : *F) {
         for (const auto &I : BB) {
           auto Results = SR.resultsAt(&I, true);
 
-          if (CFG.isExitInst(&I)) {
-            for (auto Res : Results) {
-              if (const auto *Alloca =
-                      llvm::dyn_cast<llvm::AllocaInst>(Res.first)) {
-                if (Res.second == TSD->error()) {
-                  // ERROR STATE DETECTED
-                  this->Printer->onResult(&I, Res.first, TSD->error(),
-                                          TSD->analysisType());
-                }
-              }
-            }
-          } else {
-            for (auto Res : Results) {
-              if (const auto *Alloca =
-                      llvm::dyn_cast<llvm::AllocaInst>(Res.first)) {
-                if (Res.second == TSD->error()) {
-                  // ERROR STATE DETECTED
-                  this->Printer->onResult(&I, Res.first, TSD->error(),
-                                          TSD->analysisType());
-                }
+          for (auto Res : Results) {
+            if (const auto *Alloca =
+                    llvm::dyn_cast<llvm::AllocaInst>(Res.first)) {
+              if (Res.second == TSD->error()) {
+                // ERROR STATE DETECTED
+                this->onResult(&I, Res.first, TSD->error(),
+                               TSD->analysisType());
               }
             }
           }
         }
       }
     }
 
-    this->Printer->onFinalize();
+    this->Printer->onFinalize(OS);
   }
 
   [[nodiscard]] bool

include/phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSConstAnalysis.h

@@ -49,8 +49,6 @@ class IFDSConstAnalysis
   IFDSConstAnalysis(const LLVMProjectIRDB *IRDB, LLVMAliasInfoRef PT,
                     std::vector<std::string> EntryPoints = {"main"});
 
-  ~IFDSConstAnalysis() override = default;
-
   /**
    * If the current instruction is a store instruction, the memory locations's
    * state of initialization is checked. If the memory location was already

include/phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSTaintAnalysis.h

@@ -58,8 +58,6 @@ class IFDSTaintAnalysis
                     std::vector<std::string> EntryPoints = {"main"},
                     bool TaintMainArgs = true);
 
-  ~IFDSTaintAnalysis() override = default;
-
   FlowFunctionPtrType getNormalFlowFunction(n_t Curr, n_t Succ) override;
 
   FlowFunctionPtrType getCallFlowFunction(n_t CallSite, f_t DestFun) override;

include/phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSUninitializedVariables.h

@@ -40,8 +40,6 @@ class IFDSUninitializedVariables
   IFDSUninitializedVariables(const LLVMProjectIRDB *IRDB,
                              std::vector<std::string> EntryPoints = {"main"});
 
-  ~IFDSUninitializedVariables() override = default;
-
   FlowFunctionPtrType getNormalFlowFunction(n_t Curr, n_t Succ) override;
 
   FlowFunctionPtrType getCallFlowFunction(n_t CallSite, f_t DestFun) override;

include/phasar/PhasarLLVM/Domain/LLVMAnalysisDomain.h

@@ -11,6 +11,9 @@
 #define PHASAR_PHASARLLVM_DOMAIN_LLVMANALYSISDOMAIN_H
 
 #include "phasar/Domain/AnalysisDomain.h"
+#include "phasar/PhasarLLVM/Utils/LLVMAnalysisPrinter.h"
+#include "phasar/Utils/DefaultAnalysisPrinterSelector.h"
+#include "phasar/Utils/TypeTraits.h"
 
 namespace llvm {
 class Value;
@@ -43,6 +46,13 @@ struct LLVMAnalysisDomainDefault : public AnalysisDomain {
 using LLVMIFDSAnalysisDomainDefault =
     WithBinaryValueDomain<LLVMAnalysisDomainDefault>;
 
+extern template class DefaultLLVMAnalysisPrinter<LLVMIFDSAnalysisDomainDefault>;
+
+template <>
+struct DefaultAnalysisPrinterSelector<LLVMIFDSAnalysisDomainDefault>
+    : type_identity<DefaultLLVMAnalysisPrinter<LLVMIFDSAnalysisDomainDefault>> {
+};
+
 } // namespace psr
 
 #endif // PHASAR_PHASARLLVM_DOMAIN_LLVMANALYSISDOMAIN_H

include/phasar/PhasarLLVM/Utils/LLVMAnalysisPrinter.h

@@ -0,0 +1,115 @@
+#ifndef PHASAR_PHASARLLVM_UTILS_LLVMANALYSISPRINTER_H
+#define PHASAR_PHASARLLVM_UTILS_LLVMANALYSISPRINTER_H
+
+#include "phasar/PhasarLLVM/Utils/LLVMIRToSrc.h"
+#include "phasar/Utils/ByRef.h"
+#include "phasar/Utils/DefaultAnalysisPrinter.h"
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/IR/Function.h"
+
+#include <type_traits>
+
+namespace psr {
+
+template <typename AnalysisDomainTy>
+class DefaultLLVMAnalysisPrinter
+    : public AnalysisPrinterBase<AnalysisDomainTy> {
+  using n_t = typename AnalysisDomainTy::n_t;
+  using d_t = typename AnalysisDomainTy::d_t;
+  using l_t = typename AnalysisDomainTy::l_t;
+
+public:
+  DefaultLLVMAnalysisPrinter() noexcept = default;
+
+private:
+  template <typename D = d_t>
+  static std::optional<DebugLocation> getDbgLoc(n_t Instr,
+                                                ByConstRef<d_t> DfFact) {
+    auto Ret = getDebugLocation(Instr);
+    if constexpr (std::is_convertible_v<ByConstRef<D>, const llvm::Value *>) {
+      if (!Ret) {
+        Ret = getDebugLocation(static_cast<const llvm::Value *>(DfFact));
+      }
+    }
+    return Ret;
+  }
+  template <typename D = d_t>
+  void printVariables(llvm::raw_ostream &OS,
+                      llvm::ArrayRef<Warning<AnalysisDomainTy>> Results) {
+    if constexpr (std::is_convertible_v<const D &, const llvm::Value *>) {
+      bool HasVariable = false;
+      for (const auto &Warn : Results) {
+        if (auto VarName = getVarNameFromIR(Warn.Fact); !VarName.empty()) {
+          if (!HasVariable) {
+            HasVariable = true;
+            OS << "  Variable: " << VarName;
+          } else {
+            OS << ", " << VarName;
+          }
+        }
+      }
+      if (HasVariable) {
+        OS << '\n';
+      }
+    }
+  }
+
+  void doOnResult(n_t Instr, d_t DfFact, l_t Lattice,
+                  DataFlowAnalysisType AnalysisType) override {
+    if (auto DbgLoc = getDbgLoc(Instr, DfFact)) {
+      DbgResultsEntries[*DbgLoc].emplace_back(Instr, std::move(DfFact),
+                                              std::move(Lattice), AnalysisType);
+    } else {
+      NonDbgResultsEntries.emplace_back(Instr, std::move(DfFact),
+                                        std::move(Lattice), AnalysisType);
+    }
+  }
+
+  void doOnFinalize(llvm::raw_ostream &OS) override {
+    size_t Ctr = 0;
+    for (const auto &[DbgLoc, Results] : DbgResultsEntries) {
+      OS << '#' << ++Ctr << ": ";
+      OS << "At " << getFilePathFromIR(DbgLoc.File) << ':' << DbgLoc.Line << ':'
+         << DbgLoc.Column << ":\n";
+      OS << "  In Function: " << Results.front().Instr->getFunction()->getName()
+         << '\n';
+      if (auto SrcCode = getSrcCodeFromIR(DbgLoc); !SrcCode.empty()) {
+        OS << "  Source code: " << SrcCode << '\n';
+      }
+      printVariables(OS, Results);
+      OS << "\n  Corresponding IR Statements:\n";
+      for (const auto &Warn : Results) {
+        OS << "    At IR statement: " << NToString(Warn.Instr) << '\n';
+        OS << "      Fact: " << DToString(Warn.Fact) << '\n';
+
+        if constexpr (!std::is_same_v<l_t, BinaryDomain>) {
+          OS << "      Value: " << LToString(Warn.LatticeElement) << '\n';
+        }
+        OS << '\n';
+      }
+    }
+
+    // Fallback in case we don't have debug information:
+    for (const auto &Iter : NonDbgResultsEntries) {
+      OS << "At IR statement: " << NToString(Iter.Instr) << '\n';
+      OS << "  In Function: " << Iter.Instr->getFunction()->getName() << '\n';
+      OS << "  Fact: " << DToString(Iter.Fact) << '\n';
+
+      if constexpr (!std::is_same_v<l_t, BinaryDomain>) {
+        OS << "  Value: " << LToString(Iter.LatticeElement) << '\n';
+      }
+      OS << '\n';
+    }
+    NonDbgResultsEntries.clear();
+  }
+
+  std::map<DebugLocation, llvm::SmallVector<Warning<AnalysisDomainTy>, 1>>
+      DbgResultsEntries;
+  std::vector<Warning<AnalysisDomainTy>> NonDbgResultsEntries{};
+};
+
+} // namespace psr
+
+#endif // PHASAR_PHASARLLVM_UTILS_LLVMANALYSISPRINTER_H

include/phasar/PhasarLLVM/Utils/LLVMIRToSrc.h

@@ -23,6 +23,7 @@
 
 #include <optional>
 #include <string>
+#include <tuple>
 
 // Forward declaration of types for which we only use its pointer or ref type
 namespace llvm {
@@ -47,6 +48,15 @@ struct DebugLocation {
   unsigned Line{};
   unsigned Column{};
   const llvm::DIFile *File{};
+
+  friend constexpr bool operator<(DebugLocation L, DebugLocation R) noexcept {
+    return std::tie(L.File, L.Line, L.Column) <
+           std::tie(R.File, R.Line, R.Column);
+  }
+  friend constexpr bool operator==(DebugLocation L, DebugLocation R) noexcept {
+    return std::tie(L.File, L.Line, L.Column) ==
+           std::tie(R.File, R.Line, R.Column);
+  }
 };
 
 [[nodiscard]] llvm::DILocalVariable *getDILocalVariable(const llvm::Value *V);