Improve file IO + enable DominatorTree analysis injection into the IDEExtendedTaintAnalysis

Author: fabianbs96

include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEExtendedTaintAnalysis.h

@@ -36,6 +36,7 @@
 #include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Solver/IDESolver.h"
 #include "phasar/PhasarLLVM/Domain/AnalysisDomain.h"
 #include "phasar/PhasarLLVM/TaintConfig/TaintConfig.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchy.h"
 #include "phasar/PhasarLLVM/Utils/BasicBlockOrdering.h"
 #include "phasar/PhasarLLVM/Utils/LatticeDomain.h"
 #include "phasar/Utils/LLVMShorthands.h"
@@ -44,7 +45,6 @@
 namespace psr {
 
 class ProjectIRDB;
-class LLVMTypeHierarchy;
 class LLVMBasedICFG;
 class LLVMPointsToInfo;
 
@@ -62,21 +62,15 @@ class IDEExtendedTaintAnalysis
   using base_t = IDETabulationProblem<IDEExtendedTaintAnalysisDomain>;
 
 public:
-  using n_t =
-      typename IDETabulationProblem<IDEExtendedTaintAnalysisDomain>::n_t;
-  using f_t =
-      typename IDETabulationProblem<IDEExtendedTaintAnalysisDomain>::f_t;
-  using d_t =
-      typename IDETabulationProblem<IDEExtendedTaintAnalysisDomain>::d_t;
-  using l_t =
-      typename IDETabulationProblem<IDEExtendedTaintAnalysisDomain>::l_t;
-  using FlowFunctionPtrType = typename IDETabulationProblem<
+  using typename IDETabulationProblem<IDEExtendedTaintAnalysisDomain>::n_t;
+  using typename IDETabulationProblem<IDEExtendedTaintAnalysisDomain>::f_t;
+  using typename IDETabulationProblem<IDEExtendedTaintAnalysisDomain>::d_t;
+  using typename IDETabulationProblem<IDEExtendedTaintAnalysisDomain>::l_t;
+  using typename IDETabulationProblem<
       IDEExtendedTaintAnalysisDomain>::FlowFunctionPtrType;
-  using EdgeFunctionPtrType = typename IDETabulationProblem<
+  using typename IDETabulationProblem<
       IDEExtendedTaintAnalysisDomain>::EdgeFunctionPtrType;
 
-  // using FunctionInfoSetTy = XTaint::FunctionInfoSetTy;
-
   using config_callback_t = TaintConfig::TaintDescriptionCallBackTy;
 
 private:
@@ -146,11 +140,25 @@ class IDEExtendedTaintAnalysis
 public:
   /// Constructor. If EntryPoints is empty, use the TaintAPI functions as
   /// entrypoints.
+  /// The GetDomTree parameter can be used to inject a custom DominatorTree
+  /// analysis or the results from a LLVM pass computing dominator trees
+  template <typename GetDomTree = DefaultDominatorTreeAnalysis>
   IDEExtendedTaintAnalysis(const ProjectIRDB *IRDB, const LLVMTypeHierarchy *TH,
                            const LLVMBasedICFG *ICF, LLVMPointsToInfo *PT,
                            const TaintConfig *TSF,
                            std::set<std::string> EntryPoints, unsigned Bound,
-                           bool DisableStrongUpdates);
+                           bool DisableStrongUpdates,
+                           GetDomTree &&GDT = DefaultDominatorTreeAnalysis{})
+      : base_t(IRDB, TH, ICF, PT, std::move(EntryPoints)), AnalysisBase(TSF),
+        BBO(std::forward<GetDomTree>(GDT)),
+        FactFactory(IRDB->getNumInstructions()),
+        DL((*IRDB->getAllModules().begin())->getDataLayout()), Bound(Bound),
+        PostProcessed(DisableStrongUpdates),
+        DisableStrongUpdates(DisableStrongUpdates) {
+    base_t::ZeroValue = createZeroValue();
+
+    FactFactory.setDataLayout(DL);
+  }
 
   ~IDEExtendedTaintAnalysis() override = default;
 
@@ -283,12 +291,15 @@ class IDEExtendedTaintAnalysis
 template <unsigned BOUND = 3, bool USE_STRONG_UPDATES = true>
 class IDEExtendedTaintAnalysis : public XTaint::IDEExtendedTaintAnalysis {
 public:
+  template <typename GetDomTree = DefaultDominatorTreeAnalysis>
   IDEExtendedTaintAnalysis(const ProjectIRDB *IRDB, const LLVMTypeHierarchy *TH,
                            const LLVMBasedICFG *ICF, LLVMPointsToInfo *PT,
                            const TaintConfig &TSF,
-                           std::set<std::string> EntryPoints = {})
+                           std::set<std::string> EntryPoints = {},
+                           GetDomTree &&GDT = DefaultDominatorTreeAnalysis{})
       : XTaint::IDEExtendedTaintAnalysis(IRDB, TH, ICF, PT, &TSF, EntryPoints,
-                                         BOUND, !USE_STRONG_UPDATES) {}
+                                         BOUND, !USE_STRONG_UPDATES,
+                                         std::forward<GetDomTree>(GDT)) {}
 
   using ConfigurationTy = TaintConfig;
 };

include/phasar/PhasarLLVM/Utils/BasicBlockOrdering.h

@@ -11,8 +11,10 @@
 #define PHASAR_PHASARLLVM_UTILS_BASICBLOCKORDERING_H_
 
 #include <memory>
+#include <type_traits>
 
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/FunctionExtras.h"
 
 #include "phasar/DB/ProjectIRDB.h"
 
@@ -24,15 +26,29 @@ class DominatorTree;
 } // namespace llvm
 
 namespace psr {
-/// Provides a simple partial ordering of BasicBlocks based on LLVM's
-/// DominatorTree.
-class BasicBlockOrdering {
+
+class DefaultDominatorTreeAnalysis {
   llvm::DenseMap<const llvm::Function *, std::unique_ptr<llvm::DominatorTree>>
       Dom;
 
-  llvm::DominatorTree &getDom(const llvm::Function *F);
+public:
+  llvm::DominatorTree &operator()(const llvm::Function *F);
+};
+
+/// Provides a simple partial ordering of BasicBlocks based on LLVM's
+/// DominatorTree.
+class BasicBlockOrdering {
+  /// Note: Cannot use std::function, because we need to support move-only
+  /// functors(e.g. DefaultDominatorTreeAnalysis)
+  llvm::unique_function<llvm::DominatorTree &(const llvm::Function *)> getDom;
 
 public:
+  template <
+      typename DTA,
+      typename = std::enable_if_t<!std::is_same_v<
+          BasicBlockOrdering, std::remove_reference_t<std::decay_t<DTA>>>>>
+  explicit BasicBlockOrdering(DTA &&Dta) : getDom(std::forward<DTA>(Dta)) {}
+
   bool mustComeBefore(const llvm::Instruction *LHS,
                       const llvm::Instruction *RHS);
 };

include/phasar/Utils/IO.h

@@ -18,14 +18,19 @@
 #define PHASAR_UTILS_IO_H
 
 #include <filesystem>
+#include <memory>
 #include <string>
 
+#include "llvm/Support/MemoryBuffer.h"
+
 namespace psr {
 
 std::string readTextFile(const std::filesystem::path &Path);
 
-void writeTextFile(const std::filesystem::path &Path,
-                   const std::string &Content);
+std::unique_ptr<llvm::MemoryBuffer> readFile(const std::filesystem::path &Path);
+std::unique_ptr<llvm::MemoryBuffer> readFile(const llvm::Twine &Path);
+
+void writeTextFile(const std::filesystem::path &Path, llvm::StringRef Content);
 
 } // namespace psr
 

lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEExtendedTaintAnalysis.cpp

@@ -33,20 +33,20 @@
 
 namespace psr::XTaint {
 
-IDEExtendedTaintAnalysis::IDEExtendedTaintAnalysis(
-    const ProjectIRDB *IRDB, const LLVMTypeHierarchy *TH,
-    const LLVMBasedICFG *ICF, LLVMPointsToInfo *PT, const TaintConfig *TSF,
-    std::set<std::string> EntryPoints, unsigned Bound,
-    bool DisableStrongUpdates)
-    : base_t(IRDB, TH, ICF, PT, std::move(EntryPoints)), AnalysisBase(TSF),
-      FactFactory(IRDB->getNumInstructions()),
-      DL((*IRDB->getAllModules().begin())->getDataLayout()), Bound(Bound),
-      PostProcessed(DisableStrongUpdates),
-      DisableStrongUpdates(DisableStrongUpdates) {
-  base_t::ZeroValue = createZeroValue();
-
-  FactFactory.setDataLayout(DL);
-}
+// IDEExtendedTaintAnalysis::IDEExtendedTaintAnalysis(
+//     const ProjectIRDB *IRDB, const LLVMTypeHierarchy *TH,
+//     const LLVMBasedICFG *ICF, LLVMPointsToInfo *PT, const TaintConfig *TSF,
+//     std::set<std::string> EntryPoints, unsigned Bound,
+//     bool DisableStrongUpdates)
+//     : base_t(IRDB, TH, ICF, PT, std::move(EntryPoints)), AnalysisBase(TSF),
+//       FactFactory(IRDB->getNumInstructions()),
+//       DL((*IRDB->getAllModules().begin())->getDataLayout()), Bound(Bound),
+//       PostProcessed(DisableStrongUpdates),
+//       DisableStrongUpdates(DisableStrongUpdates) {
+//   base_t::ZeroValue = createZeroValue();
+
+//   FactFactory.setDataLayout(DL);
+// }
 
 InitialSeeds<IDEExtendedTaintAnalysis::n_t, IDEExtendedTaintAnalysis::d_t,
              IDEExtendedTaintAnalysis::l_t>

lib/PhasarLLVM/Utils/BasicBlockOrdering.cpp

@@ -10,7 +10,8 @@
 
 namespace psr {
 
-llvm::DominatorTree &BasicBlockOrdering::getDom(const llvm::Function *F) {
+llvm::DominatorTree &
+DefaultDominatorTreeAnalysis::operator()(const llvm::Function *F) {
   auto &Ret = Dom[F];
   if (!Ret) {
     Ret =

lib/Utils/IO.cpp

@@ -21,6 +21,7 @@
 #include <string>
 #include <system_error>
 
+#include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include "phasar/Utils/IO.h"
@@ -29,43 +30,30 @@
 namespace psr {
 
 std::string readTextFile(const std::filesystem::path &Path) {
-  if (!(std::filesystem::exists(Path) &&
-        std::filesystem::is_regular_file(Path))) {
-    throw std::ios_base::failure("File does not exist: " + Path.string());
-  }
-
-  auto NumBytes = std::filesystem::file_size(Path);
-
-  auto *F = std::fopen(Path.c_str(), "r");
-
-  if (!F) {
-    throw std::ios_base::failure("Could not open file: " + Path.string());
-  }
-
-  auto CloseFile = scope_exit([F]() { std::fclose(F); });
-
-  std::string Contents;
-
-  /// TODO: Get rid of the zero-initialization of the string
-  Contents.resize(NumBytes);
+  auto Buffer = readFile(Path);
+  return Buffer->getBuffer().str();
+}
 
-  auto ReadBytes = std::fread(Contents.data(), 1, NumBytes, F);
+std::unique_ptr<llvm::MemoryBuffer>
+readFile(const std::filesystem::path &Path) {
+  return readFile(llvm::StringRef(Path.string()));
+}
+std::unique_ptr<llvm::MemoryBuffer> readFile(const llvm::Twine &Path) {
+  auto Ret = llvm::MemoryBuffer::getFile(Path);
 
-  if (ReadBytes != NumBytes) {
-    throw std::ios_base::failure("Could not read file: " + Path.string());
+  if (!Ret) {
+    throw std::system_error(Ret.getError());
   }
 
-  return Contents;
+  return std::move(Ret.get());
 }
 
-void writeTextFile(const std::filesystem::path &Path,
-                   const std::string &Content) {
+void writeTextFile(const std::filesystem::path &Path, llvm::StringRef Content) {
   std::error_code EC;
   llvm::raw_fd_ostream ROS(Path.string(), EC);
 
   if (EC) {
-    throw std::ios_base::failure("Error creating the file: " + Path.string() +
-                                 "; " + EC.message());
+    throw std::system_error(EC);
   }
 
   ROS.write(Content.data(), Content.size());