Refactor AnalysisPrinter part2

fabianbs96 · Feb 12, 2024 · ca7565b · ca7565b
1 parent 1cc8a26
commit ca7565b
Show file tree

Hide file tree

Showing 13 changed files with 105 additions and 85 deletions.
diff --git a/include/phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IDETypeStateAnalysis.h b/include/phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IDETypeStateAnalysis.h
@@ -530,11 +530,9 @@ class IDETypeStateAnalysis
               if (const auto *Alloca =
                       llvm::dyn_cast<llvm::AllocaInst>(Res.first)) {
                 if (Res.second == TSD->error()) {
-                  Warning<IDETypeStateAnalysisDomain<TypeStateDescriptionTy>>
-                      Warn(&I, Res.first, TSD->error(),
-                           DataFlowAnalysisType::None);
                   // ERROR STATE DETECTED
-                  this->Printer->onResult(Warn);
+                  this->Printer->onResult(&I, Res.first, TSD->error(),
+                                          DataFlowAnalysisType::None);
                 }
               }
             }
@@ -543,11 +541,9 @@ class IDETypeStateAnalysis
               if (const auto *Alloca =
                       llvm::dyn_cast<llvm::AllocaInst>(Res.first)) {
                 if (Res.second == TSD->error()) {
-                  Warning<IDETypeStateAnalysisDomain<TypeStateDescriptionTy>>
-                      Warn(&I, Res.first, TSD->error(),
-                           DataFlowAnalysisType::None);
                   // ERROR STATE DETECTED
-                  this->Printer->onResult(Warn);
+                  this->Printer->onResult(&I, Res.first, TSD->error(),
+                                          DataFlowAnalysisType::None);
                 }
               }
             }

diff --git a/include/phasar/PhasarLLVM/Utils/SourceMgrPrinter.h b/include/phasar/PhasarLLVM/Utils/SourceMgrPrinter.h
@@ -7,19 +7,22 @@
 #include "phasar/Utils/MaybeUniquePtr.h"
 
 #include "llvm/ADT/FunctionExtras.h"
-#include "llvm/Support/MemoryBuffer.h"
-
-#include <llvm/ADT/StringMap.h>
-#include <llvm/ADT/StringRef.h>
-#include <llvm/Support/SourceMgr.h>
-#include <llvm/Support/raw_ostream.h> /// TODO: quoting style
+#include "llvm/ADT/StringMap.h"
+#include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/raw_ostream.h"
 
 namespace psr {
 
-std::optional<unsigned> getSourceBufId(llvm::StringRef FileName);
+std::optional<unsigned> getSourceBufId(llvm::StringRef FileName,
+                                       llvm::StringMap<unsigned> &FileNameIDMap,
+                                       llvm::SourceMgr &SrcMgr);
 
 template <typename AnalysisDomainTy>
 class SourceMgrPrinter : 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:
   SourceMgrPrinter(
       llvm::unique_function<std::string(DataFlowAnalysisType)> &&PrintMessage,
@@ -28,21 +31,24 @@ class SourceMgrPrinter : public AnalysisPrinterBase<AnalysisDomainTy> {
 
   void onInitialize() override {}
   void onFinalize() override {}
-  void onResult(Warning<AnalysisDomainTy> Warn) override {
-    auto BufIdOpt = getSourceBufId(getFilePathFromIR(Warn.Instr));
+  void onResult(n_t Instr, d_t /*DfFact*/, l_t /*Lattice*/,
+                DataFlowAnalysisType AnalysisType) override {
+    auto BufIdOpt =
+        getSourceBufId(getFilePathFromIR(Instr), FileNameIDMap, SrcMgr);
     if (BufIdOpt.has_value()) {
       std::pair<unsigned int, unsigned int> LineAndCol =
-          getLineAndColFromIR(Warn.Instr);
+          getLineAndColFromIR(Instr);
       /// TODO: Configuration options for warning or error
       SrcMgr.PrintMessage(
           *OS,
           SrcMgr.FindLocForLineAndColumn(BufIdOpt.value(), LineAndCol.first,
                                          LineAndCol.second),
-          llvm::SourceMgr::DK_Warning, GetPrintMessage(Warn.AnalysisType));
+          llvm::SourceMgr::DK_Warning, GetPrintMessage(AnalysisType));
     }
   }
 
 private:
+  llvm::StringMap<unsigned> FileNameIDMap{};
   llvm::SourceMgr SrcMgr{};
   llvm::unique_function<std::string(DataFlowAnalysisType)> GetPrintMessage;
   MaybeUniquePtr<llvm::raw_ostream> OS = &llvm::errs();

diff --git a/include/phasar/Utils/AnalysisPrinterBase.h b/include/phasar/Utils/AnalysisPrinterBase.h
@@ -7,30 +7,17 @@
 
 namespace psr {
 
-/// TODO: move warning to default analysis printer
-template <typename AnalysisDomainTy> struct Warning {
+template <typename AnalysisDomainTy> class AnalysisPrinterBase {
   using n_t = typename AnalysisDomainTy::n_t;
   using d_t = typename AnalysisDomainTy::d_t;
   using l_t = typename AnalysisDomainTy::l_t;
 
-  n_t Instr;
-  d_t Fact;
-  l_t LatticeElement;
-  DataFlowAnalysisType AnalysisType;
-
-  // Constructor
-  Warning(n_t Inst, d_t DfFact, l_t Lattice,
-          DataFlowAnalysisType DfAnalysisType)
-      : Instr(std::move(Inst)), Fact(std::move(DfFact)),
-        LatticeElement(std::move(Lattice)), AnalysisType(DfAnalysisType) {}
-};
-
-template <typename AnalysisDomainTy> class AnalysisPrinterBase {
 public:
   /// TODO: use non-virtual function to call virtual function with default
   /// parameters +
   /// TODO: templace magic - #include "memory_resource"
-  virtual void onResult(Warning<AnalysisDomainTy> /*Warn*/) = 0;
+  virtual void onResult(n_t /*Instr*/, d_t /*DfFact*/, l_t /*LatticeElement*/,
+                        DataFlowAnalysisType /*AnalysisType*/) = 0;
   virtual void onInitialize() = 0;
   virtual void onFinalize() = 0;
 

diff --git a/include/phasar/Utils/DefaultAnalysisPrinter.h b/include/phasar/Utils/DefaultAnalysisPrinter.h
@@ -12,16 +12,36 @@
 
 namespace psr {
 
+template <typename AnalysisDomainTy> struct Warning {
+  using n_t = typename AnalysisDomainTy::n_t;
+  using d_t = typename AnalysisDomainTy::d_t;
+  using l_t = typename AnalysisDomainTy::l_t;
+
+  n_t Instr;
+  d_t Fact;
+  l_t LatticeElement;
+  DataFlowAnalysisType AnalysisType;
+
+  // Constructor
+  Warning(n_t Inst, d_t DfFact, l_t Lattice,
+          DataFlowAnalysisType DfAnalysisType)
+      : Instr(std::move(Inst)), Fact(std::move(DfFact)),
+        LatticeElement(std::move(Lattice)), AnalysisType(DfAnalysisType) {}
+};
+
 template <typename AnalysisDomainTy>
 class DefaultAnalysisPrinter : 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:
   ~DefaultAnalysisPrinter() override = default;
   DefaultAnalysisPrinter(llvm::raw_ostream &OS = llvm::outs()) : OS(&OS) {}
 
-  void onResult(Warning<AnalysisDomainTy> Warn) override {
-    AnalysisResults.emplace_back(std::move(Warn));
+  void onResult(n_t Instr, d_t DfFact, l_t Lattice,
+                DataFlowAnalysisType AnalysisType) override {
+    AnalysisResults.emplace_back(Instr, DfFact, Lattice, AnalysisType);
   }
 
   void onInitialize() override{};

diff --git a/include/phasar/Utils/NullAnalysisPrinter.h b/include/phasar/Utils/NullAnalysisPrinter.h
@@ -7,14 +7,19 @@ namespace psr {
 
 template <typename AnalysisDomainTy>
 class NullAnalysisPrinter final : 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:
   static NullAnalysisPrinter *getInstance() {
     static auto Instance = NullAnalysisPrinter();
     return &Instance;
   }
 
   void onInitialize() override{};
-  void onResult(Warning<AnalysisDomainTy> /*War*/) override{};
+  void onResult(n_t /*Instr*/, d_t /*DfFact*/, l_t /*Lattice*/,
+                DataFlowAnalysisType /*AnalysisType*/) override{};
   void onFinalize() override{};
 
 private:

diff --git a/include/phasar/Utils/OnTheFlyAnalysisPrinter.h b/include/phasar/Utils/OnTheFlyAnalysisPrinter.h
@@ -7,14 +7,16 @@
 #include "phasar/Utils/MaybeUniquePtr.h"
 #include "phasar/Utils/Printer.h"
 
-#include <cassert>
+#include "llvm/ADT/Twine.h"
+#include "llvm/Support/raw_ostream.h"
 
-#include <llvm/ADT/Twine.h>
-#include <llvm/Support/raw_ostream.h>
+#include <cassert>
 namespace psr {
 
 template <typename AnalysisDomainTy>
 class OnTheFlyAnalysisPrinter : 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:
@@ -29,12 +31,13 @@ class OnTheFlyAnalysisPrinter : public AnalysisPrinterBase<AnalysisDomainTy> {
   ~OnTheFlyAnalysisPrinter<AnalysisDomainTy>() = default;
 
   void onInitialize() override{};
-  void onResult(Warning<AnalysisDomainTy> Warn) override {
+  void onResult(n_t Instr, d_t DfFact, l_t LatticeElement,
+                DataFlowAnalysisType /*AnalysisType*/) override {
     assert(isValid());
-    *OS << "\nAt IR statement: " << NToString(Warn.Instr) << "\n";
-    *OS << "\tFact: " << DToString(Warn.Fact) << "\n";
+    *OS << "\nAt IR statement: " << NToString(Instr) << "\n";
+    *OS << "\tFact: " << DToString(DfFact) << "\n";
     if constexpr (std::is_same_v<l_t, BinaryDomain>) {
-      *OS << "Value: " << LToString(Warn.LatticeElement) << "\n";
+      *OS << "Value: " << LToString(LatticeElement) << "\n";
     }
   }
 

diff --git a/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IDEExtendedTaintAnalysis.cpp b/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IDEExtendedTaintAnalysis.cpp
@@ -228,10 +228,8 @@ void IDEExtendedTaintAnalysis::reportLeakIfNecessary(
     const llvm::Value *LeakCandidate) {
   if (isSink(SinkCandidate, Inst)) {
     Leaks[Inst].insert(LeakCandidate);
-    Warning<IDEExtendedTaintAnalysisDomain> Warn(
-        Inst, makeFlowFact(LeakCandidate), Top{},
-        DataFlowAnalysisType::IDEExtendedTaintAnalysis);
-    Printer->onResult(Warn);
+    Printer->onResult(Inst, makeFlowFact(LeakCandidate), Top{},
+                      DataFlowAnalysisType::IDEExtendedTaintAnalysis);
   }
 }
 
@@ -756,10 +754,8 @@ void IDEExtendedTaintAnalysis::emitTextReport(
 
   for (auto &[Inst, LeakSet] : Leaks) {
     for (const auto &Leak : LeakSet) {
-      Warning<IDEExtendedTaintAnalysisDomain> Warn(
-          Inst, makeFlowFact(Leak), Top{},
-          DataFlowAnalysisType::IDEExtendedTaintAnalysis);
-      Printer->onResult(Warn);
+      Printer->onResult(Inst, makeFlowFact(Leak), Top{},
+                        DataFlowAnalysisType::IDEExtendedTaintAnalysis);
     }
   }
 

diff --git a/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSTaintAnalysis.cpp b/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSTaintAnalysis.cpp
@@ -411,10 +411,8 @@ auto IFDSTaintAnalysis::getSummaryFlowFunction([[maybe_unused]] n_t CallSite,
                          CallSite](d_t Source) -> container_type {
         if (Leak.count(Source)) {
           if (Leaks[CallSite].insert(Source).second) {
-            Warning<LLVMIFDSAnalysisDomainDefault> Warn(
-                CallSite, Source, topElement(),
-                DataFlowAnalysisType::IFDSTaintAnalysis);
-            Printer->onResult(Warn);
+            Printer->onResult(CallSite, Source, topElement(),
+                              DataFlowAnalysisType::IFDSTaintAnalysis);
           }
         }
 
@@ -441,10 +439,8 @@ auto IFDSTaintAnalysis::getSummaryFlowFunction([[maybe_unused]] n_t CallSite,
 
     if (Leak.count(Source)) {
       if (Leaks[CallSite].insert(Source).second) {
-        Warning<LLVMIFDSAnalysisDomainDefault> Warn(
-            CallSite, Source, topElement(),
-            DataFlowAnalysisType::IFDSTaintAnalysis);
-        Printer->onResult(Warn);
+        Printer->onResult(CallSite, Source, topElement(),
+                          DataFlowAnalysisType::IFDSTaintAnalysis);
       }
     }
 

diff --git a/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSUninitializedVariables.cpp b/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSUninitializedVariables.cpp
@@ -204,10 +204,8 @@ IFDSUninitializedVariables::getNormalFlowFunction(
             !llvm::isa<llvm::CastInst>(Curr) &&
             !llvm::isa<llvm::PHINode>(Curr)) {
           UndefValueUses[Curr].insert(Operand);
-          Warning<LLVMIFDSAnalysisDomainDefault> Warn(
-              Curr, Operand, BinaryDomain::TOP,
-              DataFlowAnalysisType::IFDSUninitializedVariables);
-          Printer->onResult(Warn);
+          Printer->onResult(Curr, Operand, BinaryDomain::TOP,
+                            DataFlowAnalysisType::IFDSUninitializedVariables);
         }
         return {Source, Curr};
       }

diff --git a/lib/PhasarLLVM/Utils/SourceMgrPrinter.cpp b/lib/PhasarLLVM/Utils/SourceMgrPrinter.cpp
@@ -1,13 +1,10 @@
 #include "phasar/PhasarLLVM/Utils/SourceMgrPrinter.h"
 
-#include <llvm/Support/SourceMgr.h>
-
 namespace psr {
 
-llvm::StringMap<unsigned> FileNameIDMap{};
-llvm::SourceMgr SrcMgr{};
-
-std::optional<unsigned> getSourceBufId(llvm::StringRef FileName) {
+std::optional<unsigned> getSourceBufId(llvm::StringRef FileName,
+                                       llvm::StringMap<unsigned> &FileNameIDMap,
+                                       llvm::SourceMgr &SrcMgr) {
   if (auto It = FileNameIDMap.find(FileName); It != FileNameIDMap.end()) {
     return It->second;
   }

diff --git a/unittests/Utils/AnalysisPrinterTest.cpp b/unittests/Utils/AnalysisPrinterTest.cpp
@@ -22,6 +22,11 @@ using CallBackPairTy = std::pair<IDEExtendedTaintAnalysis<>::config_callback_t,
 // Use template to variate between Typesate and Taint analysis
 class GroundTruthCollector
     : public DefaultAnalysisPrinter<IDEExtendedTaintAnalysisDomain> {
+
+  using n_t = IDEExtendedTaintAnalysisDomain::n_t;
+  using d_t = IDEExtendedTaintAnalysisDomain::d_t;
+  using l_t = IDEExtendedTaintAnalysisDomain::l_t;
+
 public:
   // constructor init Groundtruth in each fixture
   GroundTruthCollector(llvm::DenseMap<int, std::set<std::string>> &GroundTruth)
@@ -38,11 +43,12 @@ class GroundTruthCollector
     }
   }
 
-  void onResult(Warning<IDEExtendedTaintAnalysisDomain> Warn) override {
+  void onResult(n_t Instr, d_t DfFact, l_t /*LatticeElement*/,
+                DataFlowAnalysisType /*AnalysisType*/) override {
     llvm::DenseMap<int, std::set<std::string>> FoundLeak;
-    int SinkId = stoi(getMetaDataID(Warn.Instr));
+    int SinkId = stoi(getMetaDataID(Instr));
     std::set<std::string> LeakedValueIds;
-    LeakedValueIds.insert(getMetaDataID((Warn.Fact)->base()));
+    LeakedValueIds.insert(getMetaDataID((DfFact)->base()));
     FoundLeak.try_emplace(SinkId, LeakedValueIds);
     findAndRemove(FoundLeak, GroundTruth);
   }

diff --git a/unittests/Utils/OnTheFlyAnalysisPrinterTest.cpp b/unittests/Utils/OnTheFlyAnalysisPrinterTest.cpp
@@ -7,17 +7,20 @@
 #include "phasar/PhasarLLVM/SimpleAnalysisConstructor.h"
 
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/raw_ostream.h"
 
 #include "TestConfig.h"
 #include "gtest/gtest.h"
 
-#include <llvm/ADT/StringRef.h>
-#include <llvm/Support/raw_ostream.h>
-
 using namespace psr;
 
 class GroundTruthCollector
     : public OnTheFlyAnalysisPrinter<LLVMIFDSAnalysisDomainDefault> {
+  using n_t = LLVMIFDSAnalysisDomainDefault::n_t;
+  using d_t = LLVMIFDSAnalysisDomainDefault::d_t;
+  using l_t = LLVMIFDSAnalysisDomainDefault::l_t;
+
 public:
   // constructor init Groundtruth in each fixture
   GroundTruthCollector(llvm::DenseMap<int, std::set<std::string>> &GroundTruth)
@@ -34,11 +37,12 @@ class GroundTruthCollector
     }
   }
 
-  void onResult(Warning<LLVMIFDSAnalysisDomainDefault> Warn) override {
+  void onResult(n_t Instr, d_t DfFact, l_t /*LatticeElement*/,
+                DataFlowAnalysisType /*AnalysisType*/) override {
     llvm::DenseMap<int, std::set<std::string>> FoundLeak;
-    int SinkId = stoi(getMetaDataID(Warn.Instr));
+    int SinkId = stoi(getMetaDataID(Instr));
     std::set<std::string> LeakedValueIds;
-    LeakedValueIds.insert(getMetaDataID((Warn.Fact)));
+    LeakedValueIds.insert(getMetaDataID((DfFact)));
     FoundLeak.try_emplace(SinkId, LeakedValueIds);
     findAndRemove(FoundLeak, GroundTruth);
   }