Misc Changes

include/phasar/DataFlow/IfdsIde/EdgeFunction.h

@@ -827,8 +827,7 @@ template <typename L> struct DenseMapInfo<psr::EdgeFunction<L>> {
 
 // LLVM is currently overhauling its casting system. Use the new variant once
 // possible!
-// Note: The new variant (With CastInfo) is not tested yet!
-#if LLVM_MAJOR < 15
+#if LLVM_VERSION_MAJOR < 15
 
 template <typename To, typename L>
 struct isa_impl_cl<To, const psr::EdgeFunction<L>> {
@@ -876,7 +875,7 @@ cast_or_null(const psr::EdgeFunction<L> &EF) noexcept { // NOLINT
 template <typename To, typename L>
 struct CastIsPossible<To, psr::EdgeFunction<L>> {
   static inline bool isPossible(const psr::EdgeFunction<L> &EF) noexcept {
-    return EF->template isa<To>();
+    return EF.template isa<To>();
   }
 };
 

include/phasar/DataFlow/IfdsIde/EdgeFunctionUtils.h

@@ -40,13 +40,67 @@ template <typename L> struct EdgeIdentity final {
        const EdgeFunction<l_t> &OtherFunction);
 };
 
+template <typename L> struct ConstantEdgeFunction {
+  using l_t = L;
+  using JLattice = JoinLatticeTraits<L>;
+  using value_type = typename NonTopBotValue<l_t>::type;
+
+  [[nodiscard]] l_t computeTarget(ByConstRef<l_t> /*Source*/) const
+      noexcept(std::is_nothrow_constructible_v<l_t, const value_type &>) {
+    static_assert(IsEdgeFunction<ConstantEdgeFunction>);
+    return Value;
+  }
+
+  template <typename ConcreteEF, typename = std::enable_if_t<std::is_base_of_v<
+                                     ConstantEdgeFunction, ConcreteEF>>>
+  [[nodiscard]] static EdgeFunction<l_t>
+  compose(EdgeFunctionRef<ConcreteEF> This,
+          const EdgeFunction<l_t> &SecondFunction);
+
+  template <typename ConcreteEF, typename = std::enable_if_t<std::is_base_of_v<
+                                     ConstantEdgeFunction, ConcreteEF>>>
+  [[nodiscard]] static EdgeFunction<l_t>
+  join(EdgeFunctionRef<ConcreteEF> This,
+       const EdgeFunction<l_t> &OtherFunction);
+
+  [[nodiscard]] constexpr bool isConstant() const noexcept { return true; }
+
+  // -- constant data member
+
+  value_type Value{};
+};
+
+template <typename L, typename = std::enable_if_t<
+                          CanEfficientlyPassByValue<ConstantEdgeFunction<L>>>>
+[[nodiscard]] bool operator==(ConstantEdgeFunction<L> LHS,
+                              ConstantEdgeFunction<L> RHS) noexcept {
+  return LHS.Value == RHS.Value;
+}
+
+template <typename L, typename = std::enable_if_t<
+                          !CanEfficientlyPassByValue<ConstantEdgeFunction<L>>>>
+[[nodiscard]] bool operator==(const ConstantEdgeFunction<L> &LHS,
+                              const ConstantEdgeFunction<L> &RHS) noexcept {
+  return LHS.Value == RHS.Value;
+}
+
+template <typename L>
+[[nodiscard]] llvm::raw_ostream &
+operator<<(llvm::raw_ostream &OS, ByConstRef<ConstantEdgeFunction<L>> Id) {
+  OS << "ConstantEF";
+  if constexpr (is_llvm_printable_v<
+                    typename ConstantEdgeFunction<L>::value_type>) {
+    OS << '[' << Id.Value << ']';
+  }
+  return OS;
+}
+
 template <typename L> struct AllBottom final {
   using l_t = L;
   using JLattice = JoinLatticeTraits<L>;
 
   [[no_unique_address]] std::conditional_t<HasJoinLatticeTraits<l_t>, EmptyType,
-                                           l_t>
-      BottomValue;
+                                           l_t> BottomValue;
 
   [[nodiscard]] l_t computeTarget(ByConstRef<l_t> /*Source*/) const noexcept {
     static_assert(std::is_trivially_copyable_v<AllBottom>);
@@ -61,7 +115,25 @@ template <typename L> struct AllBottom final {
   [[nodiscard]] static EdgeFunction<l_t>
   compose(EdgeFunctionRef<AllBottom> This,
           const EdgeFunction<l_t> &SecondFunction) {
-    return SecondFunction.isConstant() ? SecondFunction : This;
+    if (SecondFunction.isConstant()) {
+      return SecondFunction;
+    }
+
+    if constexpr (HasJoinLatticeTraits<L>) {
+      auto ConstVal = SecondFunction.computeTarget(JLattice::bottom());
+      if (ConstVal == JLattice::bottom()) {
+        return This;
+      }
+
+      return ConstantEdgeFunction<L>{
+          NonTopBotValue<L>::unwrap(std::move(ConstVal))};
+    } else {
+      // Note: This used to be the default behavior, but it appears to be too
+      // restrictive
+      return This;
+    }
+
+    // return SecondFunction.isConstant() ? SecondFunction : This;
   }
 
   [[nodiscard]] static EdgeFunction<l_t>
@@ -85,8 +157,7 @@ template <typename L> struct AllTop final {
   using JLattice = JoinLatticeTraits<L>;
 
   [[no_unique_address]] std::conditional_t<HasJoinLatticeTraits<l_t>, EmptyType,
-                                           l_t>
-      TopValue;
+                                           l_t> TopValue;
 
   [[nodiscard]] l_t computeTarget(ByConstRef<l_t> /*Source*/) const noexcept {
     static_assert(std::is_trivially_copyable_v<AllTop>);
@@ -149,97 +220,6 @@ defaultComposeOrNull(const EdgeFunction<L> &This,
   return nullptr;
 }
 
-template <typename L> struct ConstantEdgeFunction {
-  using l_t = L;
-  using JLattice = JoinLatticeTraits<L>;
-  using value_type = typename NonTopBotValue<l_t>::type;
-
-  [[nodiscard]] l_t computeTarget(ByConstRef<l_t> /*Source*/) const
-      noexcept(std::is_nothrow_constructible_v<l_t, const value_type &>) {
-    static_assert(IsEdgeFunction<ConstantEdgeFunction>);
-    return Value;
-  }
-
-  template <typename ConcreteEF, typename = std::enable_if_t<std::is_base_of_v<
-                                     ConstantEdgeFunction, ConcreteEF>>>
-  [[nodiscard]] static EdgeFunction<l_t>
-  compose(EdgeFunctionRef<ConcreteEF> This,
-          const EdgeFunction<l_t> &SecondFunction) {
-    if (auto Default = defaultComposeOrNull(This, SecondFunction)) {
-      return Default;
-    }
-
-    auto ConstVal = SecondFunction.computeTarget(This->Value);
-    if constexpr (!EdgeFunctionBase::IsSOOCandidate<ConstantEdgeFunction>) {
-      if (ConstVal == This->Value) {
-        return This;
-      }
-    }
-
-    if constexpr (AreEqualityComparable<decltype(JLattice::bottom()), l_t>) {
-      if (JLattice::bottom() == ConstVal) {
-        return AllBottom<l_t>{};
-      }
-    } else {
-      if (l_t(JLattice::bottom()) == ConstVal) {
-        return AllBottom<l_t>{};
-      }
-    }
-
-    if constexpr (AreEqualityComparable<decltype(JLattice::top()), l_t>) {
-      if (JLattice::top() == ConstVal) {
-        /// TODO: Can this ever happen?
-        return AllTop<l_t>{};
-      }
-    } else {
-      if (l_t(JLattice::top()) == ConstVal) {
-        /// TODO: Can this ever happen?
-        return AllTop<l_t>{};
-      }
-    }
-
-    return ConstantEdgeFunction{
-        NonTopBotValue<l_t>::unwrap(std::move(ConstVal))};
-  }
-
-  template <typename ConcreteEF, typename = std::enable_if_t<std::is_base_of_v<
-                                     ConstantEdgeFunction, ConcreteEF>>>
-  [[nodiscard]] static EdgeFunction<l_t>
-  join(EdgeFunctionRef<ConcreteEF> This,
-       const EdgeFunction<l_t> &OtherFunction);
-
-  [[nodiscard]] constexpr bool isConstant() const noexcept { return true; }
-
-  // -- constant data member
-
-  value_type Value{};
-};
-
-template <typename L, typename = std::enable_if_t<
-                          CanEfficientlyPassByValue<ConstantEdgeFunction<L>>>>
-[[nodiscard]] bool operator==(ConstantEdgeFunction<L> LHS,
-                              ConstantEdgeFunction<L> RHS) noexcept {
-  return LHS.Value == RHS.Value;
-}
-
-template <typename L, typename = std::enable_if_t<
-                          !CanEfficientlyPassByValue<ConstantEdgeFunction<L>>>>
-[[nodiscard]] bool operator==(const ConstantEdgeFunction<L> &LHS,
-                              const ConstantEdgeFunction<L> &RHS) noexcept {
-  return LHS.Value == RHS.Value;
-}
-
-template <typename L>
-[[nodiscard]] llvm::raw_ostream &
-operator<<(llvm::raw_ostream &OS, ByConstRef<ConstantEdgeFunction<L>> Id) {
-  OS << "ConstantEF";
-  if constexpr (is_llvm_printable_v<
-                    typename ConstantEdgeFunction<L>::value_type>) {
-    OS << '[' << Id.Value << ']';
-  }
-  return OS;
-}
-
 template <typename L> struct EdgeFunctionComposer {
   using l_t = L;
 
@@ -461,6 +441,47 @@ EdgeFunction<L> EdgeIdentity<L>::join(EdgeFunctionRef<EdgeIdentity> This,
   return OtherFunction.joinWith(This);
 }
 
+template <typename L>
+template <typename ConcreteEF, typename>
+EdgeFunction<L>
+ConstantEdgeFunction<L>::compose(EdgeFunctionRef<ConcreteEF> This,
+                                 const EdgeFunction<L> &SecondFunction) {
+  if (auto Default = defaultComposeOrNull(This, SecondFunction)) {
+    return Default;
+  }
+
+  auto ConstVal = SecondFunction.computeTarget(This->Value);
+  if constexpr (!EdgeFunctionBase::IsSOOCandidate<ConstantEdgeFunction>) {
+    if (ConstVal == This->Value) {
+      return This;
+    }
+  }
+
+  if constexpr (AreEqualityComparable<decltype(JLattice::bottom()), L>) {
+    if (JLattice::bottom() == ConstVal) {
+      return AllBottom<L>{};
+    }
+  } else {
+    if (L(JLattice::bottom()) == ConstVal) {
+      return AllBottom<L>{};
+    }
+  }
+
+  if constexpr (AreEqualityComparable<decltype(JLattice::top()), L>) {
+    if (JLattice::top() == ConstVal) {
+      /// TODO: Can this ever happen?
+      return AllTop<L>{};
+    }
+  } else {
+    if (L(JLattice::top()) == ConstVal) {
+      /// TODO: Can this ever happen?
+      return AllTop<L>{};
+    }
+  }
+
+  return ConstantEdgeFunction{NonTopBotValue<L>::unwrap(std::move(ConstVal))};
+}
+
 template <typename L>
 template <typename ConcreteEF, typename>
 EdgeFunction<L>

include/phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h

@@ -26,13 +26,11 @@
 #include "phasar/PhasarLLVM/ControlFlow/LLVMVFTableProvider.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h"
 #include "phasar/PhasarLLVM/Utils/LLVMBasedContainerConfig.h"
-#include "phasar/Utils/MaybeUniquePtr.h"
 #include "phasar/Utils/Soundness.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/IR/Function.h"
-#include "llvm/IR/Instruction.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/raw_ostream.h"
 

include/phasar/PhasarLLVM/ControlFlow/LLVMVFTableProvider.h

@@ -12,6 +12,8 @@
 
 #include "phasar/PhasarLLVM/TypeHierarchy/LLVMVFTable.h"
 
+#include "llvm/ADT/StringMap.h"
+
 #include <unordered_map>
 
 namespace llvm {
@@ -38,7 +40,14 @@ class LLVMVFTableProvider {
   [[nodiscard]] const LLVMVFTable *
   getVFTableOrNull(const llvm::DIType *Type) const;
 
+  [[nodiscard]] const llvm::GlobalVariable *
+  getVFTableGlobal(const llvm::DIType *Type) const;
+
+  [[nodiscard]] const llvm::GlobalVariable *
+  getVFTableGlobal(llvm::StringRef ClearTypeName) const;
+
 private:
+  llvm::StringMap<const llvm::GlobalVariable *> ClearNameTVMap;
   std::unordered_map<const llvm::DIType *, LLVMVFTable> TypeVFTMap;
 };
 } // namespace psr

include/phasar/PhasarLLVM/ControlFlow/Resolver/Resolver.h

@@ -113,6 +113,10 @@ class Resolver {
 
   [[nodiscard]] virtual std::string str() const = 0;
 
+  /// Whether the ICFG needs to reconsider all dynamic call-sites once there
+  /// have been changes through handlePossibleTargets().
+  ///
+  /// Make false for performance (may be less sound then)
   [[nodiscard]] virtual bool mutatesHelperAnalysisInformation() const noexcept {
     // Conservatively returns true. Override if possible
     return true;

include/phasar/PhasarLLVM/ControlFlow/SparseLLVMBasedICFG.h

@@ -24,7 +24,7 @@ struct SVFGCache;
 /// Conforms to the ICFGBase CRTP interface.
 ///
 /// Use this in the IDESolver or IFDSSolver to profit from the SparseIFDS or
-/// SparseIDE optimization after Karakays et al. "Symbol-Specific Sparsification
+/// SparseIDE optimization after Karakaya et al. "Symbol-Specific Sparsification
 /// of Interprocedural Distributive Environment Problems"
 /// <https://doi.org/10.48550/arXiv.2401.14813>
 class SparseLLVMBasedICFG

include/phasar/PhasarLLVM/ControlFlow/SparseLLVMBasedICFGView.h

@@ -34,7 +34,7 @@ struct CFGTraits<SparseLLVMBasedICFGView> : CFGTraits<LLVMBasedCFG> {};
 /// It still owns the sparse value-flow graphs.
 ///
 /// Use this in the IDESolver or IFDSSolver to profit from the SparseIFDS or
-/// SparseIDE optimization after Karakays et al. "Symbol-Specific Sparsification
+/// SparseIDE optimization after Karakaya et al. "Symbol-Specific Sparsification
 /// of Interprocedural Distributive Environment Problems"
 /// <https://doi.org/10.48550/arXiv.2401.14813>
 class SparseLLVMBasedICFGView

include/phasar/PhasarLLVM/DB/LLVMProjectIRDB.h

@@ -21,6 +21,7 @@
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
+#include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/MemoryBufferRef.h"
 #include "llvm/Support/raw_ostream.h"
 
@@ -56,14 +57,25 @@ class LLVMProjectIRDB : public ProjectIRDBBase<LLVMProjectIRDB> {
   /// ownership of it. The module is optionally being preprocessed.
   explicit LLVMProjectIRDB(std::unique_ptr<llvm::Module> Mod,
                            bool DoPreprocessing = true);
+  /// Initializes the new ProjectIRDB with the given IR Module and takes
+  /// ownership of it. The module is optionally being preprocessed. Takes the
+  /// given LLVMContext and binds its lifetime to the lifetime of the
+  /// constructed ProjectIRDB
+  explicit LLVMProjectIRDB(std::unique_ptr<llvm::Module> Mod,
+                           std::unique_ptr<llvm::LLVMContext> Ctx,
+                           bool DoPreprocessing = true);
+
   /// Parses the given LLVM IR file and owns the resulting IR Module.
   /// If an error occurs, an error message is written to stderr and subsequent
   /// calls to isValid() return false.
   explicit LLVMProjectIRDB(llvm::MemoryBufferRef Buf,
                            bool EnableOpaquePointers = LLVM_VERSION_MAJOR > 14);
 
   LLVMProjectIRDB(const LLVMProjectIRDB &) = delete;
-  LLVMProjectIRDB &operator=(LLVMProjectIRDB &) = delete;
+  LLVMProjectIRDB &operator=(const LLVMProjectIRDB &) = delete;
+
+  LLVMProjectIRDB(LLVMProjectIRDB &&) noexcept = default;
+  LLVMProjectIRDB &operator=(LLVMProjectIRDB &&) noexcept = default;
 
   ~LLVMProjectIRDB();
 
@@ -74,6 +86,10 @@ class LLVMProjectIRDB : public ProjectIRDBBase<LLVMProjectIRDB> {
   getParsedIRModuleOrNull(llvm::MemoryBufferRef IRFileContent,
                           llvm::LLVMContext &Ctx) noexcept;
 
+  [[nodiscard]] static llvm::ErrorOr<LLVMProjectIRDB>
+  load(const llvm::Twine &IRFileName,
+       bool EnableOpaquePointers = LLVM_VERSION_MAJOR > 14);
+
   /// Also use the const overload
   using ProjectIRDBBase::getFunction;
   /// Non-const overload
@@ -163,7 +179,8 @@ class LLVMProjectIRDB : public ProjectIRDBBase<LLVMProjectIRDB> {
   /// the preprocessing as well
   void preprocessModule(llvm::Module *NonConstMod);
 
-  llvm::LLVMContext Ctx;
+  // LLVMContext is not movable, so wrap it into a unique_ptr
+  std::unique_ptr<llvm::LLVMContext> Ctx;
   MaybeUniquePtr<llvm::Module> Mod = nullptr;
   size_t IdOffset = 0;
   llvm::SmallVector<const llvm::Value *, 0> IdToInst;