Misc Changes (#773)

* replaced llvm-14 with llvm-15 in relevant files

* some changes

* more efficient call-graph

* String-nbased vtable getter + CG-test with dbg info

* minor in CG

* annotation fix + test fix

* removed bitcasts and fixed tests

* Fix Annotation.cpp + TaintConfigTest

* Quick-fix LLVMTypeHierarchyTest

* fix one IIA test

* Fix StringtestCpp for generalized LCA

* first half of tests fixed

* fixed first half of tests

* fixed all but one test in IDEInstInteractionAnalysisTest

* fixed all but two tests

* Fix IIAFlowFact equality

* Re-add getVFTableGlobal

* fixed some newly failed tests

* trade soundness for precision in LLVMAliasSet

* ci.yml update

* Revert "fixed some newly failed tests"

* pre-commit hook

* Two Tests + xtaint09 test fix for pipeline

* Basic Opaque Pointer Impl, bugged

* switching to DebugInfoFinder

* re-add the quick-fix for LLVMTypeHierarchy

* OpaquePtr type mapping, missing subroutines

* Introducing a pass to save ptr types

* Revert "Introducing a pass to save ptr types"

This reverts commit 2a91b6d.

* moving phasar to DIBasedTypeHierarchy

* full switch to DIBasedTypeHierarchy + Test fixes

* fixed PathTracingTest

* dtaresolver deprecated and test fixes

* Fixed OTFTest

* trimmed trailing whitespace

* minor fixes

* readded TypeToDIType map for RTAResolver

* pre-commit clang-format fix

* pre-commit clang-format llvmbasedicfg.cpp

* moved RTAResolver to DITypes

* implemented review suggestions

* Log error if trying to instantiate DTAResolver + minor

* Add breaking changes

* Also compare gep type in IIA EqualGEPDescriptor

* Expose getDILocation()

* expose getSrcCodeFromIR for DebugLocation + minor

* Remove some unused includes

* Make TaintConfigData compatible with C++20

* Compatibility with opaque pointers

* Allow setting the LLVM version from higher-level projects

* Getting rid of UB in CHAResolver

* Start adding more sophisticated type extraction (WIP)

* Handle function calls in getVarTypeFromIR

* better fallback handling for getDebugLocation, etc

* Better IntraMonoSolver dump

* minor

* improve intra mono dump

* minor

* expose getNonPureVirtualVFTEntry as namespace-scope function + fix build with LLVM 14

* Fix RTA resolver

* Add missing include

* Fix solveIFDSProblem + cherry-pick fix of DIBasedTypeHierarchy::buildTypeGraph

* dump functions from debugger

* Remove unused-variable warning in release mode for CallGraph.h

* minor fix in CHA and RTA resolvers

* Some cleanup

* Add ome additional robustness to LLVMIRToSrc

* Fix AllBottom::compose + make FilteredLLVMAliasSet a bit more robust

* Make getAllExitPoints more flexible + minor

* Handle atexit() in GlobalCtorsDtorsModel (not only __cxa_atexit())

* minor fix in FilteredLLVMAliasSet::isInReachableAllocationSites

* pre-commit

* pre-commit

* Fix name

* Fix new CastInfo for EdgeFunction

* Make LLVMProjectIRDB movable and add static function load() that returns an ErrorOr

* Add function to find the va-list alloca to reduce code duplication

* Remove TODO in ProjectIRDB

* Apply review comments

* minor

---------

Co-authored-by: mxHuber <huber.maximilian.leo@gmail.com>
Co-authored-by: Fabian Schiebel <fabianbs@mail.uni-paderborn.de>
Co-authored-by: Sriteja Kummita <sriteja.ku@gmail.com>

Author: 4 people

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