From 9e7da87f4fe237d1d0b555ce60f9324e06e42aa2 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Sat, 27 Dec 2025 16:54:50 +0100
Subject: [PATCH 01/75] Initial PAGBuilder

---
 .../Pointer/LLVMPointerAssignmentGraph.h      | 134 ++++
 .../phasar/PhasarLLVM/Utils/LLVMShorthands.h  |  31 +
 .../phasar/Pointer/PointerAssignmentGraph.h   | 160 +++++
 include/phasar/Utils/ValueCompressor.h        | 121 ++++
 .../Pointer/LLVMPointerAssignmentGraph.cpp    | 580 ++++++++++++++++++
 lib/PhasarLLVM/Utils/LLVMShorthands.cpp       |  59 ++
 6 files changed, 1085 insertions(+)
 create mode 100644 include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
 create mode 100644 include/phasar/Pointer/PointerAssignmentGraph.h
 create mode 100644 include/phasar/Utils/ValueCompressor.h
 create mode 100644 lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp

diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h b/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
new file mode 100644
index 0000000000..33f24b6ee8
--- /dev/null
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
@@ -0,0 +1,134 @@
+#pragma once
+
+#include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
+#include "phasar/PhasarLLVM/Domain/LLVMAnalysisDomain.h"
+#include "phasar/Pointer/PointerAssignmentGraph.h"
+
+namespace llvm {
+class Instruction;
+class Value;
+class Function;
+} // namespace llvm
+
+namespace psr {
+
+/// The PAG-node used for LLVM-based pointer-assignment graphs. It consists of
+/// regular LLVM values + special return-slots per non-void function. In that
+/// case, the stored pointer is the corresponding function.
+///
+/// This class is compatible with llvm::TinyPtrVector and other APIs relying on
+/// llvm::PointerLikeTypeTraits.
+struct PAGVariable : public llvm::PointerIntPair<const llvm::Value *, 1, bool> {
+  using Base = llvm::PointerIntPair<const llvm::Value *, 1, bool>;
+
+  struct Return {
+    const llvm::Function *Fun;
+  };
+
+  PAGVariable() noexcept = default; // To enable move-assign in TinyPtrVector
+  PAGVariable(const llvm::Value *Var) noexcept : Base(Var, false) {
+    assert(Var != nullptr);
+  }
+  PAGVariable(Return RetVar) noexcept : Base(RetVar.Fun, true) {
+    assert(RetVar.Fun != nullptr);
+  }
+
+  [[nodiscard]] bool isReturnVariable() const noexcept {
+    return this->getInt();
+  }
+
+  [[nodiscard]] bool isInFunction() const noexcept {
+    return isReturnVariable() ||
+           llvm::isa<llvm::Argument, llvm::Instruction>(this->getPointer());
+  }
+
+  [[nodiscard]] const llvm::Function *getFunction() const noexcept {
+    const auto *Ptr = this->getPointer();
+    if (isReturnVariable()) {
+      return llvm::cast<llvm::Function>(Ptr);
+    }
+    if (const auto *Arg = llvm::dyn_cast<llvm::Argument>(Ptr)) {
+      return Arg->getParent();
+    }
+    if (const auto *Inst = llvm::dyn_cast<llvm::Instruction>(Ptr)) {
+      return Inst->getFunction();
+    }
+
+    return nullptr;
+  }
+
+  [[nodiscard]] const llvm::Value *get() const noexcept {
+    return this->getPointer();
+  }
+  explicit operator const llvm::Value *() const noexcept { return get(); }
+
+  [[nodiscard]] const llvm::Value *valueOrNull() const noexcept {
+    return isReturnVariable() ? nullptr : get();
+  }
+
+  friend bool operator==(PAGVariable V1, PAGVariable V2) noexcept {
+    return V1.getOpaqueValue() == V2.getOpaqueValue();
+  }
+  friend bool operator!=(PAGVariable V1, PAGVariable V2) noexcept {
+    return !(V1 == V2);
+  }
+
+  friend auto hash_value(PAGVariable V) noexcept {
+    return llvm::hash_value(V.getOpaqueValue());
+  }
+};
+
+[[nodiscard]] std::string to_string(PAGVariable Var);
+
+struct LLVMPAGDomain : LLVMAnalysisDomainDefault {
+  using v_t = PAGVariable;
+};
+
+class LLVMPAGBuilder : public PAGBuilder<LLVMPAGDomain> {
+  struct PAGBuildData;
+  void buildPAG(const LLVMProjectIRDB &IRDB, ValueCompressor<v_t> &VC,
+                PBStrategy &Strategy) override;
+};
+
+} // namespace psr
+
+namespace llvm {
+template <> struct PointerLikeTypeTraits<psr::PAGVariable> {
+  static inline void *getAsVoidPointer(psr::PAGVariable P) {
+    return P.getOpaqueValue();
+  }
+
+  static inline psr::PAGVariable getFromVoidPointer(void *P) {
+    psr::PAGVariable V{nullptr};
+    static_cast<psr::PAGVariable::Base &>(V) =
+        psr::PAGVariable::Base::getFromOpaqueValue(P);
+    return V;
+  }
+
+  static inline psr::PAGVariable getFromVoidPointer(const void *P) {
+    psr::PAGVariable V{nullptr};
+    static_cast<psr::PAGVariable::Base &>(V) =
+        psr::PAGVariable::Base::getFromOpaqueValue(P);
+    return V;
+  }
+
+  static constexpr int NumLowBitsAvailable =
+      PointerLikeTypeTraits<psr::PAGVariable::Base>::NumLowBitsAvailable;
+};
+
+template <> struct DenseMapInfo<psr::PAGVariable> {
+  static psr::PAGVariable getEmptyKey() noexcept {
+    return DenseMapInfo<const llvm::Value *>::getEmptyKey();
+  }
+  static psr::PAGVariable getTombstoneKey() noexcept {
+    return DenseMapInfo<const llvm::Value *>::getTombstoneKey();
+  }
+  static hash_code getHashValue(psr::PAGVariable V) noexcept {
+    return hash_value(V);
+  }
+
+  static bool isEqual(psr::PAGVariable V1, psr::PAGVariable V2) noexcept {
+    return V1 == V2;
+  }
+};
+} // namespace llvm
diff --git a/include/phasar/PhasarLLVM/Utils/LLVMShorthands.h b/include/phasar/PhasarLLVM/Utils/LLVMShorthands.h
index 582fef9500..711820f467 100644
--- a/include/phasar/PhasarLLVM/Utils/LLVMShorthands.h
+++ b/include/phasar/PhasarLLVM/Utils/LLVMShorthands.h
@@ -19,6 +19,10 @@
 
 #include "phasar/Utils/Utilities.h"
 
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/Type.h"
+#include "llvm/Support/Casting.h"
+
 #include <string>
 #include <vector>
 
@@ -256,6 +260,33 @@ bool isGuardVariable(const llvm::Value *V);
  */
 bool isStaticVariableLazyInitializationBranch(const llvm::BranchInst *Inst);
 
+/// Approximates, whether the given LLVM type may not contain a pointer.
+/// This check is designed to be extremely lightweight and is therefore not very
+/// precise.
+///
+/// \returns True, iff it can be proven that Ty does *not* contain a pointer
+[[nodiscard]] inline bool definitelyContainsNoPointer(const llvm::Type *Ty) {
+  return Ty->isIntOrIntVectorTy() || Ty->isFloatingPointTy() ||
+         Ty->isFPOrFPVectorTy() || Ty->isVoidTy();
+}
+/// Approximates, whether the given LLVM value may not contain a pointer.
+/// This check is designed to be extremely lightweight and is therefore not very
+/// precise.
+///
+/// \returns True, iff it can be proven that Val does *not* contain a pointer
+[[nodiscard]] inline bool definitelyContainsNoPointer(const llvm::Value *Val) {
+  return llvm::isa<llvm::ConstantData>(Val) ||
+         definitelyContainsNoPointer(Val->getType());
+}
+
+/// Approximates, whether the given LLVM value may be address-taken, i.e.,
+/// whether its pointer value is used for other purposes than just
+/// store/load/gep.
+///
+/// This check is designed to be rather lightweight and may therefore not be
+/// precise in all cases.
+[[nodiscard]] bool isAddressTakenVariable(const llvm::Value *Var) noexcept;
+
 /**
  * Tests for <https://llvm.org/docs/LangRef.html#llvm-var-annotation-intrinsic>
  * e.g.
diff --git a/include/phasar/Pointer/PointerAssignmentGraph.h b/include/phasar/Pointer/PointerAssignmentGraph.h
new file mode 100644
index 0000000000..1d3231c19a
--- /dev/null
+++ b/include/phasar/Pointer/PointerAssignmentGraph.h
@@ -0,0 +1,160 @@
+#pragma once
+
+#include "phasar/Utils/ByRef.h"
+#include "phasar/Utils/Macros.h"
+#include "phasar/Utils/Nullable.h"
+#include "phasar/Utils/TypeTraits.h"
+#include "phasar/Utils/Utilities.h"
+#include "phasar/Utils/ValueCompressor.h"
+
+#include <cstdint>
+#include <optional>
+#include <variant>
+
+namespace psr {
+
+/// A utility-class that can be used to build a pointer-assignment graph (PAG).
+///
+/// This class does not enforce a specifiy graph-layout -- it does not even
+/// require that you explicitly store a graph in memory. Instead, you get
+/// notified about every node and edge that should be created in the PAG.
+///
+/// \tparam AnalysisDomainT The analysis domain to use.
+template <typename AnalysisDomainT> class PAGBuilder {
+public:
+  using n_t = typename AnalysisDomainT::n_t;
+  using v_t = typename AnalysisDomainT::v_t;
+  using f_t = typename AnalysisDomainT::f_t;
+  using db_t = typename AnalysisDomainT::db_t;
+
+  struct Assign {};
+  struct Gep {
+    std::optional<int16_t> Offset;
+  };
+  struct Call {
+    uint16_t ArgNo;
+  };
+  struct Return {};
+  struct Load {};
+  struct Store {};
+  struct StorePOI {};
+  struct Copy {};
+
+  struct Edge : public std::variant<Assign, Gep, Call, Return, Load, Store,
+                                    StorePOI, Copy> {
+    using Base =
+        std::variant<Assign, Gep, Call, Return, Load, Store, StorePOI, Copy>;
+    using std::variant<Assign, Gep, Call, Return, Load, Store, StorePOI,
+                       Copy>::variant;
+
+    template <typename T> static constexpr size_t kindOf() noexcept {
+      return psr::variant_idx<Base, T>;
+    }
+
+    [[nodiscard]] constexpr size_t kind() const noexcept {
+      return this->index();
+    }
+
+    template <typename T, typename... Ts>
+    [[nodiscard]] constexpr bool isa() const noexcept {
+      return std::holds_alternative<T>(*this) ||
+             (... || std::holds_alternative<Ts>(*this));
+    }
+
+    template <typename T>
+    [[nodiscard]] constexpr std::optional<T> dyn_cast() const noexcept {
+      if (const auto *Ptr = std::get_if<T>(this)) {
+        return *Ptr;
+      }
+
+      return std::nullopt;
+    }
+
+    template <typename HandlerFn>
+    constexpr decltype(auto) apply(HandlerFn &&Handler) const {
+      return std::visit(PSR_FWD(Handler), *this);
+    }
+
+    [[nodiscard]] friend constexpr llvm::StringRef to_string(Edge E) noexcept {
+      return E.apply(psr::Overloaded{
+          [](Assign) { return "Assign"; },
+          // TODO: Print offset, if present
+          [](Gep) { return "Gep"; },
+          // TODO: Print ArgNo
+          [](Call) { return "Call"; },
+          [](Return) { return "Return"; },
+          [](Load) { return "Load"; },
+          [](Store) { return "Store"; },
+          [](StorePOI) { return "StorePOI"; },
+          [](Copy) { return "Copy"; },
+      });
+    }
+  };
+
+  /// The main customization point for PAG building.
+  /// Implement this interface to provide several callbacks to the PAGBuilder,
+  /// specifying how the PAG should be built.
+  struct PBStrategy {
+    constexpr PBStrategy() noexcept = default;
+    virtual ~PBStrategy() = default;
+
+    /// Called by buildPAG() for every (unique) edge that should be added to the
+    /// PAG
+    ///
+    /// \param From The source-node.
+    /// \param To The destination-node.
+    /// \param E The edge-label that specifies the kind of data-flow that is
+    /// denoted by this edge.
+    /// \param AtInstruction Optionally holds the instruction that caused this
+    /// edge to be created.
+    virtual void onAddEdge(ValueId From, ValueId To, Edge E,
+                           Nullable<n_t> AtInstruction) = 0;
+
+    /// Called by buildPAG() for every (unique) node that should be added to the
+    /// PAG, *excluding* nodes that have already been registered in the used
+    /// ValueCompressor before buildPAG() was called.
+    ///
+    /// \param Variable The IR-specific variable/value for which the new node
+    /// has been created.
+    /// \param VId The value-id of the newly created node.
+    virtual void onAddValue(ByConstRef<v_t> Variable, ValueId VId) {
+      // Do things like allocating a new slot in the adjacency-list here
+    }
+
+    /// Estimates the maximum number of values created in the ValueCompressor.
+    /// Must not be exact, this is just for pre-allocating buffers for
+    /// optimization purposes.
+    [[nodiscard]] virtual size_t
+    getNumPossibleValues(const db_t &IRDB) const noexcept {
+      // May use a different heuristic here...
+      return IRDB.getNumInstructions();
+    }
+
+    /// Invokes a call-back with each function that may be called at the given
+    /// call-site. Usually, you want to use a CallGraph or a Resolver here.
+    ///
+    /// \param CS The call-site.
+    /// \param WithCallee The callback to be invoked for each callee.
+    virtual void
+    withCalleesOfCallAt(ByConstRef<n_t> CS,
+                        llvm::function_ref<void(f_t)> WithCallee) const = 0;
+  };
+
+  constexpr PAGBuilder() noexcept = default;
+  virtual ~PAGBuilder() = default;
+
+  /// Iterates the passed IRDB to build a PAG, based on the given Strategy.
+  ///
+  /// \param IRDB The IR program to analyze.
+  /// \param VC The value-compressor to use for assigning unique sequential
+  /// integer-ids to each PAG-node. This VC may be pre-populated. You can expect
+  /// that buildPAG() will respect the pre-population in that case. Otherwise,
+  /// ids will be assigned in visitation order (which is not stable and should
+  /// not be relied on!).
+  /// \param Strategy The customization-point for this function. See the docs of
+  /// PBStrategy for more information.
+  virtual void buildPAG(const db_t &IRDB, ValueCompressor<v_t> &VC,
+                        PBStrategy &Strategy) = 0;
+};
+
+} // namespace psr
diff --git a/include/phasar/Utils/ValueCompressor.h b/include/phasar/Utils/ValueCompressor.h
new file mode 100644
index 0000000000..f03dba2be3
--- /dev/null
+++ b/include/phasar/Utils/ValueCompressor.h
@@ -0,0 +1,121 @@
+#pragma once
+
+#include "phasar/Utils/ByRef.h"
+#include "phasar/Utils/TypedVector.h"
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/TinyPtrVector.h"
+#include "llvm/Support/PointerLikeTypeTraits.h"
+
+#include <optional>
+#include <type_traits>
+
+namespace psr {
+
+namespace detail {
+template <typename T>
+static constexpr bool IsPointerWithAtleastOneFreeLowBit = false;
+template <typename T>
+  requires requires() { llvm::PointerLikeTypeTraits<T>::NumLowBitsAvailable; }
+static constexpr bool IsPointerWithAtleastOneFreeLowBit<T> =
+    llvm::PointerLikeTypeTraits<T>::NumLowBitsAvailable > 0;
+} // namespace detail
+
+/// The id-type for values inserted into the ValueCompressor.
+enum class ValueId : uint32_t {};
+
+/// A utility-class that assigns sequential integer-like ids (psr::ValueId) to
+/// every inserted value.
+///
+/// In contrast to psr::Compressor, the ValueCompressor can optionally
+/// assign the same id to multiple values, and it can even produce ids without
+/// corresponding values.
+///
+/// \tparam T The type of inserted values. Expected to be mostly small and
+/// trivial.
+template <typename T> class ValueCompressor {
+public:
+  using value_type = T;
+  using id_type = ValueId;
+  using var_aliases_type = std::conditional_t<
+      detail::IsPointerWithAtleastOneFreeLowBit<T>, llvm::TinyPtrVector<T>,
+      // Note: The inline-buffer of SmallVector is pointer-aligned, so it would
+      // be wasteful to only allow one, e.g., int16
+      llvm::SmallVector<T, std::max(size_t(1), sizeof(void *) / sizeof(T))>>;
+
+  [[nodiscard]] constexpr const auto &id2vars() const noexcept
+      [[clang::lifetimebound]] {
+    return Id2Vars;
+  }
+  [[nodiscard]] constexpr const auto &id2vars(ValueId Id) const noexcept
+      [[clang::lifetimebound]] {
+    return Id2Vars[Id];
+  }
+  [[nodiscard]] constexpr const auto &var2id() const noexcept
+      [[clang::lifetimebound]] {
+    return Var2Id;
+  }
+
+  std::pair<ValueId, bool> insert(ByConstRef<T> Var) {
+    auto [It, Inserted] = Var2Id.try_emplace(Var, ValueId(Id2Vars.size()));
+    if (Inserted) {
+      Id2Vars.emplace_back().push_back(Var);
+    }
+    return {It->second, Inserted};
+  }
+
+  bool addAlias(ByConstRef<T> Var, ValueId Id) {
+    assert(Id2Vars.inbounds(Id) &&
+           "Can only add an alias to an already existing Id!");
+    if (Var2Id.try_emplace(Var, Id).second) {
+      Id2Vars[Id].push_back(Var);
+      return true;
+    }
+    return false;
+  }
+
+  [[nodiscard]] ValueId addDummy() {
+    auto Ret = ValueId(Id2Vars.size());
+    Id2Vars.emplace_back();
+    return Ret;
+  }
+
+  [[nodiscard]] std::optional<ValueId> getOrNull(ByConstRef<T> Var) const {
+    auto It = Var2Id.find(Var);
+    if (It == Var2Id.end()) {
+      return std::nullopt;
+    }
+    return It->second;
+  }
+
+  void reserve(size_t Capa) {
+    Var2Id.reserve(Capa);
+    Id2Vars.reserve(Capa);
+  }
+
+  [[nodiscard]] size_t size() const noexcept { return Id2Vars.size(); }
+  [[nodiscard]] size_t empty() const noexcept { return Id2Vars.empty(); }
+
+private:
+  llvm::DenseMap<T, ValueId> Var2Id;
+  TypedVector<ValueId, var_aliases_type> Id2Vars;
+};
+
+} // namespace psr
+
+namespace llvm {
+template <> struct DenseMapInfo<psr::ValueId> {
+  static constexpr psr::ValueId getEmptyKey() noexcept {
+    return psr::ValueId(UINT32_MAX);
+  }
+  static constexpr psr::ValueId getTombstoneKey() noexcept {
+    return psr::ValueId(UINT32_MAX - 1);
+  }
+  static inline llvm::hash_code getHashValue(psr::ValueId VId) {
+    return llvm::hash_value(std::underlying_type_t<psr::ValueId>(VId));
+  }
+  static constexpr bool isEqual(psr::ValueId L, psr::ValueId R) noexcept {
+    return L == R;
+  }
+};
+} // namespace llvm
diff --git a/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp b/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp
new file mode 100644
index 0000000000..0faf7b8869
--- /dev/null
+++ b/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp
@@ -0,0 +1,580 @@
+#include "phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h"
+
+#include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
+#include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
+#include "phasar/Utils/BitSet.h"
+#include "phasar/Utils/MapUtils.h"
+#include "phasar/Utils/ValueCompressor.h"
+
+#include "llvm/ADT/BitVector.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/DataLayout.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/IntrinsicInst.h"
+#include "llvm/IR/Operator.h"
+
+#include <concepts>
+
+using namespace psr;
+
+static_assert(detail::IsPointerWithAtleastOneFreeLowBit<PAGVariable>);
+
+std::string psr::to_string(PAGVariable Var) {
+  auto Ret = llvmIRToString(Var.get());
+  if (Var.isReturnVariable()) {
+    Ret += ".<ret>";
+  }
+  return Ret;
+}
+
+namespace {
+
+using LLVMPBStrategy = LLVMPAGBuilder::PBStrategy;
+
+struct GlobalCache {
+  const llvm::DataLayout &DL; // NOLINT
+  // Due to the recursion in getOrCreateGCacheEntry, we need pointer stability
+  std::unordered_map<const llvm::Constant *, llvm::SmallVector<ValueId, 1>>
+      Cache{};
+
+  [[nodiscard]] llvm::ArrayRef<ValueId> getOrCreateGCacheEntry(
+      LLVMPBStrategy &Strategy, const llvm::Constant *Const,
+      std::invocable<const llvm::Value *, LLVMPBStrategy &> auto GetVariable) {
+    if (definitelyContainsNoPointer(Const)) {
+      return {};
+    }
+
+    auto [It, Inserted] = Cache.try_emplace(Const);
+    if (!Inserted) {
+      return It->second;
+    }
+
+    auto &Vec = It->second;
+
+    // We do not care about null here
+    if (llvm::isa<llvm::ConstantPointerNull>(Const)) {
+      return {};
+    }
+
+    if (const auto *CGep = llvm::dyn_cast<llvm::GEPOperator>(Const)) {
+      // TODO: Properly handle constant GEPs
+      return getOrCreateGCacheEntry(
+          Strategy, llvm::cast<llvm::Constant>(CGep->getPointerOperand()),
+          GetVariable);
+    }
+
+    if (Const->getType()->isPointerTy()) {
+      Vec.push_back(GetVariable(Const, Strategy));
+
+      return Vec;
+    }
+
+    if (!llvm::isa<llvm::ConstantAggregate>(Const)) {
+      return {};
+    }
+
+    // TODO: Get rid of the recursion
+
+    if (const auto *Arr = llvm::dyn_cast<llvm::ConstantAggregate>(Const)) {
+      if (Arr->getType()->isArrayTy() &&
+          definitelyContainsNoPointer(Arr->getType()->getArrayElementType())) {
+        return {};
+      }
+
+      size_t ArrayLen = Arr->getNumOperands();
+      for (size_t I = 0; I < ArrayLen; ++I) {
+        auto *Elem = llvm::cast<llvm::Constant>(
+            Arr->getAggregateElement(I)->stripPointerCastsAndAliases());
+        auto ElemVars = getOrCreateGCacheEntry(Strategy, Elem, GetVariable);
+        Vec.append(ElemVars.begin(), ElemVars.end());
+      }
+      return Vec;
+    }
+
+    // TODO: more
+
+    return Vec;
+  }
+};
+} // namespace
+struct LLVMPAGBuilder::PAGBuildData {
+  const llvm::DataLayout &DL; // NOLINT
+  ValueCompressor<v_t> &VC;   // NOLINT
+
+  llvm::DenseMap<ValueId, ValueId> TheOneLoad{};
+  BitSet<ValueId> OnlyIncomingStoresAndOutgoingLoads{};
+  TypedVector<ValueId, llvm::SmallDenseMap<ValueId, Edge, 2>> IncomingStores{};
+  TypedVector<ValueId, llvm::SmallDenseSet<ValueId, 2>> OutgoingLoads{};
+  llvm::DenseMap<const llvm::Value *, llvm::SmallDenseMap<int64_t, ValueId>>
+      LocalGeps{};
+
+  [[nodiscard]] ValueId getVariable(PAGVariable V, LLVMPBStrategy &Strategy) {
+    auto [Id, Inserted] = VC.insert(V);
+    if (Inserted) {
+      OnlyIncomingStoresAndOutgoingLoads.insert(Id);
+      IncomingStores.emplace_back();
+      OutgoingLoads.emplace_back();
+      Strategy.onAddValue(V, Id);
+    }
+
+    return Id;
+  }
+
+  void addAllIncomingStores(PBStrategy &Strategy, ValueId To,
+                            llvm::SmallDenseMap<ValueId, Edge, 2> &Froms) {
+    for (auto [From, E] : Froms) {
+      Strategy.onAddEdge(From, To, E, nullptr);
+    }
+    Froms.clear();
+  }
+  void addAllOutgoingLoads(PBStrategy &Strategy, ValueId From,
+                           llvm::SmallDenseSet<ValueId, 2> &Tos) {
+    for (auto To : Tos) {
+      Strategy.onAddEdge(From, To, Load{}, nullptr);
+    }
+    Tos.clear();
+  }
+
+  void eraseFromSimpleStoreLoad(PBStrategy &Strategy, ValueId VId) {
+    if (OnlyIncomingStoresAndOutgoingLoads.tryErase(VId)) {
+      addAllIncomingStores(Strategy, VId, IncomingStores[VId]);
+      addAllOutgoingLoads(Strategy, VId, OutgoingLoads[VId]);
+    }
+  }
+
+  void addEdge(PBStrategy &Strategy, ValueId From, ValueId To, Edge E,
+               const llvm::Instruction *AtInstruction) {
+    // llvm::errs() << "[addEdge]: " << int(From) << "->" << int(To)
+    //              << " :: " << to_string(E) << '\n';
+    if (!E.isa<Store, StorePOI>()) {
+      eraseFromSimpleStoreLoad(Strategy, To);
+    } else if (OnlyIncomingStoresAndOutgoingLoads.contains(To)) {
+      eraseFromSimpleStoreLoad(Strategy, From);
+
+      // We delay store edges
+      IncomingStores[To].try_emplace(From, E);
+      return;
+    }
+
+    if (!E.isa<Load>()) {
+      eraseFromSimpleStoreLoad(Strategy, From);
+    } else if (OnlyIncomingStoresAndOutgoingLoads.contains(From)) {
+      eraseFromSimpleStoreLoad(Strategy, To);
+      // We delay load edges
+      OutgoingLoads[From].insert(To);
+      return;
+    }
+
+    Strategy.onAddEdge(From, To, E, AtInstruction);
+  }
+
+  void initializeGlobals(const LLVMProjectIRDB &IRDB,
+                         LLVMPBStrategy &Strategy) {
+    GlobalCache GCache{IRDB.getModule()->getDataLayout()};
+
+    for (const auto &Glob : IRDB.getModule()->globals()) {
+      if (definitelyContainsNoPointer(Glob.getValueType())) {
+        continue;
+      }
+
+      if (Glob.hasInitializer()) {
+        initializeGlobal(GCache, Strategy, Glob);
+      }
+    }
+  }
+
+  void initializeGlobal(GlobalCache &GCache, LLVMPBStrategy &Strategy,
+                        const llvm::GlobalVariable &Glob) {
+    auto GlobObj = getVariable(&Glob, Strategy);
+    auto Stores = GCache.getOrCreateGCacheEntry(
+        Strategy, Glob.getInitializer(),
+        [this](const llvm::Value *V, LLVMPBStrategy &Strategy) {
+          return getVariable(V, Strategy);
+        });
+
+    for (auto Src : Stores) {
+      // NOTE: We don't consider this a POI for now; probably, that's fine
+      addEdge(Strategy, Src, GlobObj, Store{}, nullptr);
+    }
+  }
+
+  void initializeFunctions(const LLVMProjectIRDB &IRDB, PBStrategy &Strategy) {
+    // TODO: Use LibrarySummary here
+    // TODO: Skip functions that have been proven unreachable previously
+
+    for (const auto *Fun : IRDB.getAllFunctions()) {
+      if (!Fun->isDeclaration()) {
+        initializeFun(Strategy, *Fun);
+      }
+    }
+
+    addDelayedEdges(Strategy);
+  }
+
+  void initializeFun(PBStrategy &Strategy, const llvm::Function &Fun) {
+    // TODO: RPO Order to profit from OTF-merged values
+    for (const auto &BB : Fun) {
+      propagateBB(Strategy, BB);
+    }
+  }
+
+  void addDelayedEdges(PBStrategy &Strategy) {
+    OnlyIncomingStoresAndOutgoingLoads.foreach ([this, &Strategy](auto Val) {
+      auto VId = ValueId(Val);
+
+      for (auto [IncStore, _] : IncomingStores[VId]) {
+        for (auto OutLoad : OutgoingLoads[VId]) {
+          Strategy.onAddEdge(IncStore, OutLoad, Assign{}, nullptr);
+        }
+        if (OutgoingLoads[VId].empty()) {
+          Strategy.onAddEdge(IncStore, VId, StorePOI{}, nullptr);
+        }
+      }
+      if (IncomingStores[VId].empty()) {
+        for (auto OutLoad : OutgoingLoads[VId]) {
+          Strategy.onAddEdge(VId, OutLoad, Load{}, nullptr);
+        }
+      }
+    });
+  }
+
+  void propagateBB(PBStrategy &Strategy, const llvm::BasicBlock &BB) {
+    const auto *Inst = &BB.front();
+    if (Inst->isDebugOrPseudoInst()) {
+      Inst = Inst->getNextNonDebugInstruction();
+    }
+
+    for (; Inst; Inst = Inst->getNextNonDebugInstruction()) {
+      dispatch(Strategy, *Inst);
+    }
+  }
+
+  void dispatch(PBStrategy &Strategy, const llvm::Instruction &I) {
+    if (const auto *Alloca = llvm::dyn_cast<llvm::AllocaInst>(&I)) {
+      return (void)getVariable(Alloca, Strategy);
+    }
+
+    if (const auto *Store = llvm::dyn_cast<llvm::StoreInst>(&I)) {
+      return handleStore(Strategy, Store);
+    }
+
+    if (const auto *Load = llvm::dyn_cast<llvm::LoadInst>(&I)) {
+      return handleLoad(Strategy, Load);
+    }
+
+    if (const auto *Cast = llvm::dyn_cast<llvm::CastInst>(&I)) {
+      return handleCast(Strategy, Cast);
+    }
+
+    if (const auto *GEP = llvm::dyn_cast<llvm::GEPOperator>(&I)) {
+      return handleGep(Strategy, GEP);
+    }
+
+    if (const auto *MemTrn = llvm::dyn_cast<llvm::MemTransferInst>(&I)) {
+      return handleMemTransfer(Strategy, MemTrn);
+    }
+
+    if (const auto *Call = llvm::dyn_cast<llvm::CallBase>(&I)) {
+      return handleCall(Strategy, Call);
+    }
+
+    if (const auto *Ret = llvm::dyn_cast<llvm::ReturnInst>(&I)) {
+      return handleReturn(Strategy, Ret);
+    }
+
+    if (const auto *Phi = llvm::dyn_cast<llvm::PHINode>(&I)) {
+      return handlePhi(Strategy, Phi);
+    }
+
+    if (const auto *Select = llvm::dyn_cast<llvm::SelectInst>(&I)) {
+      return handleSelect(Strategy, Select);
+    }
+  }
+
+  static void handleOperand(const llvm::Value *RawOp,
+                            std::invocable<const llvm::Value *> auto Handler) {
+    RawOp = RawOp->stripPointerCastsAndAliases();
+    const auto *RawOpCExpr = llvm::dyn_cast<llvm::ConstantExpr>(RawOp);
+    if (!RawOpCExpr) [[likely]] {
+      // fast-path:
+      return (void)std::invoke(Handler, RawOp);
+    }
+
+    llvm::SmallDenseSet<const llvm::Value *> Seen = {RawOp};
+    llvm::SmallVector<const llvm::User *> WL = {RawOpCExpr};
+    do {
+      const auto *Curr = WL.pop_back_val();
+      for (const auto *Op : Curr->operand_values()) {
+        if (definitelyContainsNoPointer(Op) || !Seen.insert(Op).second) {
+          continue;
+        }
+
+        if (const auto *GObj = llvm::dyn_cast<llvm::GlobalObject>(Op)) {
+          std::invoke(Handler, GObj);
+          continue;
+        }
+
+        // TODO: Handle constant GEP!
+
+        if (const auto *OpUser = llvm::dyn_cast<llvm::User>(Op)) {
+          WL.push_back(OpUser);
+          continue;
+        }
+      }
+
+    } while (!WL.empty());
+  }
+
+  void handleStore(PBStrategy &Strategy, const llvm::StoreInst *Store) {
+
+    if (definitelyContainsNoPointer(Store->getValueOperand())) {
+      return;
+    }
+
+    handleOperand(Store->getPointerOperand(), [&](const auto *PointerOp) {
+      auto PointerObj = getVariable(PointerOp, Strategy);
+      handleOperand(Store->getValueOperand(), [&](const auto *ValueOp) {
+        auto ValueObj = getVariable(ValueOp, Strategy);
+        addEdge(Strategy, ValueObj, PointerObj, StorePOI{}, Store);
+      });
+    });
+  }
+
+  void handleLoad(PBStrategy &Strategy, const llvm::LoadInst *Ld) {
+    if (definitelyContainsNoPointer(Ld)) {
+      return;
+    }
+
+    handleOperand(Ld->getPointerOperand(), [&](const auto *PointerOp) {
+      auto PointerObj = getVariable(PointerOp, Strategy);
+      if (llvm::isa<llvm::Argument, llvm::Instruction>(PointerOp)) {
+        auto [It, Inserted] = TheOneLoad.try_emplace(PointerObj, ValueId{});
+
+        if (!Inserted) {
+          VC.addAlias(Ld, It->second);
+          return;
+        }
+
+        auto LoadObj = getVariable(Ld, Strategy);
+        It->second = LoadObj;
+        addEdge(Strategy, PointerObj, LoadObj, Load{}, Ld);
+        return;
+      }
+
+      auto LoadObj = getVariable(Ld, Strategy);
+      addEdge(Strategy, PointerObj, LoadObj, Load{}, Ld);
+    });
+  }
+
+  void handleCastImpl(PBStrategy &Strategy, const llvm::User *Cast,
+                      const llvm::Value *Op) {
+    auto OperandObj = getVariable(Op, Strategy);
+
+    if (llvm::isa<llvm::GEPOperator>(Cast)) {
+      if (const auto *LocalGeps = psr::getOrNull(this->LocalGeps, Cast)) {
+        for (auto [_, Gep] : *LocalGeps) {
+          addEdge(Strategy, OperandObj, Gep, Assign{}, nullptr);
+        }
+        return;
+      }
+    }
+
+    VC.addAlias(Cast, OperandObj);
+  }
+
+  void handleCast(PBStrategy &Strategy, const llvm::User *Cast) {
+    if (definitelyContainsNoPointer(Cast)) {
+      return;
+    }
+
+    handleOperand(Cast->getOperand(0),
+                  [&](const auto *Op) { handleCastImpl(Strategy, Cast, Op); });
+  }
+  void handleGep(PBStrategy &Strategy, const llvm::GEPOperator *Gep) {
+    handleOperand(Gep->getPointerOperand(), [&](const auto *PointerOp) {
+      if (psr::isAllocaInstOrHeapAllocaFunction(PointerOp) &&
+          !isAddressTakenVariable(PointerOp) && Gep->hasAllConstantIndices() &&
+          !Gep->hasAllZeroIndices()) {
+        llvm::APInt Offset(64, 0);
+        if (Gep->accumulateConstantOffset(DL, Offset)) {
+          auto [It, Inserted] =
+              LocalGeps[PointerOp].try_emplace(Offset.getSExtValue());
+          if (!Inserted) {
+            VC.addAlias(Gep, It->second);
+            return;
+          }
+
+          auto GepObj = getVariable(Gep, Strategy);
+          It->second = GepObj;
+          // Do not add an edge! Geps should be decoupled!
+          return;
+        }
+      }
+
+      handleCastImpl(Strategy, Gep, PointerOp);
+    });
+  }
+
+  void handleMemTransfer(PBStrategy &Strategy,
+                         const llvm::MemTransferInst *MemTrn) {
+
+    handleOperand(MemTrn->getDest(), [&](const auto *Dest) {
+      auto DestObj = getVariable(Dest, Strategy);
+
+      handleOperand(MemTrn->getSource(), [&](const auto *Src) {
+        auto SourceObj = getVariable(Src, Strategy);
+        addEdge(Strategy, SourceObj, DestObj, Copy{}, MemTrn);
+
+        const auto &DestGeps = getOrDefault(LocalGeps, Dest);
+        for (const auto &[Offset, SrcGep] : getOrDefault(LocalGeps, Src)) {
+          if (const auto *DestGep = getOrNull(DestGeps, Offset)) {
+            addEdge(Strategy, SrcGep, *DestGep, Copy{}, MemTrn);
+          } else {
+            addEdge(Strategy, SrcGep, DestObj, Copy{}, MemTrn);
+          }
+        }
+      });
+    });
+  }
+
+  void handleCallTarget(PBStrategy &Strategy, const llvm::CallBase *Call,
+                        const llvm::Function *Callee,
+                        llvm::ArrayRef<llvm::SmallDenseSet<ValueId>> Args,
+                        std::optional<ValueId> CSVal) {
+    // TODO: Handle library summaries here!
+    if (Callee->isDeclaration()) {
+      return;
+    }
+
+    if (CSVal) {
+      auto RetObj = getVariable(PAGVariable::Return{Callee}, Strategy);
+      addEdge(Strategy, RetObj, *CSVal, Return{}, Call);
+    }
+
+    for (const auto &[Param, Arg] : llvm::zip(Callee->args(), Args)) {
+      if (Arg.empty()) {
+        continue;
+      }
+
+      // XXX: Check, whether Arg is an address-taken variable. Then we can
+      // differentiate between Call and CallPOI; not relevant for now, though,
+      // because we ignore call-pois
+      auto ParamObj = getVariable(&Param, Strategy);
+      for (auto ArgVal : Arg) {
+        addEdge(Strategy, ArgVal, ParamObj,
+                LLVMPAGBuilder::Call{uint16_t(Param.getArgNo())}, Call);
+      }
+    }
+
+    // TODO: Varargs
+  }
+
+  void handleCall(PBStrategy &Strategy, const llvm::CallBase *Call) {
+    const auto *FnPtr = Call->getCalledOperand()->stripPointerCastsAndAliases();
+
+    llvm::SmallVector<llvm::SmallDenseSet<ValueId>> Args;
+    for (const auto &Arg : Call->args()) {
+      auto &ArgVal = Args.emplace_back();
+      if (definitelyContainsNoPointer(Arg)) {
+        continue;
+      }
+
+      handleOperand(Arg.get(), [&](const auto *ArgOp) {
+        ArgVal.insert(getVariable(ArgOp, Strategy));
+      });
+    }
+    std::optional<ValueId> CSVal;
+    if (Call->getType()->isPointerTy()) {
+      CSVal = getVariable(Call, Strategy);
+    }
+
+    if (const auto *Callee = llvm::dyn_cast<llvm::Function>(FnPtr)) {
+      return handleCallTarget(Strategy, Call, Callee, Args, CSVal);
+    }
+
+    Strategy.withCalleesOfCallAt(Call, [&](const auto *Callee) {
+      handleCallTarget(Strategy, Call, Callee, Args, CSVal);
+    });
+  }
+
+  void handleReturn(PBStrategy &Strategy, const llvm::ReturnInst *Ret) {
+    const auto *RetVal = Ret->getReturnValue();
+    if (!RetVal || definitelyContainsNoPointer(RetVal)) {
+      return;
+    }
+
+    auto RetObj =
+        getVariable(PAGVariable::Return{Ret->getFunction()}, Strategy);
+    handleOperand(RetVal, [&](const auto *ExitOp) {
+      auto ExitObj = getVariable(ExitOp, Strategy);
+      addEdge(Strategy, ExitObj, RetObj, Assign{}, Ret);
+    });
+  }
+
+  void handlePhi(PBStrategy &Strategy, const llvm::PHINode *Phi) {
+    if (definitelyContainsNoPointer(Phi)) {
+      return;
+    }
+
+    auto PhiObj = getVariable(Phi, Strategy);
+
+    for (const auto &Inc : Phi->incoming_values()) {
+      if (definitelyContainsNoPointer(Inc)) {
+        continue;
+      }
+
+      // Here, we should make sure that all incoming BBs are already handled...
+
+      handleOperand(Inc.get(), [&](const auto *IncOp) {
+        auto IncObj = getVariable(IncOp, Strategy);
+        addEdge(Strategy, IncObj, PhiObj, Assign{}, Phi);
+      });
+    }
+  }
+
+  void handleSelect(PBStrategy &Strategy, const llvm::SelectInst *Select) {
+    if (definitelyContainsNoPointer(Select)) {
+      return;
+    }
+
+    const auto *TrueVal = Select->getTrueValue()->stripPointerCastsAndAliases();
+    const auto *FalseVal =
+        Select->getFalseValue()->stripPointerCastsAndAliases();
+
+    auto SelectObj = getVariable(Select, Strategy);
+    // In the union-find, these are all merged; maybe be a bit smarter here...
+
+    if (!definitelyContainsNoPointer(TrueVal)) {
+      handleOperand(TrueVal, [&](const auto *TrueOp) {
+        auto TrueObj = getVariable(TrueOp, Strategy);
+        addEdge(Strategy, TrueObj, SelectObj, Assign{}, Select);
+      });
+    }
+    if (!definitelyContainsNoPointer(FalseVal)) {
+      handleOperand(FalseVal, [&](const auto *FalseOp) {
+        auto TrueObj = getVariable(FalseOp, Strategy);
+        addEdge(Strategy, TrueObj, SelectObj, Assign{}, Select);
+      });
+    }
+  }
+};
+
+void psr::LLVMPAGBuilder::buildPAG(const LLVMProjectIRDB &IRDB,
+                                   ValueCompressor<v_t> &VC,
+                                   PBStrategy &Strategy) {
+  PAGBuildData BData{IRDB.getModule()->getDataLayout(), VC};
+
+  const size_t NumPossibleValues = Strategy.getNumPossibleValues(IRDB);
+  const size_t NumPresentValues = VC.size();
+
+  BData.IncomingStores.reserve(NumPossibleValues);
+  BData.IncomingStores.resize(NumPresentValues);
+
+  BData.OutgoingLoads.reserve(NumPossibleValues);
+  BData.OutgoingLoads.resize(NumPresentValues);
+
+  BData.OnlyIncomingStoresAndOutgoingLoads.reserve(NumPossibleValues);
+
+  BData.initializeGlobals(IRDB, Strategy);
+  BData.initializeFunctions(IRDB, Strategy);
+}
diff --git a/lib/PhasarLLVM/Utils/LLVMShorthands.cpp b/lib/PhasarLLVM/Utils/LLVMShorthands.cpp
index 3af67f9d8d..6f67426f2a 100644
--- a/lib/PhasarLLVM/Utils/LLVMShorthands.cpp
+++ b/lib/PhasarLLVM/Utils/LLVMShorthands.cpp
@@ -34,6 +34,7 @@
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/ModuleSlotTracker.h"
+#include "llvm/IR/Operator.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
@@ -165,6 +166,9 @@ std::string psr::llvmIRToString(const llvm::Value *V) {
   if (const auto *F = llvm::dyn_cast<llvm::Function>(V)) {
     return "fun @" + F->getName().str();
   }
+  if (const auto *BB = llvm::dyn_cast<llvm::BasicBlock>(V)) {
+    return "block " + BB->getName().str();
+  }
 
   std::string IRBuffer;
   llvm::raw_string_ostream RSO(IRBuffer);
@@ -493,6 +497,61 @@ bool psr::isGuardVariable(const llvm::Value *V) {
   return false;
 }
 
+static bool isAllocationSiteOrSimilar(const llvm::Value *V) {
+  if (const auto *Arg = llvm::dyn_cast<llvm::Argument>(V)) {
+    return Arg->hasStructRetAttr();
+  }
+  return isAllocaInstOrHeapAllocaFunction(V);
+}
+
+bool psr::isAddressTakenVariable(const llvm::Value *Var) noexcept {
+  if (!isAllocationSiteOrSimilar(Var)) {
+    return true;
+  }
+
+  llvm::SmallVector<const llvm::Value *> WL = {Var};
+  llvm::SmallDenseSet<const llvm::Value *> Seen = {Var};
+
+  while (!WL.empty()) {
+    const auto *CurrVal = WL.pop_back_val();
+
+    for (const auto &Use : CurrVal->uses()) {
+      if (llvm::isa<llvm::LoadInst>(Use.getUser())) {
+        continue;
+      }
+      if (const auto *Store = llvm::dyn_cast<llvm::StoreInst>(Use.getUser())) {
+        if (Store->getValueOperand() == Use) {
+          continue;
+        }
+      } else if (llvm::isa<llvm::IntrinsicInst>(Use.getUser())) {
+        // Approximation!
+        continue;
+      } else if (llvm::isa<llvm::CastInst>(Use.getUser())) {
+        if (!CurrVal->getType()->isPointerTy()) {
+          return true; // ptrtoint
+        }
+
+        if (!Seen.insert(Use.getUser()).second) {
+          WL.push_back(Use.getUser());
+        }
+
+        continue;
+      } else if (const auto *GEP =
+                     llvm::dyn_cast<llvm::GEPOperator>(Use.getUser())) {
+        if (Use == GEP->getPointerOperand() && !Seen.insert(GEP).second) {
+          WL.push_back(GEP);
+        }
+
+        continue;
+      }
+
+      return true;
+    }
+  }
+
+  return false;
+}
+
 bool psr::isStaticVariableLazyInitializationBranch(
     const llvm::BranchInst *Inst) {
   if (Inst->isUnconditional()) {

From d94d8c09254eb5ee0520a53e2beb761898b30ef8 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Mon, 29 Dec 2025 15:14:40 +0100
Subject: [PATCH 02/75] Add UnionFind + minor

---
 .../Pointer/LLVMPointerAssignmentGraph.h      |  2 +
 include/phasar/Utils/UnionFind.h              | 56 +++++++++++++++++++
 .../Pointer/LLVMPointerAssignmentGraph.cpp    |  7 +--
 3 files changed, 61 insertions(+), 4 deletions(-)
 create mode 100644 include/phasar/Utils/UnionFind.h

diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h b/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
index 33f24b6ee8..5cfe8000a1 100644
--- a/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
@@ -85,7 +85,9 @@ struct LLVMPAGDomain : LLVMAnalysisDomainDefault {
 };
 
 class LLVMPAGBuilder : public PAGBuilder<LLVMPAGDomain> {
+private:
   struct PAGBuildData;
+
   void buildPAG(const LLVMProjectIRDB &IRDB, ValueCompressor<v_t> &VC,
                 PBStrategy &Strategy) override;
 };
diff --git a/include/phasar/Utils/UnionFind.h b/include/phasar/Utils/UnionFind.h
new file mode 100644
index 0000000000..66b5539f8e
--- /dev/null
+++ b/include/phasar/Utils/UnionFind.h
@@ -0,0 +1,56 @@
+#pragma once
+
+#include "llvm/ADT/IntEqClasses.h"
+
+namespace psr {
+
+template <typename IdT = uint32_t, typename MappedIdT = IdT>
+class CompressedUnionFind;
+
+template <typename IdT = uint32_t> class UnionFind {
+public:
+  UnionFind() noexcept = default;
+  explicit UnionFind(size_t InitSz) : Equiv(InitSz) {}
+
+  IdT join(IdT L, IdT R) { return IdT(Equiv.join(unsigned(L), unsigned(R))); }
+
+  [[nodiscard]] IdT find(IdT Val) const {
+    return IdT(Equiv.findLeader(unsigned(Val)));
+  }
+
+  void grow(size_t NewSz) { Equiv.grow(NewSz); }
+
+  template <typename MappedIdT = IdT>
+  [[nodiscard]] CompressedUnionFind<IdT, MappedIdT> compress() &&;
+
+private:
+  llvm::IntEqClasses Equiv;
+};
+
+template <typename IdT, typename MappedIdT> class CompressedUnionFind {
+public:
+  [[nodiscard]] size_t size() const noexcept { return Equiv.getNumClasses(); }
+
+  [[nodiscard]] bool inbounds(IdT Id) const noexcept {
+    return size_t(Id) < size();
+  }
+
+  [[nodiscard]] MappedIdT operator[](IdT Id) const {
+    assert(inbounds(Id));
+    return MappedIdT(Equiv[unsigned(Id)]);
+  }
+
+private:
+  friend UnionFind<IdT>;
+  CompressedUnionFind(llvm::IntEqClasses &&Equiv) : Equiv(std::move(Equiv)) {}
+
+  llvm::IntEqClasses Equiv;
+};
+
+template <typename IdT>
+template <typename MappedIdT>
+inline CompressedUnionFind<IdT, MappedIdT> UnionFind<IdT>::compress() && {
+  Equiv.compress();
+  return {std::move(Equiv)};
+}
+} // namespace psr
diff --git a/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp b/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp
index 0faf7b8869..084ca8b99f 100644
--- a/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp
+++ b/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp
@@ -97,7 +97,8 @@ struct GlobalCache {
   }
 };
 } // namespace
-struct LLVMPAGBuilder::PAGBuildData {
+
+struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
   const llvm::DataLayout &DL; // NOLINT
   ValueCompressor<v_t> &VC;   // NOLINT
 
@@ -219,9 +220,7 @@ struct LLVMPAGBuilder::PAGBuildData {
   }
 
   void addDelayedEdges(PBStrategy &Strategy) {
-    OnlyIncomingStoresAndOutgoingLoads.foreach ([this, &Strategy](auto Val) {
-      auto VId = ValueId(Val);
-
+    OnlyIncomingStoresAndOutgoingLoads.foreach ([this, &Strategy](auto VId) {
       for (auto [IncStore, _] : IncomingStores[VId]) {
         for (auto OutLoad : OutgoingLoads[VId]) {
           Strategy.onAddEdge(IncStore, OutLoad, Assign{}, nullptr);

From 2cb583dd7fc7955b5985d693b417caec58e425d6 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Tue, 30 Dec 2025 19:01:53 +0100
Subject: [PATCH 03/75] Optional type-erasure for PBStrategy + add
 PBStrategyCombinator

---
 .../Pointer/LLVMPointerAssignmentGraph.h      |   2 +-
 .../phasar/Pointer/PointerAssignmentGraph.h   | 369 +++++++++++++-----
 .../Pointer/LLVMPointerAssignmentGraph.cpp    |  62 +--
 3 files changed, 294 insertions(+), 139 deletions(-)

diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h b/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
index 5cfe8000a1..b7b21bed8c 100644
--- a/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
@@ -89,7 +89,7 @@ class LLVMPAGBuilder : public PAGBuilder<LLVMPAGDomain> {
   struct PAGBuildData;
 
   void buildPAG(const LLVMProjectIRDB &IRDB, ValueCompressor<v_t> &VC,
-                PBStrategy &Strategy) override;
+                pag::PBStrategyRef<LLVMPAGDomain> Strategy) override;
 };
 
 } // namespace psr
diff --git a/include/phasar/Pointer/PointerAssignmentGraph.h b/include/phasar/Pointer/PointerAssignmentGraph.h
index 1d3231c19a..4bf3f66c84 100644
--- a/include/phasar/Pointer/PointerAssignmentGraph.h
+++ b/include/phasar/Pointer/PointerAssignmentGraph.h
@@ -7,139 +7,292 @@
 #include "phasar/Utils/Utilities.h"
 #include "phasar/Utils/ValueCompressor.h"
 
+#include <concepts>
 #include <cstdint>
+#include <memory>
 #include <optional>
+#include <type_traits>
 #include <variant>
 
 namespace psr {
 
-/// A utility-class that can be used to build a pointer-assignment graph (PAG).
-///
-/// This class does not enforce a specifiy graph-layout -- it does not even
-/// require that you explicitly store a graph in memory. Instead, you get
-/// notified about every node and edge that should be created in the PAG.
-///
-/// \tparam AnalysisDomainT The analysis domain to use.
-template <typename AnalysisDomainT> class PAGBuilder {
+namespace pag {
+struct Assign {};
+struct Gep {
+  std::optional<int16_t> Offset;
+};
+struct Call {
+  uint16_t ArgNo;
+};
+struct Return {};
+struct Load {};
+struct Store {};
+struct StorePOI {};
+struct Copy {};
+
+struct Edge : public std::variant<Assign, Gep, Call, Return, Load, Store,
+                                  StorePOI, Copy> {
+  using Base =
+      std::variant<Assign, Gep, Call, Return, Load, Store, StorePOI, Copy>;
+  using std::variant<Assign, Gep, Call, Return, Load, Store, StorePOI,
+                     Copy>::variant;
+
+  template <typename T> static constexpr size_t kindOf() noexcept {
+    return psr::variant_idx<Base, T>;
+  }
+
+  [[nodiscard]] constexpr size_t kind() const noexcept { return this->index(); }
+
+  template <typename T, typename... Ts>
+  [[nodiscard]] constexpr bool isa() const noexcept {
+    return std::holds_alternative<T>(*this) ||
+           (... || std::holds_alternative<Ts>(*this));
+  }
+
+  template <typename T>
+  [[nodiscard]] constexpr std::optional<T> dyn_cast() const noexcept {
+    if (const auto *Ptr = std::get_if<T>(this)) {
+      return *Ptr;
+    }
+
+    return std::nullopt;
+  }
+
+  template <typename HandlerFn>
+  constexpr decltype(auto) apply(HandlerFn &&Handler) const {
+    return std::visit(PSR_FWD(Handler), *this);
+  }
+
+  [[nodiscard]] friend constexpr llvm::StringRef to_string(Edge E) noexcept {
+    return E.apply(psr::Overloaded{
+        [](Assign) { return "Assign"; },
+        // TODO: Print offset, if present
+        [](Gep) { return "Gep"; },
+        // TODO: Print ArgNo
+        [](Call) { return "Call"; },
+        [](Return) { return "Return"; },
+        [](Load) { return "Load"; },
+        [](Store) { return "Store"; },
+        [](StorePOI) { return "StorePOI"; },
+        [](Copy) { return "Copy"; },
+    });
+  }
+};
+
+template <typename T>
+concept PBStrategy =
+    requires(T &Strategy, const T &CStrategy, ValueId From, ValueId To,
+             const typename T::n_t &Inst, pag::Edge E) {
+      typename T::v_t;
+      typename T::db_t;
+      typename T::f_t;
+      typename T::n_t;
+
+      { T() } noexcept;
+      Strategy.onAddEdge(From, To, E, Nullable<typename T::n_t>{});
+      CStrategy.withCalleesOfCallAt(Inst, [](typename T::f_t Callee) {});
+    };
+
+template <typename T>
+concept CanOnAddValue = requires(T &Strategy, const T::v_t &Var) {
+  Strategy.onAddValue(Var, ValueId{});
+};
+
+template <typename T>
+concept CanGetNumPossibleValues =
+    requires(const T &CStrategy, const T::db_t &IRDB) {
+      {
+        CStrategy.getNumPossibleValues(IRDB)
+      } noexcept -> std::convertible_to<size_t>;
+    };
+
+template <PBStrategy FirstT, PBStrategy SecondT>
+  requires(std::same_as<typename FirstT::n_t, typename SecondT::n_t> &&
+           std::same_as<typename FirstT::v_t, typename SecondT::v_t> &&
+           std::same_as<typename FirstT::f_t, typename SecondT::f_t> &&
+           std::same_as<typename FirstT::db_t, typename SecondT::db_t>)
+struct PBStrategyCombinator {
+  using n_t = typename FirstT::n_t;
+  using v_t = typename FirstT::v_t;
+  using f_t = typename FirstT::f_t;
+  using db_t = typename FirstT::db_t;
+
+  [[no_unique_address]] FirstT First;
+  [[no_unique_address]] SecondT Second;
+
+  constexpr void onAddEdge(ValueId From, ValueId To, Edge E,
+                           Nullable<n_t> AtInstruction) {
+    First.onAddEdge(From, To, E, AtInstruction);
+    Second.onAddEdge(From, To, E, AtInstruction);
+  }
+
+  constexpr void onAddValue(ByConstRef<v_t> Variable, ValueId VId)
+    requires(CanOnAddValue<FirstT> || CanOnAddValue<SecondT>)
+  {
+    if constexpr (CanOnAddValue<FirstT>) {
+      First.onAddValue(Variable, VId);
+    }
+    if constexpr (CanOnAddValue<SecondT>) {
+      Second.onAddValue(Variable, VId);
+    }
+  }
+
+  [[nodiscard]] constexpr size_t
+  getNumPossibleValues(const db_t &IRDB) const noexcept
+    requires(CanGetNumPossibleValues<FirstT> ||
+             CanGetNumPossibleValues<SecondT>)
+  {
+    if constexpr (CanGetNumPossibleValues<SecondT>) {
+      return Second.getNumPossibleValues(IRDB);
+    }
+    if constexpr (CanGetNumPossibleValues<FirstT>) {
+      return First.getNumPossibleValues(IRDB);
+    }
+  }
+
+  constexpr void
+  withCalleesOfCallAt(ByConstRef<n_t> CS,
+                      llvm::function_ref<void(f_t)> WithCallee) const {
+    Second.withCalleesOfCallAt(CS, WithCallee);
+  }
+};
+
+/// The main customization point for PAG building.
+/// Implement this interface to provide several callbacks to the PAGBuilder,
+/// specifying how the PAG should be built.
+template <typename AnalysisDomainT> class PBStrategyRef final {
 public:
   using n_t = typename AnalysisDomainT::n_t;
   using v_t = typename AnalysisDomainT::v_t;
   using f_t = typename AnalysisDomainT::f_t;
   using db_t = typename AnalysisDomainT::db_t;
 
-  struct Assign {};
-  struct Gep {
-    std::optional<int16_t> Offset;
-  };
-  struct Call {
-    uint16_t ArgNo;
-  };
-  struct Return {};
-  struct Load {};
-  struct Store {};
-  struct StorePOI {};
-  struct Copy {};
-
-  struct Edge : public std::variant<Assign, Gep, Call, Return, Load, Store,
-                                    StorePOI, Copy> {
-    using Base =
-        std::variant<Assign, Gep, Call, Return, Load, Store, StorePOI, Copy>;
-    using std::variant<Assign, Gep, Call, Return, Load, Store, StorePOI,
-                       Copy>::variant;
-
-    template <typename T> static constexpr size_t kindOf() noexcept {
-      return psr::variant_idx<Base, T>;
-    }
-
-    [[nodiscard]] constexpr size_t kind() const noexcept {
-      return this->index();
-    }
+  /// Creates a type-erased PBStrategyRef from a non-null pointer to a concrete
+  /// Strategy-object.
+  template <PBStrategy ConcreteStrategyT>
+    requires(!same_as_decay<PBStrategyRef, ConcreteStrategyT>)
+  constexpr PBStrategyRef(ConcreteStrategyT *Strategy) noexcept
+      : VT(&VTableFor<ConcreteStrategyT>), Ctx(Strategy) {
+    assert(Strategy != nullptr);
+  }
 
-    template <typename T, typename... Ts>
-    [[nodiscard]] constexpr bool isa() const noexcept {
-      return std::holds_alternative<T>(*this) ||
-             (... || std::holds_alternative<Ts>(*this));
-    }
+  /// Called by buildPAG() for every (unique) edge that should be added to the
+  /// PAG
+  ///
+  /// \param From The source-node.
+  /// \param To The destination-node.
+  /// \param E The edge-label that specifies the kind of data-flow that is
+  /// denoted by this edge.
+  /// \param AtInstruction Optionally holds the instruction that caused this
+  /// edge to be created.
+  void onAddEdge(ValueId From, ValueId To, pag::Edge E,
+                 Nullable<n_t> AtInstruction) {
+    VT->OnAddEdge(Ctx, From, To, E, AtInstruction);
+  }
 
-    template <typename T>
-    [[nodiscard]] constexpr std::optional<T> dyn_cast() const noexcept {
-      if (const auto *Ptr = std::get_if<T>(this)) {
-        return *Ptr;
-      }
+  /// Called by buildPAG() for every (unique) node that should be added to the
+  /// PAG, *excluding* nodes that have already been registered in the used
+  /// ValueCompressor before buildPAG() was called.
+  ///
+  /// \param Variable The IR-specific variable/value for which the new node
+  /// has been created.
+  /// \param VId The value-id of the newly created node.
+  void onAddValue(ByConstRef<v_t> Variable, ValueId VId) {
+    VT->OnAddValue(Ctx, Variable, VId);
+  }
 
-      return std::nullopt;
-    }
+  /// Estimates the maximum number of values created in the ValueCompressor.
+  /// Must not be exact, this is just for pre-allocating buffers for
+  /// optimization purposes.
+  [[nodiscard]] size_t getNumPossibleValues(const db_t &IRDB) const noexcept {
+    return VT->GetNumPossibleValues(Ctx, IRDB);
+  }
 
-    template <typename HandlerFn>
-    constexpr decltype(auto) apply(HandlerFn &&Handler) const {
-      return std::visit(PSR_FWD(Handler), *this);
-    }
+  /// Invokes a call-back with each function that may be called at the given
+  /// call-site. Usually, you want to use a CallGraph or a Resolver to implement
+  /// this function.
+  ///
+  /// \param CS The call-site.
+  /// \param WithCallee The callback to be invoked for each callee.
+  void withCalleesOfCallAt(ByConstRef<n_t> CS,
+                           llvm::function_ref<void(f_t)> WithCallee) const {
+    VT->WithCalleesOfCallAt(Ctx, CS, WithCallee);
+  }
 
-    [[nodiscard]] friend constexpr llvm::StringRef to_string(Edge E) noexcept {
-      return E.apply(psr::Overloaded{
-          [](Assign) { return "Assign"; },
-          // TODO: Print offset, if present
-          [](Gep) { return "Gep"; },
-          // TODO: Print ArgNo
-          [](Call) { return "Call"; },
-          [](Return) { return "Return"; },
-          [](Load) { return "Load"; },
-          [](Store) { return "Store"; },
-          [](StorePOI) { return "StorePOI"; },
-          [](Copy) { return "Copy"; },
-      });
-    }
+private:
+  struct VTable {
+    void (*OnAddEdge)(void *Ctx, ValueId From, ValueId To, pag::Edge E,
+                      Nullable<n_t> AtInstruction);
+    void (*OnAddValue)(void *Ctx, ByConstRef<v_t> Variable, ValueId VId);
+    size_t (*GetNumPossibleValues)(const void *Ctx, const db_t &IRDB) noexcept;
+    void (*WithCalleesOfCallAt)(const void *Ctx, ByConstRef<n_t> CS,
+                                llvm::function_ref<void(f_t)> WithCallee);
   };
 
-  /// The main customization point for PAG building.
-  /// Implement this interface to provide several callbacks to the PAGBuilder,
-  /// specifying how the PAG should be built.
-  struct PBStrategy {
-    constexpr PBStrategy() noexcept = default;
-    virtual ~PBStrategy() = default;
-
-    /// Called by buildPAG() for every (unique) edge that should be added to the
-    /// PAG
-    ///
-    /// \param From The source-node.
-    /// \param To The destination-node.
-    /// \param E The edge-label that specifies the kind of data-flow that is
-    /// denoted by this edge.
-    /// \param AtInstruction Optionally holds the instruction that caused this
-    /// edge to be created.
-    virtual void onAddEdge(ValueId From, ValueId To, Edge E,
-                           Nullable<n_t> AtInstruction) = 0;
-
-    /// Called by buildPAG() for every (unique) node that should be added to the
-    /// PAG, *excluding* nodes that have already been registered in the used
-    /// ValueCompressor before buildPAG() was called.
-    ///
-    /// \param Variable The IR-specific variable/value for which the new node
-    /// has been created.
-    /// \param VId The value-id of the newly created node.
-    virtual void onAddValue(ByConstRef<v_t> Variable, ValueId VId) {
-      // Do things like allocating a new slot in the adjacency-list here
+  template <typename ConcreteStrategyT>
+  static void onAddEdgeThunk(void *Ctx, ValueId From, ValueId To, pag::Edge E,
+                             Nullable<n_t> AtInstruction) {
+    // Do things like allocating a new slot in the adjacency-list here
+    static_cast<ConcreteStrategyT *>(Ctx)->onAddEdge(From, To, E,
+                                                     AtInstruction);
+  }
+
+  template <typename ConcreteStrategyT>
+  static void onAddValueThunk(void *Ctx, ByConstRef<v_t> Variable,
+                              ValueId VId) {
+    if constexpr (CanOnAddValue<ConcreteStrategyT>) {
+      static_cast<ConcreteStrategyT *>(Ctx)->onAddValue(Variable, VId);
     }
+  }
 
-    /// Estimates the maximum number of values created in the ValueCompressor.
-    /// Must not be exact, this is just for pre-allocating buffers for
-    /// optimization purposes.
-    [[nodiscard]] virtual size_t
-    getNumPossibleValues(const db_t &IRDB) const noexcept {
-      // May use a different heuristic here...
+  template <typename ConcreteStrategyT>
+  static void getNumPossibleValuesThunk(const void *Ctx,
+                                        const db_t &IRDB) noexcept {
+    if constexpr (CanGetNumPossibleValues<ConcreteStrategyT>) {
+      return static_cast<const ConcreteStrategyT *>(Ctx)->getNumPossibleValues(
+          IRDB);
+    } else {
+      // Fallback-heuristic
       return IRDB.getNumInstructions();
     }
+  }
+
+  template <typename ConcreteStrategyT>
+  static void
+  withCalleesOfCallAtThunk(const void *Ctx, ByConstRef<n_t> CS,
+                           llvm::function_ref<void(f_t)> WithCallee) {
 
-    /// Invokes a call-back with each function that may be called at the given
-    /// call-site. Usually, you want to use a CallGraph or a Resolver here.
-    ///
-    /// \param CS The call-site.
-    /// \param WithCallee The callback to be invoked for each callee.
-    virtual void
-    withCalleesOfCallAt(ByConstRef<n_t> CS,
-                        llvm::function_ref<void(f_t)> WithCallee) const = 0;
+    static_cast<const ConcreteStrategyT *>(Ctx)->withCalleesOfCallAt(
+        CS, WithCallee);
+  }
+
+  template <typename ConcreteStrategyT>
+  static constexpr VTable VTableFor = {
+      &onAddEdgeThunk<ConcreteStrategyT>,
+      &onAddValueThunk<ConcreteStrategyT>,
+      &getNumPossibleValuesThunk<ConcreteStrategyT>,
+      &withCalleesOfCallAtThunk<ConcreteStrategyT>,
   };
 
+  const VTable *VT{};
+  void *Ctx{};
+};
+} // namespace pag
+
+/// A utility-class that can be used to build a pointer-assignment graph (PAG).
+///
+/// This class does not enforce a specifiy graph-layout -- it does not even
+/// require that you explicitly store a graph in memory. Instead, you get
+/// notified about every node and edge that should be created in the PAG.
+///
+/// \tparam AnalysisDomainT The analysis domain to use.
+template <typename AnalysisDomainT> class PAGBuilder {
+public:
+  using n_t = typename AnalysisDomainT::n_t;
+  using v_t = typename AnalysisDomainT::v_t;
+  using f_t = typename AnalysisDomainT::f_t;
+  using db_t = typename AnalysisDomainT::db_t;
+
   constexpr PAGBuilder() noexcept = default;
   virtual ~PAGBuilder() = default;
 
@@ -154,7 +307,7 @@ template <typename AnalysisDomainT> class PAGBuilder {
   /// \param Strategy The customization-point for this function. See the docs of
   /// PBStrategy for more information.
   virtual void buildPAG(const db_t &IRDB, ValueCompressor<v_t> &VC,
-                        PBStrategy &Strategy) = 0;
+                        pag::PBStrategyRef<AnalysisDomainT> Strategy) = 0;
 };
 
 } // namespace psr
diff --git a/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp b/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp
index 084ca8b99f..11ec507f91 100644
--- a/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp
+++ b/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp
@@ -16,6 +16,8 @@
 #include <concepts>
 
 using namespace psr;
+using namespace psr::pag;
+using LLVMPBStrategyRef = pag::PBStrategyRef<LLVMPAGDomain>;
 
 static_assert(detail::IsPointerWithAtleastOneFreeLowBit<PAGVariable>);
 
@@ -29,8 +31,6 @@ std::string psr::to_string(PAGVariable Var) {
 
 namespace {
 
-using LLVMPBStrategy = LLVMPAGBuilder::PBStrategy;
-
 struct GlobalCache {
   const llvm::DataLayout &DL; // NOLINT
   // Due to the recursion in getOrCreateGCacheEntry, we need pointer stability
@@ -38,8 +38,8 @@ struct GlobalCache {
       Cache{};
 
   [[nodiscard]] llvm::ArrayRef<ValueId> getOrCreateGCacheEntry(
-      LLVMPBStrategy &Strategy, const llvm::Constant *Const,
-      std::invocable<const llvm::Value *, LLVMPBStrategy &> auto GetVariable) {
+      LLVMPBStrategyRef Strategy, const llvm::Constant *Const,
+      std::invocable<const llvm::Value *, LLVMPBStrategyRef> auto GetVariable) {
     if (definitelyContainsNoPointer(Const)) {
       return {};
     }
@@ -109,7 +109,7 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
   llvm::DenseMap<const llvm::Value *, llvm::SmallDenseMap<int64_t, ValueId>>
       LocalGeps{};
 
-  [[nodiscard]] ValueId getVariable(PAGVariable V, LLVMPBStrategy &Strategy) {
+  [[nodiscard]] ValueId getVariable(PAGVariable V, LLVMPBStrategyRef Strategy) {
     auto [Id, Inserted] = VC.insert(V);
     if (Inserted) {
       OnlyIncomingStoresAndOutgoingLoads.insert(Id);
@@ -121,14 +121,14 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
     return Id;
   }
 
-  void addAllIncomingStores(PBStrategy &Strategy, ValueId To,
+  void addAllIncomingStores(LLVMPBStrategyRef Strategy, ValueId To,
                             llvm::SmallDenseMap<ValueId, Edge, 2> &Froms) {
     for (auto [From, E] : Froms) {
       Strategy.onAddEdge(From, To, E, nullptr);
     }
     Froms.clear();
   }
-  void addAllOutgoingLoads(PBStrategy &Strategy, ValueId From,
+  void addAllOutgoingLoads(LLVMPBStrategyRef Strategy, ValueId From,
                            llvm::SmallDenseSet<ValueId, 2> &Tos) {
     for (auto To : Tos) {
       Strategy.onAddEdge(From, To, Load{}, nullptr);
@@ -136,14 +136,14 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
     Tos.clear();
   }
 
-  void eraseFromSimpleStoreLoad(PBStrategy &Strategy, ValueId VId) {
+  void eraseFromSimpleStoreLoad(LLVMPBStrategyRef Strategy, ValueId VId) {
     if (OnlyIncomingStoresAndOutgoingLoads.tryErase(VId)) {
       addAllIncomingStores(Strategy, VId, IncomingStores[VId]);
       addAllOutgoingLoads(Strategy, VId, OutgoingLoads[VId]);
     }
   }
 
-  void addEdge(PBStrategy &Strategy, ValueId From, ValueId To, Edge E,
+  void addEdge(LLVMPBStrategyRef Strategy, ValueId From, ValueId To, Edge E,
                const llvm::Instruction *AtInstruction) {
     // llvm::errs() << "[addEdge]: " << int(From) << "->" << int(To)
     //              << " :: " << to_string(E) << '\n';
@@ -170,7 +170,7 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
   }
 
   void initializeGlobals(const LLVMProjectIRDB &IRDB,
-                         LLVMPBStrategy &Strategy) {
+                         LLVMPBStrategyRef Strategy) {
     GlobalCache GCache{IRDB.getModule()->getDataLayout()};
 
     for (const auto &Glob : IRDB.getModule()->globals()) {
@@ -184,12 +184,12 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
     }
   }
 
-  void initializeGlobal(GlobalCache &GCache, LLVMPBStrategy &Strategy,
+  void initializeGlobal(GlobalCache &GCache, LLVMPBStrategyRef Strategy,
                         const llvm::GlobalVariable &Glob) {
     auto GlobObj = getVariable(&Glob, Strategy);
     auto Stores = GCache.getOrCreateGCacheEntry(
         Strategy, Glob.getInitializer(),
-        [this](const llvm::Value *V, LLVMPBStrategy &Strategy) {
+        [this](const llvm::Value *V, LLVMPBStrategyRef Strategy) {
           return getVariable(V, Strategy);
         });
 
@@ -199,7 +199,8 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
     }
   }
 
-  void initializeFunctions(const LLVMProjectIRDB &IRDB, PBStrategy &Strategy) {
+  void initializeFunctions(const LLVMProjectIRDB &IRDB,
+                           LLVMPBStrategyRef Strategy) {
     // TODO: Use LibrarySummary here
     // TODO: Skip functions that have been proven unreachable previously
 
@@ -212,14 +213,14 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
     addDelayedEdges(Strategy);
   }
 
-  void initializeFun(PBStrategy &Strategy, const llvm::Function &Fun) {
+  void initializeFun(LLVMPBStrategyRef Strategy, const llvm::Function &Fun) {
     // TODO: RPO Order to profit from OTF-merged values
     for (const auto &BB : Fun) {
       propagateBB(Strategy, BB);
     }
   }
 
-  void addDelayedEdges(PBStrategy &Strategy) {
+  void addDelayedEdges(LLVMPBStrategyRef Strategy) {
     OnlyIncomingStoresAndOutgoingLoads.foreach ([this, &Strategy](auto VId) {
       for (auto [IncStore, _] : IncomingStores[VId]) {
         for (auto OutLoad : OutgoingLoads[VId]) {
@@ -237,7 +238,7 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
     });
   }
 
-  void propagateBB(PBStrategy &Strategy, const llvm::BasicBlock &BB) {
+  void propagateBB(LLVMPBStrategyRef Strategy, const llvm::BasicBlock &BB) {
     const auto *Inst = &BB.front();
     if (Inst->isDebugOrPseudoInst()) {
       Inst = Inst->getNextNonDebugInstruction();
@@ -248,7 +249,7 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
     }
   }
 
-  void dispatch(PBStrategy &Strategy, const llvm::Instruction &I) {
+  void dispatch(LLVMPBStrategyRef Strategy, const llvm::Instruction &I) {
     if (const auto *Alloca = llvm::dyn_cast<llvm::AllocaInst>(&I)) {
       return (void)getVariable(Alloca, Strategy);
     }
@@ -324,7 +325,7 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
     } while (!WL.empty());
   }
 
-  void handleStore(PBStrategy &Strategy, const llvm::StoreInst *Store) {
+  void handleStore(LLVMPBStrategyRef Strategy, const llvm::StoreInst *Store) {
 
     if (definitelyContainsNoPointer(Store->getValueOperand())) {
       return;
@@ -339,7 +340,7 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
     });
   }
 
-  void handleLoad(PBStrategy &Strategy, const llvm::LoadInst *Ld) {
+  void handleLoad(LLVMPBStrategyRef Strategy, const llvm::LoadInst *Ld) {
     if (definitelyContainsNoPointer(Ld)) {
       return;
     }
@@ -365,7 +366,7 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
     });
   }
 
-  void handleCastImpl(PBStrategy &Strategy, const llvm::User *Cast,
+  void handleCastImpl(LLVMPBStrategyRef Strategy, const llvm::User *Cast,
                       const llvm::Value *Op) {
     auto OperandObj = getVariable(Op, Strategy);
 
@@ -381,7 +382,7 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
     VC.addAlias(Cast, OperandObj);
   }
 
-  void handleCast(PBStrategy &Strategy, const llvm::User *Cast) {
+  void handleCast(LLVMPBStrategyRef Strategy, const llvm::User *Cast) {
     if (definitelyContainsNoPointer(Cast)) {
       return;
     }
@@ -389,7 +390,7 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
     handleOperand(Cast->getOperand(0),
                   [&](const auto *Op) { handleCastImpl(Strategy, Cast, Op); });
   }
-  void handleGep(PBStrategy &Strategy, const llvm::GEPOperator *Gep) {
+  void handleGep(LLVMPBStrategyRef Strategy, const llvm::GEPOperator *Gep) {
     handleOperand(Gep->getPointerOperand(), [&](const auto *PointerOp) {
       if (psr::isAllocaInstOrHeapAllocaFunction(PointerOp) &&
           !isAddressTakenVariable(PointerOp) && Gep->hasAllConstantIndices() &&
@@ -414,7 +415,7 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
     });
   }
 
-  void handleMemTransfer(PBStrategy &Strategy,
+  void handleMemTransfer(LLVMPBStrategyRef Strategy,
                          const llvm::MemTransferInst *MemTrn) {
 
     handleOperand(MemTrn->getDest(), [&](const auto *Dest) {
@@ -436,7 +437,7 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
     });
   }
 
-  void handleCallTarget(PBStrategy &Strategy, const llvm::CallBase *Call,
+  void handleCallTarget(LLVMPBStrategyRef Strategy, const llvm::CallBase *Call,
                         const llvm::Function *Callee,
                         llvm::ArrayRef<llvm::SmallDenseSet<ValueId>> Args,
                         std::optional<ValueId> CSVal) {
@@ -461,14 +462,14 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
       auto ParamObj = getVariable(&Param, Strategy);
       for (auto ArgVal : Arg) {
         addEdge(Strategy, ArgVal, ParamObj,
-                LLVMPAGBuilder::Call{uint16_t(Param.getArgNo())}, Call);
+                pag::Call{uint16_t(Param.getArgNo())}, Call);
       }
     }
 
     // TODO: Varargs
   }
 
-  void handleCall(PBStrategy &Strategy, const llvm::CallBase *Call) {
+  void handleCall(LLVMPBStrategyRef Strategy, const llvm::CallBase *Call) {
     const auto *FnPtr = Call->getCalledOperand()->stripPointerCastsAndAliases();
 
     llvm::SmallVector<llvm::SmallDenseSet<ValueId>> Args;
@@ -496,7 +497,7 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
     });
   }
 
-  void handleReturn(PBStrategy &Strategy, const llvm::ReturnInst *Ret) {
+  void handleReturn(LLVMPBStrategyRef Strategy, const llvm::ReturnInst *Ret) {
     const auto *RetVal = Ret->getReturnValue();
     if (!RetVal || definitelyContainsNoPointer(RetVal)) {
       return;
@@ -510,7 +511,7 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
     });
   }
 
-  void handlePhi(PBStrategy &Strategy, const llvm::PHINode *Phi) {
+  void handlePhi(LLVMPBStrategyRef Strategy, const llvm::PHINode *Phi) {
     if (definitelyContainsNoPointer(Phi)) {
       return;
     }
@@ -531,7 +532,8 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
     }
   }
 
-  void handleSelect(PBStrategy &Strategy, const llvm::SelectInst *Select) {
+  void handleSelect(LLVMPBStrategyRef Strategy,
+                    const llvm::SelectInst *Select) {
     if (definitelyContainsNoPointer(Select)) {
       return;
     }
@@ -560,7 +562,7 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
 
 void psr::LLVMPAGBuilder::buildPAG(const LLVMProjectIRDB &IRDB,
                                    ValueCompressor<v_t> &VC,
-                                   PBStrategy &Strategy) {
+                                   LLVMPBStrategyRef Strategy) {
   PAGBuildData BData{IRDB.getModule()->getDataLayout(), VC};
 
   const size_t NumPossibleValues = Strategy.getNumPossibleValues(IRDB);

From ebe4ffaf937af00aeef2c8cdd95ff21673596486 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Fri, 2 Jan 2026 12:42:28 +0100
Subject: [PATCH 04/75] Add basic union-find based Steensgaard-style alias
 analysis (WIP)

---
 .../ControlFlow/VTA/TypePropagator.h          |   2 +-
 .../Pointer/CallingContextConstructor.h       | 148 ++++++++
 .../phasar/Pointer/PointerAssignmentGraph.h   |  15 +-
 include/phasar/Pointer/RawAliasSet.h          |  75 ++++
 include/phasar/Pointer/UnionFindAA.h          | 353 ++++++++++++++++++
 include/phasar/Utils/BitSet.h                 |   5 +-
 include/phasar/Utils/Compressor.h             |   9 +-
 include/phasar/Utils/SCCGeneric.h             |  67 +---
 include/phasar/Utils/SCCId.h                  |  81 ++++
 include/phasar/Utils/TypeTraits.h             |  37 +-
 include/phasar/Utils/TypedVector.h            |   3 +-
 include/phasar/Utils/UnionFind.h              |  14 +-
 12 files changed, 725 insertions(+), 84 deletions(-)
 create mode 100644 include/phasar/Pointer/CallingContextConstructor.h
 create mode 100644 include/phasar/Pointer/RawAliasSet.h
 create mode 100644 include/phasar/Pointer/UnionFindAA.h
 create mode 100644 include/phasar/Utils/SCCId.h

diff --git a/include/phasar/PhasarLLVM/ControlFlow/VTA/TypePropagator.h b/include/phasar/PhasarLLVM/ControlFlow/VTA/TypePropagator.h
index 2e6d6b874d..b6b12091b0 100644
--- a/include/phasar/PhasarLLVM/ControlFlow/VTA/TypePropagator.h
+++ b/include/phasar/PhasarLLVM/ControlFlow/VTA/TypePropagator.h
@@ -11,6 +11,7 @@
 #define PHASAR_PHASARLLVM_CONTROLFLOW_TYPEPROPAGATOR_H
 
 #include "phasar/PhasarLLVM/ControlFlow/VTA/TypeAssignmentGraph.h"
+#include "phasar/Utils/SCCId.h"
 #include "phasar/Utils/TypedVector.h"
 
 #include "llvm/ADT/DenseSet.h"
@@ -22,7 +23,6 @@ class Value;
 } // namespace llvm
 
 namespace psr {
-template <typename GraphNodeId> struct SCCId;
 template <typename GraphNodeId> struct SCCHolder;
 template <typename GraphNodeId> struct SCCDependencyGraph;
 template <typename GraphNodeId> struct SCCOrder;
diff --git a/include/phasar/Pointer/CallingContextConstructor.h b/include/phasar/Pointer/CallingContextConstructor.h
new file mode 100644
index 0000000000..32e4976d60
--- /dev/null
+++ b/include/phasar/Pointer/CallingContextConstructor.h
@@ -0,0 +1,148 @@
+#pragma once
+
+#include "phasar/ControlFlow/CallGraph.h"
+#include "phasar/ControlFlow/ICFGBase.h"
+#include "phasar/Utils/ByRef.h"
+#include "phasar/Utils/Compressor.h"
+
+#include "llvm/ADT/DenseMapInfo.h"
+#include "llvm/ADT/Hashing.h"
+
+#include <array>
+
+namespace psr {
+template <typename N, unsigned K = 1> struct CallingContext {
+  using n_t = N;
+
+  std::array<n_t, K> Callers{};
+
+  [[nodiscard]] friend auto hash_value(const CallingContext &CC) {
+    return llvm::hash_combine_range(CC.Callers.begin(), CC.Callers.end());
+  }
+
+  [[nodiscard]] friend bool
+  operator==(const CallingContext &L,
+             const CallingContext &R) noexcept = default;
+
+  [[nodiscard]] CallingContext withPrefix(n_t FirstCS) const noexcept {
+    auto Ret = *this;
+    auto Tmp = FirstCS;
+    for (size_t I = 0; I != K; ++I) {
+      auto NextTmp = Ret.Callers[I];
+      Ret.Callers[I] = Tmp;
+      Tmp = NextTmp;
+    }
+
+    return Ret;
+  }
+};
+} // namespace psr
+
+namespace llvm {
+template <typename N, unsigned K>
+struct DenseMapInfo<psr::CallingContext<N, K>> {
+  using CallingContext = psr::CallingContext<N, K>;
+
+  static CallingContext getEmptyKey() noexcept {
+    CallingContext Ret{};
+    Ret.Callers[0] = llvm::DenseMapInfo<N>::getEmptyKey();
+    return Ret;
+  }
+  static CallingContext getTombstoneKey() noexcept {
+    CallingContext Ret{};
+    Ret.Callers[0] = llvm::DenseMapInfo<N>::getTombstoneKey();
+    return Ret;
+  }
+
+  static auto getHashValue(psr::ByConstRef<CallingContext> CC) {
+    return hash_value(CC);
+  }
+
+  static bool isEqual(psr::ByConstRef<CallingContext> L,
+                      psr::ByConstRef<CallingContext> R) noexcept {
+    return L == R;
+  }
+};
+} // namespace llvm
+
+namespace psr {
+enum class CallingContextId : uint32_t { None = 0 };
+
+template <typename N, typename F, unsigned K = 1>
+class CallingContextConstructor {
+public:
+  static_assert(K > 0);
+  static_assert(K < 10, "Do you really want a sooo large context-k-limit? "
+                        "Reconsider your choices!");
+
+  using n_t = N;
+  using f_t = F;
+
+  CallingContextConstructor() {
+    // Assign Id 0 === ContextId::None
+    CC2Id.getOrInsert(CallingContext<n_t, K>{});
+  }
+
+  template <typename CFGTy>
+  void visitAllCallingContexts(
+      const llvm::Function *Fun, const CallGraph<n_t, f_t> &CG,
+      const CFGBase<CFGTy> &CF,
+      std::invocable<n_t, CallingContextId> auto CCVisitor) {
+    CallingContext<n_t, K> Ctx{};
+    visitAllCallingContextsImpl<0>(Fun, CG, CF, CCVisitor, Ctx);
+  }
+
+  template <typename CFGTy>
+  void visitContextsAtCall(ByConstRef<n_t> Call, const CallGraph<n_t, f_t> &CG,
+                           const CFGBase<CFGTy> &CF,
+                           std::invocable<CallingContextId> auto CCVisitor) {
+    CallingContext<n_t, K> Ctx{};
+    Ctx.Callers[0] = Call;
+    visitAllCallingContextsImpl<1>(
+        CF.getFunctionOf(Call), CG, CF,
+        [CCVisitor{std::move(CCVisitor)}](ByConstRef<n_t>,
+                                          CallingContextId Ctx) {
+          std::invoke(CCVisitor, Ctx);
+        },
+        Ctx);
+  }
+
+  CallingContextId getOrInsert(ByConstRef<CallingContext<n_t, K>> CC) {
+    return CC2Id.getOrInsert(CC);
+  }
+
+  [[nodiscard]] ByConstRef<CallingContext<n_t, K>>
+  operator[](CallingContextId Ctx) {
+    return CC2Id[Ctx];
+  }
+
+private:
+  template <typename CFGTy, unsigned Idx>
+  void visitAllCallingContextsImpl(
+      ByConstRef<f_t> Fun, const CallGraph<n_t, f_t> &CG,
+      const CFGBase<CFGTy> &CF,
+      std::invocable<n_t, CallingContextId> auto &&CCVisitor,
+      CallingContext<n_t, K> &CurrCtx) {
+    // TODO: Improve this algorithm
+
+    if constexpr (Idx < K) {
+      auto &&CallersOfCS = CG.getCallersOf(Fun);
+
+      for (const auto &CS : CallersOfCS) {
+        CurrCtx.Callers[Idx] = CS;
+        visitAllCallingContextsImpl<(Idx + 1)>(CF.getFunctionOf(CS), CG, CF,
+                                               CCVisitor, CurrCtx);
+      }
+
+      if (!CallersOfCS.empty()) {
+        return;
+      }
+    }
+
+    auto CtxId = CC2Id.getOrInsert(CurrCtx);
+    std::invoke(CCVisitor, CurrCtx.Callers[0], CtxId);
+  }
+
+  Compressor<CallingContext<n_t, K>, CallingContextId> CC2Id{};
+};
+} // namespace psr
diff --git a/include/phasar/Pointer/PointerAssignmentGraph.h b/include/phasar/Pointer/PointerAssignmentGraph.h
index 4bf3f66c84..0fb40c6771 100644
--- a/include/phasar/Pointer/PointerAssignmentGraph.h
+++ b/include/phasar/Pointer/PointerAssignmentGraph.h
@@ -7,6 +7,8 @@
 #include "phasar/Utils/Utilities.h"
 #include "phasar/Utils/ValueCompressor.h"
 
+#include "llvm/Support/Compiler.h"
+
 #include <concepts>
 #include <cstdint>
 #include <memory>
@@ -37,11 +39,15 @@ struct Edge : public std::variant<Assign, Gep, Call, Return, Load, Store,
   using std::variant<Assign, Gep, Call, Return, Load, Store, StorePOI,
                      Copy>::variant;
 
-  template <typename T> static constexpr size_t kindOf() noexcept {
-    return psr::variant_idx<Base, T>;
+  enum class EdgeKind : uint32_t {};
+
+  template <typename T> static constexpr EdgeKind kindOf() noexcept {
+    return EdgeKind(psr::variant_idx<Base, T>);
   }
 
-  [[nodiscard]] constexpr size_t kind() const noexcept { return this->index(); }
+  [[nodiscard]] constexpr EdgeKind kind() const noexcept {
+    return EdgeKind(this->index());
+  }
 
   template <typename T, typename... Ts>
   [[nodiscard]] constexpr bool isa() const noexcept {
@@ -59,7 +65,8 @@ struct Edge : public std::variant<Assign, Gep, Call, Return, Load, Store,
   }
 
   template <typename HandlerFn>
-  constexpr decltype(auto) apply(HandlerFn &&Handler) const {
+  LLVM_ATTRIBUTE_ALWAYS_INLINE constexpr decltype(auto)
+  apply(HandlerFn &&Handler) const {
     return std::visit(PSR_FWD(Handler), *this);
   }
 
diff --git a/include/phasar/Pointer/RawAliasSet.h b/include/phasar/Pointer/RawAliasSet.h
new file mode 100644
index 0000000000..97bc3630f1
--- /dev/null
+++ b/include/phasar/Pointer/RawAliasSet.h
@@ -0,0 +1,75 @@
+#pragma once
+
+#include "phasar/Utils/TypeTraits.h"
+
+#include "llvm/ADT/SparseBitVector.h"
+
+namespace psr {
+
+template <typename ASet>
+concept IsRawAliasSet = requires(ASet &MutSet, const ASet &ConstSet,
+                                 typename ASet::value_type ValId) {
+  ASet();
+  ASet(ConstSet);
+  ASet(std::move(MutSet));
+  MutSet = ConstSet;
+  MutSet = std::move(MutSet);
+  MutSet.insert(ValId);
+  { MutSet.tryInsert(ValId) } -> std::convertible_to<bool>;
+  { ConstSet.contains(ValId) } -> std::convertible_to<bool>;
+  // ConstSet.begin();
+  // ConstSet.end();
+  ConstSet.foreach (DummyFn<typename ASet::value_type>{});
+  MutSet |= ConstSet;
+  MutSet &= ConstSet;
+  { MutSet.tryMergeWith(ConstSet) } -> std::convertible_to<bool>;
+  { MutSet.clear() } noexcept;
+  { ConstSet.empty() } noexcept -> std::convertible_to<bool>;
+  { ConstSet.size() } noexcept -> std::convertible_to<size_t>;
+
+  // TODO: Difference?
+};
+
+template <SmallIdType IdT> class RawAliasSet {
+public:
+  using value_type = IdT;
+
+  RawAliasSet() = default;
+
+  void insert(IdT Id) { Bits.set(uint32_t(Id)); }
+
+  [[nodiscard]] bool tryInsert(IdT Id) {
+    return Bits.test_and_set(uint32_t(Id));
+  }
+
+  [[nodiscard]] bool contains(IdT Id) const { return Bits.test(uint32_t(Id)); }
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE void foreach (
+      std::invocable<IdT> auto Handler) const {
+    for (auto Bit : Bits) {
+      std::invoke(Handler, IdT(Bit));
+    }
+  }
+
+  void operator|=(const RawAliasSet &Other) { Bits |= Other.Bits; }
+  void operator&=(const RawAliasSet &Other) { Bits &= Other.Bits; }
+
+  [[nodiscard]] bool empty() const noexcept { return Bits.empty(); }
+  [[nodiscard]] size_t size() const noexcept { return Bits.count(); }
+
+  void clear() noexcept { Bits.clear(); }
+
+  [[nodiscard]] auto begin() const noexcept { return Bits.begin(); }
+  [[nodiscard]] auto end() const noexcept { return Bits.end(); }
+
+  [[nodiscard]] bool tryMergeWith(const RawAliasSet &Other) {
+    return Bits |= Other.Bits;
+  }
+
+  void erase(IdT Id) { Bits.reset(uint32_t(Id)); }
+
+private:
+  llvm::SparseBitVector<> Bits;
+  // TODO: roaring::Roaring Bits;
+};
+} // namespace psr
diff --git a/include/phasar/Pointer/UnionFindAA.h b/include/phasar/Pointer/UnionFindAA.h
new file mode 100644
index 0000000000..d8e6babed1
--- /dev/null
+++ b/include/phasar/Pointer/UnionFindAA.h
@@ -0,0 +1,353 @@
+#pragma once
+
+#include "phasar/Pointer/CallingContextConstructor.h"
+#include "phasar/Pointer/PointerAssignmentGraph.h"
+#include "phasar/Pointer/RawAliasSet.h"
+#include "phasar/Utils/ByRef.h"
+#include "phasar/Utils/IotaIterator.h"
+#include "phasar/Utils/MaybeUniquePtr.h"
+#include "phasar/Utils/Nullable.h"
+#include "phasar/Utils/PointerUtils.h"
+#include "phasar/Utils/TypeTraits.h"
+#include "phasar/Utils/TypedVector.h"
+#include "phasar/Utils/UnionFind.h"
+#include "phasar/Utils/Utilities.h"
+#include "phasar/Utils/ValueCompressor.h"
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/ErrorHandling.h"
+
+#include <concepts>
+
+namespace psr {
+
+template <typename T>
+concept UnionFindAAResult = requires(const T &Result, ValueId Var) {
+  { T::isCached() } noexcept -> std::convertible_to<bool>;
+  { Result.getRawAliasSet(Var) } -> std::convertible_to<RawAliasSet<ValueId>>;
+  { Result.mayAlias(Var, Var) } -> std::convertible_to<bool>;
+};
+
+struct UnionFindAAResultBase {
+  enum class ObjectRepId : uint32_t {};
+
+  TypedVector<ObjectRepId, RawAliasSet<ValueId>> BackwardView;
+};
+
+struct BasicUnionFindAAResult : UnionFindAAResultBase {
+  TypedVector<ValueId, ObjectRepId> Var2Rep;
+
+  static constexpr bool isCached() noexcept { return true; }
+
+  [[nodiscard]] const RawAliasSet<ValueId> &
+  getRawAliasSet(ValueId Var) const noexcept {
+    auto Rep = Var2Rep[Var];
+    return BackwardView[Rep];
+  }
+
+  [[nodiscard]] bool mayAlias(ValueId Var1, ValueId Var2) const noexcept {
+    if (Var1 == Var2) {
+      return true;
+    }
+    auto Rep1 = Var2Rep[Var1];
+    auto Rep2 = Var2Rep[Var2];
+    return Rep1 == Rep2;
+  }
+};
+
+struct CallingContextSensUnionFindAAResult : UnionFindAAResultBase {
+  TypedVector<ValueId, llvm::SmallVector<ObjectRepId, 2>> Var2Rep{};
+
+  static constexpr bool isCached() noexcept { return false; }
+
+  [[nodiscard]] RawAliasSet<ValueId> getRawAliasSet(ValueId Var) const {
+    RawAliasSet<ValueId> ResultSet;
+    for (auto Rep : Var2Rep[Var]) {
+      ResultSet |= BackwardView[Rep];
+    }
+    return ResultSet;
+  }
+
+  [[nodiscard]] bool mayAlias(ValueId Var1, ValueId Var2) const noexcept {
+    if (Var1 == Var2) {
+      return true;
+    }
+
+    // Note: K is mostly small (1 or 2), so below loop should be very cheap
+    const auto &Reps1 = Var2Rep[Var1];
+    const auto &Reps2 = Var2Rep[Var2];
+    for (ObjectRepId R1 : Reps1) {
+      if (llvm::is_contained(Reps2, R1)) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+
+template <typename AnalysisDomainT, typename ObjectIdT>
+struct BasicUnionFindAA {
+  using ObjectId = ObjectIdT;
+
+  using n_t = typename AnalysisDomainT::n_t;
+  using v_t = typename AnalysisDomainT::v_t;
+  using f_t = typename AnalysisDomainT::f_t;
+  using db_t = typename AnalysisDomainT::db_t;
+
+  void onAddEdge(ObjectId From, ObjectId To, pag::Edge /*E*/,
+                 Nullable<n_t> /*AtInstruction*/) {
+    AliasSets.join(From, To);
+  }
+
+  void onAddValue(ByConstRef<v_t> /*Var*/, ObjectId VId) {
+    AliasSets.grow(size_t(VId) + 1);
+  }
+
+  [[nodiscard]] BasicUnionFindAAResult
+  consumeAAResults(size_t NumVars,
+                   std::invocable<ValueId> auto Var2Obj = IdentityFn{}) && {
+    auto Equiv = std::move(AliasSets)
+                     .template compress<BasicUnionFindAAResult::ObjectRepId>();
+
+    static constexpr auto InvalidRep =
+        BasicUnionFindAAResult::ObjectRepId(UINT32_MAX);
+
+    BasicUnionFindAAResult Result{};
+    Result.BackwardView.resize(Equiv.size());
+    Result.Var2Rep.resize(NumVars, InvalidRep);
+
+    for (auto VId : iota<ValueId>(NumVars)) {
+      // TODO: Skip only-ret val-ids
+      auto ObjId = std::invoke(Var2Obj, VId);
+      auto Rep = Equiv[ObjId];
+      assert(Result.Var2Rep[VId] == InvalidRep &&
+             "Mapping from ValueId to AliasSet-Id must be injective!");
+      Result.Var2Rep[VId] = Rep;
+      Result.BackwardView[Rep].insert(VId);
+    }
+
+    return Result;
+  }
+
+  UnionFind<ObjectId> AliasSets{};
+};
+
+template <typename AnalysisDomainT, unsigned K = 1>
+class CallingContextSensUnionFindAA {
+public:
+  enum class CtxObjectId : uint32_t {};
+
+  using n_t = typename AnalysisDomainT::n_t;
+  using v_t = typename AnalysisDomainT::v_t;
+  using f_t = typename AnalysisDomainT::f_t;
+  using db_t = typename AnalysisDomainT::db_t;
+  using i_t = typename AnalysisDomainT::i_t;
+
+  CallingContextSensUnionFindAA(MaybeUniquePtr<i_t> ICF) noexcept
+      : ICF(std::move(ICF)) {
+    assert(this->ICF != nullptr);
+  }
+
+  void onAddEdge(ValueId From, ValueId To, pag::Edge E,
+                 Nullable<n_t> CallSite) {
+    E.apply(Overloaded{
+        [&, this, CallSite](pag::Call) {
+          for (const auto &[ArgCtxId, FromObj] : Var2Obj[From]) {
+            auto ParamCtx = CC[ArgCtxId].withPrefix(CallSite);
+            auto ParamCtxId = CC.getOrInsert(ParamCtx);
+
+            if (const auto *Dst = getObjectOrNull(To, ParamCtxId)) {
+              Base.AliasSets.join(FromObj, *Dst);
+            }
+          }
+        },
+        [&, this, CallSite](pag::Return) {
+          for (const auto &[CSValCtxId, ToObj] : Var2Obj[To]) {
+            auto RetCtx = CC[CSValCtxId].withPrefix(CallSite);
+            auto RetCtxId = CC.getOrInsert(RetCtx);
+
+            if (const auto *Src = getObjectOrNull(From, RetCtxId)) {
+              Base.AliasSets.join(*Src, ToObj);
+            }
+          }
+        },
+        [&, this](auto) {
+          const auto &FromObjects = Var2Obj[From];
+          for (const auto &[FromCtx, FromObj] : FromObjects) {
+            if (FromCtx == CallingContextId::None) {
+              for (const auto &[ToCtx, ToObj] : Var2Obj[To]) {
+                Base.AliasSets.join(FromObj, ToObj);
+              }
+            } else if (const auto *Dst = getObjectOrNull(To, FromCtx)) {
+              Base.AliasSets.join(FromObj, *Dst);
+            }
+          }
+        },
+    });
+  }
+
+  void onAddValue(ByConstRef<v_t> Var, ValueId VId) {
+    Var2Obj.emplace_back();
+    if (const auto &Fun = getFunction(Var)) {
+      CC.visitAllCallingContexts(
+          unwrapNullable(Fun), *ICF, *ICF,
+          [this, VId](ByConstRef<n_t> /*FirstCS*/, CallingContextId Ctx) {
+            std::ignore = getObject(VId, Ctx);
+          });
+
+      if (!ICF->getCallersOf(unwrapNullable(Fun)).empty()) {
+        return;
+      }
+      // fallback in case, we have no callers
+    }
+    std::ignore = getObject(VId, CallingContextId::None);
+  }
+
+  [[nodiscard]] CallingContextSensUnionFindAAResult
+  consumeAAResults(size_t NumVars) && {
+    auto Equiv = std::move(Base.AliasSets)
+                     .template compress<BasicUnionFindAAResult::ObjectRepId>();
+
+    CallingContextSensUnionFindAAResult Result{};
+    Result.BackwardView.resize(Equiv.size());
+    Result.Var2Rep.resize(NumVars);
+
+    for (const auto &[ValId, Objects] : Var2Obj.enumerate()) {
+      // TODO: Skip only-ret val-ids
+
+      for (const auto &[_, Obj] : Objects) {
+        auto Rep = Equiv[Obj];
+        if (Result.BackwardView[Rep].try_insert(ValId)) {
+          Result.Var2Rep[ValId].push_back(Rep);
+        }
+      }
+      if (Objects.empty()) {
+        llvm::errs() << "Warning: Empty Objects-set for Var#" << uint32_t(ValId)
+                     << '\n';
+      }
+    }
+
+    return Result;
+  }
+
+private:
+  [[nodiscard]] Nullable<f_t> getFunction(ByConstRef<v_t> Var) {
+    auto Ptr = getPointerFrom(Var);
+    if constexpr (requires() {
+                    {
+                      Ptr->getFunction()
+                    } -> std::convertible_to<Nullable<f_t>>;
+                  }) {
+      return Ptr->getFunction();
+    } else {
+      return ICF.getFunction(Var);
+    }
+  }
+
+  [[nodiscard]] CtxObjectId getObject(ValueId VId, CallingContextId Ctx) {
+    auto [It, Inserted] =
+        Var2Obj[VId].try_emplace(Ctx, CtxObjectId(Obj2Var.size()));
+    if (Inserted) {
+      Obj2Var.emplace_back(VId, Ctx);
+      Base.AliasSets.grow(size_t(It->second) + 1);
+    }
+    return It->second;
+  }
+
+  MaybeUniquePtr<i_t> ICF;
+  TypedVector<CtxObjectId, std::pair<ValueId, CallingContextId>> Obj2Var{};
+  TypedVector<ValueId, llvm::SmallDenseMap<CallingContextId, CtxObjectId>>
+      Var2Obj{};
+
+  CallingContextConstructor<n_t, f_t, K> CC{};
+  BasicUnionFindAA<AnalysisDomainT, CtxObjectId> Base{};
+};
+
+template <typename AnalysisDomainT, unsigned K = 5>
+class IndirectionSencUnionFindAA {
+public:
+  static_assert(K > 0, "A depth-limit of 0 is invalid!");
+
+  enum class IndObjectId : uint32_t {};
+  enum class IndDepth : uint32_t {};
+
+  using n_t = typename AnalysisDomainT::n_t;
+  using v_t = typename AnalysisDomainT::v_t;
+  using f_t = typename AnalysisDomainT::f_t;
+  using db_t = typename AnalysisDomainT::db_t;
+
+  void onAddEdge(ValueId From, ValueId To, pag::Edge E,
+                 Nullable<n_t> /*CallSite*/) {
+    using namespace pag;
+    const auto &FromFldObjects = Var2Obj[From];
+    for (const auto &[FromCtx, FromObj] : FromFldObjects.enumerate()) {
+      switch (E.kind()) {
+      case Edge::kindOf<Copy>():
+        if (FromCtx == IndDepth{}) {
+          break;
+        }
+
+      // fallthrough
+      case Edge::kindOf<Assign>():
+      case Edge::kindOf<Gep>():
+      case Edge::kindOf<Call>():
+      case Edge::kindOf<Return>():
+        if (auto ToObj = getFldObjectOrNull(To, FromCtx)) {
+          Base.AliasSets.join(FromObj, *ToObj);
+        }
+
+        break;
+      case Edge::kindOf<Load>():
+        if (auto ToCtx = prevFldDepth(FromCtx)) {
+          if (auto ToObj = getFldObjectOrNull(To, *ToCtx)) {
+            Base.AliasSets.join(FromObj, *ToObj);
+          }
+        }
+        if (FromCtx == K - 1) {
+          // For soundness
+          if (auto ToObj = getFldObjectOrNull(To, FromCtx)) {
+            Base.AliasSets.join(FromObj, *ToObj);
+          }
+        }
+        break;
+      case Edge::kindOf<Store>():
+      case Edge::kindOf<StorePOI>():
+        if (auto ToObj = getFldObjectOrNull(To, nextFldDepth(FromCtx))) {
+          Base.AliasSets.join(FromObj, ToObj);
+        }
+
+        break;
+      default:
+        llvm_unreachable("This switch should cover all cases explicitly");
+      }
+    }
+  }
+
+  void onAddValue(ByConstRef<v_t> /*Var*/, ValueId VId) {
+    auto Obj = Obj2Var.size();
+    Base.AliasSets.grow(Obj + K);
+    // TODO: For some values, we can already see that depth>=2 does not make
+    // sense, so we could exit the below loop early
+    for (auto Depth : iota<IndDepth>(K)) {
+      Var2Obj[VId].push_back(IndObjectId(Obj));
+      Obj++;
+      Obj2Var.emplace_back(VId, Depth);
+    }
+  }
+
+  [[nodiscard]] BasicUnionFindAAResult consumeAAResults(size_t NumVars) && {
+    return Base.consumeAAResults(NumVars, [this](ValueId VId) {
+      // When presenting the results, we only care about the values at depth 0
+      return Var2Obj[VId][IndDepth{}];
+    });
+  }
+
+private:
+  // XXX: Replace inner TypedVector by sth like TypedInplaceVector (e.g., using
+  // std::inplace_vector once moving forward with the required C++ version)
+  TypedVector<ValueId, TypedVector<IndDepth, IndObjectId, K>> Var2Obj{};
+  TypedVector<IndObjectId, std::pair<ValueId, IndDepth>> Obj2Var{};
+  BasicUnionFindAA<AnalysisDomainT, IndObjectId> Base{};
+};
+} // namespace psr
diff --git a/include/phasar/Utils/BitSet.h b/include/phasar/Utils/BitSet.h
index b49e1d647e..720fcddde2 100644
--- a/include/phasar/Utils/BitSet.h
+++ b/include/phasar/Utils/BitSet.h
@@ -10,6 +10,8 @@
 #ifndef PHASAR_UTILS_BITSET_H
 #define PHASAR_UTILS_BITSET_H
 
+#include "phasar/Utils/TypeTraits.h"
+
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/Support/MathExtras.h"
@@ -34,7 +36,8 @@ namespace psr {
 /// convertible from and to uint32_t.
 /// \tparam BitVectorTy The underlying bit-vector to use. Must be either
 /// llvm::BitVector or llvm::SmallBitVector.
-template <typename IdT, typename BitVectorTy = llvm::BitVector> class BitSet {
+template <SmallIdType IdT, typename BitVectorTy = llvm::BitVector>
+class BitSet {
   static llvm::ArrayRef<uintptr_t> getWords(const llvm::BitVector &BV,
                                             uintptr_t & /*Store*/) {
     return BV.getData();
diff --git a/include/phasar/Utils/Compressor.h b/include/phasar/Utils/Compressor.h
index c67f54aa11..3b920c8868 100644
--- a/include/phasar/Utils/Compressor.h
+++ b/include/phasar/Utils/Compressor.h
@@ -24,13 +24,13 @@
 #include <type_traits>
 
 namespace psr {
-template <typename T, typename IdT = uint32_t> class Compressor;
+template <typename T, IdType IdT = uint32_t> class Compressor;
 
 /// \brief A utility class that assigns a sequential Id to every inserted
 /// object.
 ///
 /// This specialization handles types that can be efficiently passed by value
-template <typename T, typename IdT>
+template <typename T, IdType IdT>
   requires CanEfficientlyPassByValue<T>
 class Compressor<T, IdT> {
 public:
@@ -56,8 +56,7 @@ class Compressor<T, IdT> {
     return {It->second, Inserted};
   }
 
-  [[nodiscard]]
-  std::optional<IdT> getOrNull(T Elem) const {
+  [[nodiscard]] std::optional<IdT> getOrNull(T Elem) const {
     if (auto It = ToInt.find(Elem); It != ToInt.end()) {
       return It->second;
     }
@@ -104,7 +103,7 @@ class Compressor<T, IdT> {
 /// object.
 ///
 /// This specialization handles types that cannot be efficiently passed by value
-template <typename T, typename IdT>
+template <typename T, IdType IdT>
   requires(!CanEfficientlyPassByValue<T>)
 class Compressor<T, IdT> {
 public:
diff --git a/include/phasar/Utils/SCCGeneric.h b/include/phasar/Utils/SCCGeneric.h
index 9c31d325d0..9132a09c2b 100644
--- a/include/phasar/Utils/SCCGeneric.h
+++ b/include/phasar/Utils/SCCGeneric.h
@@ -15,10 +15,10 @@
 #include "phasar/Utils/GraphTraits.h"
 #include "phasar/Utils/IotaIterator.h"
 #include "phasar/Utils/RepeatIterator.h"
+#include "phasar/Utils/SCCId.h"
 #include "phasar/Utils/TypedVector.h"
 
 #include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
@@ -29,69 +29,6 @@
 
 namespace psr {
 
-namespace detail {
-// Unfortunately, `enum class` cannot be templated, but we want type-safety for
-// SCC-IDs...
-struct SCCIdBase {
-  uint32_t Value{};
-
-  constexpr SCCIdBase() noexcept = default;
-
-  explicit constexpr SCCIdBase(uint32_t Val) noexcept : Value(Val) {}
-
-  explicit constexpr operator uint32_t() const noexcept { return Value; }
-  template <typename T = size_t>
-  explicit constexpr operator size_t() const noexcept
-    requires(!std::is_same_v<uint32_t, T>)
-  {
-    return Value;
-  }
-
-  explicit constexpr operator ptrdiff_t() const noexcept {
-    return ptrdiff_t(Value);
-  }
-
-  constexpr uint32_t operator+() const noexcept { return Value; }
-
-  friend constexpr bool operator==(SCCIdBase L, SCCIdBase R) noexcept {
-    return L.Value == R.Value;
-  }
-  friend constexpr bool operator!=(SCCIdBase L, SCCIdBase R) noexcept {
-    return !(L == R);
-  }
-};
-} // namespace detail
-
-/// \brief The Id of a strongly-connected component in a graph.
-///
-/// \tparam GraphNodeId The vertex-type of the graph where this SCC was computed
-/// for.
-template <typename GraphNodeId> struct SCCId : detail::SCCIdBase {
-  using detail::SCCIdBase::SCCIdBase;
-};
-
-} // namespace psr
-
-namespace llvm {
-template <typename GraphNodeId> struct DenseMapInfo<psr::SCCId<GraphNodeId>> {
-  using SCCId = psr::SCCId<GraphNodeId>;
-
-  static constexpr SCCId getEmptyKey() noexcept { return SCCId(UINT32_MAX); }
-  static constexpr SCCId getTombstoneKey() noexcept {
-    return SCCId(UINT32_MAX - 1);
-  }
-
-  static auto getHashValue(SCCId SCC) noexcept {
-    return llvm::hash_value(uint32_t(SCC));
-  }
-  static constexpr bool isEqual(SCCId SCC1, SCCId SCC2) noexcept {
-    return SCC1 == SCC2;
-  }
-};
-} // namespace llvm
-
-namespace psr {
-
 /// \brief Holds the SCCs of a given graph. Each SCC is assigned a unique
 /// sequential id.
 template <typename GraphNodeId> struct SCCHolder {
@@ -169,7 +106,7 @@ struct GraphTraits<SCCDependencyGraph<GraphNodeId>> {
   using vertex_t = SCCId<GraphNodeId>;
   using edge_t = vertex_t;
 
-  static inline constexpr auto Invalid = vertex_t(UINT32_MAX);
+  static constexpr auto Invalid = vertex_t(UINT32_MAX);
 
   [[nodiscard]] static constexpr const auto &outEdges(const graph_type &G,
                                                       vertex_t Vtx) noexcept {
diff --git a/include/phasar/Utils/SCCId.h b/include/phasar/Utils/SCCId.h
new file mode 100644
index 0000000000..0cf4aeb0c0
--- /dev/null
+++ b/include/phasar/Utils/SCCId.h
@@ -0,0 +1,81 @@
+/******************************************************************************
+ * Copyright (c) 2024 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and other
+ *****************************************************************************/
+#pragma once
+
+#include "phasar/Utils/TypeTraits.h"
+
+#include "llvm/ADT/DenseMapInfo.h"
+
+#include <cstdint>
+#include <type_traits>
+
+namespace psr {
+
+namespace detail {
+// Unfortunately, `enum class` cannot be templated, but we want type-safety for
+// SCC-IDs...
+struct SCCIdBase {
+  uint32_t Value{};
+
+  constexpr SCCIdBase() noexcept = default;
+
+  explicit constexpr SCCIdBase(uint32_t Val) noexcept : Value(Val) {}
+
+  explicit constexpr operator uint32_t() const noexcept { return Value; }
+  template <typename T = size_t>
+  explicit constexpr operator size_t() const noexcept
+    requires(!std::is_same_v<uint32_t, T>)
+  {
+    return Value;
+  }
+
+  explicit constexpr operator ptrdiff_t() const noexcept {
+    return ptrdiff_t(Value);
+  }
+
+  constexpr uint32_t operator+() const noexcept { return Value; }
+
+  friend constexpr bool operator==(SCCIdBase L, SCCIdBase R) noexcept {
+    return L.Value == R.Value;
+  }
+  friend constexpr bool operator!=(SCCIdBase L, SCCIdBase R) noexcept {
+    return !(L == R);
+  }
+};
+} // namespace detail
+
+/// \brief The Id of a strongly-connected component in a graph.
+///
+/// \tparam GraphNodeId The vertex-type of the graph where this SCC was computed
+/// for.
+template <typename GraphNodeId> struct SCCId : detail::SCCIdBase {
+  using detail::SCCIdBase::SCCIdBase;
+};
+
+static_assert(IdType<SCCId<uint32_t>>);
+
+} // namespace psr
+
+namespace llvm {
+template <typename GraphNodeId> struct DenseMapInfo<psr::SCCId<GraphNodeId>> {
+  using SCCId = psr::SCCId<GraphNodeId>;
+
+  static constexpr SCCId getEmptyKey() noexcept { return SCCId(UINT32_MAX); }
+  static constexpr SCCId getTombstoneKey() noexcept {
+    return SCCId(UINT32_MAX - 1);
+  }
+
+  static auto getHashValue(SCCId SCC) noexcept {
+    return llvm::hash_value(uint32_t(SCC));
+  }
+  static constexpr bool isEqual(SCCId SCC1, SCCId SCC2) noexcept {
+    return SCC1 == SCC2;
+  }
+};
+} // namespace llvm
diff --git a/include/phasar/Utils/TypeTraits.h b/include/phasar/Utils/TypeTraits.h
index 97e324c379..9bc4d3c8ad 100644
--- a/include/phasar/Utils/TypeTraits.h
+++ b/include/phasar/Utils/TypeTraits.h
@@ -16,6 +16,7 @@
 #include "llvm/Support/raw_ostream.h"
 
 #include <concepts>
+#include <cstddef>
 #include <iterator>
 #include <string>
 #include <string_view>
@@ -56,6 +57,19 @@ class template_arg {
       decltype(getTemplateArgImpl<Base>(std::declval<const Derived &>()));
 };
 
+template <template <typename...> typename Base, typename Derived>
+class IsTemplateInstanceImpl {
+private:
+  template <template <typename...> typename TBase, typename... TT>
+  static std::true_type test(const TBase<TT...> &Impl);
+  template <template <typename...> typename TBase>
+  static std::false_type test(...);
+
+public:
+  static constexpr bool value =
+      decltype(test<Base>(std::declval<const Derived &>()))::value;
+};
+
 template <typename Var, typename T> struct variant_idx;
 template <typename... Ts, typename T>
 struct variant_idx<std::variant<Ts...>, T>
@@ -92,6 +106,12 @@ concept is_iterable_over_v = is_iterable_v<T> && requires(T &Val) {
   { *llvm::adl_begin(Val) } -> same_as_decay<Over>;
 };
 
+template <typename T>
+concept Foreachable = requires(T &Val) { Val.foreach ([](auto &&...Elem) {}); };
+template <typename T, typename... Over>
+concept ForeachableOver =
+    requires(T &Val) { Val.foreach ([](const Over &...Elem) {}); };
+
 template <typename T>
 concept is_pair_v = detail::is_pair<T>::value; // NOLINT
 
@@ -195,6 +215,17 @@ template <typename From, typename To>
 concept is_explicitly_convertible_to =
     requires(From F) { static_cast<To>(std::forward<From>(F)); };
 
+template <typename T>
+concept IdType = is_explicitly_convertible_to<T, size_t> &&
+                 is_explicitly_convertible_to<size_t, T>;
+
+template <typename T, unsigned MaxWidth = sizeof(unsigned)>
+concept SmallIdType = IdType<T> && sizeof(T) <= MaxWidth;
+
+template <typename Derived, template <typename...> typename Base>
+concept IsTemplateInstance =
+    detail::IsTemplateInstanceImpl<Base, Derived>::value;
+
 template <typename Var, typename T>
 constexpr size_t variant_idx = detail::variant_idx<Var, T>::value;
 
@@ -227,7 +258,7 @@ struct FalseFn {
 /// Delegates to the ctor of T
 template <typename T> struct DefaultConstruct {
   template <typename... U>
-  [[nodiscard]] inline T
+  [[nodiscard]] T
   operator()(U &&...Val) noexcept(std::is_nothrow_constructible_v<T, U...>) {
     return T(std::forward<U>(Val)...);
   }
@@ -258,6 +289,10 @@ struct IdentityFn {
   }
 };
 
+template <typename ArgT> struct DummyFn {
+  void operator()(ArgT Arg) const noexcept {}
+};
+
 // NOLINTEND(readability-identifier-naming)
 } // namespace psr
 
diff --git a/include/phasar/Utils/TypedVector.h b/include/phasar/Utils/TypedVector.h
index ef15f3e158..417c97eb31 100644
--- a/include/phasar/Utils/TypedVector.h
+++ b/include/phasar/Utils/TypedVector.h
@@ -11,6 +11,7 @@
 #define PHASAR_UTILS_TYPEDVECTOR_H
 
 #include "phasar/Utils/ByRef.h"
+#include "phasar/Utils/TypeTraits.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
@@ -32,7 +33,7 @@ namespace psr {
 /// \tparam ValueT The usual value_type of SmallVector.
 /// \tparam SmallSize The size of the inline-storage of SmallVector (default:
 /// 0)
-template <typename IdT, typename ValueT, unsigned SmallSize = 0>
+template <IdType IdT, typename ValueT, unsigned SmallSize = 0>
 class TypedVector {
 public:
   TypedVector() noexcept = default;
diff --git a/include/phasar/Utils/UnionFind.h b/include/phasar/Utils/UnionFind.h
index 66b5539f8e..38edeb63de 100644
--- a/include/phasar/Utils/UnionFind.h
+++ b/include/phasar/Utils/UnionFind.h
@@ -1,13 +1,15 @@
 #pragma once
 
+#include "phasar/Utils/TypeTraits.h"
+
 #include "llvm/ADT/IntEqClasses.h"
 
 namespace psr {
 
-template <typename IdT = uint32_t, typename MappedIdT = IdT>
+template <SmallIdType IdT = uint32_t, SmallIdType MappedIdT = IdT>
 class CompressedUnionFind;
 
-template <typename IdT = uint32_t> class UnionFind {
+template <SmallIdType IdT = uint32_t> class UnionFind {
 public:
   UnionFind() noexcept = default;
   explicit UnionFind(size_t InitSz) : Equiv(InitSz) {}
@@ -20,14 +22,14 @@ template <typename IdT = uint32_t> class UnionFind {
 
   void grow(size_t NewSz) { Equiv.grow(NewSz); }
 
-  template <typename MappedIdT = IdT>
+  template <SmallIdType MappedIdT = IdT>
   [[nodiscard]] CompressedUnionFind<IdT, MappedIdT> compress() &&;
 
 private:
   llvm::IntEqClasses Equiv;
 };
 
-template <typename IdT, typename MappedIdT> class CompressedUnionFind {
+template <SmallIdType IdT, SmallIdType MappedIdT> class CompressedUnionFind {
 public:
   [[nodiscard]] size_t size() const noexcept { return Equiv.getNumClasses(); }
 
@@ -47,8 +49,8 @@ template <typename IdT, typename MappedIdT> class CompressedUnionFind {
   llvm::IntEqClasses Equiv;
 };
 
-template <typename IdT>
-template <typename MappedIdT>
+template <SmallIdType IdT>
+template <SmallIdType MappedIdT>
 inline CompressedUnionFind<IdT, MappedIdT> UnionFind<IdT>::compress() && {
   Equiv.compress();
   return {std::move(Equiv)};

From 1aa428e332ffa5c88d638cc5ee38497980ca3543 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Sat, 3 Jan 2026 14:51:12 +0100
Subject: [PATCH 05/75] Add utility for UnionFindAAResults intersection and
 caching + make LLVM-based UnionFindAA compile

---
 include/phasar/DB/ProjectIRDBBase.h           |   8 +
 .../phasar/PhasarLLVM/DB/LLVMProjectIRDB.h    |   5 +
 .../Pointer/LLVMPointerAssignmentGraph.h      |   6 +-
 .../PhasarLLVM/Pointer/LLVMUnionFindAA.h      |   9 +
 .../Pointer/CallingContextConstructor.h       |  25 +--
 include/phasar/Pointer/UnionFindAA.h          | 160 +++++++++++++++---
 include/phasar/Utils/StrongTypeDef.h          |  94 ++++++++++
 include/phasar/Utils/ValueCompressor.h        |  24 +--
 lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp    |   7 +
 9 files changed, 277 insertions(+), 61 deletions(-)
 create mode 100644 include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
 create mode 100644 include/phasar/Utils/StrongTypeDef.h
 create mode 100644 lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp

diff --git a/include/phasar/DB/ProjectIRDBBase.h b/include/phasar/DB/ProjectIRDBBase.h
index 8b68b81910..602eeb5300 100644
--- a/include/phasar/DB/ProjectIRDBBase.h
+++ b/include/phasar/DB/ProjectIRDBBase.h
@@ -10,6 +10,7 @@
 #ifndef PHASAR_DB_PROJECTIRDBBASE_H
 #define PHASAR_DB_PROJECTIRDBBASE_H
 
+#include "phasar/Utils/ByRef.h"
 #include "phasar/Utils/TypeTraits.h"
 
 #include "llvm/ADT/StringRef.h"
@@ -79,6 +80,13 @@ template <typename Derived> class ProjectIRDBBase {
     return self().hasFunctionImpl(FunctionName);
   }
 
+  /// Returns the function that contains the given instruction Inst.
+  /// Each instruction must be part of a function.
+  [[nodiscard]] f_t getFunctionOf(ByConstRef<n_t> Inst) const {
+    assert(isValid());
+    return self().getFunctionOfImpl(Inst);
+  }
+
   /// Returns the global variable's definition if available, null otherwise.
   [[nodiscard]] g_t
   getGlobalVariableDefinition(llvm::StringRef GlobalVariableName) const {
diff --git a/include/phasar/PhasarLLVM/DB/LLVMProjectIRDB.h b/include/phasar/PhasarLLVM/DB/LLVMProjectIRDB.h
index 9f64625f1f..d954f555d7 100644
--- a/include/phasar/PhasarLLVM/DB/LLVMProjectIRDB.h
+++ b/include/phasar/PhasarLLVM/DB/LLVMProjectIRDB.h
@@ -160,6 +160,11 @@ class LLVMProjectIRDB : public ProjectIRDBBase<LLVMProjectIRDB> {
   hasFunctionImpl(llvm::StringRef FunctionName) const noexcept {
     return Mod->getFunction(FunctionName) != nullptr;
   }
+  [[nodiscard]] f_t getFunctionOfImpl(n_t Inst) const {
+    assert(Inst != nullptr);
+    return Inst->getFunction();
+  }
+
   [[nodiscard]] g_t
   getGlobalVariableDefinitionImpl(llvm::StringRef GlobalVariableName) const;
   [[nodiscard]] size_t getNumInstructionsImpl() const noexcept {
diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h b/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
index b7b21bed8c..c6685923c0 100644
--- a/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
@@ -96,18 +96,18 @@ class LLVMPAGBuilder : public PAGBuilder<LLVMPAGDomain> {
 
 namespace llvm {
 template <> struct PointerLikeTypeTraits<psr::PAGVariable> {
-  static inline void *getAsVoidPointer(psr::PAGVariable P) {
+  static void *getAsVoidPointer(psr::PAGVariable P) {
     return P.getOpaqueValue();
   }
 
-  static inline psr::PAGVariable getFromVoidPointer(void *P) {
+  static psr::PAGVariable getFromVoidPointer(void *P) {
     psr::PAGVariable V{nullptr};
     static_cast<psr::PAGVariable::Base &>(V) =
         psr::PAGVariable::Base::getFromOpaqueValue(P);
     return V;
   }
 
-  static inline psr::PAGVariable getFromVoidPointer(const void *P) {
+  static psr::PAGVariable getFromVoidPointer(const void *P) {
     psr::PAGVariable V{nullptr};
     static_cast<psr::PAGVariable::Base &>(V) =
         psr::PAGVariable::Base::getFromOpaqueValue(P);
diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
new file mode 100644
index 0000000000..c089e3f45a
--- /dev/null
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include "phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h"
+#include "phasar/Pointer/UnionFindAA.h"
+
+namespace psr {
+extern template class CallingContextSensUnionFindAA<LLVMPAGDomain>;
+extern template class IndirectionSensUnionFindAA<LLVMPAGDomain>;
+} // namespace psr
diff --git a/include/phasar/Pointer/CallingContextConstructor.h b/include/phasar/Pointer/CallingContextConstructor.h
index 32e4976d60..44bb517bf3 100644
--- a/include/phasar/Pointer/CallingContextConstructor.h
+++ b/include/phasar/Pointer/CallingContextConstructor.h
@@ -1,14 +1,16 @@
 #pragma once
 
 #include "phasar/ControlFlow/CallGraph.h"
-#include "phasar/ControlFlow/ICFGBase.h"
+#include "phasar/DB/ProjectIRDBBase.h"
 #include "phasar/Utils/ByRef.h"
 #include "phasar/Utils/Compressor.h"
+#include "phasar/Utils/StrongTypeDef.h"
 
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/Hashing.h"
 
 #include <array>
+#include <cstdint>
 
 namespace psr {
 template <typename N, unsigned K = 1> struct CallingContext {
@@ -65,8 +67,9 @@ struct DenseMapInfo<psr::CallingContext<N, K>> {
 };
 } // namespace llvm
 
+PHASAR_STRONG_TYPEDEF(psr, uint32_t, CallingContextId, None = 0);
+
 namespace psr {
-enum class CallingContextId : uint32_t { None = 0 };
 
 template <typename N, typename F, unsigned K = 1>
 class CallingContextConstructor {
@@ -83,23 +86,23 @@ class CallingContextConstructor {
     CC2Id.getOrInsert(CallingContext<n_t, K>{});
   }
 
-  template <typename CFGTy>
+  template <typename DBTy>
   void visitAllCallingContexts(
       const llvm::Function *Fun, const CallGraph<n_t, f_t> &CG,
-      const CFGBase<CFGTy> &CF,
+      const ProjectIRDBBase<DBTy> &IRDB,
       std::invocable<n_t, CallingContextId> auto CCVisitor) {
     CallingContext<n_t, K> Ctx{};
-    visitAllCallingContextsImpl<0>(Fun, CG, CF, CCVisitor, Ctx);
+    visitAllCallingContextsImpl<0>(Fun, CG, IRDB, CCVisitor, Ctx);
   }
 
-  template <typename CFGTy>
+  template <typename DBTy>
   void visitContextsAtCall(ByConstRef<n_t> Call, const CallGraph<n_t, f_t> &CG,
-                           const CFGBase<CFGTy> &CF,
+                           const ProjectIRDBBase<DBTy> &IRDB,
                            std::invocable<CallingContextId> auto CCVisitor) {
     CallingContext<n_t, K> Ctx{};
     Ctx.Callers[0] = Call;
     visitAllCallingContextsImpl<1>(
-        CF.getFunctionOf(Call), CG, CF,
+        IRDB.getFunctionOf(Call), CG, IRDB,
         [CCVisitor{std::move(CCVisitor)}](ByConstRef<n_t>,
                                           CallingContextId Ctx) {
           std::invoke(CCVisitor, Ctx);
@@ -117,10 +120,10 @@ class CallingContextConstructor {
   }
 
 private:
-  template <typename CFGTy, unsigned Idx>
+  template <unsigned Idx, typename DBTy>
   void visitAllCallingContextsImpl(
       ByConstRef<f_t> Fun, const CallGraph<n_t, f_t> &CG,
-      const CFGBase<CFGTy> &CF,
+      const ProjectIRDBBase<DBTy> &IRDB,
       std::invocable<n_t, CallingContextId> auto &&CCVisitor,
       CallingContext<n_t, K> &CurrCtx) {
     // TODO: Improve this algorithm
@@ -130,7 +133,7 @@ class CallingContextConstructor {
 
       for (const auto &CS : CallersOfCS) {
         CurrCtx.Callers[Idx] = CS;
-        visitAllCallingContextsImpl<(Idx + 1)>(CF.getFunctionOf(CS), CG, CF,
+        visitAllCallingContextsImpl<(Idx + 1)>(IRDB.getFunctionOf(CS), CG, IRDB,
                                                CCVisitor, CurrCtx);
       }
 
diff --git a/include/phasar/Pointer/UnionFindAA.h b/include/phasar/Pointer/UnionFindAA.h
index d8e6babed1..1ed92f9cb1 100644
--- a/include/phasar/Pointer/UnionFindAA.h
+++ b/include/phasar/Pointer/UnionFindAA.h
@@ -1,10 +1,13 @@
 #pragma once
 
+#include "phasar/ControlFlow/CallGraph.h"
 #include "phasar/Pointer/CallingContextConstructor.h"
 #include "phasar/Pointer/PointerAssignmentGraph.h"
 #include "phasar/Pointer/RawAliasSet.h"
+#include "phasar/Utils/BitSet.h"
 #include "phasar/Utils/ByRef.h"
 #include "phasar/Utils/IotaIterator.h"
+#include "phasar/Utils/MapUtils.h"
 #include "phasar/Utils/MaybeUniquePtr.h"
 #include "phasar/Utils/Nullable.h"
 #include "phasar/Utils/PointerUtils.h"
@@ -27,6 +30,72 @@ concept UnionFindAAResult = requires(const T &Result, ValueId Var) {
   { T::isCached() } noexcept -> std::convertible_to<bool>;
   { Result.getRawAliasSet(Var) } -> std::convertible_to<RawAliasSet<ValueId>>;
   { Result.mayAlias(Var, Var) } -> std::convertible_to<bool>;
+  { Result.size() } noexcept -> std::convertible_to<size_t>;
+};
+
+template <UnionFindAAResult FirstT, UnionFindAAResult SecondT>
+struct UnionFindAAResultIntersection {
+  [[nodiscard]] static constexpr bool isCached() noexcept {
+    // The set-intersection is not cached
+    return false;
+  }
+
+  [[nodiscard]] constexpr size_t size() const noexcept {
+    assert(
+        First.size() == Second.size() &&
+        "Only alias-results on the same ValueCompressor should be intersected");
+    return First.size();
+  }
+
+  [[nodiscard]] RawAliasSet<ValueId> getRawAliasSet(ValueId Var) const {
+    auto ResultSet = First.getRawAliasSet(Var);
+    ResultSet &= Second.getRawAliasSet(Var);
+    return ResultSet;
+  }
+
+  [[nodiscard]] constexpr bool mayAlias(ValueId Var1, ValueId Var2) const {
+    return First.mayAlias(Var1, Var2) && Second.mayAlias(Var1, Var2);
+  }
+
+  [[no_unique_address]] FirstT First;
+  [[no_unique_address]] SecondT Second;
+};
+
+/// Lazy caching of union-find alias-analysis results. This class is *not*
+/// thread-safe!
+template <UnionFindAAResult AAResT, bool ShouldCacheMayAlias = true>
+class CachedUnionFindAAResult {
+public:
+  explicit CachedUnionFindAAResult(AAResT &&AARes) : AARes(std::move(AARes)) {
+    Var2AliasVars.resize(this->AARes.size());
+    ComputedAliasSetFor.reserve(this->AARes.size());
+  }
+
+  [[nodiscard]] static constexpr bool isCached() noexcept { return true; }
+
+  [[nodiscard]] constexpr size_t size() const noexcept { return AARes.size(); }
+
+  [[nodiscard]] const RawAliasSet<ValueId> &getRawAliasSet(ValueId Var) const {
+    if (ComputedAliasSetFor.tryInsert(Var)) [[unlikely]] {
+      Var2AliasVars[Var] = AARes.getRawAliasSet(Var);
+    }
+    return Var2AliasVars[Var];
+  }
+
+  [[nodiscard]] bool mayAlias(ValueId Var1, ValueId Var2) const {
+    if constexpr (ShouldCacheMayAlias) {
+      return getRawAliasSet(Var1).contains(Var2);
+    } else {
+      return AARes.mayAlias(Var1, Var2);
+    }
+  }
+
+private:
+  // TODO: Combine Var2AliasVars+ComputedAliasSetFor into a ValueIdMap!
+  mutable TypedVector<ValueId, RawAliasSet<ValueId>> Var2AliasVars;
+  mutable BitSet<ValueId> ComputedAliasSetFor{};
+
+  [[no_unique_address]] AAResT AARes;
 };
 
 struct UnionFindAAResultBase {
@@ -38,7 +107,10 @@ struct UnionFindAAResultBase {
 struct BasicUnionFindAAResult : UnionFindAAResultBase {
   TypedVector<ValueId, ObjectRepId> Var2Rep;
 
-  static constexpr bool isCached() noexcept { return true; }
+  [[nodiscard]] static constexpr bool isCached() noexcept { return true; }
+  [[nodiscard]] constexpr size_t size() const noexcept {
+    return Var2Rep.size();
+  }
 
   [[nodiscard]] const RawAliasSet<ValueId> &
   getRawAliasSet(ValueId Var) const noexcept {
@@ -59,7 +131,10 @@ struct BasicUnionFindAAResult : UnionFindAAResultBase {
 struct CallingContextSensUnionFindAAResult : UnionFindAAResultBase {
   TypedVector<ValueId, llvm::SmallVector<ObjectRepId, 2>> Var2Rep{};
 
-  static constexpr bool isCached() noexcept { return false; }
+  [[nodiscard]] static constexpr bool isCached() noexcept { return false; }
+  [[nodiscard]] constexpr size_t size() const noexcept {
+    return Var2Rep.size();
+  }
 
   [[nodiscard]] RawAliasSet<ValueId> getRawAliasSet(ValueId Var) const {
     RawAliasSet<ValueId> ResultSet;
@@ -142,11 +217,12 @@ class CallingContextSensUnionFindAA {
   using v_t = typename AnalysisDomainT::v_t;
   using f_t = typename AnalysisDomainT::f_t;
   using db_t = typename AnalysisDomainT::db_t;
-  using i_t = typename AnalysisDomainT::i_t;
 
-  CallingContextSensUnionFindAA(MaybeUniquePtr<i_t> ICF) noexcept
-      : ICF(std::move(ICF)) {
-    assert(this->ICF != nullptr);
+  CallingContextSensUnionFindAA(MaybeUniquePtr<CallGraph<n_t, f_t>> CG,
+                                const db_t *IRDB) noexcept
+      : CG(std::move(CG)), IRDB(IRDB) {
+    assert(this->CG != nullptr);
+    assert(this->IRDB != nullptr);
   }
 
   void onAddEdge(ValueId From, ValueId To, pag::Edge E,
@@ -191,12 +267,12 @@ class CallingContextSensUnionFindAA {
     Var2Obj.emplace_back();
     if (const auto &Fun = getFunction(Var)) {
       CC.visitAllCallingContexts(
-          unwrapNullable(Fun), *ICF, *ICF,
+          unwrapNullable(Fun), *CG, *IRDB,
           [this, VId](ByConstRef<n_t> /*FirstCS*/, CallingContextId Ctx) {
             std::ignore = getObject(VId, Ctx);
           });
 
-      if (!ICF->getCallersOf(unwrapNullable(Fun)).empty()) {
+      if (!CG->getCallersOf(unwrapNullable(Fun)).empty()) {
         return;
       }
       // fallback in case, we have no callers
@@ -218,7 +294,7 @@ class CallingContextSensUnionFindAA {
 
       for (const auto &[_, Obj] : Objects) {
         auto Rep = Equiv[Obj];
-        if (Result.BackwardView[Rep].try_insert(ValId)) {
+        if (Result.BackwardView[Rep].tryInsert(ValId)) {
           Result.Var2Rep[ValId].push_back(Rep);
         }
       }
@@ -233,18 +309,23 @@ class CallingContextSensUnionFindAA {
 
 private:
   [[nodiscard]] Nullable<f_t> getFunction(ByConstRef<v_t> Var) {
-    auto Ptr = getPointerFrom(Var);
-    if constexpr (requires() {
-                    {
-                      Ptr->getFunction()
-                    } -> std::convertible_to<Nullable<f_t>>;
-                  }) {
-      return Ptr->getFunction();
+    if constexpr (requires() { getPointerFrom(Var)->getFunction(); }) {
+      return getPointerFrom(Var)->getFunction();
     } else {
-      return ICF.getFunction(Var);
+      return IRDB->getFunctionOf(Var);
     }
   }
 
+  [[nodiscard]] const CtxObjectId *getObjectOrNull(ValueId Val,
+                                                   CallingContextId Ctx) {
+
+    const auto *Ret = getOrNull(Var2Obj[Val], Ctx);
+    if (!Ret) {
+      Ret = getOrNull(Var2Obj[Val], CallingContextId::None);
+    }
+
+    return Ret;
+  }
   [[nodiscard]] CtxObjectId getObject(ValueId VId, CallingContextId Ctx) {
     auto [It, Inserted] =
         Var2Obj[VId].try_emplace(Ctx, CtxObjectId(Obj2Var.size()));
@@ -255,7 +336,8 @@ class CallingContextSensUnionFindAA {
     return It->second;
   }
 
-  MaybeUniquePtr<i_t> ICF;
+  MaybeUniquePtr<CallGraph<n_t, f_t>> CG;
+  const db_t *IRDB{};
   TypedVector<CtxObjectId, std::pair<ValueId, CallingContextId>> Obj2Var{};
   TypedVector<ValueId, llvm::SmallDenseMap<CallingContextId, CtxObjectId>>
       Var2Obj{};
@@ -265,7 +347,7 @@ class CallingContextSensUnionFindAA {
 };
 
 template <typename AnalysisDomainT, unsigned K = 5>
-class IndirectionSencUnionFindAA {
+class IndirectionSensUnionFindAA {
 public:
   static_assert(K > 0, "A depth-limit of 0 is invalid!");
 
@@ -293,28 +375,28 @@ class IndirectionSencUnionFindAA {
       case Edge::kindOf<Gep>():
       case Edge::kindOf<Call>():
       case Edge::kindOf<Return>():
-        if (auto ToObj = getFldObjectOrNull(To, FromCtx)) {
+        if (auto ToObj = getObjectOrNull(To, FromCtx)) {
           Base.AliasSets.join(FromObj, *ToObj);
         }
 
         break;
       case Edge::kindOf<Load>():
-        if (auto ToCtx = prevFldDepth(FromCtx)) {
-          if (auto ToObj = getFldObjectOrNull(To, *ToCtx)) {
+        if (auto ToCtx = prevDepth(FromCtx)) {
+          if (auto ToObj = getObjectOrNull(To, *ToCtx)) {
             Base.AliasSets.join(FromObj, *ToObj);
           }
         }
-        if (FromCtx == K - 1) {
+        if (FromCtx == IndDepth(K - 1)) {
           // For soundness
-          if (auto ToObj = getFldObjectOrNull(To, FromCtx)) {
+          if (auto ToObj = getObjectOrNull(To, FromCtx)) {
             Base.AliasSets.join(FromObj, *ToObj);
           }
         }
         break;
       case Edge::kindOf<Store>():
       case Edge::kindOf<StorePOI>():
-        if (auto ToObj = getFldObjectOrNull(To, nextFldDepth(FromCtx))) {
-          Base.AliasSets.join(FromObj, ToObj);
+        if (auto ToObj = getObjectOrNull(To, nextDepth(FromCtx))) {
+          Base.AliasSets.join(FromObj, *ToObj);
         }
 
         break;
@@ -337,13 +419,37 @@ class IndirectionSencUnionFindAA {
   }
 
   [[nodiscard]] BasicUnionFindAAResult consumeAAResults(size_t NumVars) && {
-    return Base.consumeAAResults(NumVars, [this](ValueId VId) {
+    return std::move(Base).consumeAAResults(NumVars, [this](ValueId VId) {
       // When presenting the results, we only care about the values at depth 0
       return Var2Obj[VId][IndDepth{}];
     });
   }
 
 private:
+  [[nodiscard]] std::optional<IndObjectId> getObjectOrNull(ValueId VId,
+                                                           IndDepth Ctx) {
+    const auto &Map = Var2Obj[VId];
+    if (!Map.inbounds(Ctx)) {
+      return std::nullopt;
+    }
+
+    return Map[Ctx];
+  }
+
+  constexpr static IndDepth nextDepth(IndDepth Ctx) noexcept {
+    if (Ctx == IndDepth(K - 1)) {
+      return Ctx;
+    }
+
+    return IndDepth(uint32_t(Ctx) + 1);
+  }
+  constexpr static std::optional<IndDepth> prevDepth(IndDepth Ctx) noexcept {
+    if (Ctx == IndDepth{}) {
+      return std::nullopt;
+    }
+    return IndDepth(uint32_t(Ctx) - 1);
+  }
+
   // XXX: Replace inner TypedVector by sth like TypedInplaceVector (e.g., using
   // std::inplace_vector once moving forward with the required C++ version)
   TypedVector<ValueId, TypedVector<IndDepth, IndObjectId, K>> Var2Obj{};
diff --git a/include/phasar/Utils/StrongTypeDef.h b/include/phasar/Utils/StrongTypeDef.h
new file mode 100644
index 0000000000..80dae2e5d1
--- /dev/null
+++ b/include/phasar/Utils/StrongTypeDef.h
@@ -0,0 +1,94 @@
+#pragma once
+
+#pragma once
+
+#include "phasar/Utils/ByRef.h"
+
+#include "llvm/ADT/DenseMapInfo.h"
+#include "llvm/Support/HashBuilder.h"
+
+#include <limits>
+#include <numeric>
+#include <type_traits>
+
+#define PHASAR_STRONG_TYPEDEF(NAMESPACE, TYPE, NAME, ...)                      \
+  namespace NAMESPACE {                                                        \
+  enum class [[clang::enum_extensibility(open)]] NAME : TYPE { __VA_ARGS__ };  \
+  }                                                                            \
+  namespace llvm {                                                             \
+  template <> struct DenseMapInfo<NAMESPACE::NAME> {                           \
+    using QUAL_NAME = NAMESPACE::NAME;                                         \
+    static constexpr QUAL_NAME getEmptyKey() noexcept {                        \
+      return QUAL_NAME(std::is_signed_v<TYPE>                                  \
+                           ? std::numeric_limits<TYPE>::min()                  \
+                           : std::numeric_limits<TYPE>::max());                \
+    }                                                                          \
+    static constexpr QUAL_NAME getTombstoneKey() noexcept {                    \
+      return QUAL_NAME(std::is_signed_v<TYPE>                                  \
+                           ? std::numeric_limits<TYPE>::min() + 1              \
+                           : std::numeric_limits<TYPE>::max() - 1);            \
+    }                                                                          \
+    static auto getHashValue(QUAL_NAME Id) noexcept {                          \
+      return llvm::hash_value(TYPE(Id));                                       \
+    }                                                                          \
+    static constexpr bool isEqual(QUAL_NAME Id1, QUAL_NAME Id2) noexcept {     \
+      return Id1 == Id2;                                                       \
+    }                                                                          \
+  };                                                                           \
+  }
+
+#define PHASAR_DERIVE_ENUM_DMI(QUAL_NAME, TYPE, TYPE_PARAM)                    \
+  namespace llvm {                                                             \
+  template <TYPE_PARAM> struct DenseMapInfo<QUAL_NAME> {                       \
+    static constexpr QUAL_NAME getEmptyKey() noexcept {                        \
+      return QUAL_NAME(std::is_signed_v<TYPE>                                  \
+                           ? std::numeric_limits<TYPE>::min()                  \
+                           : std::numeric_limits<TYPE>::max());                \
+    }                                                                          \
+    static constexpr QUAL_NAME getTombstoneKey() noexcept {                    \
+      return QUAL_NAME(std::is_signed_v<TYPE>                                  \
+                           ? std::numeric_limits<TYPE>::min() + 1              \
+                           : std::numeric_limits<TYPE>::max() - 1);            \
+    }                                                                          \
+    static auto getHashValue(QUAL_NAME Id) noexcept {                          \
+      return llvm::hash_value(TYPE(Id));                                       \
+    }                                                                          \
+    static constexpr bool isEqual(QUAL_NAME Id1, QUAL_NAME Id2) noexcept {     \
+      return Id1 == Id2;                                                       \
+    }                                                                          \
+  };                                                                           \
+  }
+
+#define PHASAR_DERIVE_DMI(QUAL_TYPE)                                           \
+  namespace llvm {                                                             \
+  template <> struct DenseMapInfo<::QUAL_TYPE> {                               \
+    using Type = ::QUAL_TYPE;                                                  \
+    static Type getEmptyKey() noexcept { return Type::getEmptyKey(); }         \
+    static Type getTombstoneKey() noexcept { return Type::getTombstoneKey(); } \
+    static bool isEqual(::psr::ByConstRef<Type> Lhs,                           \
+                        ::psr::ByConstRef<Type> Rhs) noexcept {                \
+      return Lhs == Rhs;                                                       \
+    }                                                                          \
+    static auto getHashValue(::psr::ByConstRef<Type> Val) noexcept {           \
+      using llvm::hash_value;                                                  \
+      return hash_value(Val);                                                  \
+    }                                                                          \
+  };                                                                           \
+  }
+
+namespace psr {
+template <typename EnumT>
+// NOLINTNEXTLINE(readability-identifier-naming)
+[[nodiscard]] constexpr auto to_underlying(EnumT Val) noexcept
+  requires(std::is_enum_v<EnumT>)
+{
+  return static_cast<std::underlying_type_t<EnumT>>(Val);
+}
+template <typename EnumT>
+// NOLINTNEXTLINE(readability-identifier-naming)
+[[nodiscard]] constexpr auto to_underlying(EnumT Val) noexcept
+  requires(std::is_integral_v<EnumT>)
+{
+  return Val;
+}
+} // namespace psr
diff --git a/include/phasar/Utils/ValueCompressor.h b/include/phasar/Utils/ValueCompressor.h
index f03dba2be3..e8ab22d37a 100644
--- a/include/phasar/Utils/ValueCompressor.h
+++ b/include/phasar/Utils/ValueCompressor.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "phasar/Utils/ByRef.h"
+#include "phasar/Utils/StrongTypeDef.h"
 #include "phasar/Utils/TypedVector.h"
 
 #include "llvm/ADT/DenseMap.h"
@@ -10,6 +11,9 @@
 #include <optional>
 #include <type_traits>
 
+/// The id-type for values inserted into the ValueCompressor.
+PHASAR_STRONG_TYPEDEF(psr, uint32_t, ValueId);
+
 namespace psr {
 
 namespace detail {
@@ -21,9 +25,6 @@ static constexpr bool IsPointerWithAtleastOneFreeLowBit<T> =
     llvm::PointerLikeTypeTraits<T>::NumLowBitsAvailable > 0;
 } // namespace detail
 
-/// The id-type for values inserted into the ValueCompressor.
-enum class ValueId : uint32_t {};
-
 /// A utility-class that assigns sequential integer-like ids (psr::ValueId) to
 /// every inserted value.
 ///
@@ -102,20 +103,3 @@ template <typename T> class ValueCompressor {
 };
 
 } // namespace psr
-
-namespace llvm {
-template <> struct DenseMapInfo<psr::ValueId> {
-  static constexpr psr::ValueId getEmptyKey() noexcept {
-    return psr::ValueId(UINT32_MAX);
-  }
-  static constexpr psr::ValueId getTombstoneKey() noexcept {
-    return psr::ValueId(UINT32_MAX - 1);
-  }
-  static inline llvm::hash_code getHashValue(psr::ValueId VId) {
-    return llvm::hash_value(std::underlying_type_t<psr::ValueId>(VId));
-  }
-  static constexpr bool isEqual(psr::ValueId L, psr::ValueId R) noexcept {
-    return L == R;
-  }
-};
-} // namespace llvm
diff --git a/lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp b/lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp
new file mode 100644
index 0000000000..9b358b1db6
--- /dev/null
+++ b/lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp
@@ -0,0 +1,7 @@
+#include "phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h"
+
+namespace psr {
+
+template class CallingContextSensUnionFindAA<LLVMPAGDomain>;
+template class IndirectionSensUnionFindAA<LLVMPAGDomain>;
+} // namespace psr

From 821b92cf7024653d80e3ba54e7b62c4603b70483 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabian.schiebel@iem.fraunhofer.de>
Date: Sun, 4 Jan 2026 11:48:34 +0100
Subject: [PATCH 06/75] Add alias-iterator for union-find alias-results

---
 .../PhasarLLVM/Pointer/LLVMUnionFindAA.h      | 65 +++++++++++++++++++
 .../phasar/PhasarLLVM/Utils/LLVMShorthands.h  | 12 ++++
 include/phasar/Pointer/UnionFindAA.h          | 20 ++++++
 include/phasar/Utils/Utilities.h              |  9 +++
 lib/PhasarLLVM/Pointer/FilteredAliasesUtils.h | 11 ----
 .../Pointer/FilteredLLVMAliasIterator.cpp     |  1 +
 lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp    | 25 +++++++
 7 files changed, 132 insertions(+), 11 deletions(-)

diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
index c089e3f45a..9842c2b5f2 100644
--- a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
@@ -1,9 +1,74 @@
 #pragma once
 
 #include "phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h"
+#include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
+#include "phasar/Pointer/RawAliasSet.h"
 #include "phasar/Pointer/UnionFindAA.h"
+#include "phasar/Utils/MapUtils.h"
+#include "phasar/Utils/Utilities.h"
+#include "phasar/Utils/ValueCompressor.h"
 
 namespace psr {
 extern template class CallingContextSensUnionFindAA<LLVMPAGDomain>;
 extern template class IndirectionSensUnionFindAA<LLVMPAGDomain>;
+
+namespace detail {
+class LLVMLocalUnionFindAliasIteratorBase {
+public:
+  explicit LLVMLocalUnionFindAliasIteratorBase(
+      const ValueCompressor<PAGVariable> &VC);
+
+protected:
+  llvm::DenseMap<const llvm::Function *, RawAliasSet<ValueId>> GlobalsOrInFun;
+};
+} // namespace detail
+
+template <typename AAResT>
+class LLVMLocalUnionFindAliasIterator
+    : public detail::LLVMLocalUnionFindAliasIteratorBase {
+public:
+  LLVMLocalUnionFindAliasIterator(AAResT &&AARes,
+                                  const ValueCompressor<PAGVariable> *VC)
+      : detail::LLVMLocalUnionFindAliasIteratorBase(psr::assertNotNull(VC)),
+        AARes(PSR_FWD(AARes)), VC(VC) {}
+
+  void foreachAliasOf(ValueId VId,
+                      std::invocable<const llvm::Value *> auto WithAlias,
+                      const llvm::Function *Context = nullptr) {
+    const auto AliasHandler = [this,
+                               WithAlias = copyOrRef(WithAlias)](ValueId VId) {
+      for (auto V : VC->id2vars(VId)) {
+        if (const auto *LLVMVar = V.valueOrNull()) [[likely]] {
+          std::invoke(WithAlias, LLVMVar);
+        }
+      }
+    };
+
+    auto &&RawVars = AARes.getRawAliasSet(VId);
+    if (Context) {
+      auto Vars = PSR_FWD(RawVars);
+      Vars &= getOrDefault(GlobalsOrInFun, Context);
+      Vars.foreach (AliasHandler);
+    } else {
+      RawVars.foreach (AliasHandler);
+    }
+  }
+
+  void foreachAliasOf(const llvm::Value *Val,
+                      std::invocable<const llvm::Value *> auto WithAlias,
+                      const llvm::Function *Context) {
+    if (auto ValId = VC->getOrNull(Val)) {
+      foreachAliasOf(*ValId, copyOrRef(WithAlias), Context);
+    }
+  }
+  void foreachAliasOf(const llvm::Value *Val,
+                      std::invocable<const llvm::Value *> auto WithAlias) {
+    foreachAliasOf(Val, copyOrRef(WithAlias), psr::getFunction(Val));
+  }
+
+private:
+  AAResT AARes;
+  const ValueCompressor<PAGVariable> *VC{};
+};
+
 } // namespace psr
diff --git a/include/phasar/PhasarLLVM/Utils/LLVMShorthands.h b/include/phasar/PhasarLLVM/Utils/LLVMShorthands.h
index 711820f467..68da26170f 100644
--- a/include/phasar/PhasarLLVM/Utils/LLVMShorthands.h
+++ b/include/phasar/PhasarLLVM/Utils/LLVMShorthands.h
@@ -19,7 +19,9 @@
 
 #include "phasar/Utils/Utilities.h"
 
+#include "llvm/IR/Argument.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/Instruction.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Support/Casting.h"
 
@@ -295,6 +297,16 @@ bool isStaticVariableLazyInitializationBranch(const llvm::BranchInst *Inst);
  */
 bool isVarAnnotationIntrinsic(const llvm::Function *F);
 
+inline const llvm::Function *getFunction(const llvm::Value *V) {
+  if (const auto *Inst = llvm::dyn_cast<llvm::Instruction>(V)) {
+    return Inst->getFunction();
+  }
+  if (const auto *Arg = llvm::dyn_cast<llvm::Argument>(V)) {
+    return Arg->getParent();
+  }
+  return nullptr;
+}
+
 /**
  * Retrieves String annotation value as per
  * <https://llvm.org/docs/LangRef.html#llvm-var-annotation-intrinsic>
diff --git a/include/phasar/Pointer/UnionFindAA.h b/include/phasar/Pointer/UnionFindAA.h
index 1ed92f9cb1..903b96d130 100644
--- a/include/phasar/Pointer/UnionFindAA.h
+++ b/include/phasar/Pointer/UnionFindAA.h
@@ -7,6 +7,7 @@
 #include "phasar/Utils/BitSet.h"
 #include "phasar/Utils/ByRef.h"
 #include "phasar/Utils/IotaIterator.h"
+#include "phasar/Utils/Macros.h"
 #include "phasar/Utils/MapUtils.h"
 #include "phasar/Utils/MaybeUniquePtr.h"
 #include "phasar/Utils/Nullable.h"
@@ -22,6 +23,8 @@
 #include "llvm/Support/ErrorHandling.h"
 
 #include <concepts>
+#include <functional>
+#include <type_traits>
 
 namespace psr {
 
@@ -98,6 +101,23 @@ class CachedUnionFindAAResult {
   [[no_unique_address]] AAResT AARes;
 };
 
+/// Implements the AliasIterator interface
+template <typename AAResT, typename Var2IdMapper, typename Id2VarMapper>
+  requires UnionFindAAResult<std::remove_cvref_t<AAResT>>
+struct UnionFindAliasIterator {
+  [[no_unique_address]] AAResT AARes;
+  [[no_unique_address]] Var2IdMapper Var2Id;
+  [[no_unique_address]] Id2VarMapper Id2Var;
+
+  void forallAliasesOf(auto &&Ptr, auto && /*Inst*/, auto Callback) {
+    auto Id = std::invoke(Var2Id, Ptr);
+    const auto &RawAliases = AARes.getRawAliasSet(Id);
+    RawAliases.foreach ([&, Callback = copyOrRef(Callback)](ValueId Alias) {
+      std::invoke(Id2Var, Alias, Callback);
+    });
+  }
+};
+
 struct UnionFindAAResultBase {
   enum class ObjectRepId : uint32_t {};
 
diff --git a/include/phasar/Utils/Utilities.h b/include/phasar/Utils/Utilities.h
index 414df68d30..d9cddb7531 100644
--- a/include/phasar/Utils/Utilities.h
+++ b/include/phasar/Utils/Utilities.h
@@ -10,6 +10,7 @@
 #ifndef PHASAR_UTILS_UTILITIES_H_
 #define PHASAR_UTILS_UTILITIES_H_
 
+#include "phasar/Utils/ByRef.h"
 #include "phasar/Utils/TypeTraits.h"
 
 #include "llvm/ADT/SmallVector.h"
@@ -269,6 +270,14 @@ forward_like(U &&X) noexcept { // NOLINT
   }
 }
 
+template <typename T> constexpr auto copyOrRef(T &Val) noexcept {
+  if constexpr (CanEfficientlyPassByValue<T>) {
+    return Val;
+  } else {
+    return std::ref(Val);
+  }
+}
+
 struct identity {
   template <typename T> decltype(auto) operator()(T &&Val) const noexcept {
     return std::forward<T>(Val);
diff --git a/lib/PhasarLLVM/Pointer/FilteredAliasesUtils.h b/lib/PhasarLLVM/Pointer/FilteredAliasesUtils.h
index 47e64f7cae..950017ea90 100644
--- a/lib/PhasarLLVM/Pointer/FilteredAliasesUtils.h
+++ b/lib/PhasarLLVM/Pointer/FilteredAliasesUtils.h
@@ -6,17 +6,6 @@
 #include "llvm/IR/Instructions.h"
 #include "llvm/Support/Compiler.h"
 
-inline LLVM_LIBRARY_VISIBILITY const llvm::Function *
-getFunction(const llvm::Value *V) {
-  if (const auto *Inst = llvm::dyn_cast<llvm::Instruction>(V)) {
-    return Inst->getFunction();
-  }
-  if (const auto *Arg = llvm::dyn_cast<llvm::Argument>(V)) {
-    return Arg->getParent();
-  }
-  return nullptr;
-}
-
 [[nodiscard]] inline LLVM_LIBRARY_VISIBILITY bool
 isConstantGlobalValue(const llvm::GlobalValue *GlobV) {
   if (const auto *Glob = llvm::dyn_cast<llvm::GlobalVariable>(GlobV)) {
diff --git a/lib/PhasarLLVM/Pointer/FilteredLLVMAliasIterator.cpp b/lib/PhasarLLVM/Pointer/FilteredLLVMAliasIterator.cpp
index 28762fa746..e1e82ccc9b 100644
--- a/lib/PhasarLLVM/Pointer/FilteredLLVMAliasIterator.cpp
+++ b/lib/PhasarLLVM/Pointer/FilteredLLVMAliasIterator.cpp
@@ -1,6 +1,7 @@
 #include "phasar/PhasarLLVM/Pointer/FilteredLLVMAliasIterator.h"
 
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h"
+#include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
 
 #include "llvm/IR/Constants.h"
 
diff --git a/lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp b/lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp
index 9b358b1db6..1e8edccec6 100644
--- a/lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp
+++ b/lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp
@@ -1,7 +1,32 @@
 #include "phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h"
 
+#include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
+#include "phasar/Pointer/RawAliasSet.h"
+#include "phasar/Utils/ValueCompressor.h"
+
 namespace psr {
 
 template class CallingContextSensUnionFindAA<LLVMPAGDomain>;
 template class IndirectionSensUnionFindAA<LLVMPAGDomain>;
+
+detail::LLVMLocalUnionFindAliasIteratorBase::
+    LLVMLocalUnionFindAliasIteratorBase(
+        const ValueCompressor<PAGVariable> &VC) {
+  RawAliasSet<ValueId> Globals;
+  for (const auto &[VId, Vars] : VC.id2vars().enumerate()) {
+    for (auto V : Vars) {
+      if (const auto *LLVMVar = V.valueOrNull()) {
+        if (const auto *Fun = psr::getFunction(LLVMVar)) {
+          GlobalsOrInFun[Fun].insert(VId);
+        } else {
+          Globals.insert(VId);
+        }
+      }
+    }
+  }
+
+  for (auto &[Fun, Vars] : GlobalsOrInFun) {
+    Vars |= Globals;
+  }
+}
 } // namespace psr

From d918c2d1bb90a59653e878a85c92c1dd3947e10e Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabian.schiebel@iem.fraunhofer.de>
Date: Sun, 4 Jan 2026 16:03:09 +0100
Subject: [PATCH 07/75] Add LLVMUnionFindAliasIterator + NonNullPtr

---
 .../PhasarLLVM/Pointer/LLVMUnionFindAA.h      | 77 +++++++++++++------
 .../phasar/PhasarLLVM/Utils/LLVMShorthands.h  | 10 +++
 include/phasar/Pointer/UnionFindAA.h          |  6 +-
 include/phasar/Utils/NonNullPtr.h             | 60 +++++++++++++++
 4 files changed, 128 insertions(+), 25 deletions(-)
 create mode 100644 include/phasar/Utils/NonNullPtr.h

diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
index 9842c2b5f2..97a2a53c5f 100644
--- a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
@@ -5,6 +5,7 @@
 #include "phasar/Pointer/RawAliasSet.h"
 #include "phasar/Pointer/UnionFindAA.h"
 #include "phasar/Utils/MapUtils.h"
+#include "phasar/Utils/NonNullPtr.h"
 #include "phasar/Utils/Utilities.h"
 #include "phasar/Utils/ValueCompressor.h"
 
@@ -12,6 +13,39 @@ namespace psr {
 extern template class CallingContextSensUnionFindAA<LLVMPAGDomain>;
 extern template class IndirectionSensUnionFindAA<LLVMPAGDomain>;
 
+inline constexpr std::invocable<ValueId> auto
+llvmUnionFindAliasHandler(const ValueCompressor<PAGVariable> &VC,
+                          std::invocable<const llvm::Value *> auto Callback) {
+  return [&VC, Callback](ValueId Alias) {
+    for (auto V : VC.id2vars(Alias)) {
+      if (const auto *LLVMVar = V.valueOrNull()) [[likely]] {
+        std::invoke(Callback, LLVMVar);
+      }
+    }
+  };
+}
+
+template <typename AAResT, typename Var2IdMapper, typename Id2VarMapper>
+  requires UnionFindAAResult<std::remove_cvref_t<AAResT>>
+// NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
+struct LLVMUnionFindAliasIterator {
+  AAResT AARes;
+  NonNullPtr<const ValueCompressor<PAGVariable>> VC;
+
+  void forallAliasesOf(ValueId VId, const auto & /*Inst*/,
+                       std::invocable<const llvm::Value *> auto Callback) {
+    const auto &RawAliases = AARes.getRawAliasSet(VId);
+    RawAliases.foreach (llvmUnionFindAliasHandler(VC, copyOrRef(Callback)));
+  }
+
+  void forallAliasesOf(const llvm::Value *Ptr, const auto &Inst,
+                       std::invocable<const llvm::Value *> auto Callback) {
+    if (auto ValId = VC->getOrNull(Ptr)) {
+      foreachAliasOf(*ValId, Inst, copyOrRef(Callback));
+    }
+  }
+};
+
 namespace detail {
 class LLVMLocalUnionFindAliasIteratorBase {
 public:
@@ -27,22 +61,15 @@ template <typename AAResT>
 class LLVMLocalUnionFindAliasIterator
     : public detail::LLVMLocalUnionFindAliasIteratorBase {
 public:
-  LLVMLocalUnionFindAliasIterator(AAResT &&AARes,
-                                  const ValueCompressor<PAGVariable> *VC)
-      : detail::LLVMLocalUnionFindAliasIteratorBase(psr::assertNotNull(VC)),
-        AARes(PSR_FWD(AARes)), VC(VC) {}
-
-  void foreachAliasOf(ValueId VId,
-                      std::invocable<const llvm::Value *> auto WithAlias,
-                      const llvm::Function *Context = nullptr) {
-    const auto AliasHandler = [this,
-                               WithAlias = copyOrRef(WithAlias)](ValueId VId) {
-      for (auto V : VC->id2vars(VId)) {
-        if (const auto *LLVMVar = V.valueOrNull()) [[likely]] {
-          std::invoke(WithAlias, LLVMVar);
-        }
-      }
-    };
+  LLVMLocalUnionFindAliasIterator(
+      AAResT &&AARes, NonNullPtr<const ValueCompressor<PAGVariable>> VC)
+      : detail::LLVMLocalUnionFindAliasIteratorBase(*VC), AARes(PSR_FWD(AARes)),
+        VC(VC) {}
+
+  void foreachAliasOf(ValueId VId, const llvm::Function *Context,
+                      std::invocable<const llvm::Value *> auto WithAlias) {
+    const auto AliasHandler =
+        llvmUnionFindAliasHandler(VC, copyOrRef(WithAlias));
 
     auto &&RawVars = AARes.getRawAliasSet(VId);
     if (Context) {
@@ -54,21 +81,27 @@ class LLVMLocalUnionFindAliasIterator
     }
   }
 
-  void foreachAliasOf(const llvm::Value *Val,
-                      std::invocable<const llvm::Value *> auto WithAlias,
-                      const llvm::Function *Context) {
+  void foreachAliasOf(const llvm::Value *Val, const llvm::Function *Context,
+                      std::invocable<const llvm::Value *> auto WithAlias) {
     if (auto ValId = VC->getOrNull(Val)) {
-      foreachAliasOf(*ValId, copyOrRef(WithAlias), Context);
+      foreachAliasOf(*ValId, Context, copyOrRef(WithAlias));
     }
   }
+
+  void foreachAliasOf(const llvm::Value *Val,
+                      const llvm::Instruction *AtInstruction,
+                      std::invocable<const llvm::Value *> auto WithAlias) {
+    foreachAliasOf(Val, psr::getFunction(AtInstruction), copyOrRef(WithAlias));
+  }
+
   void foreachAliasOf(const llvm::Value *Val,
                       std::invocable<const llvm::Value *> auto WithAlias) {
-    foreachAliasOf(Val, copyOrRef(WithAlias), psr::getFunction(Val));
+    foreachAliasOf(Val, psr::getFunction(Val), copyOrRef(WithAlias));
   }
 
 private:
   AAResT AARes;
-  const ValueCompressor<PAGVariable> *VC{};
+  NonNullPtr<const ValueCompressor<PAGVariable>> VC;
 };
 
 } // namespace psr
diff --git a/include/phasar/PhasarLLVM/Utils/LLVMShorthands.h b/include/phasar/PhasarLLVM/Utils/LLVMShorthands.h
index 68da26170f..4ef206dabc 100644
--- a/include/phasar/PhasarLLVM/Utils/LLVMShorthands.h
+++ b/include/phasar/PhasarLLVM/Utils/LLVMShorthands.h
@@ -298,6 +298,9 @@ bool isStaticVariableLazyInitializationBranch(const llvm::BranchInst *Inst);
 bool isVarAnnotationIntrinsic(const llvm::Function *F);
 
 inline const llvm::Function *getFunction(const llvm::Value *V) {
+  if (!V) {
+    return nullptr;
+  }
   if (const auto *Inst = llvm::dyn_cast<llvm::Instruction>(V)) {
     return Inst->getFunction();
   }
@@ -306,6 +309,13 @@ inline const llvm::Function *getFunction(const llvm::Value *V) {
   }
   return nullptr;
 }
+inline const llvm::Function *getFunction(const llvm::Instruction *Inst) {
+  if (!Inst) {
+    return nullptr;
+  }
+
+  return Inst->getFunction();
+}
 
 /**
  * Retrieves String annotation value as per
diff --git a/include/phasar/Pointer/UnionFindAA.h b/include/phasar/Pointer/UnionFindAA.h
index 903b96d130..4cd05dd53f 100644
--- a/include/phasar/Pointer/UnionFindAA.h
+++ b/include/phasar/Pointer/UnionFindAA.h
@@ -10,6 +10,7 @@
 #include "phasar/Utils/Macros.h"
 #include "phasar/Utils/MapUtils.h"
 #include "phasar/Utils/MaybeUniquePtr.h"
+#include "phasar/Utils/NonNullPtr.h"
 #include "phasar/Utils/Nullable.h"
 #include "phasar/Utils/PointerUtils.h"
 #include "phasar/Utils/TypeTraits.h"
@@ -239,10 +240,9 @@ class CallingContextSensUnionFindAA {
   using db_t = typename AnalysisDomainT::db_t;
 
   CallingContextSensUnionFindAA(MaybeUniquePtr<CallGraph<n_t, f_t>> CG,
-                                const db_t *IRDB) noexcept
+                                NonNullPtr<const db_t> IRDB) noexcept
       : CG(std::move(CG)), IRDB(IRDB) {
     assert(this->CG != nullptr);
-    assert(this->IRDB != nullptr);
   }
 
   void onAddEdge(ValueId From, ValueId To, pag::Edge E,
@@ -357,7 +357,7 @@ class CallingContextSensUnionFindAA {
   }
 
   MaybeUniquePtr<CallGraph<n_t, f_t>> CG;
-  const db_t *IRDB{};
+  NonNullPtr<const db_t> IRDB;
   TypedVector<CtxObjectId, std::pair<ValueId, CallingContextId>> Obj2Var{};
   TypedVector<ValueId, llvm::SmallDenseMap<CallingContextId, CtxObjectId>>
       Var2Obj{};
diff --git a/include/phasar/Utils/NonNullPtr.h b/include/phasar/Utils/NonNullPtr.h
new file mode 100644
index 0000000000..dd838d03bf
--- /dev/null
+++ b/include/phasar/Utils/NonNullPtr.h
@@ -0,0 +1,60 @@
+#pragma once
+
+#include "phasar/Utils/Utilities.h"
+
+#include "llvm/Support/Compiler.h"
+
+#include <functional>
+
+namespace psr {
+template <typename T>
+class [[gsl::Pointer(T)]] NonNullPtr : public std::reference_wrapper<T> {
+public:
+  constexpr NonNullPtr(std::nullptr_t) = delete;
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE constexpr NonNullPtr(T *Ptr) noexcept
+      : std::reference_wrapper<T>(psr::assertNotNull(Ptr)) {}
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE constexpr NonNullPtr(
+      std::reference_wrapper<T> RW) noexcept
+      : std::reference_wrapper<T>(RW) {}
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE explicit constexpr NonNullPtr(T &Ref) noexcept
+      : std::reference_wrapper<T>(Ref) {}
+
+  template <typename U>
+    requires(!std::same_as<U, T> && std::convertible_to<U *, T *>)
+  LLVM_ATTRIBUTE_ALWAYS_INLINE constexpr NonNullPtr(
+      NonNullPtr<U> Other) noexcept
+      : std::reference_wrapper<T>(Other) {}
+
+  [[nodiscard]] LLVM_ATTRIBUTE_ALWAYS_INLINE
+      LLVM_ATTRIBUTE_RETURNS_NONNULL constexpr T *
+      operator->() const noexcept {
+    return std::addressof(this->get());
+  }
+
+  [[nodiscard]] LLVM_ATTRIBUTE_ALWAYS_INLINE constexpr T &
+  operator*() const noexcept {
+    return this->get();
+  }
+
+  [[nodiscard]] LLVM_ATTRIBUTE_ALWAYS_INLINE constexpr bool
+  operator==(NonNullPtr Other) noexcept {
+    return &this->get() == &Other.get();
+  }
+  [[nodiscard]] LLVM_ATTRIBUTE_ALWAYS_INLINE constexpr bool
+  operator==(const T *R) noexcept {
+    return &this->get() == R;
+  }
+  [[nodiscard]] LLVM_ATTRIBUTE_ALWAYS_INLINE constexpr bool
+  operator==(std::nullptr_t) noexcept = delete; // NonNullPtr is never null
+
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, NonNullPtr RW) {
+    return OS << &RW.get();
+  }
+  friend std::ostream &operator<<(std::ostream &OS, NonNullPtr RW) {
+    return OS << &RW.get();
+  }
+};
+} // namespace psr

From 2e194847bd8394996e58189d7be99d5360ffdd24 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabian.schiebel@iem.fraunhofer.de>
Date: Mon, 5 Jan 2026 20:12:59 +0100
Subject: [PATCH 08/75] Start adding unit-tests for union-find-AA

---
 .../Pointer/LLVMPointerAssignmentGraph.h      |  11 +-
 .../phasar/Pointer/PointerAssignmentGraph.h   |  59 +++++-
 include/phasar/Pointer/RawAliasSet.h          |  14 +-
 include/phasar/Pointer/UnionFindAA.h          |  18 +-
 include/phasar/Utils/UnionFind.h              |   7 +-
 .../Pointer/LLVMPointerAssignmentGraph.cpp    |  12 +-
 lib/PhasarLLVM/Utils/LLVMShorthands.cpp       |   8 +-
 test/llvm_test_code/pointers/CMakeLists.txt   |   1 +
 test/llvm_test_code/pointers/context_01.c     |  12 ++
 unittests/PhasarLLVM/Pointer/CMakeLists.txt   |   1 +
 .../Pointer/LLVMUnionFindAATest.cpp           | 193 ++++++++++++++++++
 11 files changed, 308 insertions(+), 28 deletions(-)
 create mode 100644 test/llvm_test_code/pointers/context_01.c
 create mode 100644 unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp

diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h b/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
index c6685923c0..9ee309b535 100644
--- a/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
@@ -26,9 +26,7 @@ struct PAGVariable : public llvm::PointerIntPair<const llvm::Value *, 1, bool> {
   };
 
   PAGVariable() noexcept = default; // To enable move-assign in TinyPtrVector
-  PAGVariable(const llvm::Value *Var) noexcept : Base(Var, false) {
-    assert(Var != nullptr);
-  }
+  PAGVariable(const llvm::Value *Var) noexcept : Base(Var, false) {}
   PAGVariable(Return RetVar) noexcept : Base(RetVar.Fun, true) {
     assert(RetVar.Fun != nullptr);
   }
@@ -85,11 +83,12 @@ struct LLVMPAGDomain : LLVMAnalysisDomainDefault {
 };
 
 class LLVMPAGBuilder : public PAGBuilder<LLVMPAGDomain> {
-private:
-  struct PAGBuildData;
-
+public:
   void buildPAG(const LLVMProjectIRDB &IRDB, ValueCompressor<v_t> &VC,
                 pag::PBStrategyRef<LLVMPAGDomain> Strategy) override;
+
+private:
+  struct PAGBuildData;
 };
 
 } // namespace psr
diff --git a/include/phasar/Pointer/PointerAssignmentGraph.h b/include/phasar/Pointer/PointerAssignmentGraph.h
index 0fb40c6771..20e01dad08 100644
--- a/include/phasar/Pointer/PointerAssignmentGraph.h
+++ b/include/phasar/Pointer/PointerAssignmentGraph.h
@@ -87,7 +87,13 @@ struct Edge : public std::variant<Assign, Gep, Call, Return, Load, Store,
 };
 
 template <typename T>
-concept PBStrategy =
+concept CanOnAddEdge =
+    requires(T &Strategy, ValueId From, ValueId To, pag::Edge E) {
+      Strategy.onAddEdge(From, To, E, Nullable<typename T::n_t>{});
+    };
+
+template <typename T>
+concept PBStrategyBase =
     requires(T &Strategy, const T &CStrategy, ValueId From, ValueId To,
              const typename T::n_t &Inst, pag::Edge E) {
       typename T::v_t;
@@ -95,11 +101,12 @@ concept PBStrategy =
       typename T::f_t;
       typename T::n_t;
 
-      { T() } noexcept;
-      Strategy.onAddEdge(From, To, E, Nullable<typename T::n_t>{});
       CStrategy.withCalleesOfCallAt(Inst, [](typename T::f_t Callee) {});
     };
 
+template <typename T>
+concept PBStrategy = CanOnAddEdge<T> && PBStrategyBase<T>;
+
 template <typename T>
 concept CanOnAddValue = requires(T &Strategy, const T::v_t &Var) {
   Strategy.onAddValue(Var, ValueId{});
@@ -113,7 +120,7 @@ concept CanGetNumPossibleValues =
       } noexcept -> std::convertible_to<size_t>;
     };
 
-template <PBStrategy FirstT, PBStrategy SecondT>
+template <PBStrategy FirstT, CanOnAddEdge SecondT>
   requires(std::same_as<typename FirstT::n_t, typename SecondT::n_t> &&
            std::same_as<typename FirstT::v_t, typename SecondT::v_t> &&
            std::same_as<typename FirstT::f_t, typename SecondT::f_t> &&
@@ -164,6 +171,46 @@ struct PBStrategyCombinator {
   }
 };
 
+template <CanOnAddEdge FirstT, PBStrategyBase SecondT> struct PBMixin {
+  using n_t = typename SecondT::n_t;
+  using v_t = typename SecondT::v_t;
+  using f_t = typename SecondT::f_t;
+  using db_t = typename SecondT::db_t;
+
+  [[no_unique_address]] FirstT First;
+  [[no_unique_address]] SecondT Second;
+
+  constexpr void onAddEdge(ValueId From, ValueId To, Edge E,
+                           Nullable<n_t> AtInstruction) {
+    First.onAddEdge(From, To, E, AtInstruction);
+  }
+
+  constexpr void onAddValue(ByConstRef<v_t> Variable, ValueId VId)
+    requires CanOnAddValue<FirstT>
+  {
+    First.onAddValue(Variable, VId);
+  }
+
+  [[nodiscard]] constexpr size_t
+  getNumPossibleValues(const db_t &IRDB) const noexcept
+    requires(CanGetNumPossibleValues<FirstT> ||
+             CanGetNumPossibleValues<SecondT>)
+  {
+    if constexpr (CanGetNumPossibleValues<FirstT>) {
+      return First.getNumPossibleValues(IRDB);
+    }
+    if constexpr (CanGetNumPossibleValues<SecondT>) {
+      return Second.getNumPossibleValues(IRDB);
+    }
+  }
+
+  constexpr void
+  withCalleesOfCallAt(ByConstRef<n_t> CS,
+                      llvm::function_ref<void(f_t)> WithCallee) const {
+    Second.withCalleesOfCallAt(CS, WithCallee);
+  }
+};
+
 /// The main customization point for PAG building.
 /// Implement this interface to provide several callbacks to the PAGBuilder,
 /// specifying how the PAG should be built.
@@ -253,8 +300,8 @@ template <typename AnalysisDomainT> class PBStrategyRef final {
   }
 
   template <typename ConcreteStrategyT>
-  static void getNumPossibleValuesThunk(const void *Ctx,
-                                        const db_t &IRDB) noexcept {
+  static size_t getNumPossibleValuesThunk(const void *Ctx,
+                                          const db_t &IRDB) noexcept {
     if constexpr (CanGetNumPossibleValues<ConcreteStrategyT>) {
       return static_cast<const ConcreteStrategyT *>(Ctx)->getNumPossibleValues(
           IRDB);
diff --git a/include/phasar/Pointer/RawAliasSet.h b/include/phasar/Pointer/RawAliasSet.h
index 97bc3630f1..8e39d2003b 100644
--- a/include/phasar/Pointer/RawAliasSet.h
+++ b/include/phasar/Pointer/RawAliasSet.h
@@ -4,6 +4,8 @@
 
 #include "llvm/ADT/SparseBitVector.h"
 
+#include <concepts>
+
 namespace psr {
 
 template <typename ASet>
@@ -22,12 +24,13 @@ concept IsRawAliasSet = requires(ASet &MutSet, const ASet &ConstSet,
   ConstSet.foreach (DummyFn<typename ASet::value_type>{});
   MutSet |= ConstSet;
   MutSet &= ConstSet;
+  MutSet -= ConstSet;
+  { ConstSet == ConstSet } noexcept -> std::convertible_to<bool>;
+  { ConstSet != ConstSet } noexcept -> std::convertible_to<bool>;
   { MutSet.tryMergeWith(ConstSet) } -> std::convertible_to<bool>;
   { MutSet.clear() } noexcept;
   { ConstSet.empty() } noexcept -> std::convertible_to<bool>;
   { ConstSet.size() } noexcept -> std::convertible_to<size_t>;
-
-  // TODO: Difference?
 };
 
 template <SmallIdType IdT> class RawAliasSet {
@@ -53,6 +56,9 @@ template <SmallIdType IdT> class RawAliasSet {
 
   void operator|=(const RawAliasSet &Other) { Bits |= Other.Bits; }
   void operator&=(const RawAliasSet &Other) { Bits &= Other.Bits; }
+  void operator-=(const RawAliasSet &Other) {
+    Bits.intersectWithComplement(Other.Bits);
+  }
 
   [[nodiscard]] bool empty() const noexcept { return Bits.empty(); }
   [[nodiscard]] size_t size() const noexcept { return Bits.count(); }
@@ -68,6 +74,10 @@ template <SmallIdType IdT> class RawAliasSet {
 
   void erase(IdT Id) { Bits.reset(uint32_t(Id)); }
 
+  [[nodiscard]] bool operator==(const RawAliasSet &Other) const noexcept {
+    return Bits == Other.Bits;
+  }
+
 private:
   llvm::SparseBitVector<> Bits;
   // TODO: roaring::Roaring Bits;
diff --git a/include/phasar/Pointer/UnionFindAA.h b/include/phasar/Pointer/UnionFindAA.h
index 4cd05dd53f..183057114f 100644
--- a/include/phasar/Pointer/UnionFindAA.h
+++ b/include/phasar/Pointer/UnionFindAA.h
@@ -210,7 +210,7 @@ struct BasicUnionFindAA {
         BasicUnionFindAAResult::ObjectRepId(UINT32_MAX);
 
     BasicUnionFindAAResult Result{};
-    Result.BackwardView.resize(Equiv.size());
+    Result.BackwardView.resize(Equiv.numClasses());
     Result.Var2Rep.resize(NumVars, InvalidRep);
 
     for (auto VId : iota<ValueId>(NumVars)) {
@@ -239,7 +239,7 @@ class CallingContextSensUnionFindAA {
   using f_t = typename AnalysisDomainT::f_t;
   using db_t = typename AnalysisDomainT::db_t;
 
-  CallingContextSensUnionFindAA(MaybeUniquePtr<CallGraph<n_t, f_t>> CG,
+  CallingContextSensUnionFindAA(MaybeUniquePtr<const CallGraph<n_t, f_t>> CG,
                                 NonNullPtr<const db_t> IRDB) noexcept
       : CG(std::move(CG)), IRDB(IRDB) {
     assert(this->CG != nullptr);
@@ -247,6 +247,9 @@ class CallingContextSensUnionFindAA {
 
   void onAddEdge(ValueId From, ValueId To, pag::Edge E,
                  Nullable<n_t> CallSite) {
+    // llvm::errs() << "[CtxAA][onAddEdge]: From: " << int(From)
+    //              << ", To: " << int(To) << ", E: " << to_string(E)
+    //              << ", At: " << llvmIRToString(CallSite) << '\n';
     E.apply(Overloaded{
         [&, this, CallSite](pag::Call) {
           for (const auto &[ArgCtxId, FromObj] : Var2Obj[From]) {
@@ -300,13 +303,20 @@ class CallingContextSensUnionFindAA {
     std::ignore = getObject(VId, CallingContextId::None);
   }
 
+  void withCalleesOfCallAt(ByConstRef<n_t> CS,
+                           std::invocable<f_t> auto WithCallee) const {
+    for (const auto &Callee : CG->getCalleesOfCallAt(CS)) {
+      std::invoke(WithCallee, Callee);
+    }
+  }
+
   [[nodiscard]] CallingContextSensUnionFindAAResult
   consumeAAResults(size_t NumVars) && {
     auto Equiv = std::move(Base.AliasSets)
                      .template compress<BasicUnionFindAAResult::ObjectRepId>();
 
     CallingContextSensUnionFindAAResult Result{};
-    Result.BackwardView.resize(Equiv.size());
+    Result.BackwardView.resize(Equiv.numClasses());
     Result.Var2Rep.resize(NumVars);
 
     for (const auto &[ValId, Objects] : Var2Obj.enumerate()) {
@@ -356,7 +366,7 @@ class CallingContextSensUnionFindAA {
     return It->second;
   }
 
-  MaybeUniquePtr<CallGraph<n_t, f_t>> CG;
+  MaybeUniquePtr<const CallGraph<n_t, f_t>> CG;
   NonNullPtr<const db_t> IRDB;
   TypedVector<CtxObjectId, std::pair<ValueId, CallingContextId>> Obj2Var{};
   TypedVector<ValueId, llvm::SmallDenseMap<CallingContextId, CtxObjectId>>
diff --git a/include/phasar/Utils/UnionFind.h b/include/phasar/Utils/UnionFind.h
index 38edeb63de..5dd78257de 100644
--- a/include/phasar/Utils/UnionFind.h
+++ b/include/phasar/Utils/UnionFind.h
@@ -31,14 +31,11 @@ template <SmallIdType IdT = uint32_t> class UnionFind {
 
 template <SmallIdType IdT, SmallIdType MappedIdT> class CompressedUnionFind {
 public:
-  [[nodiscard]] size_t size() const noexcept { return Equiv.getNumClasses(); }
-
-  [[nodiscard]] bool inbounds(IdT Id) const noexcept {
-    return size_t(Id) < size();
+  [[nodiscard]] size_t numClasses() const noexcept {
+    return Equiv.getNumClasses();
   }
 
   [[nodiscard]] MappedIdT operator[](IdT Id) const {
-    assert(inbounds(Id));
     return MappedIdT(Equiv[unsigned(Id)]);
   }
 
diff --git a/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp b/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp
index 11ec507f91..33f67eea69 100644
--- a/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp
+++ b/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp
@@ -6,7 +6,7 @@
 #include "phasar/Utils/MapUtils.h"
 #include "phasar/Utils/ValueCompressor.h"
 
-#include "llvm/ADT/BitVector.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Instructions.h"
@@ -222,11 +222,19 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
 
   void addDelayedEdges(LLVMPBStrategyRef Strategy) {
     OnlyIncomingStoresAndOutgoingLoads.foreach ([this, &Strategy](auto VId) {
+      const bool NeedsStoreSafetyFallback =
+          OutgoingLoads[VId].empty() &&
+          llvm::any_of(VC.id2vars(VId), [](PAGVariable Var) {
+            return Var.isReturnVariable() ||
+                   isAddressTakenVariable(Var.valueOrNull());
+          });
+
       for (auto [IncStore, _] : IncomingStores[VId]) {
         for (auto OutLoad : OutgoingLoads[VId]) {
           Strategy.onAddEdge(IncStore, OutLoad, Assign{}, nullptr);
         }
-        if (OutgoingLoads[VId].empty()) {
+        if (NeedsStoreSafetyFallback) {
+          // Safety-fallback: we may have missed a use of the stored value
           Strategy.onAddEdge(IncStore, VId, StorePOI{}, nullptr);
         }
       }
diff --git a/lib/PhasarLLVM/Utils/LLVMShorthands.cpp b/lib/PhasarLLVM/Utils/LLVMShorthands.cpp
index 6f67426f2a..2e7dba48fa 100644
--- a/lib/PhasarLLVM/Utils/LLVMShorthands.cpp
+++ b/lib/PhasarLLVM/Utils/LLVMShorthands.cpp
@@ -505,6 +505,9 @@ static bool isAllocationSiteOrSimilar(const llvm::Value *V) {
 }
 
 bool psr::isAddressTakenVariable(const llvm::Value *Var) noexcept {
+  if (!Var) {
+    return false;
+  }
   if (!isAllocationSiteOrSimilar(Var)) {
     return true;
   }
@@ -520,11 +523,10 @@ bool psr::isAddressTakenVariable(const llvm::Value *Var) noexcept {
         continue;
       }
       if (const auto *Store = llvm::dyn_cast<llvm::StoreInst>(Use.getUser())) {
-        if (Store->getValueOperand() == Use) {
+        if (Store->getPointerOperand() == Use) {
           continue;
         }
-      } else if (llvm::isa<llvm::IntrinsicInst>(Use.getUser())) {
-        // Approximation!
+      } else if (llvm::isa<llvm::DbgInfoIntrinsic>(Use.getUser())) {
         continue;
       } else if (llvm::isa<llvm::CastInst>(Use.getUser())) {
         if (!CurrVal->getType()->isPointerTy()) {
diff --git a/test/llvm_test_code/pointers/CMakeLists.txt b/test/llvm_test_code/pointers/CMakeLists.txt
index 8201a4fbfb..95b22ec143 100644
--- a/test/llvm_test_code/pointers/CMakeLists.txt
+++ b/test/llvm_test_code/pointers/CMakeLists.txt
@@ -5,6 +5,7 @@ set(lca_files
   global_01.cpp
   inter_dynamic_01.cpp
   inter_dynamic_02.cpp
+  context_01.c
 )
 
 set(lca_files_mem2reg
diff --git a/test/llvm_test_code/pointers/context_01.c b/test/llvm_test_code/pointers/context_01.c
new file mode 100644
index 0000000000..66962033a2
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_01.c
@@ -0,0 +1,12 @@
+
+int *id(int *p) { return p; }
+
+int main() {
+  int x = 42;
+  int y = 43;
+
+  int *xx = id(&x);
+  int *yy = id(&y);
+
+  return *xx;
+}
diff --git a/unittests/PhasarLLVM/Pointer/CMakeLists.txt b/unittests/PhasarLLVM/Pointer/CMakeLists.txt
index 290062d69e..7a8857df82 100644
--- a/unittests/PhasarLLVM/Pointer/CMakeLists.txt
+++ b/unittests/PhasarLLVM/Pointer/CMakeLists.txt
@@ -2,6 +2,7 @@ set(PointerFlowSources
 	LLVMAliasSetTest.cpp
 	LLVMAliasSetSerializationTest.cpp
 	FilteredLLVMAliasSetTest.cpp
+	LLVMUnionFindAATest.cpp
 )
 
 if (PHASAR_USE_SVF)
diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
new file mode 100644
index 0000000000..48e0c6f844
--- /dev/null
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -0,0 +1,193 @@
+#include "phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h"
+
+#include "phasar/ControlFlow/CallGraphAnalysisType.h"
+#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraph.h"
+#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraphBuilder.h"
+#include "phasar/PhasarLLVM/ControlFlow/LLVMVFTableProvider.h"
+#include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
+#include "phasar/Pointer/PointerAssignmentGraph.h"
+#include "phasar/Pointer/RawAliasSet.h"
+#include "phasar/Pointer/UnionFindAA.h"
+#include "phasar/Utils/ValueCompressor.h"
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/IR/Instruction.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include "SrcCodeLocationEntry.h"
+#include "TestConfig.h"
+#include "gtest/gtest.h"
+
+#include <map>
+#include <vector>
+
+namespace {
+using namespace psr;
+
+constexpr auto PathToLLFiles = PHASAR_BUILD_SUBFOLDER("pointers/");
+
+[[nodiscard]] ValueId asId(const ValueCompressor<PAGVariable> &VC,
+                           const LLVMProjectIRDB &IRDB,
+                           unittest::TestingSrcLocation Var) {
+
+  const auto *LLVMVar = unittest::testingLocInIR(Var, IRDB);
+  return VC.getOrNull(LLVMVar).value();
+}
+
+[[nodiscard]] RawAliasSet<ValueId>
+asIdBased(const ValueCompressor<PAGVariable> &VC, const LLVMProjectIRDB &IRDB,
+          llvm::ArrayRef<unittest::TestingSrcLocation> AliasSet) {
+  RawAliasSet<ValueId> Ret;
+
+  for (auto Var : AliasSet) {
+    const auto *LLVMVar = unittest::testingLocInIR(Var, IRDB);
+    Ret.insert(VC.getOrNull(LLVMVar).value());
+  }
+
+  return Ret;
+}
+
+[[nodiscard]] std::string stringifyVal(const ValueCompressor<PAGVariable> &VC,
+                                       ValueId Id) {
+  std::string Ret;
+  llvm::raw_string_ostream ROS(Ret);
+
+  ROS << "{ ";
+
+  const auto &LLVMVars = VC.id2vars(Id);
+  llvm::interleaveComma(LLVMVars, ROS, [&](PAGVariable Var) {
+    // XXX: Should we map back to TestingSrcLocation?
+    ROS << to_string(Var);
+  });
+
+  ROS << " }";
+
+  return Ret;
+}
+
+using GTMap = std::map<unittest::TestingSrcLocation,
+                       std::vector<unittest::TestingSrcLocation>>;
+
+void doAnalysisAndCompareResults(
+    const llvm::Twine &IRFile, const GTMap &ExpectedResults,
+    std::invocable<const LLVMProjectIRDB &, const LLVMBasedCallGraph &> auto
+        AABuilder) {
+
+  auto IRDB = LLVMProjectIRDB::loadOrExit(PathToLLFiles + IRFile);
+  auto TH = DIBasedTypeHierarchy(IRDB);
+  auto VTP = LLVMVFTableProvider(IRDB);
+  auto BaseCG = buildLLVMBasedCallGraph(IRDB, CallGraphAnalysisType::RTA,
+                                        {"main"}, TH, VTP);
+
+  ValueCompressor<PAGVariable> VC;
+  auto PB = LLVMPAGBuilder();
+  auto AA = AABuilder(IRDB, BaseCG);
+  PB.buildPAG(IRDB, VC, &AA);
+
+  UnionFindAAResult auto Results = std::move(AA).consumeAAResults(VC.size());
+
+  for (const auto &[PtrVar, ExpectedAliasVars] : ExpectedResults) {
+    const auto PtrId = asId(VC, IRDB, PtrVar);
+    const auto ExpectedAliasIds = asIdBased(VC, IRDB, ExpectedAliasVars);
+
+    const RawAliasSet<ValueId> &ComputedAliasIds =
+        Results.getRawAliasSet(PtrId);
+
+    ExpectedAliasIds.foreach ([&](ValueId VId) {
+      if (!ComputedAliasIds.contains(VId)) {
+        ADD_FAILURE() << "Did not compute expected alias of " << PtrVar << ": "
+                      << stringifyVal(VC, VId);
+      }
+    });
+
+    ComputedAliasIds.foreach ([&](ValueId VId) {
+      if (ExpectedAliasIds.contains(VId)) {
+        return;
+      }
+
+      const auto &Vars = VC.id2vars(VId);
+      if (llvm::any_of(Vars, [](PAGVariable Var) {
+            if (Var.isReturnVariable()) {
+              return true;
+            }
+
+            if (llvm::isa<llvm::LoadInst>(Var.valueOrNull())) {
+              return true;
+            }
+
+            return false;
+          })) {
+        return;
+      }
+      ADD_FAILURE() << "Computed unexpected alias of " << PtrVar << ": "
+                    << stringifyVal(VC, VId);
+    });
+  }
+}
+
+using namespace psr::unittest;
+
+constexpr auto ContextAABuilder = [](const auto &IRDB, const auto &CG) {
+  return CallingContextSensUnionFindAA<LLVMPAGDomain>{
+      &CG,
+      &IRDB,
+  };
+};
+
+constexpr auto IndAABuilder = [](const auto & /*IRDB*/, const auto & /*CG*/) {
+  return IndirectionSensUnionFindAA<LLVMPAGDomain>{};
+};
+
+TEST(CtxSensUnionFindAATest, Basic01) {
+  GTMap GT = {{LineColFunOp{3, 0, "main", llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{3, 0, "main", llvm::Instruction::Alloca},
+                   LineColFunOp{5, 0, "main", llvm::Instruction::Load},
+               }}};
+  doAnalysisAndCompareResults("basic_01_cpp_dbg.ll", GT, ContextAABuilder);
+}
+
+// TODO: Add more basic tests
+
+TEST(CtxSensUnionFindAATest, Context01) {
+  GTMap GT = {
+      {LineColFunOp{5, 0, "main", llvm::Instruction::Alloca},
+       {
+           LineColFunOp{5, 0, "main", llvm::Instruction::Alloca},
+           LineColFunOp{8, 0, "main", llvm::Instruction::Call},
+           LineColFunOp{11, 0, "main", llvm::Instruction::Load},
+           ArgInFun{0, "id"},
+       }},
+      {LineColFunOp{6, 0, "main", llvm::Instruction::Alloca},
+       {
+           LineColFunOp{6, 0, "main", llvm::Instruction::Alloca},
+           LineColFunOp{9, 0, "main", llvm::Instruction::Call},
+           ArgInFun{0, "id"},
+       }},
+      {ArgInFun{0, "id"},
+       {
+           LineColFunOp{5, 0, "main", llvm::Instruction::Alloca},
+           LineColFunOp{6, 0, "main", llvm::Instruction::Alloca},
+           LineColFunOp{8, 0, "main", llvm::Instruction::Call},
+           LineColFunOp{9, 0, "main", llvm::Instruction::Call},
+           LineColFunOp{11, 0, "main", llvm::Instruction::Load},
+           ArgInFun{0, "id"},
+       }},
+  };
+  doAnalysisAndCompareResults("context_01_c_dbg.ll", GT, ContextAABuilder);
+}
+
+// TODO: Add more context tests
+
+// TODO: Add tests for IndirectionSensUnionFindAA
+
+} // namespace
+
+int main(int Argc, char **Argv) {
+  ::testing::InitGoogleTest(&Argc, Argv);
+  return RUN_ALL_TESTS();
+}

From 70ab85452736b89d9b77fab1c726f894ce7e7d1d Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabian.schiebel@iem.fraunhofer.de>
Date: Tue, 6 Jan 2026 17:14:32 +0100
Subject: [PATCH 09/75] Fix PBMixin + add some comments

---
 .../PhasarLLVM/Pointer/LLVMUnionFindAA.h      | 21 ++++++++++++
 .../phasar/Pointer/PointerAssignmentGraph.h   | 24 +++----------
 include/phasar/Pointer/UnionFindAA.h          | 34 +++++++++++++++++--
 .../Pointer/LLVMUnionFindAATest.cpp           | 10 ++++--
 4 files changed, 65 insertions(+), 24 deletions(-)

diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
index 97a2a53c5f..0be48eee58 100644
--- a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraph.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h"
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
 #include "phasar/Pointer/RawAliasSet.h"
@@ -25,6 +26,26 @@ llvmUnionFindAliasHandler(const ValueCompressor<PAGVariable> &VC,
   };
 }
 
+namespace pag {
+/// Utility class to make pag::PBMixin<IndirectionSensUnionFindAA,
+/// LLVMCGProvider> implement PBStrategy.
+class LLVMCGProvider : public LLVMPAGDomain {
+public:
+  constexpr LLVMCGProvider(NonNullPtr<const LLVMBasedCallGraph> CG) noexcept
+      : CG(CG) {}
+
+  void withCalleesOfCallAt(n_t Inst,
+                           std::invocable<f_t> auto WithCallee) const {
+    for (const auto *Callee : CG->getCalleesOfCallAt(Inst)) {
+      std::invoke(WithCallee, Callee);
+    }
+  }
+
+private:
+  NonNullPtr<const LLVMBasedCallGraph> CG;
+};
+} // namespace pag
+
 template <typename AAResT, typename Var2IdMapper, typename Id2VarMapper>
   requires UnionFindAAResult<std::remove_cvref_t<AAResT>>
 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
diff --git a/include/phasar/Pointer/PointerAssignmentGraph.h b/include/phasar/Pointer/PointerAssignmentGraph.h
index 20e01dad08..b62f87f8fa 100644
--- a/include/phasar/Pointer/PointerAssignmentGraph.h
+++ b/include/phasar/Pointer/PointerAssignmentGraph.h
@@ -171,37 +171,21 @@ struct PBStrategyCombinator {
   }
 };
 
-template <CanOnAddEdge FirstT, PBStrategyBase SecondT> struct PBMixin {
+template <CanOnAddEdge FirstT, PBStrategyBase SecondT>
+struct PBMixin : public FirstT {
   using n_t = typename SecondT::n_t;
   using v_t = typename SecondT::v_t;
   using f_t = typename SecondT::f_t;
   using db_t = typename SecondT::db_t;
 
-  [[no_unique_address]] FirstT First;
   [[no_unique_address]] SecondT Second;
 
-  constexpr void onAddEdge(ValueId From, ValueId To, Edge E,
-                           Nullable<n_t> AtInstruction) {
-    First.onAddEdge(From, To, E, AtInstruction);
-  }
-
-  constexpr void onAddValue(ByConstRef<v_t> Variable, ValueId VId)
-    requires CanOnAddValue<FirstT>
-  {
-    First.onAddValue(Variable, VId);
-  }
-
   [[nodiscard]] constexpr size_t
   getNumPossibleValues(const db_t &IRDB) const noexcept
-    requires(CanGetNumPossibleValues<FirstT> ||
+    requires(!CanGetNumPossibleValues<FirstT> &&
              CanGetNumPossibleValues<SecondT>)
   {
-    if constexpr (CanGetNumPossibleValues<FirstT>) {
-      return First.getNumPossibleValues(IRDB);
-    }
-    if constexpr (CanGetNumPossibleValues<SecondT>) {
-      return Second.getNumPossibleValues(IRDB);
-    }
+    return Second.getNumPossibleValues(IRDB);
   }
 
   constexpr void
diff --git a/include/phasar/Pointer/UnionFindAA.h b/include/phasar/Pointer/UnionFindAA.h
index 183057114f..12a9773a8b 100644
--- a/include/phasar/Pointer/UnionFindAA.h
+++ b/include/phasar/Pointer/UnionFindAA.h
@@ -29,6 +29,7 @@
 
 namespace psr {
 
+/// Base interface for results of a union-find alias-analysis.
 template <typename T>
 concept UnionFindAAResult = requires(const T &Result, ValueId Var) {
   { T::isCached() } noexcept -> std::convertible_to<bool>;
@@ -37,6 +38,9 @@ concept UnionFindAAResult = requires(const T &Result, ValueId Var) {
   { Result.size() } noexcept -> std::convertible_to<size_t>;
 };
 
+/// The intersection of two (different) independent union-find alias-analysis
+/// results.
+/// Use this to achieve better precision than feasible with a single analysis.
 template <UnionFindAAResult FirstT, UnionFindAAResult SecondT>
 struct UnionFindAAResultIntersection {
   [[nodiscard]] static constexpr bool isCached() noexcept {
@@ -102,7 +106,7 @@ class CachedUnionFindAAResult {
   [[no_unique_address]] AAResT AARes;
 };
 
-/// Implements the AliasIterator interface
+/// Implements the AliasIterator interface on union-find alias-analysis results.
 template <typename AAResT, typename Var2IdMapper, typename Id2VarMapper>
   requires UnionFindAAResult<std::remove_cvref_t<AAResT>>
 struct UnionFindAliasIterator {
@@ -119,12 +123,14 @@ struct UnionFindAliasIterator {
   }
 };
 
+/// Common base-class of union-find alias-analysis results.
 struct UnionFindAAResultBase {
   enum class ObjectRepId : uint32_t {};
 
   TypedVector<ObjectRepId, RawAliasSet<ValueId>> BackwardView;
 };
 
+/// Basic implementation of union-find alias-analysis results.
 struct BasicUnionFindAAResult : UnionFindAAResultBase {
   TypedVector<ValueId, ObjectRepId> Var2Rep;
 
@@ -149,6 +155,8 @@ struct BasicUnionFindAAResult : UnionFindAAResultBase {
   }
 };
 
+/// Union-find alias-analysis results for an analysis that achieves (partial)
+/// calling-context sensitivity through heap cloning.
 struct CallingContextSensUnionFindAAResult : UnionFindAAResultBase {
   TypedVector<ValueId, llvm::SmallVector<ObjectRepId, 2>> Var2Rep{};
 
@@ -182,7 +190,14 @@ struct CallingContextSensUnionFindAAResult : UnionFindAAResultBase {
   }
 };
 
-template <typename AnalysisDomainT, typename ObjectIdT>
+/// Union-find alias-analysis that is neither context, nor field, nor
+/// indirection sensitive.
+/// Most useful for building a more precise alias-analysis on top of this,
+/// instead of using this directly.
+///
+/// \tparam AnalysisDomainT The analysis domain to use, e.g., LLVMPAGDomain.
+/// \tparam ObjectIdT The type of object-Ids (default ValueId).
+template <typename AnalysisDomainT, typename ObjectIdT = ValueId>
 struct BasicUnionFindAA {
   using ObjectId = ObjectIdT;
 
@@ -229,6 +244,12 @@ struct BasicUnionFindAA {
   UnionFind<ObjectId> AliasSets{};
 };
 
+/// Union-find alias-analysis that achieves (partial) calling-context
+/// sensitivity through heap cloning.
+/// Implements pag::PBStrategy.
+///
+/// \tparam AnalysisDomainT The analysis domain to use, e.g., LLVMPAGDomain.
+/// \tparam K The maximum length of call-strings (default 1).
 template <typename AnalysisDomainT, unsigned K = 1>
 class CallingContextSensUnionFindAA {
 public:
@@ -310,6 +331,7 @@ class CallingContextSensUnionFindAA {
     }
   }
 
+  /// Retrieve the analysis results after buildPAG() has returned.
   [[nodiscard]] CallingContextSensUnionFindAAResult
   consumeAAResults(size_t NumVars) && {
     auto Equiv = std::move(Base.AliasSets)
@@ -376,6 +398,13 @@ class CallingContextSensUnionFindAA {
   BasicUnionFindAA<AnalysisDomainT, CtxObjectId> Base{};
 };
 
+/// Union-find alias-analysis that achieves (partial) indirection-depth-context
+/// sensitivity through heap cloning.
+/// Use this with pag::PBMixin to implement pag::PBStrategy.
+///
+/// \tparam AnalysisDomainT The analysis domain to use, e.g., LLVMPAGDomain.
+/// \tparam K The maximum depth of pointer-indirections that can be
+/// differentiated (default 5).
 template <typename AnalysisDomainT, unsigned K = 5>
 class IndirectionSensUnionFindAA {
 public:
@@ -448,6 +477,7 @@ class IndirectionSensUnionFindAA {
     }
   }
 
+  /// Retrieve the analysis results after buildPAG() has returned.
   [[nodiscard]] BasicUnionFindAAResult consumeAAResults(size_t NumVars) && {
     return std::move(Base).consumeAAResults(NumVars, [this](ValueId VId) {
       // When presenting the results, we only care about the values at depth 0
diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index 48e0c6f844..86f89584fa 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -138,8 +138,14 @@ constexpr auto ContextAABuilder = [](const auto &IRDB, const auto &CG) {
   };
 };
 
-constexpr auto IndAABuilder = [](const auto & /*IRDB*/, const auto & /*CG*/) {
-  return IndirectionSensUnionFindAA<LLVMPAGDomain>{};
+constexpr auto IndAABuilder = [](const auto & /*IRDB*/, const auto &CG) {
+  auto Ret = pag::PBMixin{
+      IndirectionSensUnionFindAA<LLVMPAGDomain>{},
+      pag::LLVMCGProvider{&CG},
+  };
+
+  static_assert(pag::PBStrategy<decltype(Ret)>);
+  return Ret;
 };
 
 TEST(CtxSensUnionFindAATest, Basic01) {

From 101b03b4e8489ab5dda65eb3ff1535055842be41 Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Wed, 7 Jan 2026 17:21:54 +0100
Subject: [PATCH 10/75] Added more basic and context tests for pointers

---
 test/llvm_test_code/pointers/CMakeLists.txt   | 19 +++++++++++++++++--
 .../pointers/{basic_01.cpp => basic_01.c}     |  0
 test/llvm_test_code/pointers/basic_02.c       |  7 +++++++
 test/llvm_test_code/pointers/basic_03.c       |  9 +++++++++
 test/llvm_test_code/pointers/basic_04.c       | 10 ++++++++++
 test/llvm_test_code/pointers/basic_05.c       | 10 ++++++++++
 test/llvm_test_code/pointers/basic_06.cpp     |  7 +++++++
 test/llvm_test_code/pointers/basic_07.cpp     |  7 +++++++
 test/llvm_test_code/pointers/context_02.c     | 13 +++++++++++++
 test/llvm_test_code/pointers/context_03.c     | 11 +++++++++++
 test/llvm_test_code/pointers/context_04.c     | 15 +++++++++++++++
 11 files changed, 106 insertions(+), 2 deletions(-)
 rename test/llvm_test_code/pointers/{basic_01.cpp => basic_01.c} (100%)
 create mode 100644 test/llvm_test_code/pointers/basic_02.c
 create mode 100644 test/llvm_test_code/pointers/basic_03.c
 create mode 100644 test/llvm_test_code/pointers/basic_04.c
 create mode 100644 test/llvm_test_code/pointers/basic_05.c
 create mode 100644 test/llvm_test_code/pointers/basic_06.cpp
 create mode 100644 test/llvm_test_code/pointers/basic_07.cpp
 create mode 100644 test/llvm_test_code/pointers/context_02.c
 create mode 100644 test/llvm_test_code/pointers/context_03.c
 create mode 100644 test/llvm_test_code/pointers/context_04.c

diff --git a/test/llvm_test_code/pointers/CMakeLists.txt b/test/llvm_test_code/pointers/CMakeLists.txt
index 95b22ec143..859864b2fb 100644
--- a/test/llvm_test_code/pointers/CMakeLists.txt
+++ b/test/llvm_test_code/pointers/CMakeLists.txt
@@ -1,15 +1,30 @@
 set(lca_files
-  basic_01.cpp
+  basic_01.c
+  basic_02.c
+  basic_03.c
+  basic_04.c
+  basic_05.c
+  basic_06.cpp
+  basic_07.cpp
   call_01.cpp
   dynamic_01.cpp
   global_01.cpp
   inter_dynamic_01.cpp
   inter_dynamic_02.cpp
   context_01.c
+  context_02.c
+  context_03.c
+  context_04.c
 )
 
 set(lca_files_mem2reg
-  basic_01.cpp
+  basic_01.c
+  basic_02.c
+  basic_03.c
+  basic_04.c
+  basic_05.c
+  basic_06.cpp
+  basic_07.cpp
   dynamic_01.cpp
   inter_dynamic_01.cpp
   inter_dynamic_02.cpp
diff --git a/test/llvm_test_code/pointers/basic_01.cpp b/test/llvm_test_code/pointers/basic_01.c
similarity index 100%
rename from test/llvm_test_code/pointers/basic_01.cpp
rename to test/llvm_test_code/pointers/basic_01.c
diff --git a/test/llvm_test_code/pointers/basic_02.c b/test/llvm_test_code/pointers/basic_02.c
new file mode 100644
index 0000000000..aa3ea971de
--- /dev/null
+++ b/test/llvm_test_code/pointers/basic_02.c
@@ -0,0 +1,7 @@
+
+int main() {
+  int i;
+  int *p = &i;
+  int **q = &p;
+  **q = 13;
+}
diff --git a/test/llvm_test_code/pointers/basic_03.c b/test/llvm_test_code/pointers/basic_03.c
new file mode 100644
index 0000000000..ba6f3ae977
--- /dev/null
+++ b/test/llvm_test_code/pointers/basic_03.c
@@ -0,0 +1,9 @@
+#include <stdlib.h>
+
+int main() {
+  char *i = (char *)(malloc(3 * sizeof(char)));
+  i[0] = 'A';
+  i[1] = 'B';
+  i[2] = 'C';
+  free(i);
+}
diff --git a/test/llvm_test_code/pointers/basic_04.c b/test/llvm_test_code/pointers/basic_04.c
new file mode 100644
index 0000000000..fb9f63f509
--- /dev/null
+++ b/test/llvm_test_code/pointers/basic_04.c
@@ -0,0 +1,10 @@
+#include <stdlib.h>
+
+int main() {
+  char *i = (char *)(malloc(3 * sizeof(char)));
+  char **p = &i;
+  *p[0] = 'A';
+  *p[1] = 'B';
+  *p[2] = 'C';
+  free(i);
+}
diff --git a/test/llvm_test_code/pointers/basic_05.c b/test/llvm_test_code/pointers/basic_05.c
new file mode 100644
index 0000000000..693daa92e8
--- /dev/null
+++ b/test/llvm_test_code/pointers/basic_05.c
@@ -0,0 +1,10 @@
+
+struct Lorem {
+  int Ipsum;
+};
+
+int main() {
+  struct Lorem i;
+  struct Lorem *p = &i;
+  p->Ipsum = 3;
+}
diff --git a/test/llvm_test_code/pointers/basic_06.cpp b/test/llvm_test_code/pointers/basic_06.cpp
new file mode 100644
index 0000000000..6dfe86daf8
--- /dev/null
+++ b/test/llvm_test_code/pointers/basic_06.cpp
@@ -0,0 +1,7 @@
+#include <string>
+
+int main() {
+  std::string i;
+  std::string *p = &i;
+  *p = "Six";
+}
diff --git a/test/llvm_test_code/pointers/basic_07.cpp b/test/llvm_test_code/pointers/basic_07.cpp
new file mode 100644
index 0000000000..3a725dea94
--- /dev/null
+++ b/test/llvm_test_code/pointers/basic_07.cpp
@@ -0,0 +1,7 @@
+#include <functional>
+
+int main() {
+  std::function<int()> Func = []() { return 1; };
+  auto *FuncPtr = &Func;
+  *FuncPtr = []() { return 2; };
+}
diff --git a/test/llvm_test_code/pointers/context_02.c b/test/llvm_test_code/pointers/context_02.c
new file mode 100644
index 0000000000..6c892f4f36
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_02.c
@@ -0,0 +1,13 @@
+
+int *id1(int *p) { return p; }
+int *id2(int *q) { return q; }
+
+int main() {
+  int x = 42;
+  int y = 43;
+
+  int *xx = id1(&x);
+  int *yy = id2(&y);
+
+  return *xx;
+}
diff --git a/test/llvm_test_code/pointers/context_03.c b/test/llvm_test_code/pointers/context_03.c
new file mode 100644
index 0000000000..785ede7a38
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_03.c
@@ -0,0 +1,11 @@
+
+int *id1(int *p) { return p; }
+int *id2(int *q) { return id1(q); }
+
+int main() {
+  int x = 42;
+
+  int *xx = id2(&x);
+
+  return *xx;
+}
diff --git a/test/llvm_test_code/pointers/context_04.c b/test/llvm_test_code/pointers/context_04.c
new file mode 100644
index 0000000000..97bccc36f4
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_04.c
@@ -0,0 +1,15 @@
+
+struct Lorem {
+  int i;
+  int *j;
+};
+
+int main() {
+  struct Lorem Ipsum;
+
+  int Value = 7;
+  Ipsum.i = Value;
+  Ipsum.j = &Value;
+
+  return *Ipsum.j;
+}

From c92d364a5389f22cc8276193b8e0b23f5417c12e Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabian.schiebel@iem.fraunhofer.de>
Date: Sat, 10 Jan 2026 11:13:05 +0100
Subject: [PATCH 11/75] Small fix in IndirectionSensUnionFindAA::onAddValue

---
 include/phasar/Pointer/UnionFindAA.h          | 12 ++--
 include/phasar/Utils/TypedArray.h             | 71 +++++++++++++++++++
 .../Pointer/LLVMUnionFindAATest.cpp           |  2 +-
 3 files changed, 79 insertions(+), 6 deletions(-)
 create mode 100644 include/phasar/Utils/TypedArray.h

diff --git a/include/phasar/Pointer/UnionFindAA.h b/include/phasar/Pointer/UnionFindAA.h
index 12a9773a8b..b235a3e901 100644
--- a/include/phasar/Pointer/UnionFindAA.h
+++ b/include/phasar/Pointer/UnionFindAA.h
@@ -14,6 +14,7 @@
 #include "phasar/Utils/Nullable.h"
 #include "phasar/Utils/PointerUtils.h"
 #include "phasar/Utils/TypeTraits.h"
+#include "phasar/Utils/TypedArray.h"
 #include "phasar/Utils/TypedVector.h"
 #include "phasar/Utils/UnionFind.h"
 #include "phasar/Utils/Utilities.h"
@@ -468,11 +469,14 @@ class IndirectionSensUnionFindAA {
   void onAddValue(ByConstRef<v_t> /*Var*/, ValueId VId) {
     auto Obj = Obj2Var.size();
     Base.AliasSets.grow(Obj + K);
+    Var2Obj.emplace_back(generate_tag, [Obj](IndDepth Depth) {
+      return IndObjectId(Obj + size_t(Depth));
+    });
     // TODO: For some values, we can already see that depth>=2 does not make
     // sense, so we could exit the below loop early
     for (auto Depth : iota<IndDepth>(K)) {
-      Var2Obj[VId].push_back(IndObjectId(Obj));
-      Obj++;
+      // Var2Obj[VId].push_back(IndObjectId(Obj));
+      // Obj++;
       Obj2Var.emplace_back(VId, Depth);
     }
   }
@@ -510,9 +514,7 @@ class IndirectionSensUnionFindAA {
     return IndDepth(uint32_t(Ctx) - 1);
   }
 
-  // XXX: Replace inner TypedVector by sth like TypedInplaceVector (e.g., using
-  // std::inplace_vector once moving forward with the required C++ version)
-  TypedVector<ValueId, TypedVector<IndDepth, IndObjectId, K>> Var2Obj{};
+  TypedVector<ValueId, TypedArray<IndDepth, IndObjectId, K>> Var2Obj{};
   TypedVector<IndObjectId, std::pair<ValueId, IndDepth>> Obj2Var{};
   BasicUnionFindAA<AnalysisDomainT, IndObjectId> Base{};
 };
diff --git a/include/phasar/Utils/TypedArray.h b/include/phasar/Utils/TypedArray.h
new file mode 100644
index 0000000000..82ebd6defb
--- /dev/null
+++ b/include/phasar/Utils/TypedArray.h
@@ -0,0 +1,71 @@
+#pragma once
+
+#include "phasar/Utils/ByRef.h"
+#include "phasar/Utils/TypeTraits.h"
+
+#include <array>
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+namespace psr {
+
+struct generate_tag_t {};
+inline constexpr generate_tag_t generate_tag{};
+
+template <IdType IdT, typename ValueT, unsigned N>
+class TypedArray : public std::array<ValueT, N> {
+  using Base = std::array<ValueT, N>;
+
+public:
+  using std::array<ValueT, N>::array;
+
+  explicit constexpr TypedArray(
+      generate_tag_t /*unused*/,
+      std::invocable<IdT> auto
+          Gen) noexcept(std::is_nothrow_invocable_v<decltype(Gen) &, IdT>) {
+    [this, Gen = copyOrRef(Gen)]<size_t... I>(std::index_sequence<I...>) {
+      ((this->Base::operator[](I) =
+            std::invoke(Gen, std::integral_constant<IdT, IdT(I)>())),
+       ...);
+    }(std::make_index_sequence<N>());
+  }
+
+  [[nodiscard]] constexpr bool inbounds(IdT Id) const noexcept {
+    return size_t(Id) < N;
+  }
+
+  [[nodiscard]] constexpr const ValueT &operator[](IdT Id) const & {
+    assert(inbounds(Id));
+    return this->Base::operator[](size_t(Id));
+  }
+
+  [[nodiscard]] constexpr ValueT &operator[](IdT Id) & {
+    assert(inbounds(Id));
+    return this->Base::operator[](size_t(Id));
+  }
+
+  [[nodiscard]] constexpr ValueT operator[](IdT Id) && {
+    assert(inbounds(Id));
+    return std::move(this->Base::operator[](size_t(Id)));
+  }
+
+  [[nodiscard]] llvm::ArrayRef<ValueT> asRef() const & noexcept {
+    return {this->Base::data(), N};
+  }
+  [[nodiscard]] llvm::ArrayRef<ValueT> asRef() && noexcept = delete;
+
+  [[nodiscard]] auto enumerate() const noexcept {
+    return llvm::map_range(llvm::enumerate(*this), [](const auto &IndexAndVal) {
+      return std::pair<IdT, ByConstRef<ValueT>>{IdT(IndexAndVal.index()),
+                                                IndexAndVal.value()};
+    });
+  }
+  [[nodiscard]] auto enumerate() noexcept {
+    return llvm::map_range(llvm::enumerate(*this), [](auto &IndexAndVal) {
+      return std::pair<IdT, ValueT &>{IdT(IndexAndVal.index()),
+                                      IndexAndVal.value()};
+    });
+  }
+};
+} // namespace psr
diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index 86f89584fa..38ce7267a5 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -154,7 +154,7 @@ TEST(CtxSensUnionFindAATest, Basic01) {
                    LineColFunOp{3, 0, "main", llvm::Instruction::Alloca},
                    LineColFunOp{5, 0, "main", llvm::Instruction::Load},
                }}};
-  doAnalysisAndCompareResults("basic_01_cpp_dbg.ll", GT, ContextAABuilder);
+  doAnalysisAndCompareResults("basic_01_c_dbg.ll", GT, ContextAABuilder);
 }
 
 // TODO: Add more basic tests

From bed07ffc989039747d25a36c6a61298c5bfe63f9 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabian.schiebel@iem.fraunhofer.de>
Date: Sun, 11 Jan 2026 11:00:46 +0100
Subject: [PATCH 12/75] Add summary-based union-find alias-analysis

---
 include/phasar/ControlFlow/CallGraphBase.h    |  94 +++++++++
 .../DataFlow/IfdsIde/Solver/Compressor.h      |  21 --
 .../PhasarLLVM/Pointer/LLVMUnionFindAA.h      |   2 +
 include/phasar/Pointer/BottomupUnionFindAA.h  | 182 ++++++++++++++++++
 .../phasar/Pointer/PointerAssignmentGraph.h   |   6 +
 include/phasar/Pointer/UnionFindAA.h          |  18 +-
 include/phasar/Utils/Compressor.h             |  40 +++-
 include/phasar/Utils/DebugOutput.h            |  13 +-
 include/phasar/Utils/NonNullPtr.h             |  20 +-
 lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp    |   1 +
 lib/Pointer/UnionFindAA.cpp                   |  28 +++
 test/llvm_test_code/pointers/CMakeLists.txt   |   1 +
 test/llvm_test_code/pointers/context_05.c     |  15 ++
 .../Pointer/LLVMUnionFindAATest.cpp           |  39 ++++
 14 files changed, 439 insertions(+), 41 deletions(-)
 create mode 100644 include/phasar/Pointer/BottomupUnionFindAA.h
 create mode 100644 lib/Pointer/UnionFindAA.cpp
 create mode 100644 test/llvm_test_code/pointers/context_05.c

diff --git a/include/phasar/ControlFlow/CallGraphBase.h b/include/phasar/ControlFlow/CallGraphBase.h
index 1bc44b603c..b84d8f6a68 100644
--- a/include/phasar/ControlFlow/CallGraphBase.h
+++ b/include/phasar/ControlFlow/CallGraphBase.h
@@ -12,8 +12,16 @@
 
 #include "phasar/Utils/ByRef.h"
 #include "phasar/Utils/CRTPUtils.h"
+#include "phasar/Utils/Compressor.h"
+#include "phasar/Utils/GraphTraits.h"
+#include "phasar/Utils/IotaIterator.h"
+#include "phasar/Utils/NonNullPtr.h"
 #include "phasar/Utils/TypeTraits.h"
 
+#include "llvm/ADT/STLExtras.h"
+
+#include <type_traits>
+
 namespace psr {
 template <typename T> struct CGTraits {
   // using n_t
@@ -51,6 +59,92 @@ template <typename Derived> class CallGraphBase : public CRTPBase<Derived> {
     return self().getCallersOfImpl(Fun);
   }
 };
+
+/// A view over a call-graph that implements psr::GraphTraits on the
+/// getCallersOf() relation.
+/// Useful to compute CG-SCCs.
+template <typename CallGraphTy, typename DB> class ReverseCGGraph {
+  static constexpr bool NeedsMapping = !IdType<typename CallGraphTy::f_t>;
+
+  enum class FunctionIdImpl : uint32_t {};
+
+public:
+  using FunctionId = std::conditional_t<NeedsMapping, FunctionIdImpl,
+                                        typename CallGraphTy::f_t>;
+
+  constexpr ReverseCGGraph(
+      NonNullPtr<const CallGraphTy> CGView, NonNullPtr<const DB> IRDB,
+      Compressor<typename CallGraphTy::f_t, FunctionId> FC) noexcept
+    requires(NeedsMapping)
+      : CGView(CGView), IRDB(IRDB), FC(std::move(FC)) {}
+
+  constexpr ReverseCGGraph(NonNullPtr<const CallGraphTy> CGView,
+                           NonNullPtr<const DB> IRDB) noexcept
+      : CGView(CGView), IRDB(IRDB) {
+    FC.reserve(CGView->getNumVertexFunctions());
+    for (const auto &Fun : CGView->getAllVertexFunctions()) {
+      FC.insert(Fun);
+    }
+  }
+
+  NonNullPtr<const CallGraphTy> CGView;
+  NonNullPtr<const DB> IRDB;
+  [[no_unique_address]] std::conditional_t<
+      NeedsMapping, Compressor<typename CallGraphTy::f_t, FunctionId>,
+      NoneCompressor> FC{};
+};
+
+template <typename CallGraphTy, typename DB>
+ReverseCGGraph(NonNullPtr<const CallGraphTy>, NonNullPtr<const DB>)
+    -> ReverseCGGraph<CallGraphTy, DB>;
+template <typename CallGraphTy, typename DB>
+ReverseCGGraph(const CallGraphTy *, const DB *)
+    -> ReverseCGGraph<CallGraphTy, DB>;
+
+template <typename CallGraphTy, typename DB>
+struct GraphTraits<ReverseCGGraph<CallGraphTy, DB>> {
+  using graph_type = ReverseCGGraph<CallGraphTy, DB>;
+  using value_type = typename CallGraphTy::f_t;
+  using vertex_t = typename graph_type::FunctionId;
+  using edge_t = vertex_t;
+
+  static constexpr vertex_t Invalid = vertex_t(UINT32_MAX);
+
+  static constexpr auto mapToFunction(const graph_type &G) {
+    return [&G](ByConstRef<typename CallGraphTy::n_t> Inst) {
+      const auto &Fun = G.IRDB->getFunctionOf(Inst);
+      return G.FC.getOrNull(Fun).value();
+    };
+  }
+
+  static constexpr auto outEdges(const graph_type &G, vertex_t Vtx) {
+    return llvm::map_range(G.CGView->getCallersOf(G.FC[Vtx]), mapToFunction(G));
+  }
+
+  static constexpr decltype(auto) nodes(const graph_type &G) {
+    return G.CGView->getAllVertexFunctions();
+  }
+
+  // TODO: Roots
+
+  static constexpr auto vertices(const graph_type &G) {
+    return iota<vertex_t>(G.CGView->getNumVertexFunctions());
+  }
+
+  static constexpr decltype(auto) node(const graph_type &G, vertex_t Vtx) {
+    return G.FC[Vtx];
+  }
+
+  static constexpr size_t size(const graph_type &G) {
+    return G.CGView->getNumVertexFunctions();
+  }
+
+  static constexpr vertex_t target(edge_t Edge) { return Edge; }
+  static constexpr vertex_t withEdgeTarget(edge_t /*Edge*/, vertex_t Vtx) {
+    return Vtx;
+  }
+};
+
 } // namespace psr
 
 #endif // PHASAR_CONTROLFLOW_CALLGRAPHBASE_H
diff --git a/include/phasar/DataFlow/IfdsIde/Solver/Compressor.h b/include/phasar/DataFlow/IfdsIde/Solver/Compressor.h
index fdeef7e304..460a5e9539 100644
--- a/include/phasar/DataFlow/IfdsIde/Solver/Compressor.h
+++ b/include/phasar/DataFlow/IfdsIde/Solver/Compressor.h
@@ -10,27 +10,6 @@
 
 namespace psr {
 
-struct NoneCompressor final {
-  constexpr NoneCompressor() noexcept = default;
-
-  template <typename T>
-    requires(!std::is_same_v<NoneCompressor, T>)
-  constexpr NoneCompressor(const T & /*unused*/) noexcept {}
-
-  template <typename T>
-  [[nodiscard]] decltype(auto) getOrInsert(T &&Val) const noexcept {
-    return std::forward<T>(Val);
-  }
-  template <typename T>
-  [[nodiscard]] decltype(auto) operator[](T &&Val) const noexcept {
-    return std::forward<T>(Val);
-  }
-  void reserve(size_t /*unused*/) const noexcept {}
-
-  [[nodiscard]] size_t size() const noexcept { return 0; }
-  [[nodiscard]] size_t capacity() const noexcept { return 0; }
-};
-
 class LLVMProjectIRDB;
 
 /// Once we have fast instruction IDs (as we already have in IntelliSecPhasar),
diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
index 0be48eee58..587806c70c 100644
--- a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
@@ -3,6 +3,7 @@
 #include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraph.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h"
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
+#include "phasar/Pointer/BottomupUnionFindAA.h"
 #include "phasar/Pointer/RawAliasSet.h"
 #include "phasar/Pointer/UnionFindAA.h"
 #include "phasar/Utils/MapUtils.h"
@@ -13,6 +14,7 @@
 namespace psr {
 extern template class CallingContextSensUnionFindAA<LLVMPAGDomain>;
 extern template class IndirectionSensUnionFindAA<LLVMPAGDomain>;
+extern template class BottomupUnionFindAA<LLVMPAGDomain>;
 
 inline constexpr std::invocable<ValueId> auto
 llvmUnionFindAliasHandler(const ValueCompressor<PAGVariable> &VC,
diff --git a/include/phasar/Pointer/BottomupUnionFindAA.h b/include/phasar/Pointer/BottomupUnionFindAA.h
new file mode 100644
index 0000000000..07883cc761
--- /dev/null
+++ b/include/phasar/Pointer/BottomupUnionFindAA.h
@@ -0,0 +1,182 @@
+#pragma once
+
+#include "phasar/ControlFlow/CallGraph.h"
+#include "phasar/ControlFlow/CallGraphBase.h"
+#include "phasar/Pointer/PointerAssignmentGraph.h"
+#include "phasar/Pointer/RawAliasSet.h"
+#include "phasar/Pointer/UnionFindAA.h"
+#include "phasar/Utils/DebugOutput.h"
+#include "phasar/Utils/IotaIterator.h"
+#include "phasar/Utils/Logger.h"
+#include "phasar/Utils/MapUtils.h"
+#include "phasar/Utils/MaybeUniquePtr.h"
+#include "phasar/Utils/Printer.h"
+#include "phasar/Utils/SCCGeneric.h"
+#include "phasar/Utils/SCCId.h"
+#include "phasar/Utils/TypedVector.h"
+#include "phasar/Utils/ValueCompressor.h"
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
+
+#include <cstdint>
+#include <optional>
+#include <unordered_map>
+
+namespace psr {
+template <typename AnalysisDomainT> class BottomupUnionFindAA {
+  struct CallSiteInfo {
+    llvm::SmallVector<std::tuple<ValueId, ValueId, pag::Call>, 2> Params{};
+    llvm::SmallVector<ValueId, 1> Ret{};
+    std::optional<ValueId> RetSlot{};
+  };
+
+public:
+  using n_t = typename AnalysisDomainT::n_t;
+  using v_t = typename AnalysisDomainT::v_t;
+  using f_t = typename AnalysisDomainT::f_t;
+  using db_t = typename AnalysisDomainT::db_t;
+
+  using CGTy = CallGraph<n_t, f_t>;
+  using RevCGTy = ReverseCGGraph<CGTy, db_t>;
+  using FunVtxTy = typename RevCGTy::FunctionId;
+
+  static constexpr auto InvalidSCC = SCCId<FunVtxTy>(UINT32_MAX);
+
+  constexpr BottomupUnionFindAA(RevCGTy &&RevCG,
+                                NonNullPtr<SCCHolder<FunVtxTy>> CGSCCs)
+      : RevCG(std::move(RevCG)), CGSCCs(CGSCCs.get()) {
+    const auto NumSCCs = CGSCCs->size();
+    Calls.resize(NumSCCs);
+    IdsForSum.resize(NumSCCs);
+  }
+
+  constexpr BottomupUnionFindAA(RevCGTy &&RevCG) : RevCG(std::move(RevCG)) {
+    auto SCCs = computeSCCs(this->RevCG);
+    this->CGSCCs = std::make_unique<SCCHolder<FunVtxTy>>(std::move(SCCs));
+    const auto NumSCCs = CGSCCs->size();
+    Calls.resize(NumSCCs);
+    IdsForSum.resize(NumSCCs);
+  }
+
+  void withCalleesOfCallAt(ByConstRef<n_t> CS,
+                           std::invocable<f_t> auto WithCallee) const {
+    for (const auto &Callee : RevCG.CGView->getCalleesOfCallAt(CS)) {
+      std::invoke(WithCallee, Callee);
+    }
+  }
+
+  void onAddEdge(ValueId From, ValueId To, pag::Edge E,
+                 Nullable<n_t> CallSite) {
+    if (E.isa<pag::Call>()) {
+      auto FromSCC = SCCOfVal[From];
+      auto ToSCC = SCCOfVal[To];
+      if (FromSCC != ToSCC && FromSCC != InvalidSCC && ToSCC != InvalidSCC) {
+        Calls[FromSCC][CallSite].Params.emplace_back(From, To,
+                                                     E.cast<pag::Call>());
+        IdsForSum[ToSCC].insert(To);
+        return;
+      }
+    } else if (E.isa<pag::Return>()) {
+      auto FromSCC = SCCOfVal[From];
+      auto ToSCC = SCCOfVal[To];
+      if (FromSCC != ToSCC && FromSCC != InvalidSCC && ToSCC != InvalidSCC) {
+        auto &RetInfo = Calls[ToSCC][CallSite];
+        assert(RetInfo.RetSlot == std::nullopt || RetInfo.RetSlot == To);
+        RetInfo.RetSlot = To;
+        RetInfo.Ret.push_back(From);
+
+        IdsForSum[FromSCC].insert(From);
+        return;
+      }
+      return;
+    }
+
+    Base.onAddEdge(From, To, E, CallSite);
+  }
+
+  void onAddValue(ByConstRef<v_t> Var, ValueId VId) {
+    auto &SccPlace = SCCOfVal.emplace_back(InvalidSCC);
+    if (auto &&Fun = getFunction(Var)) {
+      if (auto FunVtx = RevCG.FC.getOrNull(Fun)) {
+        SccPlace = CGSCCs->SCCOfNode[*FunVtx];
+      }
+    }
+
+    Base.onAddValue(Var, VId);
+  }
+
+  [[nodiscard]] BasicUnionFindAAResult consumeAAResults(size_t NumVars) && {
+    TypedVector<ValueId, RawAliasSet<ValueId>> IntermediateBackView(NumVars);
+
+    for (SCCId<FunVtxTy> CurrSCC :
+         llvm::reverse(iota<SCCId<FunVtxTy>>(CGSCCs->size()))) {
+
+      for (const auto &[CS, CSInfo] : Calls[CurrSCC]) {
+        PHASAR_LOG_LEVEL_CAT(DEBUG, "BottomupUnionFindAA",
+                             "At CS: " << NToString(CS));
+        llvm::SmallDenseMap<ValueId, llvm::SmallVector<ValueId, 2>> BackMap;
+
+        for (const auto &[Arg, Param, E] : CSInfo.Params) {
+          BackMap[Param].push_back(Arg);
+        }
+        if (CSInfo.RetSlot) {
+          for (auto Ret : CSInfo.Ret) {
+            BackMap[Ret].push_back(*CSInfo.RetSlot);
+          }
+        }
+
+        // --- Apply summaries:
+        for (const auto &[Param, Args] : BackMap) {
+          PHASAR_LOG_LEVEL_CAT(DEBUG, "BottomupUnionFindAA",
+                               "  Param: " << psr::to_underlying(Param)
+                                           << "; Args: "
+                                           << PrettyPrinter{Args});
+
+          const auto &ToAliases = IntermediateBackView[Param];
+          ToAliases.foreach ([&](ValueId Alias) {
+            if (const auto *AliasFroms = getOrNull(BackMap, Alias)) {
+              for (auto Arg : Args) {
+                PHASAR_LOG_LEVEL_CAT(DEBUG, "BottomupUnionFindAA",
+                                     "  JOIN " << psr::to_underlying(Arg)
+                                               << " WITH "
+                                               << PrettyPrinter{*AliasFroms});
+
+                for (auto Alias : *AliasFroms) {
+                  Base.AliasSets.join(Arg, Alias);
+                }
+              }
+            }
+          });
+        }
+      }
+      // --- Compute new summaries:
+
+      IdsForSum[CurrSCC].foreach ([&](ValueId SumId) {
+        auto SumIdRep = Base.AliasSets.find(SumId);
+        IntermediateBackView[SumIdRep].insert(SumId);
+      });
+    }
+
+    return std::move(Base).consumeAAResults(NumVars);
+  }
+
+private:
+  [[nodiscard]] Nullable<f_t> getFunction(ByConstRef<v_t> Var) {
+    if constexpr (requires() { getPointerFrom(Var)->getFunction(); }) {
+      return getPointerFrom(Var)->getFunction();
+    } else {
+      return RevCG.IRDB->getFunctionOf(Var);
+    }
+  }
+
+  RevCGTy RevCG;
+  MaybeUniquePtr<SCCHolder<FunVtxTy>> CGSCCs;
+
+  TypedVector<ValueId, SCCId<FunVtxTy>> SCCOfVal;
+  TypedVector<SCCId<FunVtxTy>, std::unordered_map<n_t, CallSiteInfo>> Calls;
+  TypedVector<SCCId<FunVtxTy>, RawAliasSet<ValueId>> IdsForSum;
+  BasicUnionFindAA<AnalysisDomainT> Base{};
+};
+} // namespace psr
diff --git a/include/phasar/Pointer/PointerAssignmentGraph.h b/include/phasar/Pointer/PointerAssignmentGraph.h
index b62f87f8fa..61e3812ee5 100644
--- a/include/phasar/Pointer/PointerAssignmentGraph.h
+++ b/include/phasar/Pointer/PointerAssignmentGraph.h
@@ -64,6 +64,12 @@ struct Edge : public std::variant<Assign, Gep, Call, Return, Load, Store,
     return std::nullopt;
   }
 
+  template <typename T> [[nodiscard]] constexpr T cast() const noexcept {
+    assert(isa<T>() && "Invalid cast!");
+    const auto *Ptr = std::get_if<T>(this);
+    return *Ptr;
+  }
+
   template <typename HandlerFn>
   LLVM_ATTRIBUTE_ALWAYS_INLINE constexpr decltype(auto)
   apply(HandlerFn &&Handler) const {
diff --git a/include/phasar/Pointer/UnionFindAA.h b/include/phasar/Pointer/UnionFindAA.h
index b235a3e901..96692f5cd1 100644
--- a/include/phasar/Pointer/UnionFindAA.h
+++ b/include/phasar/Pointer/UnionFindAA.h
@@ -9,7 +9,6 @@
 #include "phasar/Utils/IotaIterator.h"
 #include "phasar/Utils/Macros.h"
 #include "phasar/Utils/MapUtils.h"
-#include "phasar/Utils/MaybeUniquePtr.h"
 #include "phasar/Utils/NonNullPtr.h"
 #include "phasar/Utils/Nullable.h"
 #include "phasar/Utils/PointerUtils.h"
@@ -129,6 +128,8 @@ struct UnionFindAAResultBase {
   enum class ObjectRepId : uint32_t {};
 
   TypedVector<ObjectRepId, RawAliasSet<ValueId>> BackwardView;
+
+  void dump(llvm::raw_ostream &OS = llvm::errs(), uint32_t Indent = 0) const;
 };
 
 /// Basic implementation of union-find alias-analysis results.
@@ -216,9 +217,9 @@ struct BasicUnionFindAA {
     AliasSets.grow(size_t(VId) + 1);
   }
 
+  template <std::invocable<ValueId> Var2ObjFn = IdentityFn>
   [[nodiscard]] BasicUnionFindAAResult
-  consumeAAResults(size_t NumVars,
-                   std::invocable<ValueId> auto Var2Obj = IdentityFn{}) && {
+  consumeAAResults(size_t NumVars, Var2ObjFn Var2Obj = {}) && {
     auto Equiv = std::move(AliasSets)
                      .template compress<BasicUnionFindAAResult::ObjectRepId>();
 
@@ -261,11 +262,10 @@ class CallingContextSensUnionFindAA {
   using f_t = typename AnalysisDomainT::f_t;
   using db_t = typename AnalysisDomainT::db_t;
 
-  CallingContextSensUnionFindAA(MaybeUniquePtr<const CallGraph<n_t, f_t>> CG,
-                                NonNullPtr<const db_t> IRDB) noexcept
-      : CG(std::move(CG)), IRDB(IRDB) {
-    assert(this->CG != nullptr);
-  }
+  constexpr CallingContextSensUnionFindAA(
+      NonNullPtr<const CallGraph<n_t, f_t>> CG,
+      NonNullPtr<const db_t> IRDB) noexcept
+      : CG(CG), IRDB(IRDB) {}
 
   void onAddEdge(ValueId From, ValueId To, pag::Edge E,
                  Nullable<n_t> CallSite) {
@@ -389,7 +389,7 @@ class CallingContextSensUnionFindAA {
     return It->second;
   }
 
-  MaybeUniquePtr<const CallGraph<n_t, f_t>> CG;
+  NonNullPtr<const CallGraph<n_t, f_t>> CG;
   NonNullPtr<const db_t> IRDB;
   TypedVector<CtxObjectId, std::pair<ValueId, CallingContextId>> Obj2Var{};
   TypedVector<ValueId, llvm::SmallDenseMap<CallingContextId, CtxObjectId>>
diff --git a/include/phasar/Utils/Compressor.h b/include/phasar/Utils/Compressor.h
index 3b920c8868..d3d445d7fe 100644
--- a/include/phasar/Utils/Compressor.h
+++ b/include/phasar/Utils/Compressor.h
@@ -21,7 +21,6 @@
 #include <deque>
 #include <functional>
 #include <optional>
-#include <type_traits>
 
 namespace psr {
 template <typename T, IdType IdT = uint32_t> class Compressor;
@@ -234,6 +233,45 @@ class Compressor<T, IdT> {
   llvm::DenseMap<const T *, IdT, DSI> ToInt;
 };
 
+struct NoneCompressor final {
+  constexpr NoneCompressor() noexcept = default;
+
+  template <typename T>
+    requires(!std::is_same_v<NoneCompressor, T>)
+  constexpr NoneCompressor(const T & /*unused*/) noexcept {}
+
+  template <typename T>
+  [[nodiscard]] constexpr decltype(auto) getOrInsert(T &&Val) const noexcept {
+    return std::forward<T>(Val);
+  }
+
+  template <typename T>
+  constexpr std::pair<T, bool> insert(const T &Elem) const {
+    return {Elem, false};
+  }
+
+  template <typename T>
+  constexpr std::optional<T> getOrNull(const T &Elem) const {
+    return {Elem};
+  }
+
+  template <typename T> constexpr T get(const T &Elem) const { return Elem; }
+
+  template <typename T>
+  [[nodiscard]] constexpr bool inbounds(const T & /*Idx*/) const noexcept {
+    return true;
+  }
+
+  template <typename T>
+  [[nodiscard]] constexpr decltype(auto) operator[](T &&Val) const noexcept {
+    return std::forward<T>(Val);
+  }
+  constexpr void reserve(size_t /*unused*/) const noexcept {}
+
+  [[nodiscard]] constexpr size_t size() const noexcept { return 0; }
+  [[nodiscard]] constexpr size_t capacity() const noexcept { return 0; }
+};
+
 } // namespace psr
 
 #endif // PHASAR_DATAFLOW_IFDSIDE_SOLVER_COMPRESSOR_H
diff --git a/include/phasar/Utils/DebugOutput.h b/include/phasar/Utils/DebugOutput.h
index bfd282183f..064ff23a29 100644
--- a/include/phasar/Utils/DebugOutput.h
+++ b/include/phasar/Utils/DebugOutput.h
@@ -10,6 +10,7 @@
 #define PHASAR_UTILS_DEBUGOUTPUT_H
 
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
+#include "phasar/Utils/TypeTraits.h"
 
 #include "llvm/IR/Type.h"
 #include "llvm/Support/raw_os_ostream.h"
@@ -29,8 +30,8 @@ namespace detail {
 template <typename OS_t, typename T> void printHelper(OS_t &OS, const T &Data);
 
 template <typename OS_t, typename... Args, size_t... Idx>
-void printTuple(OS_t &OS, const std::tuple<Args...> &Tup,
-                std::index_sequence<Idx...> /*unused*/) {
+inline void printTuple(OS_t &OS, const std::tuple<Args...> &Tup,
+                       std::index_sequence<Idx...> /*unused*/) {
   OS << "(";
   ((OS << (Idx == 0 ? "" : ", "), printHelper(OS, std::get<Idx>(Tup))), ...);
   OS << ")";
@@ -55,6 +56,12 @@ template <typename OS_t, typename T> void printHelper(OS_t &OS, const T &Data) {
     }
   } else if constexpr (is_printable_v<ElemTy, OS_t>) {
     OS << Data;
+  } else if constexpr (has_str_v<ElemTy>) {
+    OS << Data.str();
+  } else if constexpr (has_adl_to_string_v<ElemTy>) {
+    OS << psr::adl_to_string(Data);
+  } else if constexpr (std::is_enum_v<ElemTy>) {
+    OS << std::underlying_type_t<ElemTy>(Data);
   } else if constexpr (is_pair_v<ElemTy>) {
     OS << "(";
     printHelper(OS, Data.first);
@@ -63,8 +70,6 @@ template <typename OS_t, typename T> void printHelper(OS_t &OS, const T &Data) {
     OS << ")";
   } else if constexpr (is_tuple_v<ElemTy>) {
     printTuple(OS, Data, std::make_index_sequence<std::tuple_size_v<ElemTy>>());
-  } else if constexpr (has_str_v<ElemTy>) {
-    OS << Data.str();
   } else if constexpr (is_iterable_v<ElemTy>) {
     OS << "{ ";
     bool Frst = true;
diff --git a/include/phasar/Utils/NonNullPtr.h b/include/phasar/Utils/NonNullPtr.h
index dd838d03bf..f7ed812d93 100644
--- a/include/phasar/Utils/NonNullPtr.h
+++ b/include/phasar/Utils/NonNullPtr.h
@@ -9,6 +9,8 @@
 namespace psr {
 template <typename T>
 class [[gsl::Pointer(T)]] NonNullPtr : public std::reference_wrapper<T> {
+  using Base = std::reference_wrapper<T>;
+
 public:
   constexpr NonNullPtr(std::nullptr_t) = delete;
 
@@ -28,33 +30,39 @@ class [[gsl::Pointer(T)]] NonNullPtr : public std::reference_wrapper<T> {
       NonNullPtr<U> Other) noexcept
       : std::reference_wrapper<T>(Other) {}
 
+  [[nodiscard]] LLVM_ATTRIBUTE_ALWAYS_INLINE
+      LLVM_ATTRIBUTE_RETURNS_NONNULL constexpr T *
+      get() const noexcept {
+    return std::addressof(this->Base::get());
+  }
+
   [[nodiscard]] LLVM_ATTRIBUTE_ALWAYS_INLINE
       LLVM_ATTRIBUTE_RETURNS_NONNULL constexpr T *
       operator->() const noexcept {
-    return std::addressof(this->get());
+    return get();
   }
 
   [[nodiscard]] LLVM_ATTRIBUTE_ALWAYS_INLINE constexpr T &
   operator*() const noexcept {
-    return this->get();
+    return this->Base::get();
   }
 
   [[nodiscard]] LLVM_ATTRIBUTE_ALWAYS_INLINE constexpr bool
   operator==(NonNullPtr Other) noexcept {
-    return &this->get() == &Other.get();
+    return get() == Other.get();
   }
   [[nodiscard]] LLVM_ATTRIBUTE_ALWAYS_INLINE constexpr bool
   operator==(const T *R) noexcept {
-    return &this->get() == R;
+    return get() == R;
   }
   [[nodiscard]] LLVM_ATTRIBUTE_ALWAYS_INLINE constexpr bool
   operator==(std::nullptr_t) noexcept = delete; // NonNullPtr is never null
 
   friend llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, NonNullPtr RW) {
-    return OS << &RW.get();
+    return OS << RW.get();
   }
   friend std::ostream &operator<<(std::ostream &OS, NonNullPtr RW) {
-    return OS << &RW.get();
+    return OS << RW.get();
   }
 };
 } // namespace psr
diff --git a/lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp b/lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp
index 1e8edccec6..8b39a54d81 100644
--- a/lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp
+++ b/lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp
@@ -8,6 +8,7 @@ namespace psr {
 
 template class CallingContextSensUnionFindAA<LLVMPAGDomain>;
 template class IndirectionSensUnionFindAA<LLVMPAGDomain>;
+template class BottomupUnionFindAA<LLVMPAGDomain>;
 
 detail::LLVMLocalUnionFindAliasIteratorBase::
     LLVMLocalUnionFindAliasIteratorBase(
diff --git a/lib/Pointer/UnionFindAA.cpp b/lib/Pointer/UnionFindAA.cpp
new file mode 100644
index 0000000000..3800d533d6
--- /dev/null
+++ b/lib/Pointer/UnionFindAA.cpp
@@ -0,0 +1,28 @@
+
+#include "phasar/Pointer/UnionFindAA.h"
+
+#include "phasar/Utils/StrongTypeDef.h"
+
+using namespace psr;
+
+void psr::UnionFindAAResultBase::dump(llvm::raw_ostream &OS,
+                                      uint32_t Indent) const {
+  OS.indent(Indent) << "UnionFindAAResult {\n";
+
+  for (const auto &[RepId, Aliases] : BackwardView.enumerate()) {
+    OS.indent(Indent + 2) << "#" << psr::to_underlying(RepId) << ": <";
+    bool First = true;
+    Aliases.foreach ([&](auto AliasId) {
+      if (First) {
+        First = false;
+      } else {
+        OS << ", ";
+      }
+
+      OS << psr::to_underlying(AliasId);
+    });
+    OS << ">\n";
+  }
+
+  OS.indent(Indent) << "}\n";
+}
diff --git a/test/llvm_test_code/pointers/CMakeLists.txt b/test/llvm_test_code/pointers/CMakeLists.txt
index 859864b2fb..077f75677a 100644
--- a/test/llvm_test_code/pointers/CMakeLists.txt
+++ b/test/llvm_test_code/pointers/CMakeLists.txt
@@ -15,6 +15,7 @@ set(lca_files
   context_02.c
   context_03.c
   context_04.c
+  context_05.c
 )
 
 set(lca_files_mem2reg
diff --git a/test/llvm_test_code/pointers/context_05.c b/test/llvm_test_code/pointers/context_05.c
new file mode 100644
index 0000000000..04724b7ca0
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_05.c
@@ -0,0 +1,15 @@
+
+int *buzz(int *s) { return s; }
+int *baz(int *r) { return buzz(r); }
+int *bar(int *q) { return baz(q); }
+int *foo(int *p) { return bar(p); }
+
+int main() {
+  int x = 42;
+  int y = 43;
+
+  int *xx = foo(&x);
+  int *yy = foo(&y);
+
+  return *xx;
+}
diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index 38ce7267a5..e186cdaf10 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -1,12 +1,14 @@
 #include "phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h"
 
 #include "phasar/ControlFlow/CallGraphAnalysisType.h"
+#include "phasar/ControlFlow/CallGraphBase.h"
 #include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraph.h"
 #include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraphBuilder.h"
 #include "phasar/PhasarLLVM/ControlFlow/LLVMVFTableProvider.h"
 #include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h"
 #include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
+#include "phasar/Pointer/BottomupUnionFindAA.h"
 #include "phasar/Pointer/PointerAssignmentGraph.h"
 #include "phasar/Pointer/RawAliasSet.h"
 #include "phasar/Pointer/UnionFindAA.h"
@@ -127,6 +129,10 @@ void doAnalysisAndCompareResults(
                     << stringifyVal(VC, VId);
     });
   }
+
+  if (::testing::Test::HasFailure()) {
+    Results.dump();
+  }
 }
 
 using namespace psr::unittest;
@@ -148,6 +154,18 @@ constexpr auto IndAABuilder = [](const auto & /*IRDB*/, const auto &CG) {
   return Ret;
 };
 
+constexpr auto BotAABuilder = [](const auto &IRDB, const auto &CG) {
+  auto Ret = BottomupUnionFindAA<LLVMPAGDomain>{
+      ReverseCGGraph{
+          &CG,
+          &IRDB,
+      },
+  };
+
+  static_assert(pag::PBStrategy<decltype(Ret)>);
+  return Ret;
+};
+
 TEST(CtxSensUnionFindAATest, Basic01) {
   GTMap GT = {{LineColFunOp{3, 0, "main", llvm::Instruction::Alloca},
                {
@@ -191,6 +209,27 @@ TEST(CtxSensUnionFindAATest, Context01) {
 
 // TODO: Add tests for IndirectionSensUnionFindAA
 
+TEST(BotUnionFindAATest, Context05) {
+  GTMap GT = {
+      {LineColFunOp{8, 0, "main", llvm::Instruction::Alloca},
+       {
+           LineColFunOp{8, 0, "main", llvm::Instruction::Alloca},
+           LineColFunOp{11, 0, "main", llvm::Instruction::Call},
+           LineColFunOp{14, 0, "main", llvm::Instruction::Load},
+       }},
+      {LineColFunOp{9, 0, "main", llvm::Instruction::Alloca},
+       {
+           LineColFunOp{9, 0, "main", llvm::Instruction::Alloca},
+           LineColFunOp{12, 0, "main", llvm::Instruction::Call},
+       }},
+  };
+  // psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
+  //                                     "BottomupUnionFindAA");
+  doAnalysisAndCompareResults("context_05_c_dbg.ll", GT, BotAABuilder);
+}
+
+// TODO: Add more tests for BottomupUnionFindAA
+
 } // namespace
 
 int main(int Argc, char **Argv) {

From e75f438b06ba37cf19891ac2a9621fd4cfec118d Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Tue, 13 Jan 2026 11:15:32 +0100
Subject: [PATCH 13/75] context tests with different depth

---
 test/llvm_test_code/pointers/context_02.c |  8 +++++---
 test/llvm_test_code/pointers/context_03.c |  1 +
 test/llvm_test_code/pointers/context_04.c | 16 +++++++---------
 test/llvm_test_code/pointers/context_05.c | 14 ++++++++++++++
 test/llvm_test_code/pointers/context_06.c | 15 +++++++++++++++
 5 files changed, 42 insertions(+), 12 deletions(-)
 create mode 100644 test/llvm_test_code/pointers/context_05.c
 create mode 100644 test/llvm_test_code/pointers/context_06.c

diff --git a/test/llvm_test_code/pointers/context_02.c b/test/llvm_test_code/pointers/context_02.c
index 6c892f4f36..542f953fda 100644
--- a/test/llvm_test_code/pointers/context_02.c
+++ b/test/llvm_test_code/pointers/context_02.c
@@ -6,8 +6,10 @@ int main() {
   int x = 42;
   int y = 43;
 
-  int *xx = id1(&x);
-  int *yy = id2(&y);
+  int *xx1 = id1(&x);
+  int *xx2 = id1(&x);
+  int *yy1 = id2(&y);
+  int *yy2 = id2(&y);
 
-  return *xx;
+  return *xx1;
 }
diff --git a/test/llvm_test_code/pointers/context_03.c b/test/llvm_test_code/pointers/context_03.c
index 785ede7a38..c561917160 100644
--- a/test/llvm_test_code/pointers/context_03.c
+++ b/test/llvm_test_code/pointers/context_03.c
@@ -6,6 +6,7 @@ int main() {
   int x = 42;
 
   int *xx = id2(&x);
+  int *yy = id2(&x);
 
   return *xx;
 }
diff --git a/test/llvm_test_code/pointers/context_04.c b/test/llvm_test_code/pointers/context_04.c
index 97bccc36f4..851e809267 100644
--- a/test/llvm_test_code/pointers/context_04.c
+++ b/test/llvm_test_code/pointers/context_04.c
@@ -1,15 +1,13 @@
 
-struct Lorem {
-  int i;
-  int *j;
-};
+int *id1(int *p) { return p; }
+int *id2(int *q) { return id1(q); }
+int *id3(int *r) { return id2(r); }
 
 int main() {
-  struct Lorem Ipsum;
+  int x = 42;
 
-  int Value = 7;
-  Ipsum.i = Value;
-  Ipsum.j = &Value;
+  int *xx = id3(&x);
+  int *yy = id3(&x);
 
-  return *Ipsum.j;
+  return *xx;
 }
diff --git a/test/llvm_test_code/pointers/context_05.c b/test/llvm_test_code/pointers/context_05.c
new file mode 100644
index 0000000000..cbfb72270d
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_05.c
@@ -0,0 +1,14 @@
+
+int *id1(int *p) { return p; }
+int *id2(int *q) { return id1(q); }
+int *id3(int *r) { return id2(r); }
+int *id4(int *s) { return id3(s); }
+
+int main() {
+  int x = 42;
+
+  int *xx = id4(&x);
+  int *yy = id4(&x);
+
+  return *xx;
+}
diff --git a/test/llvm_test_code/pointers/context_06.c b/test/llvm_test_code/pointers/context_06.c
new file mode 100644
index 0000000000..ff8a990cf2
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_06.c
@@ -0,0 +1,15 @@
+
+int *id1(int *p) { return p; }
+int *id2(int *q) { return id1(q); }
+int *id3(int *r) { return id2(r); }
+int *id4(int *s) { return id3(s); }
+int *id5(int *t) { return id4(t); }
+
+int main() {
+  int x = 42;
+
+  int *xx = id5(&x);
+  int *yy = id5(&x);
+
+  return *xx;
+}

From 294f73093c14606c8933ea8972e0a3d3cb0640eb Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Tue, 13 Jan 2026 11:20:43 +0100
Subject: [PATCH 14/75] renamed tests

---
 test/llvm_test_code/pointers/context_05-.c | 14 --------------
 test/llvm_test_code/pointers/context_05.c  | 13 ++++++-------
 test/llvm_test_code/pointers/context_07.c  | 15 +++++++++++++++
 3 files changed, 21 insertions(+), 21 deletions(-)
 delete mode 100644 test/llvm_test_code/pointers/context_05-.c
 create mode 100644 test/llvm_test_code/pointers/context_07.c

diff --git a/test/llvm_test_code/pointers/context_05-.c b/test/llvm_test_code/pointers/context_05-.c
deleted file mode 100644
index cbfb72270d..0000000000
--- a/test/llvm_test_code/pointers/context_05-.c
+++ /dev/null
@@ -1,14 +0,0 @@
-
-int *id1(int *p) { return p; }
-int *id2(int *q) { return id1(q); }
-int *id3(int *r) { return id2(r); }
-int *id4(int *s) { return id3(s); }
-
-int main() {
-  int x = 42;
-
-  int *xx = id4(&x);
-  int *yy = id4(&x);
-
-  return *xx;
-}
diff --git a/test/llvm_test_code/pointers/context_05.c b/test/llvm_test_code/pointers/context_05.c
index 04724b7ca0..cbfb72270d 100644
--- a/test/llvm_test_code/pointers/context_05.c
+++ b/test/llvm_test_code/pointers/context_05.c
@@ -1,15 +1,14 @@
 
-int *buzz(int *s) { return s; }
-int *baz(int *r) { return buzz(r); }
-int *bar(int *q) { return baz(q); }
-int *foo(int *p) { return bar(p); }
+int *id1(int *p) { return p; }
+int *id2(int *q) { return id1(q); }
+int *id3(int *r) { return id2(r); }
+int *id4(int *s) { return id3(s); }
 
 int main() {
   int x = 42;
-  int y = 43;
 
-  int *xx = foo(&x);
-  int *yy = foo(&y);
+  int *xx = id4(&x);
+  int *yy = id4(&x);
 
   return *xx;
 }
diff --git a/test/llvm_test_code/pointers/context_07.c b/test/llvm_test_code/pointers/context_07.c
new file mode 100644
index 0000000000..04724b7ca0
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_07.c
@@ -0,0 +1,15 @@
+
+int *buzz(int *s) { return s; }
+int *baz(int *r) { return buzz(r); }
+int *bar(int *q) { return baz(q); }
+int *foo(int *p) { return bar(p); }
+
+int main() {
+  int x = 42;
+  int y = 43;
+
+  int *xx = foo(&x);
+  int *yy = foo(&y);
+
+  return *xx;
+}

From 6e49be81b475c347f6b42742800c2bfe58ec0106 Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Tue, 13 Jan 2026 22:54:15 +0100
Subject: [PATCH 15/75] More context tests

---
 test/llvm_test_code/pointers/context_08.c | 20 +++++++++++
 test/llvm_test_code/pointers/context_09.c | 21 ++++++++++++
 test/llvm_test_code/pointers/context_10.c | 33 ++++++++++++++++++
 test/llvm_test_code/pointers/context_11.c | 42 +++++++++++++++++++++++
 test/llvm_test_code/pointers/context_12.c | 14 ++++++++
 test/llvm_test_code/pointers/context_13.c | 18 ++++++++++
 test/llvm_test_code/pointers/context_14.c | 21 ++++++++++++
 7 files changed, 169 insertions(+)
 create mode 100644 test/llvm_test_code/pointers/context_08.c
 create mode 100644 test/llvm_test_code/pointers/context_09.c
 create mode 100644 test/llvm_test_code/pointers/context_10.c
 create mode 100644 test/llvm_test_code/pointers/context_11.c
 create mode 100644 test/llvm_test_code/pointers/context_12.c
 create mode 100644 test/llvm_test_code/pointers/context_13.c
 create mode 100644 test/llvm_test_code/pointers/context_14.c

diff --git a/test/llvm_test_code/pointers/context_08.c b/test/llvm_test_code/pointers/context_08.c
new file mode 100644
index 0000000000..b0615dca11
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_08.c
@@ -0,0 +1,20 @@
+
+int *selfRecursion(int *Ptr) {
+  if (*Ptr <= 0) {
+    return Ptr;
+  }
+  return Ptr;
+}
+
+int main() {
+  int k = 1;
+  int *kptr = &k;
+
+  int *x = selfRecursion(kptr);
+
+  k = 1;
+
+  int *y = selfRecursion(kptr);
+
+  return *x;
+}
diff --git a/test/llvm_test_code/pointers/context_09.c b/test/llvm_test_code/pointers/context_09.c
new file mode 100644
index 0000000000..aa35598a1e
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_09.c
@@ -0,0 +1,21 @@
+
+int *selfRecursion(int *Ptr) {
+  if (*Ptr <= 0) {
+    return Ptr;
+  }
+
+  *Ptr = *Ptr - 1;
+  return selfRecursion(Ptr);
+}
+
+int main() {
+  int k = 4;
+
+  int *x = selfRecursion(&k);
+
+  k = 4;
+
+  int *y = selfRecursion(&k);
+
+  return *y;
+}
diff --git a/test/llvm_test_code/pointers/context_10.c b/test/llvm_test_code/pointers/context_10.c
new file mode 100644
index 0000000000..785bb151b2
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_10.c
@@ -0,0 +1,33 @@
+
+int *Back(int *Ptr);
+
+int *Forth(int *Ptr) {
+  if (*Ptr > 0) {
+    *Ptr = *Ptr - 1;
+    return Back(Ptr);
+  }
+
+  return Ptr;
+}
+
+int *Back(int *Ptr) {
+  if (*Ptr > 0) {
+    *Ptr = *Ptr - 1;
+    return Forth(Ptr);
+  }
+
+  return Ptr;
+}
+
+// Mutual recursion test
+int main() {
+  int k = 2;
+
+  int *x = Back(&k);
+
+  k = 2;
+
+  int *y = Back(&k);
+
+  return *x;
+}
diff --git a/test/llvm_test_code/pointers/context_11.c b/test/llvm_test_code/pointers/context_11.c
new file mode 100644
index 0000000000..86192e1b51
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_11.c
@@ -0,0 +1,42 @@
+
+int *Back(int *Ptr);
+int *Stop(int *Ptr);
+
+int *Forth(int *Ptr) {
+  if (*Ptr > 0) {
+    *Ptr = *Ptr - 1;
+    return Stop(Ptr);
+  }
+
+  return Ptr;
+}
+
+int *Back(int *Ptr) {
+  if (*Ptr > 0) {
+    *Ptr = *Ptr - 1;
+    return Stop(Ptr);
+  }
+
+  return Ptr;
+}
+
+int *Stop(int *Ptr) {
+  if (*Ptr % 2 == 1) {
+    return Forth(Ptr);
+  }
+
+  return Back(Ptr);
+}
+
+// Mutual recursion test
+int main() {
+  int k = 2;
+
+  int *x = Back(&k);
+
+  k = 3;
+
+  int *y = Forth(&k);
+
+  return *x;
+}
diff --git a/test/llvm_test_code/pointers/context_12.c b/test/llvm_test_code/pointers/context_12.c
new file mode 100644
index 0000000000..db42786d34
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_12.c
@@ -0,0 +1,14 @@
+
+int *argretq(int *p, int *q) { return q; }
+
+int main() {
+  int x = 42;
+  int y = 43;
+
+  int *xx1 = argretq(&x, &y);
+  int *xx2 = argretq(&x, &y);
+  int *yy1 = argretq(&y, &x);
+  int *yy2 = argretq(&y, &x);
+
+  return *xx1;
+}
diff --git a/test/llvm_test_code/pointers/context_13.c b/test/llvm_test_code/pointers/context_13.c
new file mode 100644
index 0000000000..2bd9aff23e
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_13.c
@@ -0,0 +1,18 @@
+
+int *argretq(int *p, int *q, int *r) { return q; }
+
+int main() {
+  int x = 42;
+  int y = 43;
+
+  int *xx1 = argretq(&x, &x, &x);
+  int *xx2 = argretq(&x, &x, &y);
+  int *xx3 = argretq(&y, &x, &y);
+  int *xx4 = argretq(&y, &x, &x);
+  int *yy1 = argretq(&x, &y, &x);
+  int *yy2 = argretq(&x, &y, &y);
+  int *yy3 = argretq(&y, &y, &y);
+  int *yy4 = argretq(&y, &y, &x);
+
+  return *xx1;
+}
diff --git a/test/llvm_test_code/pointers/context_14.c b/test/llvm_test_code/pointers/context_14.c
new file mode 100644
index 0000000000..6873b0a572
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_14.c
@@ -0,0 +1,21 @@
+
+struct LinkedList {
+  int Val;
+  LinkedList *Next;
+};
+
+int main() {
+  LinkedList Foo;
+  Foo = {0, &Foo};
+
+  LinkedList Bar;
+  Bar = {42, &Foo};
+
+  LinkedList Baz = Bar;
+  LinkedList Boar = Baz;
+
+  Boar.Next = &Bar;
+  Baz.Next = &Boar;
+
+  return Boar.Val;
+}

From eb695c811707801d1d51beb65cc14c26e2551642 Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Tue, 13 Jan 2026 22:56:28 +0100
Subject: [PATCH 16/75] fixed error

---
 test/llvm_test_code/pointers/CMakeLists.txt              | 9 +++++++++
 .../pointers/{context_14.c => context_14.cpp}            | 0
 2 files changed, 9 insertions(+)
 rename test/llvm_test_code/pointers/{context_14.c => context_14.cpp} (100%)

diff --git a/test/llvm_test_code/pointers/CMakeLists.txt b/test/llvm_test_code/pointers/CMakeLists.txt
index 077f75677a..0153685d7b 100644
--- a/test/llvm_test_code/pointers/CMakeLists.txt
+++ b/test/llvm_test_code/pointers/CMakeLists.txt
@@ -16,6 +16,15 @@ set(lca_files
   context_03.c
   context_04.c
   context_05.c
+  context_06.c
+  context_07.c
+  context_08.c
+  context_09.c
+  context_10.c
+  context_11.c
+  context_12.c
+  context_13.c
+  context_14.cpp
 )
 
 set(lca_files_mem2reg
diff --git a/test/llvm_test_code/pointers/context_14.c b/test/llvm_test_code/pointers/context_14.cpp
similarity index 100%
rename from test/llvm_test_code/pointers/context_14.c
rename to test/llvm_test_code/pointers/context_14.cpp

From fa7038c8a66bf52fe5d5dc723aa6ece5746819be Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Thu, 15 Jan 2026 13:21:36 +0100
Subject: [PATCH 17/75] removed bad basic tests + expanded unittest

---
 test/llvm_test_code/pointers/CMakeLists.txt   |  12 +-
 test/llvm_test_code/pointers/basic_03.c       |   9 -
 .../pointers/{basic_07.cpp => basic_03.cpp}   |   0
 test/llvm_test_code/pointers/basic_04.c       |  10 -
 test/llvm_test_code/pointers/basic_05.c       |  10 -
 test/llvm_test_code/pointers/basic_06.cpp     |   7 -
 test/llvm_test_code/pointers/context_03.c     |   6 +-
 test/llvm_test_code/pointers/context_04.c     |   6 +-
 .../Pointer/LLVMUnionFindAATest.cpp           | 352 ++++++++++++++++--
 9 files changed, 332 insertions(+), 80 deletions(-)
 delete mode 100644 test/llvm_test_code/pointers/basic_03.c
 rename test/llvm_test_code/pointers/{basic_07.cpp => basic_03.cpp} (100%)
 delete mode 100644 test/llvm_test_code/pointers/basic_04.c
 delete mode 100644 test/llvm_test_code/pointers/basic_05.c
 delete mode 100644 test/llvm_test_code/pointers/basic_06.cpp

diff --git a/test/llvm_test_code/pointers/CMakeLists.txt b/test/llvm_test_code/pointers/CMakeLists.txt
index 0153685d7b..8543297c32 100644
--- a/test/llvm_test_code/pointers/CMakeLists.txt
+++ b/test/llvm_test_code/pointers/CMakeLists.txt
@@ -1,11 +1,7 @@
 set(lca_files
   basic_01.c
   basic_02.c
-  basic_03.c
-  basic_04.c
-  basic_05.c
-  basic_06.cpp
-  basic_07.cpp
+  basic_03.cpp
   call_01.cpp
   dynamic_01.cpp
   global_01.cpp
@@ -30,11 +26,7 @@ set(lca_files
 set(lca_files_mem2reg
   basic_01.c
   basic_02.c
-  basic_03.c
-  basic_04.c
-  basic_05.c
-  basic_06.cpp
-  basic_07.cpp
+  basic_03.cpp
   dynamic_01.cpp
   inter_dynamic_01.cpp
   inter_dynamic_02.cpp
diff --git a/test/llvm_test_code/pointers/basic_03.c b/test/llvm_test_code/pointers/basic_03.c
deleted file mode 100644
index ba6f3ae977..0000000000
--- a/test/llvm_test_code/pointers/basic_03.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdlib.h>
-
-int main() {
-  char *i = (char *)(malloc(3 * sizeof(char)));
-  i[0] = 'A';
-  i[1] = 'B';
-  i[2] = 'C';
-  free(i);
-}
diff --git a/test/llvm_test_code/pointers/basic_07.cpp b/test/llvm_test_code/pointers/basic_03.cpp
similarity index 100%
rename from test/llvm_test_code/pointers/basic_07.cpp
rename to test/llvm_test_code/pointers/basic_03.cpp
diff --git a/test/llvm_test_code/pointers/basic_04.c b/test/llvm_test_code/pointers/basic_04.c
deleted file mode 100644
index fb9f63f509..0000000000
--- a/test/llvm_test_code/pointers/basic_04.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdlib.h>
-
-int main() {
-  char *i = (char *)(malloc(3 * sizeof(char)));
-  char **p = &i;
-  *p[0] = 'A';
-  *p[1] = 'B';
-  *p[2] = 'C';
-  free(i);
-}
diff --git a/test/llvm_test_code/pointers/basic_05.c b/test/llvm_test_code/pointers/basic_05.c
deleted file mode 100644
index 693daa92e8..0000000000
--- a/test/llvm_test_code/pointers/basic_05.c
+++ /dev/null
@@ -1,10 +0,0 @@
-
-struct Lorem {
-  int Ipsum;
-};
-
-int main() {
-  struct Lorem i;
-  struct Lorem *p = &i;
-  p->Ipsum = 3;
-}
diff --git a/test/llvm_test_code/pointers/basic_06.cpp b/test/llvm_test_code/pointers/basic_06.cpp
deleted file mode 100644
index 6dfe86daf8..0000000000
--- a/test/llvm_test_code/pointers/basic_06.cpp
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <string>
-
-int main() {
-  std::string i;
-  std::string *p = &i;
-  *p = "Six";
-}
diff --git a/test/llvm_test_code/pointers/context_03.c b/test/llvm_test_code/pointers/context_03.c
index c561917160..c390e0dea9 100644
--- a/test/llvm_test_code/pointers/context_03.c
+++ b/test/llvm_test_code/pointers/context_03.c
@@ -5,8 +5,8 @@ int *id2(int *q) { return id1(q); }
 int main() {
   int x = 42;
 
-  int *xx = id2(&x);
-  int *yy = id2(&x);
+  int *xx1 = id2(&x);
+  int *xx2 = id2(&x);
 
-  return *xx;
+  return *xx1;
 }
diff --git a/test/llvm_test_code/pointers/context_04.c b/test/llvm_test_code/pointers/context_04.c
index 851e809267..b4badf43a6 100644
--- a/test/llvm_test_code/pointers/context_04.c
+++ b/test/llvm_test_code/pointers/context_04.c
@@ -6,8 +6,8 @@ int *id3(int *r) { return id2(r); }
 int main() {
   int x = 42;
 
-  int *xx = id3(&x);
-  int *yy = id3(&x);
+  int *xx1 = id3(&x);
+  int *xx2 = id3(&x);
 
-  return *xx;
+  return *xx1;
 }
diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index e186cdaf10..87a609e18f 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -167,39 +167,120 @@ constexpr auto BotAABuilder = [](const auto &IRDB, const auto &CG) {
 };
 
 TEST(CtxSensUnionFindAATest, Basic01) {
-  GTMap GT = {{LineColFunOp{3, 0, "main", llvm::Instruction::Alloca},
+  GTMap GT = {{LineColFunOp{.Line = 3,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
                {
-                   LineColFunOp{3, 0, "main", llvm::Instruction::Alloca},
-                   LineColFunOp{5, 0, "main", llvm::Instruction::Load},
+                   LineColFunOp{.Line = 3,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 5,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
                }}};
   doAnalysisAndCompareResults("basic_01_c_dbg.ll", GT, ContextAABuilder);
 }
 
-// TODO: Add more basic tests
+TEST(CtxSensUnionFindAATest, Basic02) {
+  GTMap GT = {{LineColFunOp{.Line = 3,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 3,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 6,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("basic_02_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Basic03) {
+  GTMap GT = {{LineColFunOp{.Line = 4,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 4,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 6,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("basic_03_c_dbg.ll", GT, ContextAABuilder);
+}
 
 TEST(CtxSensUnionFindAATest, Context01) {
   GTMap GT = {
-      {LineColFunOp{5, 0, "main", llvm::Instruction::Alloca},
+      {LineColFunOp{.Line = 5,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
        {
-           LineColFunOp{5, 0, "main", llvm::Instruction::Alloca},
-           LineColFunOp{8, 0, "main", llvm::Instruction::Call},
-           LineColFunOp{11, 0, "main", llvm::Instruction::Load},
-           ArgInFun{0, "id"},
+           LineColFunOp{.Line = 5,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 8,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 11,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Load},
+           ArgInFun{.Idx = 0, .InFunction = "id"},
        }},
-      {LineColFunOp{6, 0, "main", llvm::Instruction::Alloca},
+      {LineColFunOp{.Line = 6,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
        {
-           LineColFunOp{6, 0, "main", llvm::Instruction::Alloca},
-           LineColFunOp{9, 0, "main", llvm::Instruction::Call},
-           ArgInFun{0, "id"},
+           LineColFunOp{.Line = 6,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 9,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           ArgInFun{.Idx = 0, .InFunction = "id"},
        }},
-      {ArgInFun{0, "id"},
+      {ArgInFun{.Idx = 0, .InFunction = "id"},
        {
-           LineColFunOp{5, 0, "main", llvm::Instruction::Alloca},
-           LineColFunOp{6, 0, "main", llvm::Instruction::Alloca},
-           LineColFunOp{8, 0, "main", llvm::Instruction::Call},
-           LineColFunOp{9, 0, "main", llvm::Instruction::Call},
-           LineColFunOp{11, 0, "main", llvm::Instruction::Load},
-           ArgInFun{0, "id"},
+           LineColFunOp{.Line = 5,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 6,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 8,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 9,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 11,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Load},
+           ArgInFun{.Idx = 0, .InFunction = "id"},
        }},
   };
   doAnalysisAndCompareResults("context_01_c_dbg.ll", GT, ContextAABuilder);
@@ -209,23 +290,238 @@ TEST(CtxSensUnionFindAATest, Context01) {
 
 // TODO: Add tests for IndirectionSensUnionFindAA
 
+TEST(BotUnionFindAATest, Context01) {
+  GTMap GT = {
+      {LineColFunOp{.Line = 5,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 5,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 8,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 11,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Load},
+       }},
+      {LineColFunOp{.Line = 6,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 6,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 9,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+       }},
+  };
+
+  doAnalysisAndCompareResults("context_01_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context02) {
+  GTMap GT = {
+      {LineColFunOp{.Line = 6,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 6,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 9,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 10,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 14,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Load},
+       }},
+      {LineColFunOp{.Line = 7,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 7,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 11,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 12,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+       }},
+  };
+
+  doAnalysisAndCompareResults("context_02_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context03) {
+  GTMap GT = {{LineColFunOp{.Line = 6,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 6,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_03_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context04) {
+  GTMap GT = {{LineColFunOp{.Line = 7,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 7,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_04_c_dbg.ll", GT, BotAABuilder);
+}
+
 TEST(BotUnionFindAATest, Context05) {
+  GTMap GT = {{LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 13,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_05_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context06) {
+  GTMap GT = {{LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 14,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_06_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context07) {
   GTMap GT = {
-      {LineColFunOp{8, 0, "main", llvm::Instruction::Alloca},
+      {LineColFunOp{.Line = 8,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
        {
-           LineColFunOp{8, 0, "main", llvm::Instruction::Alloca},
-           LineColFunOp{11, 0, "main", llvm::Instruction::Call},
-           LineColFunOp{14, 0, "main", llvm::Instruction::Load},
+           LineColFunOp{.Line = 8,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 11,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 14,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Load},
        }},
-      {LineColFunOp{9, 0, "main", llvm::Instruction::Alloca},
+      {LineColFunOp{.Line = 9,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
        {
-           LineColFunOp{9, 0, "main", llvm::Instruction::Alloca},
-           LineColFunOp{12, 0, "main", llvm::Instruction::Call},
+           LineColFunOp{.Line = 9,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 12,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
        }},
   };
   // psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
   //                                     "BottomupUnionFindAA");
-  doAnalysisAndCompareResults("context_05_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_07_c_dbg.ll", GT, BotAABuilder);
 }
 
 // TODO: Add more tests for BottomupUnionFindAA

From 2e408d01a9ccdfbe6644523a5272410a5d887537 Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Fri, 16 Jan 2026 00:03:02 +0100
Subject: [PATCH 18/75] added context_08 to unittest, fails

---
 test/llvm_test_code/pointers/context_08.c     |  4 +-
 .../Pointer/LLVMUnionFindAATest.cpp           | 44 ++++++++++++++++++-
 2 files changed, 45 insertions(+), 3 deletions(-)

diff --git a/test/llvm_test_code/pointers/context_08.c b/test/llvm_test_code/pointers/context_08.c
index b0615dca11..c311df1886 100644
--- a/test/llvm_test_code/pointers/context_08.c
+++ b/test/llvm_test_code/pointers/context_08.c
@@ -3,7 +3,9 @@ int *selfRecursion(int *Ptr) {
   if (*Ptr <= 0) {
     return Ptr;
   }
-  return Ptr;
+
+  *Ptr = *Ptr - 1;
+  return selfRecursion(Ptr);
 }
 
 int main() {
diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index 87a609e18f..63865954f4 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -519,11 +519,51 @@ TEST(BotUnionFindAATest, Context07) {
                         .OpCode = llvm::Instruction::Call},
        }},
   };
-  // psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
-  //                                     "BottomupUnionFindAA");
+
   doAnalysisAndCompareResults("context_07_c_dbg.ll", GT, BotAABuilder);
 }
 
+TEST(BotUnionFindAATest, Context08) {
+  GTMap GT = {
+      {LineColFunOp{.Line = 12,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 12,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 15,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 21,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Load},
+       }},
+      {{LineColFunOp{.Line = 2,
+                     .Col = 25,
+                     .InFunction = "selfRecursion",
+                     .OpCode = llvm::Instruction::Alloca}},
+       {LineColFunOp{.Line = 3,
+                     .Col = 7,
+                     .InFunction = "selfRecursion",
+                     .OpCode = llvm::Instruction::Load},
+        LineColFunOp{.Line = 7,
+                     .Col = 10,
+                     .InFunction = "selfRecursion",
+                     .OpCode = llvm::Instruction::Load},
+        LineColFunOp{.Line = 10,
+                     .Col = 0,
+                     .InFunction = "selfRecursion",
+                     .OpCode = llvm::Instruction::Call}}},
+  };
+
+  doAnalysisAndCompareResults("context_08_c_dbg.ll", GT, BotAABuilder);
+}
+
 // TODO: Add more tests for BottomupUnionFindAA
 
 } // namespace

From ef4f5a17feaa5093cd16ae464cf75ff3b5e5922f Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Mon, 19 Jan 2026 08:32:25 +0100
Subject: [PATCH 19/75] added more context tests to unittest

---
 .../Pointer/LLVMUnionFindAATest.cpp           | 325 +++++++++++++++++-
 1 file changed, 308 insertions(+), 17 deletions(-)

diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index 63865954f4..fd91d61fb5 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -538,32 +538,323 @@ TEST(BotUnionFindAATest, Context08) {
                         .Col = 0,
                         .InFunction = "main",
                         .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 19,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
            LineColFunOp{.Line = 21,
                         .Col = 0,
                         .InFunction = "main",
                         .OpCode = llvm::Instruction::Load},
-       }},
-      {{LineColFunOp{.Line = 2,
-                     .Col = 25,
-                     .InFunction = "selfRecursion",
-                     .OpCode = llvm::Instruction::Alloca}},
-       {LineColFunOp{.Line = 3,
-                     .Col = 7,
-                     .InFunction = "selfRecursion",
-                     .OpCode = llvm::Instruction::Load},
-        LineColFunOp{.Line = 7,
-                     .Col = 10,
-                     .InFunction = "selfRecursion",
-                     .OpCode = llvm::Instruction::Load},
-        LineColFunOp{.Line = 10,
-                     .Col = 0,
-                     .InFunction = "selfRecursion",
-                     .OpCode = llvm::Instruction::Call}}},
+       }}
+      // ,
+      // {{LineColFunOp{.Line = 2,
+      //                .Col = 25,
+      //                .InFunction = "selfRecursion",
+      //                .OpCode = llvm::Instruction::Alloca}},
+      //  {LineColFunOp{.Line = 3,
+      //                .Col = 7,
+      //                .InFunction = "selfRecursion",
+      //                .OpCode = llvm::Instruction::Load},
+      //   LineColFunOp{.Line = 7,
+      //                .Col = 10,
+      //                .InFunction = "selfRecursion",
+      //                .OpCode = llvm::Instruction::Load},
+      //   LineColFunOp{.Line = 8,
+      //                .Col = 0,
+      //                .InFunction = "selfRecursion",
+      //                .OpCode = llvm::Instruction::Call}}},
   };
 
+  psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
+                                      "BottomupUnionFindAA");
+
   doAnalysisAndCompareResults("context_08_c_dbg.ll", GT, BotAABuilder);
 }
 
+TEST(BotUnionFindAATest, Context09) {
+  GTMap GT = {
+      {LineColFunOp{.Line = 12,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 12,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 14,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 18,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 20,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Load},
+       }}
+      // ,
+      // {{LineColFunOp{.Line = 2,
+      //                .Col = 25,
+      //                .InFunction = "selfRecursion",
+      //                .OpCode = llvm::Instruction::Alloca}},
+      //  {LineColFunOp{.Line = 3,
+      //                .Col = 7,
+      //                .InFunction = "selfRecursion",
+      //                .OpCode = llvm::Instruction::Load},
+      //   LineColFunOp{.Line = 7,
+      //                .Col = 10,
+      //                .InFunction = "selfRecursion",
+      //                .OpCode = llvm::Instruction::Load},
+      //   LineColFunOp{.Line = 10,
+      //                .Col = 0,
+      //                .InFunction = "selfRecursion",
+      //                .OpCode = llvm::Instruction::Call}}},
+  };
+
+  psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
+                                      "BottomupUnionFindAA");
+
+  doAnalysisAndCompareResults("context_09_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context10) {
+  GTMap GT = {
+      {LineColFunOp{.Line = 24,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 24,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 26,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 30,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 32,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Load}
+           //              ,
+           // LineColFunOp{.Line = 2,
+           //              .Col = 25,
+           //              .InFunction = "Back",
+           //              .OpCode = llvm::Instruction::Alloca},
+           // LineColFunOp{.Line = 21,
+           //              .Col = 0,
+           //              .InFunction = "Back",
+           //              .OpCode = llvm::Instruction::Load},
+       }}
+      // ,
+      // {{LineColFunOp{.Line = 24,
+      //                .Col = 0,
+      //                .InFunction = "main",
+      //                .OpCode = llvm::Instruction::Alloca}},
+      //  {LineColFunOp{.Line = 14,
+      //                .Col = 7,
+      //                .InFunction = "Forth",
+      //                .OpCode = llvm::Instruction::Load},
+      //   LineColFunOp{.Line = 15,
+      //                .Col = 5,
+      //                .InFunction = "Forth",
+      //                .OpCode = llvm::Instruction::Load},
+      //   LineColFunOp{.Line = 16,
+      //                .Col = 12,
+      //                .InFunction = "Forth",
+      //                .OpCode = llvm::Instruction::Call}}},
+  };
+
+  psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
+                                      "BottomupUnionFindAA");
+
+  doAnalysisAndCompareResults("context_10_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context11) {
+  GTMap GT{{LineColFunOp{.Line = 33,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 33,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 35,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 39,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 41,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}}};
+
+  psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
+                                      "BottomupUnionFindAA");
+
+  doAnalysisAndCompareResults("context_11_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context12) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 10,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 13,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+
+           {LineColFunOp{.Line = 6,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}}};
+
+  psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
+                                      "BottomupUnionFindAA");
+
+  doAnalysisAndCompareResults("context_12_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context13) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 10,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 17,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+
+           {LineColFunOp{.Line = 6,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 10,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}}};
+
+  psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
+                                      "BottomupUnionFindAA");
+
+  doAnalysisAndCompareResults("context_13_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context14) {
+  GTMap GT{{LineColFunOp{.Line = 8,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 14,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 15,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 17,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 18,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
+
+  psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
+                                      "BottomupUnionFindAA");
+
+  doAnalysisAndCompareResults("context_14_cpp_dbg.ll", GT, BotAABuilder);
+}
+
+// TEST(BotUnionFindAATest, Context15) {
+//   // TODO:
+//   GTMap GT;
+//
+//   psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
+//                                       "BottomupUnionFindAA");
+//
+//   doAnalysisAndCompareResults("context_15_c_dbg.ll", GT, BotAABuilder);
+// }
+
 // TODO: Add more tests for BottomupUnionFindAA
 
 } // namespace

From b77cc39cb84b180252568330099862c35b280de5 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabian.schiebel@iem.fraunhofer.de>
Date: Mon, 19 Jan 2026 18:49:18 +0100
Subject: [PATCH 20/75] Add soundness to BottomupUnionFindAA

---
 include/phasar/Pointer/BottomupUnionFindAA.h | 46 ++++++++++++++++++--
 include/phasar/Utils/IotaIterator.h          |  3 +-
 2 files changed, 44 insertions(+), 5 deletions(-)

diff --git a/include/phasar/Pointer/BottomupUnionFindAA.h b/include/phasar/Pointer/BottomupUnionFindAA.h
index 07883cc761..3835444dd0 100644
--- a/include/phasar/Pointer/BottomupUnionFindAA.h
+++ b/include/phasar/Pointer/BottomupUnionFindAA.h
@@ -13,6 +13,7 @@
 #include "phasar/Utils/Printer.h"
 #include "phasar/Utils/SCCGeneric.h"
 #include "phasar/Utils/SCCId.h"
+#include "phasar/Utils/Soundness.h"
 #include "phasar/Utils/TypedVector.h"
 #include "phasar/Utils/ValueCompressor.h"
 
@@ -25,9 +26,15 @@
 #include <unordered_map>
 
 namespace psr {
-template <typename AnalysisDomainT> class BottomupUnionFindAA {
+template <typename AnalysisDomainT, Soundness SoundnessFlag = Soundness::Soundy>
+class BottomupUnionFindAA {
+  struct ParamInfo {
+    ValueId Arg;
+    ValueId Param;
+    pag::Call CS;
+  };
   struct CallSiteInfo {
-    llvm::SmallVector<std::tuple<ValueId, ValueId, pag::Call>, 2> Params{};
+    llvm::SmallVector<ParamInfo, 2> Params{};
     llvm::SmallVector<ValueId, 1> Ret{};
     std::optional<ValueId> RetSlot{};
   };
@@ -108,6 +115,19 @@ template <typename AnalysisDomainT> class BottomupUnionFindAA {
   }
 
   [[nodiscard]] BasicUnionFindAAResult consumeAAResults(size_t NumVars) && {
+
+    bottomupPropagation(NumVars);
+
+    if constexpr (SoundnessFlag != Soundness::Unsound) {
+      // For soundness, we need to handle parameter aliasing
+      topdownPropagation();
+    }
+
+    return std::move(Base).consumeAAResults(NumVars);
+  }
+
+private:
+  void bottomupPropagation(size_t NumVars) {
     TypedVector<ValueId, RawAliasSet<ValueId>> IntermediateBackView(NumVars);
 
     for (SCCId<FunVtxTy> CurrSCC :
@@ -158,11 +178,29 @@ template <typename AnalysisDomainT> class BottomupUnionFindAA {
         IntermediateBackView[SumIdRep].insert(SumId);
       });
     }
+  }
 
-    return std::move(Base).consumeAAResults(NumVars);
+  void topdownPropagation() {
+    for (SCCId<FunVtxTy> CurrSCC : iota<SCCId<FunVtxTy>>(CGSCCs->size())) {
+      for (const auto &[CS, CSInfo] : Calls[CurrSCC]) {
+        const size_t Sz = CSInfo.Params.size();
+        for (size_t I : psr::iota(Sz)) {
+          const ParamInfo FirstInfo = CSInfo.Params[I];
+          const auto FirstArgRep = Base.AliasSets.find(FirstInfo.Arg);
+          for (size_t J : psr::iota(I + 1, Sz)) {
+            const ParamInfo &SecondInfo = CSInfo.Params[J];
+            const auto SecondArgRep = Base.AliasSets.find(SecondInfo.Arg);
+
+            if (FirstArgRep == SecondArgRep) {
+              // Found parameter-aliasing!
+              Base.AliasSets.join(FirstInfo.Param, SecondInfo.Param);
+            }
+          }
+        }
+      }
+    }
   }
 
-private:
   [[nodiscard]] Nullable<f_t> getFunction(ByConstRef<v_t> Var) {
     if constexpr (requires() { getPointerFrom(Var)->getFunction(); }) {
       return getPointerFrom(Var)->getFunction();
diff --git a/include/phasar/Utils/IotaIterator.h b/include/phasar/Utils/IotaIterator.h
index c01805f688..10d8e19faa 100644
--- a/include/phasar/Utils/IotaIterator.h
+++ b/include/phasar/Utils/IotaIterator.h
@@ -84,7 +84,8 @@ template <typename IdT>
   return Ret;
 }
 
-template <typename IdT> [[nodiscard]] constexpr auto iota(size_t To) noexcept {
+template <typename IdT = size_t>
+[[nodiscard]] constexpr auto iota(size_t To) noexcept {
   static_assert(is_explicitly_convertible_to<size_t, IdT> &&
                     is_explicitly_convertible_to<IdT, size_t>,
                 "Iota only works on integers and integer-like types");

From 494409be50a541666428f10d50dad6c474368a09 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabian.schiebel@iem.fraunhofer.de>
Date: Mon, 19 Jan 2026 20:06:19 +0100
Subject: [PATCH 21/75] Add convenience-functions to compute union-find alias
 info for LLVM

---
 CMakeLists.txt                                |   2 +-
 .../phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h |   5 +
 .../PhasarLLVM/Pointer/LLVMUnionFindAA.h      | 122 ++++++++++++++++-
 .../phasar/Pointer/PointerAssignmentGraph.h   |  15 ++-
 include/phasar/Pointer/UnionFindAA.h          |  25 ++++
 include/phasar/Utils/MaybeUniquePtr.h         |  10 ++
 lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp    | 127 ++++++++++++++++++
 7 files changed, 300 insertions(+), 6 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 86c4fece2b..fcc61a5773 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -406,7 +406,7 @@ if (PHASAR_ENABLE_WARNINGS)
   if (MSVC)
     string(APPEND CMAKE_CXX_FLAGS " /W4")
   else()
-    string(APPEND CMAKE_CXX_FLAGS " -Wall -Wextra -Wno-unused-parameter")
+    string(APPEND CMAKE_CXX_FLAGS " -Wall -Wextra -Wno-unused-parameter -Werror=return-type")
   endif()
 endif (PHASAR_ENABLE_WARNINGS)
 
diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h b/include/phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h
index bbe69a0f74..4bb0bc21f6 100644
--- a/include/phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h
@@ -24,6 +24,11 @@ namespace psr {
 using LLVMAliasIteratorRef =
     AliasIteratorRef<const llvm::Value *, const llvm::Instruction *>;
 
+template <typename T>
+concept IsLLVMAliasIterator =
+    detail::IsAliasIteratorFor<T, const llvm::Value *,
+                               const llvm::Instruction *>;
+
 using LLVMAliasInfoRef =
     AliasInfoRef<const llvm::Value *, const llvm::Instruction *>;
 
diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
index 587806c70c..791974d79e 100644
--- a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
@@ -1,16 +1,21 @@
 #pragma once
 
 #include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraph.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h"
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
 #include "phasar/Pointer/BottomupUnionFindAA.h"
 #include "phasar/Pointer/RawAliasSet.h"
 #include "phasar/Pointer/UnionFindAA.h"
 #include "phasar/Utils/MapUtils.h"
+#include "phasar/Utils/MaybeUniquePtr.h"
 #include "phasar/Utils/NonNullPtr.h"
 #include "phasar/Utils/Utilities.h"
 #include "phasar/Utils/ValueCompressor.h"
 
+#include <memory>
+#include <type_traits>
+
 namespace psr {
 extern template class CallingContextSensUnionFindAA<LLVMPAGDomain>;
 extern template class IndirectionSensUnionFindAA<LLVMPAGDomain>;
@@ -48,12 +53,15 @@ class LLVMCGProvider : public LLVMPAGDomain {
 };
 } // namespace pag
 
-template <typename AAResT, typename Var2IdMapper, typename Id2VarMapper>
+template <typename AAResT>
   requires UnionFindAAResult<std::remove_cvref_t<AAResT>>
 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
 struct LLVMUnionFindAliasIterator {
   AAResT AARes;
-  NonNullPtr<const ValueCompressor<PAGVariable>> VC;
+  MaybeUniquePtr<const ValueCompressor<PAGVariable>> VC;
+
+  using v_t = const llvm::Value *;
+  using n_t = const llvm::Instruction *;
 
   void forallAliasesOf(ValueId VId, const auto & /*Inst*/,
                        std::invocable<const llvm::Value *> auto Callback) {
@@ -69,6 +77,14 @@ struct LLVMUnionFindAliasIterator {
   }
 };
 
+template <typename AAResT>
+LLVMUnionFindAliasIterator(AAResT,
+                           MaybeUniquePtr<const ValueCompressor<PAGVariable>>)
+    -> LLVMUnionFindAliasIterator<AAResT>;
+template <typename AAResT>
+LLVMUnionFindAliasIterator(AAResT, const ValueCompressor<PAGVariable> *)
+    -> LLVMUnionFindAliasIterator<AAResT>;
+
 namespace detail {
 class LLVMLocalUnionFindAliasIteratorBase {
 public:
@@ -127,4 +143,106 @@ class LLVMLocalUnionFindAliasIterator
   NonNullPtr<const ValueCompressor<PAGVariable>> VC;
 };
 
+template <pag::PBStrategy AnalysisT,
+          std::derived_from<PAGBuilder<LLVMPAGDomain>> PAGBuilderImpl =
+              LLVMPAGBuilder>
+[[nodiscard]] inline UnionFindAAResult auto
+computeUnionFindAARaw(const LLVMProjectIRDB &IRDB, AnalysisT &&Ana,
+                      MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr,
+                      PAGBuilderImpl Impl = {}) {
+  if (!VC) {
+    VC = std::make_unique<ValueCompressor<PAGVariable>>();
+  }
+
+  Impl.buildPAG(IRDB, *VC, &Ana);
+
+  const auto NumVars = VC->size();
+  return PSR_FWD(Ana).consumeAAResults(NumVars);
+}
+
+template <pag::CanOnAddEdge AnalysisT,
+          std::derived_from<PAGBuilder<LLVMPAGDomain>> PAGBuilderImpl =
+              LLVMPAGBuilder>
+[[nodiscard]] inline UnionFindAAResult auto
+computeUnionFindAARaw(const LLVMProjectIRDB &IRDB, AnalysisT &&Ana,
+                      const LLVMBasedCallGraph &CG,
+                      MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr,
+                      PAGBuilderImpl Impl = {}) {
+  auto Strategy = pag::PBMixin{
+      PSR_FWD(Ana),
+      pag::LLVMCGProvider{&CG},
+  };
+  return computeUnionFindAARaw(IRDB, Strategy, std::move(VC), std::move(Impl));
+}
+
+[[nodiscard]] CallingContextSensUnionFindAAResult
+computeCtxSensUnionFindAARaw(const LLVMProjectIRDB &IRDB,
+                             const LLVMBasedCallGraph &CG);
+[[nodiscard]] BasicUnionFindAAResult
+computeBotCtxSensUnionFindAARaw(const LLVMProjectIRDB &IRDB,
+                                const LLVMBasedCallGraph &CG);
+[[nodiscard]] BasicUnionFindAAResult
+computeIndSensUnionFindAARaw(const LLVMProjectIRDB &IRDB,
+                             const LLVMBasedCallGraph &CG);
+[[nodiscard]] UnionFindAAResultIntersection<CallingContextSensUnionFindAAResult,
+                                            BasicUnionFindAAResult>
+computeCtxIndSensUnionFindAARaw(const LLVMProjectIRDB &IRDB,
+                                const LLVMBasedCallGraph &CG);
+[[nodiscard]] UnionFindAAResultIntersection<BasicUnionFindAAResult,
+                                            BasicUnionFindAAResult>
+computeBotCtxIndSensUnionFindAARaw(const LLVMProjectIRDB &IRDB,
+                                   const LLVMBasedCallGraph &CG);
+
+template <pag::PBStrategy AnalysisT,
+          std::derived_from<PAGBuilder<LLVMPAGDomain>> PAGBuilderImpl =
+              LLVMPAGBuilder>
+[[nodiscard]] inline IsLLVMAliasIterator auto
+computeUnionFindAA(const LLVMProjectIRDB &IRDB, AnalysisT &&Ana,
+                   MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr,
+                   PAGBuilderImpl Impl = {}) {
+  if (!VC) {
+    VC = std::make_unique<ValueCompressor<PAGVariable>>();
+  }
+
+  auto AARes =
+      computeUnionFindAARaw(IRDB, PSR_FWD(Ana), VC.get(), std::move(Impl));
+  return LLVMUnionFindAliasIterator{
+      std::move(AARes),
+      std::move(VC),
+  };
+}
+
+template <pag::CanOnAddEdge AnalysisT,
+          std::derived_from<PAGBuilder<LLVMPAGDomain>> PAGBuilderImpl =
+              LLVMPAGBuilder>
+[[nodiscard]] inline IsLLVMAliasIterator auto
+computeUnionFindAA(const LLVMProjectIRDB &IRDB, AnalysisT &&Ana,
+                   const LLVMBasedCallGraph &CG,
+                   MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr,
+                   PAGBuilderImpl Impl = {}) {
+  auto Strategy = pag::PBMixin{
+      PSR_FWD(Ana),
+      pag::LLVMCGProvider{&CG},
+  };
+  return computeUnionFindAA(IRDB, Strategy, std::move(VC), std::move(Impl));
+}
+
+[[nodiscard]] LLVMUnionFindAliasIterator<CallingContextSensUnionFindAAResult>
+computeCtxSensUnionFindAA(const LLVMProjectIRDB &IRDB,
+                          const LLVMBasedCallGraph &CG);
+[[nodiscard]] LLVMUnionFindAliasIterator<BasicUnionFindAAResult>
+computeBotCtxSensUnionFindAA(const LLVMProjectIRDB &IRDB,
+                             const LLVMBasedCallGraph &CG);
+[[nodiscard]] LLVMUnionFindAliasIterator<BasicUnionFindAAResult>
+computeIndSensUnionFindAA(const LLVMProjectIRDB &IRDB,
+                          const LLVMBasedCallGraph &CG);
+[[nodiscard]] LLVMUnionFindAliasIterator<UnionFindAAResultIntersection<
+    CallingContextSensUnionFindAAResult, BasicUnionFindAAResult>>
+computeCtxIndSensUnionFindAA(const LLVMProjectIRDB &IRDB,
+                             const LLVMBasedCallGraph &CG);
+[[nodiscard]] LLVMUnionFindAliasIterator<UnionFindAAResultIntersection<
+    BasicUnionFindAAResult, BasicUnionFindAAResult>>
+computeBotCtxIndSensUnionFindAA(const LLVMProjectIRDB &IRDB,
+                                const LLVMBasedCallGraph &CG);
+
 } // namespace psr
diff --git a/include/phasar/Pointer/PointerAssignmentGraph.h b/include/phasar/Pointer/PointerAssignmentGraph.h
index 61e3812ee5..25168859c8 100644
--- a/include/phasar/Pointer/PointerAssignmentGraph.h
+++ b/include/phasar/Pointer/PointerAssignmentGraph.h
@@ -98,16 +98,21 @@ concept CanOnAddEdge =
       Strategy.onAddEdge(From, To, E, Nullable<typename T::n_t>{});
     };
 
+template <typename T>
+concept CanWithCalleesOfCallAt =
+    requires(const T &CStrategy, const typename T::n_t &Inst) {
+      CStrategy.withCalleesOfCallAt(Inst, [](typename T::f_t Callee) {});
+    };
+
 template <typename T>
 concept PBStrategyBase =
+    CanWithCalleesOfCallAt<T> &&
     requires(T &Strategy, const T &CStrategy, ValueId From, ValueId To,
              const typename T::n_t &Inst, pag::Edge E) {
       typename T::v_t;
       typename T::db_t;
       typename T::f_t;
       typename T::n_t;
-
-      CStrategy.withCalleesOfCallAt(Inst, [](typename T::f_t Callee) {});
     };
 
 template <typename T>
@@ -173,7 +178,11 @@ struct PBStrategyCombinator {
   constexpr void
   withCalleesOfCallAt(ByConstRef<n_t> CS,
                       llvm::function_ref<void(f_t)> WithCallee) const {
-    Second.withCalleesOfCallAt(CS, WithCallee);
+    if constexpr (CanWithCalleesOfCallAt<SecondT>) {
+      Second.withCalleesOfCallAt(CS, WithCallee);
+    } else {
+      First.withCalleesOfCallAt(CS, WithCallee);
+    }
   }
 };
 
diff --git a/include/phasar/Pointer/UnionFindAA.h b/include/phasar/Pointer/UnionFindAA.h
index 96692f5cd1..d05ce439f5 100644
--- a/include/phasar/Pointer/UnionFindAA.h
+++ b/include/phasar/Pointer/UnionFindAA.h
@@ -69,6 +69,31 @@ struct UnionFindAAResultIntersection {
   [[no_unique_address]] SecondT Second;
 };
 
+template <pag::PBStrategy FirstT, pag::CanOnAddEdge SecondT>
+  requires(std::same_as<typename FirstT::n_t, typename SecondT::n_t> &&
+           std::same_as<typename FirstT::v_t, typename SecondT::v_t> &&
+           std::same_as<typename FirstT::f_t, typename SecondT::f_t> &&
+           std::same_as<typename FirstT::db_t, typename SecondT::db_t>)
+struct UnionFindAACombinator
+    : public pag::PBStrategyCombinator<FirstT, SecondT> {
+
+  constexpr UnionFindAACombinator(std::convertible_to<FirstT> auto &&First,
+                                  std::convertible_to<SecondT> auto &&Second)
+      : pag::PBStrategyCombinator<FirstT, SecondT>{PSR_FWD(First),
+                                                   PSR_FWD(Second)} {}
+
+  [[nodiscard]] UnionFindAAResult auto consumeAAResults(size_t NumVars) && {
+    return UnionFindAAResultIntersection{
+        std::move(this->First).consumeAAResults(NumVars),
+        std::move(this->Second).consumeAAResults(NumVars),
+    };
+  }
+};
+
+template <typename FirstT, typename SecondT>
+UnionFindAACombinator(FirstT, SecondT)
+    -> UnionFindAACombinator<FirstT, SecondT>;
+
 /// Lazy caching of union-find alias-analysis results. This class is *not*
 /// thread-safe!
 template <UnionFindAAResult AAResT, bool ShouldCacheMayAlias = true>
diff --git a/include/phasar/Utils/MaybeUniquePtr.h b/include/phasar/Utils/MaybeUniquePtr.h
index 11c55553cd..7ad6d12155 100644
--- a/include/phasar/Utils/MaybeUniquePtr.h
+++ b/include/phasar/Utils/MaybeUniquePtr.h
@@ -61,6 +61,8 @@ template <typename T> class MaybeUniquePtrBase<T, true> {
 template <typename T, bool RequireAlignment = false>
 class [[clang::trivial_abi]] MaybeUniquePtr
     : detail::MaybeUniquePtrBase<T, RequireAlignment> {
+  template <typename U, bool Align> friend class MaybeUniquePtr;
+
   using detail::MaybeUniquePtrBase<T, RequireAlignment>::Data;
 
 public:
@@ -83,6 +85,14 @@ class [[clang::trivial_abi]] MaybeUniquePtr
     Other.Data = {};
   }
 
+  constexpr MaybeUniquePtr(
+      MaybeUniquePtr<std::remove_const_t<T>> &&Other) noexcept
+    requires std::is_const_v<T>
+      : detail::MaybeUniquePtrBase<T, RequireAlignment>(Other.get(),
+                                                        Other.owns()) {
+    Other.Data = {};
+  }
+
   constexpr void swap(MaybeUniquePtr &Other) noexcept {
     std::swap(Data, Other.Data);
   }
diff --git a/lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp b/lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp
index 8b39a54d81..a2eb40e84b 100644
--- a/lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp
+++ b/lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp
@@ -2,6 +2,7 @@
 
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
 #include "phasar/Pointer/RawAliasSet.h"
+#include "phasar/Pointer/UnionFindAA.h"
 #include "phasar/Utils/ValueCompressor.h"
 
 namespace psr {
@@ -30,4 +31,130 @@ detail::LLVMLocalUnionFindAliasIteratorBase::
     Vars |= Globals;
   }
 }
+
 } // namespace psr
+
+using namespace psr;
+
+CallingContextSensUnionFindAAResult
+psr::computeCtxSensUnionFindAARaw(const LLVMProjectIRDB &IRDB,
+                                  const LLVMBasedCallGraph &CG) {
+  auto Strategy = CallingContextSensUnionFindAA<LLVMPAGDomain>{
+      &CG,
+      &IRDB,
+  };
+  return computeUnionFindAARaw(IRDB, std::move(Strategy));
+}
+
+BasicUnionFindAAResult
+psr::computeBotCtxSensUnionFindAARaw(const LLVMProjectIRDB &IRDB,
+                                     const LLVMBasedCallGraph &CG) {
+  auto Strategy = BottomupUnionFindAA<LLVMPAGDomain>{
+      ReverseCGGraph{
+          &CG,
+          &IRDB,
+      },
+  };
+  return computeUnionFindAARaw(IRDB, std::move(Strategy));
+}
+
+BasicUnionFindAAResult
+psr::computeIndSensUnionFindAARaw(const LLVMProjectIRDB &IRDB,
+                                  const LLVMBasedCallGraph &CG) {
+  auto Strategy = pag::PBMixin{
+      IndirectionSensUnionFindAA<LLVMPAGDomain>{},
+      pag::LLVMCGProvider{&CG},
+  };
+  return computeUnionFindAARaw(IRDB, std::move(Strategy));
+}
+
+UnionFindAAResultIntersection<CallingContextSensUnionFindAAResult,
+                              BasicUnionFindAAResult>
+psr::computeCtxIndSensUnionFindAARaw(const LLVMProjectIRDB &IRDB,
+                                     const LLVMBasedCallGraph &CG) {
+  auto Strategy = UnionFindAACombinator{
+      CallingContextSensUnionFindAA<LLVMPAGDomain>{
+          &CG,
+          &IRDB,
+      },
+      IndirectionSensUnionFindAA<LLVMPAGDomain>{},
+  };
+  return computeUnionFindAARaw(IRDB, std::move(Strategy));
+}
+
+UnionFindAAResultIntersection<BasicUnionFindAAResult, BasicUnionFindAAResult>
+psr::computeBotCtxIndSensUnionFindAARaw(const LLVMProjectIRDB &IRDB,
+                                        const LLVMBasedCallGraph &CG) {
+  auto Strategy = UnionFindAACombinator{
+      BottomupUnionFindAA<LLVMPAGDomain>{
+          ReverseCGGraph{
+              &CG,
+              &IRDB,
+          },
+      },
+      IndirectionSensUnionFindAA<LLVMPAGDomain>{},
+  };
+  return computeUnionFindAARaw(IRDB, std::move(Strategy));
+}
+
+LLVMUnionFindAliasIterator<CallingContextSensUnionFindAAResult>
+psr::computeCtxSensUnionFindAA(const LLVMProjectIRDB &IRDB,
+                               const LLVMBasedCallGraph &CG) {
+  auto Strategy = CallingContextSensUnionFindAA<LLVMPAGDomain>{
+      &CG,
+      &IRDB,
+  };
+  return computeUnionFindAA(IRDB, std::move(Strategy));
+}
+
+LLVMUnionFindAliasIterator<BasicUnionFindAAResult>
+psr::computeBotCtxSensUnionFindAA(const LLVMProjectIRDB &IRDB,
+                                  const LLVMBasedCallGraph &CG) {
+  auto Strategy = BottomupUnionFindAA<LLVMPAGDomain>{
+      ReverseCGGraph{
+          &CG,
+          &IRDB,
+      },
+  };
+  return computeUnionFindAA(IRDB, std::move(Strategy));
+}
+
+LLVMUnionFindAliasIterator<BasicUnionFindAAResult>
+psr::computeIndSensUnionFindAA(const LLVMProjectIRDB &IRDB,
+                               const LLVMBasedCallGraph &CG) {
+  auto Strategy = pag::PBMixin{
+      IndirectionSensUnionFindAA<LLVMPAGDomain>{},
+      pag::LLVMCGProvider{&CG},
+  };
+  return computeUnionFindAA(IRDB, std::move(Strategy));
+}
+
+LLVMUnionFindAliasIterator<UnionFindAAResultIntersection<
+    CallingContextSensUnionFindAAResult, BasicUnionFindAAResult>>
+psr::computeCtxIndSensUnionFindAA(const LLVMProjectIRDB &IRDB,
+                                  const LLVMBasedCallGraph &CG) {
+  auto Strategy = UnionFindAACombinator{
+      CallingContextSensUnionFindAA<LLVMPAGDomain>{
+          &CG,
+          &IRDB,
+      },
+      IndirectionSensUnionFindAA<LLVMPAGDomain>{},
+  };
+  return computeUnionFindAA(IRDB, std::move(Strategy));
+}
+
+LLVMUnionFindAliasIterator<UnionFindAAResultIntersection<
+    BasicUnionFindAAResult, BasicUnionFindAAResult>>
+psr::computeBotCtxIndSensUnionFindAA(const LLVMProjectIRDB &IRDB,
+                                     const LLVMBasedCallGraph &CG) {
+  auto Strategy = UnionFindAACombinator{
+      BottomupUnionFindAA<LLVMPAGDomain>{
+          ReverseCGGraph{
+              &CG,
+              &IRDB,
+          },
+      },
+      IndirectionSensUnionFindAA<LLVMPAGDomain>{},
+  };
+  return computeUnionFindAA(IRDB, std::move(Strategy));
+}

From c803b8db5da32c38d3b8402138eb8f5adbabebc8 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabian.schiebel@iem.fraunhofer.de>
Date: Mon, 19 Jan 2026 20:08:20 +0100
Subject: [PATCH 22/75] minor

---
 unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index fd91d61fb5..ae613fb944 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -86,11 +86,10 @@ void doAnalysisAndCompareResults(
                                         {"main"}, TH, VTP);
 
   ValueCompressor<PAGVariable> VC;
-  auto PB = LLVMPAGBuilder();
   auto AA = AABuilder(IRDB, BaseCG);
-  PB.buildPAG(IRDB, VC, &AA);
 
-  UnionFindAAResult auto Results = std::move(AA).consumeAAResults(VC.size());
+  UnionFindAAResult auto Results =
+      computeUnionFindAARaw(IRDB, std::move(AA), &VC);
 
   for (const auto &[PtrVar, ExpectedAliasVars] : ExpectedResults) {
     const auto PtrId = asId(VC, IRDB, PtrVar);

From 8288b77275a893c7910f6e529e09db12db62993c Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Tue, 20 Jan 2026 17:27:51 +0100
Subject: [PATCH 23/75] added more tests + fixed some old ones

---
 test/llvm_test_code/pointers/CMakeLists.txt   |  26 +-
 .../pointers/{context_04.c => context_04_0.c} |   0
 test/llvm_test_code/pointers/context_04_1.c   |  16 +
 .../pointers/{context_05.c => context_05_0.c} |   0
 test/llvm_test_code/pointers/context_05_1.c   |  17 +
 .../pointers/{context_06.c => context_06_0.c} |   0
 test/llvm_test_code/pointers/context_06_1.c   |  18 +
 .../pointers/{context_09.c => context_09_0.c} |   6 +-
 test/llvm_test_code/pointers/context_09_1.c   |  23 +
 .../pointers/{context_10.c => context_10_0.c} |   0
 test/llvm_test_code/pointers/context_10_1.c   |  36 ++
 .../pointers/{context_11.c => context_11_0.c} |   6 +-
 test/llvm_test_code/pointers/context_11_1.c   |  42 ++
 test/llvm_test_code/pointers/context_12.c     |  14 -
 test/llvm_test_code/pointers/context_12_0.c   |  14 +
 test/llvm_test_code/pointers/context_12_1.c   |  12 +
 .../pointers/{context_13.c => context_13_0.c} |   0
 test/llvm_test_code/pointers/context_13_1.c   |  12 +
 test/llvm_test_code/pointers/context_14.cpp   |  21 -
 test/llvm_test_code/pointers/indirection_01.c |  21 +
 .../Pointer/LLVMUnionFindAATest.cpp           | 546 ++++++++++++------
 21 files changed, 595 insertions(+), 235 deletions(-)
 rename test/llvm_test_code/pointers/{context_04.c => context_04_0.c} (100%)
 create mode 100644 test/llvm_test_code/pointers/context_04_1.c
 rename test/llvm_test_code/pointers/{context_05.c => context_05_0.c} (100%)
 create mode 100644 test/llvm_test_code/pointers/context_05_1.c
 rename test/llvm_test_code/pointers/{context_06.c => context_06_0.c} (100%)
 create mode 100644 test/llvm_test_code/pointers/context_06_1.c
 rename test/llvm_test_code/pointers/{context_09.c => context_09_0.c} (82%)
 create mode 100644 test/llvm_test_code/pointers/context_09_1.c
 rename test/llvm_test_code/pointers/{context_10.c => context_10_0.c} (100%)
 create mode 100644 test/llvm_test_code/pointers/context_10_1.c
 rename test/llvm_test_code/pointers/{context_11.c => context_11_0.c} (92%)
 create mode 100644 test/llvm_test_code/pointers/context_11_1.c
 delete mode 100644 test/llvm_test_code/pointers/context_12.c
 create mode 100644 test/llvm_test_code/pointers/context_12_0.c
 create mode 100644 test/llvm_test_code/pointers/context_12_1.c
 rename test/llvm_test_code/pointers/{context_13.c => context_13_0.c} (100%)
 create mode 100644 test/llvm_test_code/pointers/context_13_1.c
 delete mode 100644 test/llvm_test_code/pointers/context_14.cpp
 create mode 100644 test/llvm_test_code/pointers/indirection_01.c

diff --git a/test/llvm_test_code/pointers/CMakeLists.txt b/test/llvm_test_code/pointers/CMakeLists.txt
index 8543297c32..a6af1568f3 100644
--- a/test/llvm_test_code/pointers/CMakeLists.txt
+++ b/test/llvm_test_code/pointers/CMakeLists.txt
@@ -10,17 +10,25 @@ set(lca_files
   context_01.c
   context_02.c
   context_03.c
-  context_04.c
-  context_05.c
-  context_06.c
+  context_04_0.c
+  context_04_1.c
+  context_05_0.c
+  context_05_1.c
+  context_06_0.c
+  context_06_1.c
   context_07.c
   context_08.c
-  context_09.c
-  context_10.c
-  context_11.c
-  context_12.c
-  context_13.c
-  context_14.cpp
+  context_09_0.c
+  context_09_1.c
+  context_10_0.c
+  context_10_1.c
+  context_11_0.c
+  context_11_1.c
+  context_12_0.c
+  context_12_1.c
+  context_13_0.c
+  context_13_1.c
+  indirection_01.c
 )
 
 set(lca_files_mem2reg
diff --git a/test/llvm_test_code/pointers/context_04.c b/test/llvm_test_code/pointers/context_04_0.c
similarity index 100%
rename from test/llvm_test_code/pointers/context_04.c
rename to test/llvm_test_code/pointers/context_04_0.c
diff --git a/test/llvm_test_code/pointers/context_04_1.c b/test/llvm_test_code/pointers/context_04_1.c
new file mode 100644
index 0000000000..5ee815e778
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_04_1.c
@@ -0,0 +1,16 @@
+
+int *id1(int *p) { return p; }
+int *id2(int *q) { return id1(q); }
+int *id3(int *r) { return id2(r); }
+
+int main() {
+  int x = 4;
+  int y = 2;
+
+  int *xx1 = id3(&x);
+  int *xx2 = id3(&x);
+  int *yy1 = id3(&y);
+  int *yy2 = id3(&y);
+
+  return *xx1;
+}
diff --git a/test/llvm_test_code/pointers/context_05.c b/test/llvm_test_code/pointers/context_05_0.c
similarity index 100%
rename from test/llvm_test_code/pointers/context_05.c
rename to test/llvm_test_code/pointers/context_05_0.c
diff --git a/test/llvm_test_code/pointers/context_05_1.c b/test/llvm_test_code/pointers/context_05_1.c
new file mode 100644
index 0000000000..d0bd55e5a7
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_05_1.c
@@ -0,0 +1,17 @@
+
+int *id1(int *p) { return p; }
+int *id2(int *q) { return id1(q); }
+int *id3(int *r) { return id2(r); }
+int *id4(int *s) { return id3(s); }
+
+int main() {
+  int x = 4;
+  int y = 2;
+
+  int *xx1 = id4(&x);
+  int *xx2 = id4(&x);
+  int *yy1 = id4(&y);
+  int *yy2 = id4(&y);
+
+  return *xx2;
+}
diff --git a/test/llvm_test_code/pointers/context_06.c b/test/llvm_test_code/pointers/context_06_0.c
similarity index 100%
rename from test/llvm_test_code/pointers/context_06.c
rename to test/llvm_test_code/pointers/context_06_0.c
diff --git a/test/llvm_test_code/pointers/context_06_1.c b/test/llvm_test_code/pointers/context_06_1.c
new file mode 100644
index 0000000000..6ae198a51a
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_06_1.c
@@ -0,0 +1,18 @@
+
+int *id1(int *p) { return p; }
+int *id2(int *q) { return id1(q); }
+int *id3(int *r) { return id2(r); }
+int *id4(int *s) { return id3(s); }
+int *id5(int *t) { return id4(t); }
+
+int main() {
+  int x = 4;
+  int y = 2;
+
+  int *xx1 = id5(&x);
+  int *xx2 = id5(&x);
+  int *yy1 = id5(&y);
+  int *yy2 = id5(&y);
+
+  return *yy1;
+}
diff --git a/test/llvm_test_code/pointers/context_09.c b/test/llvm_test_code/pointers/context_09_0.c
similarity index 82%
rename from test/llvm_test_code/pointers/context_09.c
rename to test/llvm_test_code/pointers/context_09_0.c
index aa35598a1e..a43381e368 100644
--- a/test/llvm_test_code/pointers/context_09.c
+++ b/test/llvm_test_code/pointers/context_09_0.c
@@ -10,12 +10,10 @@ int *selfRecursion(int *Ptr) {
 
 int main() {
   int k = 4;
+  int l = 4;
 
   int *x = selfRecursion(&k);
-
-  k = 4;
-
-  int *y = selfRecursion(&k);
+  int *y = selfRecursion(&l);
 
   return *y;
 }
diff --git a/test/llvm_test_code/pointers/context_09_1.c b/test/llvm_test_code/pointers/context_09_1.c
new file mode 100644
index 0000000000..b05dc51d20
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_09_1.c
@@ -0,0 +1,23 @@
+
+int *selfRecursion(int *Ptr) {
+  if (*Ptr <= 0) {
+    return Ptr;
+  }
+
+  *Ptr = *Ptr - 1;
+  return selfRecursion(Ptr);
+}
+
+int main() {
+  int k = 4;
+  int l = 4;
+
+  int *xx1 = selfRecursion(&k);
+  k = 4;
+  int *xx2 = selfRecursion(&k);
+  int *yy1 = selfRecursion(&l);
+  l = 4;
+  int *yy2 = selfRecursion(&l);
+
+  return *yy2;
+}
diff --git a/test/llvm_test_code/pointers/context_10.c b/test/llvm_test_code/pointers/context_10_0.c
similarity index 100%
rename from test/llvm_test_code/pointers/context_10.c
rename to test/llvm_test_code/pointers/context_10_0.c
diff --git a/test/llvm_test_code/pointers/context_10_1.c b/test/llvm_test_code/pointers/context_10_1.c
new file mode 100644
index 0000000000..294729cd17
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_10_1.c
@@ -0,0 +1,36 @@
+
+int *Back(int *Ptr);
+
+int *Forth(int *Ptr) {
+  if (*Ptr > 0) {
+    *Ptr = *Ptr - 1;
+    return Back(Ptr);
+  }
+
+  return Ptr;
+}
+
+int *Back(int *Ptr) {
+  if (*Ptr > 0) {
+    *Ptr = *Ptr - 1;
+    return Forth(Ptr);
+  }
+
+  return Ptr;
+}
+
+// Mutual recursion test
+int main() {
+  int k = 2;
+  int l = 2;
+
+  int *xx1 = Back(&k);
+  k = 2;
+  int *xx2 = Back(&k);
+
+  int *yy1 = Back(&l);
+  l = 4;
+  int *yy2 = Back(&l);
+
+  return *xx1;
+}
diff --git a/test/llvm_test_code/pointers/context_11.c b/test/llvm_test_code/pointers/context_11_0.c
similarity index 92%
rename from test/llvm_test_code/pointers/context_11.c
rename to test/llvm_test_code/pointers/context_11_0.c
index 86192e1b51..e5e3f0b5e9 100644
--- a/test/llvm_test_code/pointers/context_11.c
+++ b/test/llvm_test_code/pointers/context_11_0.c
@@ -31,12 +31,10 @@ int *Stop(int *Ptr) {
 // Mutual recursion test
 int main() {
   int k = 2;
+  int l = 3;
 
   int *x = Back(&k);
-
-  k = 3;
-
-  int *y = Forth(&k);
+  int *y = Forth(&l);
 
   return *x;
 }
diff --git a/test/llvm_test_code/pointers/context_11_1.c b/test/llvm_test_code/pointers/context_11_1.c
new file mode 100644
index 0000000000..f320b5e7df
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_11_1.c
@@ -0,0 +1,42 @@
+
+int *Back(int *Ptr);
+int *Stop(int *Ptr);
+
+int *Forth(int *Ptr) {
+  if (*Ptr > 0) {
+    *Ptr = *Ptr - 1;
+    return Stop(Ptr);
+  }
+
+  return Ptr;
+}
+
+int *Back(int *Ptr) {
+  if (*Ptr > 0) {
+    *Ptr = *Ptr - 1;
+    return Stop(Ptr);
+  }
+
+  return Ptr;
+}
+
+int *Stop(int *Ptr) {
+  if (*Ptr % 2 == 1) {
+    return Forth(Ptr);
+  }
+
+  return Back(Ptr);
+}
+
+// Mutual recursion test
+int main() {
+  int k = 2;
+  int l = 2;
+
+  int *xx1 = Back(&k);
+  int *xx2 = Back(&k);
+  int *yy1 = Forth(&l);
+  int *yy2 = Forth(&l);
+
+  return *xx2;
+}
diff --git a/test/llvm_test_code/pointers/context_12.c b/test/llvm_test_code/pointers/context_12.c
deleted file mode 100644
index db42786d34..0000000000
--- a/test/llvm_test_code/pointers/context_12.c
+++ /dev/null
@@ -1,14 +0,0 @@
-
-int *argretq(int *p, int *q) { return q; }
-
-int main() {
-  int x = 42;
-  int y = 43;
-
-  int *xx1 = argretq(&x, &y);
-  int *xx2 = argretq(&x, &y);
-  int *yy1 = argretq(&y, &x);
-  int *yy2 = argretq(&y, &x);
-
-  return *xx1;
-}
diff --git a/test/llvm_test_code/pointers/context_12_0.c b/test/llvm_test_code/pointers/context_12_0.c
new file mode 100644
index 0000000000..c689896661
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_12_0.c
@@ -0,0 +1,14 @@
+
+int *argretq(int *p, int *q) { return q; }
+
+int main() {
+  int x = 42;
+  int y = 43;
+
+  int *xx1 = argretq(&y, &x);
+  int *xx2 = argretq(&y, &x);
+  int *yy1 = argretq(&x, &y);
+  int *yy2 = argretq(&x, &y);
+
+  return *xx1;
+}
diff --git a/test/llvm_test_code/pointers/context_12_1.c b/test/llvm_test_code/pointers/context_12_1.c
new file mode 100644
index 0000000000..36eded1211
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_12_1.c
@@ -0,0 +1,12 @@
+
+int *argretq(int *p, int *q) { return q; }
+
+int main() {
+  int x = 42;
+  int y = 43;
+
+  int *xx1 = argretq(&y, &x);
+  int *yy1 = argretq(&x, &y);
+
+  return *xx1;
+}
diff --git a/test/llvm_test_code/pointers/context_13.c b/test/llvm_test_code/pointers/context_13_0.c
similarity index 100%
rename from test/llvm_test_code/pointers/context_13.c
rename to test/llvm_test_code/pointers/context_13_0.c
diff --git a/test/llvm_test_code/pointers/context_13_1.c b/test/llvm_test_code/pointers/context_13_1.c
new file mode 100644
index 0000000000..3771792d29
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_13_1.c
@@ -0,0 +1,12 @@
+
+int *argretq(int *p, int *q, int *r) { return q; }
+
+int main() {
+  int x = 42;
+  int y = 43;
+
+  int *xx1 = argretq(&x, &x, &x);
+  int *yy1 = argretq(&y, &y, &y);
+
+  return *yy1;
+}
diff --git a/test/llvm_test_code/pointers/context_14.cpp b/test/llvm_test_code/pointers/context_14.cpp
deleted file mode 100644
index 6873b0a572..0000000000
--- a/test/llvm_test_code/pointers/context_14.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-
-struct LinkedList {
-  int Val;
-  LinkedList *Next;
-};
-
-int main() {
-  LinkedList Foo;
-  Foo = {0, &Foo};
-
-  LinkedList Bar;
-  Bar = {42, &Foo};
-
-  LinkedList Baz = Bar;
-  LinkedList Boar = Baz;
-
-  Boar.Next = &Bar;
-  Baz.Next = &Boar;
-
-  return Boar.Val;
-}
diff --git a/test/llvm_test_code/pointers/indirection_01.c b/test/llvm_test_code/pointers/indirection_01.c
new file mode 100644
index 0000000000..32d6d99c8a
--- /dev/null
+++ b/test/llvm_test_code/pointers/indirection_01.c
@@ -0,0 +1,21 @@
+
+typedef struct _LinkedList {
+  int Val;
+  struct _LinkedList *Next;
+} LinkedList;
+
+int main() {
+  LinkedList Foo;
+  Foo = (LinkedList){0, &Foo};
+
+  LinkedList Bar;
+  Bar = (LinkedList){42, &Foo};
+
+  LinkedList Baz = Bar;
+  LinkedList Boar = Baz;
+
+  Boar.Next = &Bar;
+  Baz.Next = &Boar;
+
+  return (int)Boar.Next;
+}
diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index ae613fb944..68cbc67ad8 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -402,7 +402,7 @@ TEST(BotUnionFindAATest, Context03) {
   doAnalysisAndCompareResults("context_03_c_dbg.ll", GT, BotAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context04) {
+TEST(BotUnionFindAATest, Context04_0) {
   GTMap GT = {{LineColFunOp{.Line = 7,
                             .Col = 0,
                             .InFunction = "main",
@@ -426,10 +426,53 @@ TEST(BotUnionFindAATest, Context04) {
                                 .OpCode = llvm::Instruction::Load},
                }}};
 
-  doAnalysisAndCompareResults("context_04_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_04_0_c_dbg.ll", GT, BotAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context05) {
+TEST(BotUnionFindAATest, Context04_1) {
+  GTMap GT = {{LineColFunOp{.Line = 7,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 7,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 15,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_04_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context05_0) {
   GTMap GT = {{LineColFunOp{.Line = 8,
                             .Col = 0,
                             .InFunction = "main",
@@ -453,10 +496,64 @@ TEST(BotUnionFindAATest, Context05) {
                                 .OpCode = llvm::Instruction::Load},
                }}};
 
-  doAnalysisAndCompareResults("context_05_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_05_0_c_dbg.ll", GT, BotAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context06) {
+TEST(BotUnionFindAATest, Context05_1) {
+  GTMap GT = {{LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 13,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_05_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context06_0) {
+  GTMap GT = {{LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 14,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_06_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context06_1) {
   GTMap GT = {{LineColFunOp{.Line = 9,
                             .Col = 0,
                             .InFunction = "main",
@@ -480,7 +577,7 @@ TEST(BotUnionFindAATest, Context06) {
                                 .OpCode = llvm::Instruction::Load},
                }}};
 
-  doAnalysisAndCompareResults("context_06_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_06_1_c_dbg.ll", GT, BotAABuilder);
 }
 
 TEST(BotUnionFindAATest, Context07) {
@@ -523,162 +620,189 @@ TEST(BotUnionFindAATest, Context07) {
 }
 
 TEST(BotUnionFindAATest, Context08) {
-  GTMap GT = {
-      {LineColFunOp{.Line = 12,
-                    .Col = 0,
-                    .InFunction = "main",
-                    .OpCode = llvm::Instruction::Alloca},
-       {
-           LineColFunOp{.Line = 12,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 15,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 19,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 21,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Load},
-       }}
-      // ,
-      // {{LineColFunOp{.Line = 2,
-      //                .Col = 25,
-      //                .InFunction = "selfRecursion",
-      //                .OpCode = llvm::Instruction::Alloca}},
-      //  {LineColFunOp{.Line = 3,
-      //                .Col = 7,
-      //                .InFunction = "selfRecursion",
-      //                .OpCode = llvm::Instruction::Load},
-      //   LineColFunOp{.Line = 7,
-      //                .Col = 10,
-      //                .InFunction = "selfRecursion",
-      //                .OpCode = llvm::Instruction::Load},
-      //   LineColFunOp{.Line = 8,
-      //                .Col = 0,
-      //                .InFunction = "selfRecursion",
-      //                .OpCode = llvm::Instruction::Call}}},
-  };
+  GTMap GT = {{LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 15,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 19,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 21,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_08_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context09_0) {
+  GTMap GT = {{LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}},
+              {LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 16,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}}};
 
   psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
                                       "BottomupUnionFindAA");
 
-  doAnalysisAndCompareResults("context_08_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_09_0_c_dbg.ll", GT, BotAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context09) {
-  GTMap GT = {
-      {LineColFunOp{.Line = 12,
-                    .Col = 0,
-                    .InFunction = "main",
-                    .OpCode = llvm::Instruction::Alloca},
-       {
-           LineColFunOp{.Line = 12,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 14,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 18,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 20,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Load},
-       }}
-      // ,
-      // {{LineColFunOp{.Line = 2,
-      //                .Col = 25,
-      //                .InFunction = "selfRecursion",
-      //                .OpCode = llvm::Instruction::Alloca}},
-      //  {LineColFunOp{.Line = 3,
-      //                .Col = 7,
-      //                .InFunction = "selfRecursion",
-      //                .OpCode = llvm::Instruction::Load},
-      //   LineColFunOp{.Line = 7,
-      //                .Col = 10,
-      //                .InFunction = "selfRecursion",
-      //                .OpCode = llvm::Instruction::Load},
-      //   LineColFunOp{.Line = 10,
-      //                .Col = 0,
-      //                .InFunction = "selfRecursion",
-      //                .OpCode = llvm::Instruction::Call}}},
-  };
+TEST(BotUnionFindAATest, Context09_1) {
+  GTMap GT = {{LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}},
+              {LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 16,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}}};
 
   psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
                                       "BottomupUnionFindAA");
 
-  doAnalysisAndCompareResults("context_09_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_09_1_c_dbg.ll", GT, BotAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context10) {
-  GTMap GT = {
-      {LineColFunOp{.Line = 24,
-                    .Col = 0,
-                    .InFunction = "main",
-                    .OpCode = llvm::Instruction::Alloca},
-       {
-           LineColFunOp{.Line = 24,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 26,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 30,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 32,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Load}
-           //              ,
-           // LineColFunOp{.Line = 2,
-           //              .Col = 25,
-           //              .InFunction = "Back",
-           //              .OpCode = llvm::Instruction::Alloca},
-           // LineColFunOp{.Line = 21,
-           //              .Col = 0,
-           //              .InFunction = "Back",
-           //              .OpCode = llvm::Instruction::Load},
-       }}
-      // ,
-      // {{LineColFunOp{.Line = 24,
-      //                .Col = 0,
-      //                .InFunction = "main",
-      //                .OpCode = llvm::Instruction::Alloca}},
-      //  {LineColFunOp{.Line = 14,
-      //                .Col = 7,
-      //                .InFunction = "Forth",
-      //                .OpCode = llvm::Instruction::Load},
-      //   LineColFunOp{.Line = 15,
-      //                .Col = 5,
-      //                .InFunction = "Forth",
-      //                .OpCode = llvm::Instruction::Load},
-      //   LineColFunOp{.Line = 16,
-      //                .Col = 12,
-      //                .InFunction = "Forth",
-      //                .OpCode = llvm::Instruction::Call}}},
-  };
+TEST(BotUnionFindAATest, Context10_0) {
+  GTMap GT = {{LineColFunOp{.Line = 24,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 24,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 26,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}}};
+
+  psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
+                                      "BottomupUnionFindAA");
+
+  doAnalysisAndCompareResults("context_10_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context10_1) {
+  GTMap GT = {{LineColFunOp{.Line = 24,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 24,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 26,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}}};
+
+  psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
+                                      "BottomupUnionFindAA");
+
+  doAnalysisAndCompareResults("context_10_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context11_0) {
+  GTMap GT{{LineColFunOp{.Line = 33,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 33,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 35,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 39,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 41,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}}};
 
   psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
                                       "BottomupUnionFindAA");
 
-  doAnalysisAndCompareResults("context_10_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_11_0_c_dbg.ll", GT, BotAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context11) {
+TEST(BotUnionFindAATest, Context11_1) {
   GTMap GT{{LineColFunOp{.Line = 33,
                          .Col = 0,
                          .InFunction = "main",
@@ -703,10 +827,10 @@ TEST(BotUnionFindAATest, Context11) {
   psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
                                       "BottomupUnionFindAA");
 
-  doAnalysisAndCompareResults("context_11_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_11_1_c_dbg.ll", GT, BotAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context12) {
+TEST(BotUnionFindAATest, Context12_0) {
   GTMap GT{{LineColFunOp{.Line = 5,
                          .Col = 0,
                          .InFunction = "main",
@@ -715,11 +839,11 @@ TEST(BotUnionFindAATest, Context12) {
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 10,
+             LineColFunOp{.Line = 8,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 11,
+             LineColFunOp{.Line = 9,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Call},
@@ -736,11 +860,56 @@ TEST(BotUnionFindAATest, Context12) {
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 10,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}}};
+
+  psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
+                                      "BottomupUnionFindAA");
+
+  doAnalysisAndCompareResults("context_12_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context12_1) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
              LineColFunOp{.Line = 8,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Call},
              LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 13,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+
+           {LineColFunOp{.Line = 6,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 10,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Call}}}};
@@ -748,10 +917,10 @@ TEST(BotUnionFindAATest, Context12) {
   psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
                                       "BottomupUnionFindAA");
 
-  doAnalysisAndCompareResults("context_12_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_12_1_c_dbg.ll", GT, BotAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context13) {
+TEST(BotUnionFindAATest, Context13_0) {
   GTMap GT{{LineColFunOp{.Line = 5,
                          .Col = 0,
                          .InFunction = "main",
@@ -789,73 +958,84 @@ TEST(BotUnionFindAATest, Context13) {
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 8,
+             LineColFunOp{.Line = 12,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 9,
+             LineColFunOp{.Line = 13,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 10,
+             LineColFunOp{.Line = 14,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 11,
+             LineColFunOp{.Line = 15,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Call}}}};
 
-  psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
-                                      "BottomupUnionFindAA");
-
-  doAnalysisAndCompareResults("context_13_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_13_0_c_dbg.ll", GT, BotAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context14) {
-  GTMap GT{{LineColFunOp{.Line = 8,
+TEST(BotUnionFindAATest, Context13_1) {
+  GTMap GT{{LineColFunOp{.Line = 5,
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 11,
+            {LineColFunOp{.Line = 5,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 14,
+             LineColFunOp{.Line = 8,
                           .Col = 0,
                           .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 15,
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 9,
                           .Col = 0,
                           .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 10,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
              LineColFunOp{.Line = 17,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+
+           {LineColFunOp{.Line = 6,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 6,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 18,
+             LineColFunOp{.Line = 12,
                           .Col = 0,
                           .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca}}}};
-
-  psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
-                                      "BottomupUnionFindAA");
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 13,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 14,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 15,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}}};
 
-  doAnalysisAndCompareResults("context_14_cpp_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_13_1_c_dbg.ll", GT, BotAABuilder);
 }
 
-// TEST(BotUnionFindAATest, Context15) {
-//   // TODO:
-//   GTMap GT;
-//
-//   psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
-//                                       "BottomupUnionFindAA");
-//
-//   doAnalysisAndCompareResults("context_15_c_dbg.ll", GT, BotAABuilder);
-// }
-
-// TODO: Add more tests for BottomupUnionFindAA
-
 } // namespace
 
 int main(int Argc, char **Argv) {

From c99e512d126848e7fc7497c172f9d1e0a88089e0 Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Wed, 21 Jan 2026 13:48:41 +0100
Subject: [PATCH 24/75] Fixed context unit tests

---
 .../Pointer/LLVMUnionFindAATest.cpp           | 193 ++++++++++--------
 1 file changed, 109 insertions(+), 84 deletions(-)

diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index 68cbc67ad8..9b274fbf7e 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -509,19 +509,35 @@ TEST(BotUnionFindAATest, Context05_1) {
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Alloca},
-                   LineColFunOp{.Line = 10,
+                   LineColFunOp{.Line = 11,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 11,
+                   LineColFunOp{.Line = 12,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 13,
+                   LineColFunOp{.Line = 16,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Load},
-               }}};
+               }},
+              {LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}}};
 
   doAnalysisAndCompareResults("context_05_1_c_dbg.ll", GT, BotAABuilder);
 }
@@ -558,20 +574,36 @@ TEST(BotUnionFindAATest, Context06_1) {
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}},
+              {LineColFunOp{.Line = 10,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
                {
-                   LineColFunOp{.Line = 9,
+                   LineColFunOp{.Line = 10,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Alloca},
-                   LineColFunOp{.Line = 11,
+                   LineColFunOp{.Line = 14,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 12,
+                   LineColFunOp{.Line = 15,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 14,
+                   LineColFunOp{.Line = 17,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Load},
@@ -676,9 +708,6 @@ TEST(BotUnionFindAATest, Context09_0) {
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Load}}}};
 
-  psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
-                                      "BottomupUnionFindAA");
-
   doAnalysisAndCompareResults("context_09_0_c_dbg.ll", GT, BotAABuilder);
 }
 
@@ -692,6 +721,10 @@ TEST(BotUnionFindAATest, Context09_1) {
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
                 LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 17,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Call}}},
@@ -703,18 +736,19 @@ TEST(BotUnionFindAATest, Context09_1) {
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 16,
+                LineColFunOp{.Line = 18,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 18,
+                LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 22,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Load}}}};
 
-  psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
-                                      "BottomupUnionFindAA");
-
   doAnalysisAndCompareResults("context_09_1_c_dbg.ll", GT, BotAABuilder);
 }
 
@@ -740,9 +774,6 @@ TEST(BotUnionFindAATest, Context10_0) {
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Load}}}};
 
-  psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
-                                      "BottomupUnionFindAA");
-
   doAnalysisAndCompareResults("context_10_0_c_dbg.ll", GT, BotAABuilder);
 }
 
@@ -755,21 +786,34 @@ TEST(BotUnionFindAATest, Context10_1) {
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 26,
+                LineColFunOp{.Line = 27,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 30,
+                LineColFunOp{.Line = 29,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 32,
+                LineColFunOp{.Line = 35,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load}}}};
-
-  psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
-                                      "BottomupUnionFindAA");
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 25,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 25,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 31,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}}};
 
   doAnalysisAndCompareResults("context_10_1_c_dbg.ll", GT, BotAABuilder);
 }
@@ -783,22 +827,31 @@ TEST(BotUnionFindAATest, Context11_0) {
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 35,
+             LineColFunOp{.Line = 36,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Call},
              LineColFunOp{.Line = 39,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 34,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 34,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 37,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 41,
+             LineColFunOp{.Line = 39,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Load}}}};
 
-  psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
-                                      "BottomupUnionFindAA");
-
   doAnalysisAndCompareResults("context_11_0_c_dbg.ll", GT, BotAABuilder);
 }
 
@@ -811,21 +864,34 @@ TEST(BotUnionFindAATest, Context11_1) {
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 35,
+             LineColFunOp{.Line = 36,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 39,
+             LineColFunOp{.Line = 37,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Call},
              LineColFunOp{.Line = 41,
                           .Col = 0,
                           .InFunction = "main",
-                          .OpCode = llvm::Instruction::Load}}}};
-
-  psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
-                                      "BottomupUnionFindAA");
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 34,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 34,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 38,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 39,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}}};
 
   doAnalysisAndCompareResults("context_11_1_c_dbg.ll", GT, BotAABuilder);
 }
@@ -869,9 +935,6 @@ TEST(BotUnionFindAATest, Context12_0) {
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Call}}}};
 
-  psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
-                                      "BottomupUnionFindAA");
-
   doAnalysisAndCompareResults("context_12_0_c_dbg.ll", GT, BotAABuilder);
 }
 
@@ -888,15 +951,10 @@ TEST(BotUnionFindAATest, Context12_1) {
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 9,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 13,
+             LineColFunOp{.Line = 11,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Load}}},
-
            {LineColFunOp{.Line = 6,
                          .Col = 0,
                          .InFunction = "main",
@@ -905,18 +963,11 @@ TEST(BotUnionFindAATest, Context12_1) {
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 10,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 11,
+             LineColFunOp{.Line = 9,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Call}}}};
 
-  psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
-                                      "BottomupUnionFindAA");
-
   doAnalysisAndCompareResults("context_12_1_c_dbg.ll", GT, BotAABuilder);
 }
 
@@ -949,7 +1000,6 @@ TEST(BotUnionFindAATest, Context13_0) {
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Load}}},
-
            {LineColFunOp{.Line = 6,
                          .Col = 0,
                          .InFunction = "main",
@@ -990,24 +1040,7 @@ TEST(BotUnionFindAATest, Context13_1) {
              LineColFunOp{.Line = 8,
                           .Col = 0,
                           .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 9,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 10,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 11,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 17,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Load}}},
-
+                          .OpCode = llvm::Instruction::Call}}},
            {LineColFunOp{.Line = 6,
                          .Col = 0,
                          .InFunction = "main",
@@ -1016,22 +1049,14 @@ TEST(BotUnionFindAATest, Context13_1) {
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 12,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 13,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 14,
+             LineColFunOp{.Line = 9,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 15,
+             LineColFunOp{.Line = 11,
                           .Col = 0,
                           .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call}}}};
+                          .OpCode = llvm::Instruction::Load}}}};
 
   doAnalysisAndCompareResults("context_13_1_c_dbg.ll", GT, BotAABuilder);
 }

From 83cd49ccce2119685e5c8fa13fc1f89749b3bf4d Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Fri, 23 Jan 2026 07:22:57 +0100
Subject: [PATCH 25/75] added CtxSens and IndirSens unittests

---
 .../Pointer/LLVMUnionFindAATest.cpp           | 1676 ++++++++++++++++-
 1 file changed, 1632 insertions(+), 44 deletions(-)

diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index 9b274fbf7e..415374d6d4 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -285,11 +285,1574 @@ TEST(CtxSensUnionFindAATest, Context01) {
   doAnalysisAndCompareResults("context_01_c_dbg.ll", GT, ContextAABuilder);
 }
 
+TEST(CtxSensUnionFindAATest, Context02) {
+  GTMap GT = {
+      {LineColFunOp{.Line = 6,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 6,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 9,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 10,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 14,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Load},
+       }},
+      {LineColFunOp{.Line = 7,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 7,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 11,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 12,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+       }},
+  };
+
+  doAnalysisAndCompareResults("context_02_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context03) {
+  GTMap GT = {{LineColFunOp{.Line = 6,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 6,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_03_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context04_0) {
+  GTMap GT = {{LineColFunOp{.Line = 7,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 7,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_04_0_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context04_1) {
+  GTMap GT = {{LineColFunOp{.Line = 7,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 7,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 15,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_04_1_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context05_0) {
+  GTMap GT = {{LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 13,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_05_0_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context05_1) {
+  GTMap GT = {{LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 16,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_05_1_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context06_0) {
+  GTMap GT = {{LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 14,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_06_0_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context06_1) {
+  GTMap GT = {{LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}},
+              {LineColFunOp{.Line = 10,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 14,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 15,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 17,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_06_1_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context07) {
+  GTMap GT = {
+      {LineColFunOp{.Line = 8,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 8,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 11,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 14,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Load},
+       }},
+      {LineColFunOp{.Line = 9,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 9,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 12,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+       }},
+  };
+
+  doAnalysisAndCompareResults("context_07_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context08) {
+  GTMap GT = {{LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 15,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 19,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 21,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_08_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context09_0) {
+  GTMap GT = {{LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}},
+              {LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 16,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}}};
+
+  doAnalysisAndCompareResults("context_09_0_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context09_1) {
+  GTMap GT = {{LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 17,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}},
+              {LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}}};
+
+  doAnalysisAndCompareResults("context_09_1_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context10_0) {
+  GTMap GT = {{LineColFunOp{.Line = 24,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 24,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 26,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}}};
+
+  doAnalysisAndCompareResults("context_10_0_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context10_1) {
+  GTMap GT = {{LineColFunOp{.Line = 24,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 24,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 27,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 29,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 35,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 25,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 25,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 31,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_10_1_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context11_0) {
+  GTMap GT{{LineColFunOp{.Line = 33,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 33,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 36,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 39,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 34,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 34,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 37,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 39,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}}};
+
+  doAnalysisAndCompareResults("context_11_0_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context11_1) {
+  GTMap GT{{LineColFunOp{.Line = 33,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 33,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 36,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 37,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 41,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 34,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 34,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 38,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 39,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_11_1_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context12_0) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 13,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+
+           {LineColFunOp{.Line = 6,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 10,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_12_0_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context12_1) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 6,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_12_1_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context13_0) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 10,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 17,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 6,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 12,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 13,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 14,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 15,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_13_0_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context13_1) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}},
+           {LineColFunOp{.Line = 6,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}}};
+
+  doAnalysisAndCompareResults("context_13_1_c_dbg.ll", GT, ContextAABuilder);
+}
+
 // TODO: Add more context tests
 
-// TODO: Add tests for IndirectionSensUnionFindAA
+// TODO: Add tests for IndirectionSensUnionFindAA
+
+TEST(BotUnionFindAATest, Context01) {
+  GTMap GT = {
+      {LineColFunOp{.Line = 5,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 5,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 8,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 11,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Load},
+       }},
+      {LineColFunOp{.Line = 6,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 6,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 9,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+       }},
+  };
+
+  doAnalysisAndCompareResults("context_01_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context02) {
+  GTMap GT = {
+      {LineColFunOp{.Line = 6,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 6,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 9,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 10,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 14,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Load},
+       }},
+      {LineColFunOp{.Line = 7,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 7,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 11,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 12,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+       }},
+  };
+
+  doAnalysisAndCompareResults("context_02_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context03) {
+  GTMap GT = {{LineColFunOp{.Line = 6,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 6,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_03_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context04_0) {
+  GTMap GT = {{LineColFunOp{.Line = 7,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 7,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_04_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context04_1) {
+  GTMap GT = {{LineColFunOp{.Line = 7,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 7,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 15,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_04_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context05_0) {
+  GTMap GT = {{LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 13,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_05_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context05_1) {
+  GTMap GT = {{LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 16,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_05_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context06_0) {
+  GTMap GT = {{LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 14,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_06_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context06_1) {
+  GTMap GT = {{LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}},
+              {LineColFunOp{.Line = 10,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 14,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 15,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 17,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_06_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context07) {
+  GTMap GT = {
+      {LineColFunOp{.Line = 8,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 8,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 11,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 14,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Load},
+       }},
+      {LineColFunOp{.Line = 9,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 9,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 12,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+       }},
+  };
+
+  doAnalysisAndCompareResults("context_07_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context08) {
+  GTMap GT = {{LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 15,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 19,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 21,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_08_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context09_0) {
+  GTMap GT = {{LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}},
+              {LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 16,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}}};
+
+  doAnalysisAndCompareResults("context_09_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context09_1) {
+  GTMap GT = {{LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 17,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}},
+              {LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}}};
+
+  doAnalysisAndCompareResults("context_09_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context10_0) {
+  GTMap GT = {{LineColFunOp{.Line = 24,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 24,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 26,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}}};
+
+  doAnalysisAndCompareResults("context_10_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context10_1) {
+  GTMap GT = {{LineColFunOp{.Line = 24,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 24,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 27,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 29,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 35,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 25,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 25,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 31,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_10_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context11_0) {
+  GTMap GT{{LineColFunOp{.Line = 33,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 33,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 36,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 39,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 34,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 34,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 37,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 39,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}}};
+
+  doAnalysisAndCompareResults("context_11_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context11_1) {
+  GTMap GT{{LineColFunOp{.Line = 33,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 33,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 36,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 37,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 41,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 34,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 34,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 38,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 39,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_11_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context12_0) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 13,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+
+           {LineColFunOp{.Line = 6,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 10,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_12_0_c_dbg.ll", GT, BotAABuilder);
+}
 
-TEST(BotUnionFindAATest, Context01) {
+TEST(BotUnionFindAATest, Context12_1) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 6,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_12_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context13_0) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 10,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 17,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 6,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 12,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 13,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 14,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 15,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_13_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context13_1) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}},
+           {LineColFunOp{.Line = 6,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}}};
+
+  doAnalysisAndCompareResults("context_13_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+// IndirectionSensUnionFindAA Tests
+
+TEST(IndirectionSensUnionFindAATest, Basic01) {
+  GTMap GT = {{LineColFunOp{.Line = 3,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 3,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 5,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+  doAnalysisAndCompareResults("basic_01_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Basic02) {
+  GTMap GT = {{LineColFunOp{.Line = 3,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 3,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 6,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("basic_02_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Basic03) {
+  GTMap GT = {{LineColFunOp{.Line = 4,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 4,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 6,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("basic_03_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context01) {
   GTMap GT = {
       {LineColFunOp{.Line = 5,
                     .Col = 0,
@@ -308,6 +1871,7 @@ TEST(BotUnionFindAATest, Context01) {
                         .Col = 0,
                         .InFunction = "main",
                         .OpCode = llvm::Instruction::Load},
+           ArgInFun{.Idx = 0, .InFunction = "id"},
        }},
       {LineColFunOp{.Line = 6,
                     .Col = 0,
@@ -322,13 +1886,37 @@ TEST(BotUnionFindAATest, Context01) {
                         .Col = 0,
                         .InFunction = "main",
                         .OpCode = llvm::Instruction::Call},
+           ArgInFun{.Idx = 0, .InFunction = "id"},
+       }},
+      {ArgInFun{.Idx = 0, .InFunction = "id"},
+       {
+           LineColFunOp{.Line = 5,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 6,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 8,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 9,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 11,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Load},
+           ArgInFun{.Idx = 0, .InFunction = "id"},
        }},
   };
-
-  doAnalysisAndCompareResults("context_01_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_01_c_dbg.ll", GT, IndAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context02) {
+TEST(IndirectionSensUnionFindAATest, Context02) {
   GTMap GT = {
       {LineColFunOp{.Line = 6,
                     .Col = 0,
@@ -372,10 +1960,10 @@ TEST(BotUnionFindAATest, Context02) {
        }},
   };
 
-  doAnalysisAndCompareResults("context_02_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_02_c_dbg.ll", GT, IndAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context03) {
+TEST(IndirectionSensUnionFindAATest, Context03) {
   GTMap GT = {{LineColFunOp{.Line = 6,
                             .Col = 0,
                             .InFunction = "main",
@@ -399,10 +1987,10 @@ TEST(BotUnionFindAATest, Context03) {
                                 .OpCode = llvm::Instruction::Load},
                }}};
 
-  doAnalysisAndCompareResults("context_03_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_03_c_dbg.ll", GT, IndAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context04_0) {
+TEST(IndirectionSensUnionFindAATest, Context04_0) {
   GTMap GT = {{LineColFunOp{.Line = 7,
                             .Col = 0,
                             .InFunction = "main",
@@ -426,10 +2014,10 @@ TEST(BotUnionFindAATest, Context04_0) {
                                 .OpCode = llvm::Instruction::Load},
                }}};
 
-  doAnalysisAndCompareResults("context_04_0_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_04_0_c_dbg.ll", GT, IndAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context04_1) {
+TEST(IndirectionSensUnionFindAATest, Context04_1) {
   GTMap GT = {{LineColFunOp{.Line = 7,
                             .Col = 0,
                             .InFunction = "main",
@@ -469,10 +2057,10 @@ TEST(BotUnionFindAATest, Context04_1) {
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Call}}}};
 
-  doAnalysisAndCompareResults("context_04_1_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_04_1_c_dbg.ll", GT, IndAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context05_0) {
+TEST(IndirectionSensUnionFindAATest, Context05_0) {
   GTMap GT = {{LineColFunOp{.Line = 8,
                             .Col = 0,
                             .InFunction = "main",
@@ -496,10 +2084,10 @@ TEST(BotUnionFindAATest, Context05_0) {
                                 .OpCode = llvm::Instruction::Load},
                }}};
 
-  doAnalysisAndCompareResults("context_05_0_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_05_0_c_dbg.ll", GT, IndAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context05_1) {
+TEST(IndirectionSensUnionFindAATest, Context05_1) {
   GTMap GT = {{LineColFunOp{.Line = 8,
                             .Col = 0,
                             .InFunction = "main",
@@ -539,10 +2127,10 @@ TEST(BotUnionFindAATest, Context05_1) {
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Call}}}};
 
-  doAnalysisAndCompareResults("context_05_1_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_05_1_c_dbg.ll", GT, IndAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context06_0) {
+TEST(IndirectionSensUnionFindAATest, Context06_0) {
   GTMap GT = {{LineColFunOp{.Line = 9,
                             .Col = 0,
                             .InFunction = "main",
@@ -566,10 +2154,10 @@ TEST(BotUnionFindAATest, Context06_0) {
                                 .OpCode = llvm::Instruction::Load},
                }}};
 
-  doAnalysisAndCompareResults("context_06_0_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_06_0_c_dbg.ll", GT, IndAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context06_1) {
+TEST(IndirectionSensUnionFindAATest, Context06_1) {
   GTMap GT = {{LineColFunOp{.Line = 9,
                             .Col = 0,
                             .InFunction = "main",
@@ -609,10 +2197,10 @@ TEST(BotUnionFindAATest, Context06_1) {
                                 .OpCode = llvm::Instruction::Load},
                }}};
 
-  doAnalysisAndCompareResults("context_06_1_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_06_1_c_dbg.ll", GT, IndAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context07) {
+TEST(IndirectionSensUnionFindAATest, Context07) {
   GTMap GT = {
       {LineColFunOp{.Line = 8,
                     .Col = 0,
@@ -648,10 +2236,10 @@ TEST(BotUnionFindAATest, Context07) {
        }},
   };
 
-  doAnalysisAndCompareResults("context_07_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_07_c_dbg.ll", GT, IndAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context08) {
+TEST(IndirectionSensUnionFindAATest, Context08) {
   GTMap GT = {{LineColFunOp{.Line = 12,
                             .Col = 0,
                             .InFunction = "main",
@@ -675,10 +2263,10 @@ TEST(BotUnionFindAATest, Context08) {
                                 .OpCode = llvm::Instruction::Load},
                }}};
 
-  doAnalysisAndCompareResults("context_08_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_08_c_dbg.ll", GT, IndAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context09_0) {
+TEST(IndirectionSensUnionFindAATest, Context09_0) {
   GTMap GT = {{LineColFunOp{.Line = 12,
                             .Col = 0,
                             .InFunction = "main",
@@ -708,10 +2296,10 @@ TEST(BotUnionFindAATest, Context09_0) {
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Load}}}};
 
-  doAnalysisAndCompareResults("context_09_0_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_09_0_c_dbg.ll", GT, IndAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context09_1) {
+TEST(IndirectionSensUnionFindAATest, Context09_1) {
   GTMap GT = {{LineColFunOp{.Line = 12,
                             .Col = 0,
                             .InFunction = "main",
@@ -749,10 +2337,10 @@ TEST(BotUnionFindAATest, Context09_1) {
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Load}}}};
 
-  doAnalysisAndCompareResults("context_09_1_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_09_1_c_dbg.ll", GT, IndAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context10_0) {
+TEST(IndirectionSensUnionFindAATest, Context10_0) {
   GTMap GT = {{LineColFunOp{.Line = 24,
                             .Col = 0,
                             .InFunction = "main",
@@ -774,10 +2362,10 @@ TEST(BotUnionFindAATest, Context10_0) {
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Load}}}};
 
-  doAnalysisAndCompareResults("context_10_0_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_10_0_c_dbg.ll", GT, IndAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context10_1) {
+TEST(IndirectionSensUnionFindAATest, Context10_1) {
   GTMap GT = {{LineColFunOp{.Line = 24,
                             .Col = 0,
                             .InFunction = "main",
@@ -815,10 +2403,10 @@ TEST(BotUnionFindAATest, Context10_1) {
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Call}}}};
 
-  doAnalysisAndCompareResults("context_10_1_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_10_1_c_dbg.ll", GT, IndAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context11_0) {
+TEST(IndirectionSensUnionFindAATest, Context11_0) {
   GTMap GT{{LineColFunOp{.Line = 33,
                          .Col = 0,
                          .InFunction = "main",
@@ -852,10 +2440,10 @@ TEST(BotUnionFindAATest, Context11_0) {
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Load}}}};
 
-  doAnalysisAndCompareResults("context_11_0_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_11_0_c_dbg.ll", GT, IndAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context11_1) {
+TEST(IndirectionSensUnionFindAATest, Context11_1) {
   GTMap GT{{LineColFunOp{.Line = 33,
                          .Col = 0,
                          .InFunction = "main",
@@ -893,10 +2481,10 @@ TEST(BotUnionFindAATest, Context11_1) {
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Call}}}};
 
-  doAnalysisAndCompareResults("context_11_1_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_11_1_c_dbg.ll", GT, IndAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context12_0) {
+TEST(IndirectionSensUnionFindAATest, Context12_0) {
   GTMap GT{{LineColFunOp{.Line = 5,
                          .Col = 0,
                          .InFunction = "main",
@@ -935,10 +2523,10 @@ TEST(BotUnionFindAATest, Context12_0) {
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Call}}}};
 
-  doAnalysisAndCompareResults("context_12_0_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_12_0_c_dbg.ll", GT, IndAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context12_1) {
+TEST(IndirectionSensUnionFindAATest, Context12_1) {
   GTMap GT{{LineColFunOp{.Line = 5,
                          .Col = 0,
                          .InFunction = "main",
@@ -968,10 +2556,10 @@ TEST(BotUnionFindAATest, Context12_1) {
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Call}}}};
 
-  doAnalysisAndCompareResults("context_12_1_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_12_1_c_dbg.ll", GT, IndAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context13_0) {
+TEST(IndirectionSensUnionFindAATest, Context13_0) {
   GTMap GT{{LineColFunOp{.Line = 5,
                          .Col = 0,
                          .InFunction = "main",
@@ -1025,10 +2613,10 @@ TEST(BotUnionFindAATest, Context13_0) {
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Call}}}};
 
-  doAnalysisAndCompareResults("context_13_0_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_13_0_c_dbg.ll", GT, IndAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context13_1) {
+TEST(IndirectionSensUnionFindAATest, Context13_1) {
   GTMap GT{{LineColFunOp{.Line = 5,
                          .Col = 0,
                          .InFunction = "main",
@@ -1058,7 +2646,7 @@ TEST(BotUnionFindAATest, Context13_1) {
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Load}}}};
 
-  doAnalysisAndCompareResults("context_13_1_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_13_1_c_dbg.ll", GT, IndAABuilder);
 }
 
 } // namespace

From e865e5f516b5a4c3938409662f066a26a394d64c Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Fri, 23 Jan 2026 14:26:28 +0100
Subject: [PATCH 26/75] Some fix in BottomupUnionFindAA

---
 include/phasar/Pointer/BottomupUnionFindAA.h  |  25 ++-
 .../Pointer/LLVMUnionFindAATest.cpp           | 152 ++++++++++--------
 2 files changed, 104 insertions(+), 73 deletions(-)

diff --git a/include/phasar/Pointer/BottomupUnionFindAA.h b/include/phasar/Pointer/BottomupUnionFindAA.h
index 3835444dd0..3a7c7b867f 100644
--- a/include/phasar/Pointer/BottomupUnionFindAA.h
+++ b/include/phasar/Pointer/BottomupUnionFindAA.h
@@ -26,8 +26,13 @@
 #include <unordered_map>
 
 namespace psr {
+
+struct BottomupUnionFindAABase {
+  static constexpr llvm::StringLiteral LogCategory = "BottomupUnionFindAA";
+};
+
 template <typename AnalysisDomainT, Soundness SoundnessFlag = Soundness::Soundy>
-class BottomupUnionFindAA {
+class BottomupUnionFindAA : BottomupUnionFindAABase {
   struct ParamInfo {
     ValueId Arg;
     ValueId Param;
@@ -49,6 +54,8 @@ class BottomupUnionFindAA {
   using RevCGTy = ReverseCGGraph<CGTy, db_t>;
   using FunVtxTy = typename RevCGTy::FunctionId;
 
+  using BottomupUnionFindAABase::LogCategory;
+
   static constexpr auto InvalidSCC = SCCId<FunVtxTy>(UINT32_MAX);
 
   constexpr BottomupUnionFindAA(RevCGTy &&RevCG,
@@ -134,31 +141,33 @@ class BottomupUnionFindAA {
          llvm::reverse(iota<SCCId<FunVtxTy>>(CGSCCs->size()))) {
 
       for (const auto &[CS, CSInfo] : Calls[CurrSCC]) {
-        PHASAR_LOG_LEVEL_CAT(DEBUG, "BottomupUnionFindAA",
-                             "At CS: " << NToString(CS));
+        PHASAR_LOG_LEVEL_CAT(DEBUG, LogCategory, "At CS: " << NToString(CS));
         llvm::SmallDenseMap<ValueId, llvm::SmallVector<ValueId, 2>> BackMap;
 
         for (const auto &[Arg, Param, E] : CSInfo.Params) {
-          BackMap[Param].push_back(Arg);
+          auto ParamRep = Base.AliasSets.find(Param);
+          BackMap[ParamRep].push_back(Arg);
         }
         if (CSInfo.RetSlot) {
           for (auto Ret : CSInfo.Ret) {
-            BackMap[Ret].push_back(*CSInfo.RetSlot);
+            auto RetRep = Base.AliasSets.find(Ret);
+            BackMap[RetRep].push_back(*CSInfo.RetSlot);
           }
         }
 
         // --- Apply summaries:
         for (const auto &[Param, Args] : BackMap) {
-          PHASAR_LOG_LEVEL_CAT(DEBUG, "BottomupUnionFindAA",
+          PHASAR_LOG_LEVEL_CAT(DEBUG, LogCategory,
                                "  Param: " << psr::to_underlying(Param)
                                            << "; Args: "
                                            << PrettyPrinter{Args});
 
           const auto &ToAliases = IntermediateBackView[Param];
           ToAliases.foreach ([&](ValueId Alias) {
-            if (const auto *AliasFroms = getOrNull(BackMap, Alias)) {
+            auto AliasRep = Base.AliasSets.find(Alias);
+            if (const auto *AliasFroms = getOrNull(BackMap, AliasRep)) {
               for (auto Arg : Args) {
-                PHASAR_LOG_LEVEL_CAT(DEBUG, "BottomupUnionFindAA",
+                PHASAR_LOG_LEVEL_CAT(DEBUG, LogCategory,
                                      "  JOIN " << psr::to_underlying(Arg)
                                                << " WITH "
                                                << PrettyPrinter{*AliasFroms});
diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index 415374d6d4..cee3e0895a 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -25,6 +25,7 @@
 #include "gtest/gtest.h"
 
 #include <map>
+#include <source_location>
 #include <vector>
 
 namespace {
@@ -77,7 +78,8 @@ using GTMap = std::map<unittest::TestingSrcLocation,
 void doAnalysisAndCompareResults(
     const llvm::Twine &IRFile, const GTMap &ExpectedResults,
     std::invocable<const LLVMProjectIRDB &, const LLVMBasedCallGraph &> auto
-        AABuilder) {
+        AABuilder,
+    std::source_location Loc = std::source_location::current()) {
 
   auto IRDB = LLVMProjectIRDB::loadOrExit(PathToLLFiles + IRFile);
   auto TH = DIBasedTypeHierarchy(IRDB);
@@ -100,8 +102,9 @@ void doAnalysisAndCompareResults(
 
     ExpectedAliasIds.foreach ([&](ValueId VId) {
       if (!ComputedAliasIds.contains(VId)) {
-        ADD_FAILURE() << "Did not compute expected alias of " << PtrVar << ": "
-                      << stringifyVal(VC, VId);
+        ADD_FAILURE_AT(Loc.file_name(), Loc.line())
+            << "Did not compute expected alias of " << PtrVar << ": "
+            << stringifyVal(VC, VId);
       }
     });
 
@@ -124,12 +127,21 @@ void doAnalysisAndCompareResults(
           })) {
         return;
       }
-      ADD_FAILURE() << "Computed unexpected alias of " << PtrVar << ": "
-                    << stringifyVal(VC, VId);
+      ADD_FAILURE_AT(Loc.file_name(), Loc.line())
+          << "Computed unexpected alias of " << PtrVar << ": "
+          << stringifyVal(VC, VId);
     });
   }
 
   if (::testing::Test::HasFailure()) {
+    llvm::errs() << "ValueCompressor: {\n";
+    for (const auto &[VId, Values] : VC.id2vars().enumerate()) {
+      llvm::errs() << "  #" << uint32_t(VId) << ":\n";
+      for (const auto Val : Values) {
+        llvm::errs() << "    " << to_string(Val) << '\n';
+      }
+    }
+    llvm::errs() << "}\n";
     Results.dump();
   }
 }
@@ -218,7 +230,7 @@ TEST(CtxSensUnionFindAATest, Basic03) {
                                 .OpCode = llvm::Instruction::Load},
                }}};
 
-  doAnalysisAndCompareResults("basic_03_c_dbg.ll", GT, ContextAABuilder);
+  doAnalysisAndCompareResults("basic_03_cpp_dbg.ll", GT, ContextAABuilder);
 }
 
 TEST(CtxSensUnionFindAATest, Context01) {
@@ -1511,79 +1523,89 @@ TEST(BotUnionFindAATest, Context10_0) {
 }
 
 TEST(BotUnionFindAATest, Context10_1) {
-  GTMap GT = {{LineColFunOp{.Line = 24,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 24,
+  GTMap GT = {
+      {LineColFunOp{.Line = 24,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 24,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 27,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 29,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 35,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Load},
+       }},
+      {LineColFunOp{.Line = 25,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 25,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 31,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 33,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+       }},
+  };
+
+  doAnalysisAndCompareResults("context_10_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context11_0) {
+  GTMap GT{{LineColFunOp{.Line = 33,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 33,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 27,
+                LineColFunOp{.Line = 36,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 29,
+                LineColFunOp{.Line = 39,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 35,
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 39,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load}}},
-              {LineColFunOp{.Line = 25,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 25,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 31,
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 34,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 34,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 33,
+                LineColFunOp{.Line = 37,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call}}}};
-
-  doAnalysisAndCompareResults("context_10_1_c_dbg.ll", GT, BotAABuilder);
-}
-
-TEST(BotUnionFindAATest, Context11_0) {
-  GTMap GT{{LineColFunOp{.Line = 33,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 33,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 36,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 39,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Load}}},
-           {LineColFunOp{.Line = 34,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 34,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 37,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 39,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Load}}}};
+                             .OpCode = llvm::Instruction::Call},
+            }}};
 
   doAnalysisAndCompareResults("context_11_0_c_dbg.ll", GT, BotAABuilder);
 }
@@ -1849,7 +1871,7 @@ TEST(IndirectionSensUnionFindAATest, Basic03) {
                                 .OpCode = llvm::Instruction::Load},
                }}};
 
-  doAnalysisAndCompareResults("basic_03_c_dbg.ll", GT, IndAABuilder);
+  doAnalysisAndCompareResults("basic_03_cpp_dbg.ll", GT, IndAABuilder);
 }
 
 TEST(IndirectionSensUnionFindAATest, Context01) {

From dc8fcafe1c261f528c517d9ebd5514c686d31795 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Mon, 26 Jan 2026 15:29:56 +0100
Subject: [PATCH 27/75] Fix error due to merge

---
 lib/PhasarLLVM/Pointer/FilteredAliasesUtils.h | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/lib/PhasarLLVM/Pointer/FilteredAliasesUtils.h b/lib/PhasarLLVM/Pointer/FilteredAliasesUtils.h
index f227673121..49a6373ac3 100644
--- a/lib/PhasarLLVM/Pointer/FilteredAliasesUtils.h
+++ b/lib/PhasarLLVM/Pointer/FilteredAliasesUtils.h
@@ -6,17 +6,6 @@
 #include "llvm/IR/Instructions.h"
 #include "llvm/Support/Compiler.h"
 
-LLVM_LIBRARY_VISIBILITY inline const llvm::Function *
-getFunction(const llvm::Value *V) {
-  if (const auto *Inst = llvm::dyn_cast<llvm::Instruction>(V)) {
-    return Inst->getFunction();
-  }
-  if (const auto *Arg = llvm::dyn_cast<llvm::Argument>(V)) {
-    return Arg->getParent();
-  }
-  return nullptr;
-}
-
 [[nodiscard]] LLVM_LIBRARY_VISIBILITY inline bool
 isConstantGlobalValue(const llvm::GlobalValue *GlobV) {
   if (const auto *Glob = llvm::dyn_cast<llvm::GlobalVariable>(GlobV)) {

From b64fc3bb4366bbb9170a6c761a1fc11f5a34010b Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Mon, 26 Jan 2026 17:50:07 +0100
Subject: [PATCH 28/75] Start adding LLVMUnionFindAliasSet (WIP)

---
 .../PhasarLLVM/Pointer/LLVMUnionFindAA.h      | 208 +++++++++++++++---
 .../Pointer/LLVMUnionFindAliasSet.h           | 168 ++++++++++++++
 include/phasar/Pointer/AliasAnalysisType.def  |   1 +
 .../Pointer/LLVMUnionFindAliasSet.cpp         | 171 ++++++++++++++
 4 files changed, 515 insertions(+), 33 deletions(-)
 create mode 100644 include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h
 create mode 100644 lib/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.cpp

diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
index 791974d79e..743b08b6d9 100644
--- a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
@@ -4,9 +4,11 @@
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h"
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
+#include "phasar/Pointer/AliasResult.h"
 #include "phasar/Pointer/BottomupUnionFindAA.h"
 #include "phasar/Pointer/RawAliasSet.h"
 #include "phasar/Pointer/UnionFindAA.h"
+#include "phasar/Utils/Macros.h"
 #include "phasar/Utils/MapUtils.h"
 #include "phasar/Utils/MaybeUniquePtr.h"
 #include "phasar/Utils/NonNullPtr.h"
@@ -21,10 +23,10 @@ extern template class CallingContextSensUnionFindAA<LLVMPAGDomain>;
 extern template class IndirectionSensUnionFindAA<LLVMPAGDomain>;
 extern template class BottomupUnionFindAA<LLVMPAGDomain>;
 
-inline constexpr std::invocable<ValueId> auto
+constexpr std::invocable<ValueId> auto
 llvmUnionFindAliasHandler(const ValueCompressor<PAGVariable> &VC,
                           std::invocable<const llvm::Value *> auto Callback) {
-  return [&VC, Callback](ValueId Alias) {
+  return [&VC, Callback{copyOrRef(Callback)}](ValueId Alias) {
     for (auto V : VC.id2vars(Alias)) {
       if (const auto *LLVMVar = V.valueOrNull()) [[likely]] {
         std::invoke(Callback, LLVMVar);
@@ -53,28 +55,90 @@ class LLVMCGProvider : public LLVMPAGDomain {
 };
 } // namespace pag
 
-template <typename AAResT>
+template <typename Derived, typename AAResT>
   requires UnionFindAAResult<std::remove_cvref_t<AAResT>>
 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
-struct LLVMUnionFindAliasIterator {
-  AAResT AARes;
-  MaybeUniquePtr<const ValueCompressor<PAGVariable>> VC;
+struct LLVMUnionFindAliasIteratorMixin {
+  [[no_unique_address]] AAResT AARes;
 
   using v_t = const llvm::Value *;
   using n_t = const llvm::Instruction *;
 
-  void forallAliasesOf(ValueId VId, const auto & /*Inst*/,
-                       std::invocable<const llvm::Value *> auto Callback) {
+  [[nodiscard]] decltype(auto) getRawAliasSet(ValueId ValId) const {
+    return AARes.getRawAliasSet(ValId);
+  }
+
+  void
+  forallAliasesOf(ValueId VId, const auto & /*Inst*/,
+                  std::invocable<const llvm::Value *> auto Callback) const {
     const auto &RawAliases = AARes.getRawAliasSet(VId);
-    RawAliases.foreach (llvmUnionFindAliasHandler(VC, copyOrRef(Callback)));
+    RawAliases.foreach (
+        llvmUnionFindAliasHandler(*self().VC, copyOrRef(Callback)));
   }
 
-  void forallAliasesOf(const llvm::Value *Ptr, const auto &Inst,
-                       std::invocable<const llvm::Value *> auto Callback) {
-    if (auto ValId = VC->getOrNull(Ptr)) {
-      foreachAliasOf(*ValId, Inst, copyOrRef(Callback));
+  void
+  forallAliasesOf(const llvm::Value *Ptr, const auto &Inst,
+                  std::invocable<const llvm::Value *> auto Callback) const {
+    if (auto ValId = self().VC->getOrNull(Ptr)) {
+      forallAliasesOf(*ValId, Inst, copyOrRef(Callback));
     }
   }
+
+  [[nodiscard]] bool mayAlias(ValueId Ptr1, ValueId Ptr2) const {
+    return AARes.mayAlias(Ptr1, Ptr2);
+  }
+
+  [[nodiscard]] bool mayAlias(ValueId Ptr1, ValueId Ptr2,
+                              const auto & /*AtInstruction*/) const {
+    return AARes.mayAlias(Ptr1, Ptr2);
+  }
+
+  [[nodiscard]] bool mayAlias(const llvm::Value *Ptr1,
+                              const llvm::Value *Ptr2) const {
+    auto ValId1 = self().VC->getOrNull(Ptr1);
+    auto ValId2 = self().VC->getOrNull(Ptr2);
+
+    return ValId1 && ValId2 && mayAlias(*ValId1, *ValId2);
+  }
+
+  [[nodiscard]] bool mayAlias(const llvm::Value *Ptr1, const llvm::Value *Ptr2,
+                              const auto & /*AtInstruction*/) const {
+    return mayAlias(Ptr1, Ptr2);
+  }
+
+  [[nodiscard]] AliasResult alias(const llvm::Value *Ptr1,
+                                  const llvm::Value *Ptr2,
+                                  const auto &AtInstruction) const {
+    auto ValId1 = self().VC->getOrNull(Ptr1);
+    auto ValId2 = self().VC->getOrNull(Ptr2);
+    if (!ValId1 || !ValId2) {
+      return AliasResult::NoAlias;
+    }
+    if (*ValId1 == *ValId2) {
+      return AliasResult::MustAlias;
+    }
+    return mayAlias(*ValId1, *ValId2, AtInstruction) ? AliasResult::MayAlias
+                                                     : AliasResult::NoAlias;
+  }
+
+  [[nodiscard]] constexpr const Derived &self() const noexcept {
+    return *static_cast<const Derived *>(this);
+  }
+};
+
+template <typename AAResT>
+  requires UnionFindAAResult<std::remove_cvref_t<AAResT>>
+// NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
+struct LLVMUnionFindAliasIterator
+    : public LLVMUnionFindAliasIteratorMixin<LLVMUnionFindAliasIterator<AAResT>,
+                                             AAResT> {
+  MaybeUniquePtr<const ValueCompressor<PAGVariable>> VC;
+
+  constexpr LLVMUnionFindAliasIterator(
+      AAResT &&AARes, MaybeUniquePtr<const ValueCompressor<PAGVariable>> VC)
+      : psr::LLVMUnionFindAliasIteratorMixin<LLVMUnionFindAliasIterator<AAResT>,
+                                             AAResT>{PSR_FWD(AARes)},
+        VC(std::move(VC)) {}
 };
 
 template <typename AAResT>
@@ -96,19 +160,37 @@ class LLVMLocalUnionFindAliasIteratorBase {
 };
 } // namespace detail
 
-template <typename AAResT>
-class LLVMLocalUnionFindAliasIterator
+template <typename Derived, typename AAResT>
+class LLVMLocalUnionFindAliasIteratorMixin
     : public detail::LLVMLocalUnionFindAliasIteratorBase {
 public:
-  LLVMLocalUnionFindAliasIterator(
-      AAResT &&AARes, NonNullPtr<const ValueCompressor<PAGVariable>> VC)
-      : detail::LLVMLocalUnionFindAliasIteratorBase(*VC), AARes(PSR_FWD(AARes)),
-        VC(VC) {}
+  LLVMLocalUnionFindAliasIteratorMixin(AAResT &&AARes,
+                                       const ValueCompressor<PAGVariable> &VC)
+      : detail::LLVMLocalUnionFindAliasIteratorBase(VC), AARes(PSR_FWD(AARes)) {
+  }
 
-  void foreachAliasOf(ValueId VId, const llvm::Function *Context,
-                      std::invocable<const llvm::Value *> auto WithAlias) {
+  [[nodiscard]] decltype(auto) getRawAliasSet(ValueId ValId) const {
+    return AARes.getRawAliasSet(ValId);
+  }
+
+  [[nodiscard]] auto getRawAliasSet(ValueId ValId,
+                                    const llvm::Function *Context) const {
+    auto Vars = AARes.getRawAliasSet(ValId);
+    if (Context) {
+      Vars &= getOrDefault(GlobalsOrInFun, Context);
+    }
+    return Vars;
+  }
+
+  [[nodiscard]] auto getRawAliasSet(ValueId ValId,
+                                    const llvm::Instruction *Context) const {
+    return getRawAliasSet(ValId, getFunction(Context));
+  }
+
+  void forallAliasesOf(ValueId VId, const llvm::Function *Context,
+                       std::invocable<const llvm::Value *> auto WithAlias) {
     const auto AliasHandler =
-        llvmUnionFindAliasHandler(VC, copyOrRef(WithAlias));
+        llvmUnionFindAliasHandler(*self().VC, copyOrRef(WithAlias));
 
     auto &&RawVars = AARes.getRawAliasSet(VId);
     if (Context) {
@@ -120,26 +202,86 @@ class LLVMLocalUnionFindAliasIterator
     }
   }
 
-  void foreachAliasOf(const llvm::Value *Val, const llvm::Function *Context,
-                      std::invocable<const llvm::Value *> auto WithAlias) {
-    if (auto ValId = VC->getOrNull(Val)) {
-      foreachAliasOf(*ValId, Context, copyOrRef(WithAlias));
+  void forallAliasesOf(const llvm::Value *Val, const llvm::Function *Context,
+                       std::invocable<const llvm::Value *> auto WithAlias) {
+    if (auto ValId = self().VC->getOrNull(Val)) {
+      forallAliasesOf(*ValId, Context, copyOrRef(WithAlias));
     }
   }
 
-  void foreachAliasOf(const llvm::Value *Val,
-                      const llvm::Instruction *AtInstruction,
-                      std::invocable<const llvm::Value *> auto WithAlias) {
-    foreachAliasOf(Val, psr::getFunction(AtInstruction), copyOrRef(WithAlias));
+  void forallAliasesOf(ValueId ValId, const llvm::Instruction *AtInstruction,
+                       std::invocable<const llvm::Value *> auto WithAlias) {
+    forallAliasesOf(ValId, psr::getFunction(AtInstruction),
+                    copyOrRef(WithAlias));
   }
 
-  void foreachAliasOf(const llvm::Value *Val,
-                      std::invocable<const llvm::Value *> auto WithAlias) {
-    foreachAliasOf(Val, psr::getFunction(Val), copyOrRef(WithAlias));
+  void forallAliasesOf(const llvm::Value *Val,
+                       const llvm::Instruction *AtInstruction,
+                       std::invocable<const llvm::Value *> auto WithAlias) {
+    forallAliasesOf(Val, psr::getFunction(AtInstruction), copyOrRef(WithAlias));
+  }
+
+  void forallAliasesOf(const llvm::Value *Val,
+                       std::invocable<const llvm::Value *> auto WithAlias) {
+    forallAliasesOf(Val, psr::getFunction(Val), copyOrRef(WithAlias));
+  }
+
+  [[nodiscard]] bool
+  mayAlias(ValueId ValId1, ValueId ValId2,
+           const llvm::Instruction * /*AtInstruction*/ = nullptr) const {
+    // TODO: Should we filter by AtInstruction-context here as well?
+    return AARes.mayAlias(ValId1, ValId2);
+  }
+
+  [[nodiscard]] bool
+  mayAlias(const llvm::Value *Ptr1, const llvm::Value *Ptr2,
+           const llvm::Instruction * /*AtInstruction*/ = nullptr) const {
+    auto ValId1 = self().VC->getOrNull(Ptr1);
+    auto ValId2 = self().VC->getOrNull(Ptr2);
+
+    // TODO: Should we filter by AtInstruction-context here as well?
+    return ValId1 && ValId2 && AARes.mayAlias(*ValId1, *ValId2);
+  }
+
+  [[nodiscard]] AliasResult alias(const llvm::Value *Ptr1,
+                                  const llvm::Value *Ptr2,
+                                  const auto &AtInstruction) const {
+    auto ValId1 = self().VC->getOrNull(Ptr1);
+    auto ValId2 = self().VC->getOrNull(Ptr2);
+    if (!ValId1 || !ValId2) {
+      return AliasResult::NoAlias;
+    }
+    if (*ValId1 == *ValId2) {
+      return AliasResult::MustAlias;
+    }
+    return mayAlias(*ValId1, *ValId2, AtInstruction) ? AliasResult::MayAlias
+                                                     : AliasResult::NoAlias;
+  }
+
+  [[nodiscard]] constexpr const Derived &self() const noexcept {
+    return *static_cast<const Derived *>(this);
   }
 
 private:
   AAResT AARes;
+};
+
+template <typename AAResT>
+class LLVMLocalUnionFindAliasIterator
+    : public LLVMLocalUnionFindAliasIteratorMixin<
+          LLVMLocalUnionFindAliasIterator<AAResT>, AAResT> {
+  friend LLVMLocalUnionFindAliasIteratorMixin<
+      LLVMLocalUnionFindAliasIterator<AAResT>, AAResT>;
+
+public:
+  LLVMLocalUnionFindAliasIterator(
+      AAResT &&AARes, NonNullPtr<const ValueCompressor<PAGVariable>> VC)
+      : LLVMLocalUnionFindAliasIteratorMixin<
+            LLVMLocalUnionFindAliasIterator<AAResT>, AAResT>(PSR_FWD(AARes),
+                                                             *VC),
+        VC(VC) {}
+
+private:
   NonNullPtr<const ValueCompressor<PAGVariable>> VC;
 };
 
diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h
new file mode 100644
index 0000000000..3454f11e5a
--- /dev/null
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h
@@ -0,0 +1,168 @@
+#pragma once
+
+#include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMPointsToUtils.h"
+#include "phasar/Pointer/AliasAnalysisType.h"
+#include "phasar/Pointer/AliasInfoTraits.h"
+#include "phasar/Pointer/AliasResult.h"
+#include "phasar/Pointer/AliasSetOwner.h"
+#include "phasar/Pointer/RawAliasSet.h"
+#include "phasar/Utils/AnalysisProperties.h"
+#include "phasar/Utils/TypedVector.h"
+#include "phasar/Utils/ValueCompressor.h"
+
+#include <memory>
+#include <type_traits>
+
+namespace llvm {
+class Value;
+class Instruction;
+class Function;
+} // namespace llvm
+
+namespace psr {
+
+class LLVMUnionFindAliasSet;
+class LLVMProjectIRDB;
+
+template <>
+struct AliasInfoTraits<LLVMUnionFindAliasSet>
+    : DefaultAATraits<const llvm::Value *, const llvm::Instruction *> {};
+
+class LLVMUnionFindAliasSet
+    : public AnalysisPropertiesMixin<LLVMUnionFindAliasSet> {
+public:
+  using traits_t = AliasInfoTraits<LLVMUnionFindAliasSet>;
+  using n_t = traits_t::n_t;
+  using v_t = traits_t::v_t;
+  using AliasSetTy = traits_t::AliasSetTy;
+  using AliasSetPtrTy = traits_t::AliasSetPtrTy;
+  using AllocationSiteSetPtrTy = traits_t::AllocationSiteSetPtrTy;
+  using AliasSetMap = llvm::DenseMap<const llvm::Value *, BoxedPtr<AliasSetTy>>;
+
+  enum class AnalysisType {
+    CtxSens,
+    IndSens,
+    CtxIndSens,
+    BotCtxSens,
+    BotCtxIndSens,
+  };
+
+  enum class AnalysisLocality {
+    Global,
+    FunctionLocal,
+  };
+
+  struct Config {
+    AnalysisType AType = AnalysisType::BotCtxIndSens;
+    AnalysisLocality ALocality = AnalysisLocality::Global;
+  };
+
+  explicit LLVMUnionFindAliasSet(const LLVMProjectIRDB *IRDB, Config Cfg,
+                                 ValueCompressor<PAGVariable> *VC);
+  explicit LLVMUnionFindAliasSet(const LLVMProjectIRDB *IRDB, Config Cfg)
+      : LLVMUnionFindAliasSet(IRDB, Cfg, nullptr) {}
+  explicit LLVMUnionFindAliasSet(const LLVMProjectIRDB *IRDB)
+      : LLVMUnionFindAliasSet(IRDB, Config{}, nullptr) {}
+
+  [[nodiscard]] constexpr std::false_type isInterProcedural() const noexcept {
+    return {};
+  };
+
+  [[nodiscard]] constexpr std::integral_constant<AliasAnalysisType,
+                                                 AliasAnalysisType::UnionFind>
+  getAliasAnalysisType() const noexcept {
+    return {};
+  };
+
+  [[nodiscard]] constexpr AnalysisProperties
+  getAnalysisProperties() const noexcept {
+    return Props;
+  }
+
+  [[nodiscard]] constexpr AliasResult alias(v_t V1, v_t V2, n_t I) const {
+    return AARes->alias(V1, V2, I);
+  }
+
+  void foreachAliasOf(v_t V, n_t I,
+                      llvm::function_ref<void(v_t)> WithAlias) const {
+    AARes->forallAliasesOf(V, I, WithAlias);
+  }
+
+  [[nodiscard]] AliasSetPtrTy getAliasSet(v_t V, n_t I) {
+    auto ValId = AARes->VC->getOrNull(V);
+    if (!ValId) {
+      return getEmptyAliasSet();
+    }
+
+    assert(AliasSets.inbounds(*ValId));
+    if (!AliasSets[*ValId]) [[unlikely]] {
+      AliasSets[*ValId] = AARes->constructAliasSet(*ValId, I, Owner);
+    }
+
+    return AliasSets[*ValId];
+  }
+
+  [[nodiscard]] AllocationSiteSetPtrTy
+  getReachableAllocationSites(v_t V, bool IntraProcOnly, n_t I) const {
+    auto ValId = AARes->VC->getOrNull(V);
+    if (!ValId) {
+      return std::make_unique<AliasSetTy>();
+    }
+
+    return AARes->constructReachableAllocSites(V, *ValId, IntraProcOnly, I);
+  }
+
+  [[nodiscard]] bool isInReachableAllocationSites(
+      const llvm::Value *V, const llvm::Value *PotentialValue,
+      bool IntraProcOnly, const llvm::Instruction *I) const {
+    if (!psr::isInterestingPointer(V)) {
+      return false;
+    }
+
+    if (!psr::isInReachableAllocationSitesTy(V, PotentialValue,
+                                             IntraProcOnly)) {
+      return false;
+    }
+
+    return alias(V, PotentialValue, I) != AliasResult::NoAlias;
+  }
+
+private:
+  struct UnionFindAAResultConcept {
+    MaybeUniquePtr<const ValueCompressor<PAGVariable>> VC;
+    std::optional<RawAliasSet<ValueId>> AllocationSites{};
+
+    UnionFindAAResultConcept(
+        MaybeUniquePtr<const ValueCompressor<PAGVariable>> VC) noexcept
+        : VC(std::move(VC)) {}
+    virtual ~UnionFindAAResultConcept() = default;
+
+    virtual void forallAliasesOf(v_t Ptr, n_t Inst,
+                                 llvm::function_ref<void(v_t)> Callback) = 0;
+
+    virtual AliasResult alias(v_t Ptr1, v_t Ptr2, n_t AtInstruction) = 0;
+
+    virtual AliasSetPtrTy
+    constructAliasSet(ValueId ValId, n_t Inst,
+                      AliasSetOwner<AliasSetTy> &Owner) = 0;
+
+    virtual AllocationSiteSetPtrTy
+    constructReachableAllocSites(v_t V, ValueId ValId, bool IntraProcOnly,
+                                 n_t Inst) = 0;
+  };
+
+  template <template <typename, typename> typename AAResIterT, typename AAResT>
+  struct UnionFindAAResultModel;
+
+  [[nodiscard]] static BoxedPtr<AliasSetTy> getEmptyAliasSet();
+
+  std::unique_ptr<UnionFindAAResultConcept> AARes{};
+  AnalysisProperties Props{};
+
+  AliasSetOwner<AliasSetTy>::memory_resource_type MRes{};
+  AliasSetOwner<AliasSetTy> Owner{&MRes};
+  TypedVector<ValueId, AliasSetPtrTy> AliasSets;
+};
+} // namespace psr
diff --git a/include/phasar/Pointer/AliasAnalysisType.def b/include/phasar/Pointer/AliasAnalysisType.def
index c65c28b105..258819b378 100644
--- a/include/phasar/Pointer/AliasAnalysisType.def
+++ b/include/phasar/Pointer/AliasAnalysisType.def
@@ -15,6 +15,7 @@ ALIAS_ANALYSIS_TYPE(Basic, "basic", "Basic LLVM alias resolving based on simple,
 ALIAS_ANALYSIS_TYPE(CFLSteens, "cflsteens", "Steensgaard-style alias analysis (equality-based)")
 ALIAS_ANALYSIS_TYPE(CFLAnders, "cflanders", "Andersen-style alias analysis (subset-based) (default)")
 ALIAS_ANALYSIS_TYPE(PointsTo, "points-to", "Alias-information based on (external) points-to information")
+ALIAS_ANALYSIS_TYPE(UnionFind, "union-find", "Steensgaard-style alias analysis based on union-find structures")
 
 #ifdef PHASAR_USE_SVF
 ALIAS_ANALYSIS_TYPE(SVFDDA, "svf-dda", "Alias-information based on SVF's ContextDDA analysis. Requires SVF.")
diff --git a/lib/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.cpp b/lib/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.cpp
new file mode 100644
index 0000000000..588f9682cf
--- /dev/null
+++ b/lib/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.cpp
@@ -0,0 +1,171 @@
+#include "phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h"
+
+#include "phasar/PhasarLLVM/ControlFlow/EntryFunctionUtils.h"
+#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraphBuilder.h"
+#include "phasar/PhasarLLVM/ControlFlow/LLVMVFTableProvider.h"
+#include "phasar/PhasarLLVM/ControlFlow/Resolver/RTAResolver.h"
+#include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
+#include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
+#include "phasar/Pointer/RawAliasSet.h"
+#include "phasar/Pointer/UnionFindAA.h"
+#include "phasar/Utils/MaybeUniquePtr.h"
+#include "phasar/Utils/ValueCompressor.h"
+
+#include "llvm/IR/Argument.h"
+#include "llvm/IR/InstrTypes.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/Support/Casting.h"
+
+#include <memory>
+#include <type_traits>
+
+#include <llvm-16/llvm/Support/ErrorHandling.h>
+
+using namespace psr;
+
+static inline bool isPotentialAllocSite(const llvm::Value *Val) {
+  if (!Val->getType()->isPointerTy()) {
+    return false;
+  }
+  if (llvm::isa<llvm::AllocaInst, llvm::Argument>(Val)) {
+    return true;
+  }
+  if (const auto *Call = llvm::dyn_cast<llvm::CallBase>(Val)) {
+    return Call->getCalledFunction() &&
+           psr::isHeapAllocatingFunction(Call->getCalledFunction());
+  }
+  return false;
+}
+
+template <template <typename, typename> typename AAResIterT, typename AAResT>
+struct [[clang::internal_linkage]] LLVMUnionFindAliasSet::UnionFindAAResultModel
+    : public UnionFindAAResultConcept,
+      public AAResIterT<UnionFindAAResultModel<AAResIterT, AAResT>, AAResT> {
+
+  using base_t = AAResIterT<UnionFindAAResultModel<AAResIterT, AAResT>, AAResT>;
+
+  template <typename... ArgsT>
+  constexpr UnionFindAAResultModel(
+      MaybeUniquePtr<const ValueCompressor<PAGVariable>> VC, ArgsT &&...Args)
+      : UnionFindAAResultConcept{std::move(VC)}, base_t{PSR_FWD(Args)...} {}
+
+  void forallAliasesOf(v_t Ptr, n_t Inst,
+                       llvm::function_ref<void(v_t)> Callback) override {
+    this->base_t::forallAliasesOf(Ptr, Inst, Callback);
+  }
+
+  AliasResult alias(v_t Ptr1, v_t Ptr2, n_t AtInstruction = nullptr) override {
+    return this->base_t::alias(Ptr1, Ptr2, AtInstruction);
+  }
+
+  AliasSetPtrTy constructAliasSet(ValueId ValId, n_t Inst,
+                                  AliasSetOwner<AliasSetTy> &Owner) override {
+    auto ASet = Owner.acquire();
+    try {
+      this->base_t::forallAliasesOf(
+          ValId, Inst,
+          [ASet{ASet.get()}](v_t Alias) -> void { ASet->insert(Alias); });
+      return ASet;
+    } catch (...) {
+      Owner.release(ASet.get());
+      throw;
+    }
+  }
+
+  AllocationSiteSetPtrTy constructReachableAllocSites(v_t V, ValueId ValId,
+                                                      bool IntraProcOnly,
+                                                      n_t Inst) override {
+    if (!this->AllocationSites) [[unlikely]] {
+      this->AllocationSites.emplace();
+      for (const auto &[VId, Vars] : this->VC->id2vars().enumerate()) {
+        for (const PAGVariable &Var : Vars) {
+          if (const auto *LLVMVar = Var.valueOrNull();
+              LLVMVar && isPotentialAllocSite(LLVMVar)) {
+            this->AllocationSites->insert(VId);
+            break;
+          }
+        }
+      }
+    }
+
+    auto RawAliases = [&]() -> RawAliasSet<ValueId> {
+      if constexpr (requires() { this->base_t::getRawAliasSet(ValId, Inst); }) {
+        return this->base_t::getRawAliasSet(ValId, Inst);
+      } else {
+        return this->base_t::getRawAliasSet(ValId);
+      }
+    }();
+    RawAliases &= *this->AllocationSites;
+
+    auto Ret = std::make_unique<AliasSetTy>();
+
+    RawAliases.foreach (llvmUnionFindAliasHandler(
+        *this->VC, [&Ret, V, IntraProcOnly](v_t Alias) {
+          if (psr::isInReachableAllocationSitesTy(V, Alias, IntraProcOnly)) {
+            Ret->insert(Alias);
+          }
+        }));
+
+    return Ret;
+  }
+};
+
+LLVMUnionFindAliasSet::LLVMUnionFindAliasSet(const LLVMProjectIRDB *IRDB,
+                                             Config Cfg,
+                                             ValueCompressor<PAGVariable> *VC) {
+  MaybeUniquePtr<ValueCompressor<PAGVariable>> VCOwn = VC;
+  if (!VC) {
+    VCOwn = std::make_unique<ValueCompressor<PAGVariable>>();
+  }
+
+  const auto MakeAAResModel =
+      [Cfg, &VC]<UnionFindAAResult AAResT>(
+          AAResT &&AARes) -> std::unique_ptr<UnionFindAAResultConcept> {
+    if (Cfg.ALocality == AnalysisLocality::FunctionLocal) {
+      const auto &VCRef = *VC;
+      return std::make_unique<UnionFindAAResultModel<
+          LLVMLocalUnionFindAliasIteratorMixin, std::remove_cvref_t<AAResT>>>(
+          std::move(VC), PSR_FWD(AARes), VCRef);
+    }
+
+    return std::make_unique<UnionFindAAResultModel<
+        LLVMUnionFindAliasIteratorMixin, std::remove_cvref_t<AAResT>>>(
+        std::move(VC), PSR_FWD(AARes));
+  };
+
+  auto VTP = LLVMVFTableProvider(*IRDB);
+  auto TH = DIBasedTypeHierarchy(*IRDB);
+  auto Res = RTAResolver(IRDB, &VTP, &TH);
+  const auto BaseCG = buildLLVMBasedCallGraph(
+      *IRDB, Res, getEntryFunctions(*IRDB, getDefaultEntryPoints(*IRDB)));
+
+  switch (Cfg.AType) {
+  case AnalysisType::CtxSens:
+    AARes = MakeAAResModel(computeCtxSensUnionFindAARaw(*IRDB, BaseCG));
+    return;
+  case AnalysisType::IndSens:
+    AARes = MakeAAResModel(computeIndSensUnionFindAARaw(*IRDB, BaseCG));
+    return;
+  case AnalysisType::CtxIndSens:
+    AARes = MakeAAResModel(computeCtxIndSensUnionFindAARaw(*IRDB, BaseCG));
+    return;
+  case AnalysisType::BotCtxSens:
+    AARes = MakeAAResModel(computeBotCtxSensUnionFindAARaw(*IRDB, BaseCG));
+    return;
+  case AnalysisType::BotCtxIndSens:
+    AARes = MakeAAResModel(computeBotCtxIndSensUnionFindAARaw(*IRDB, BaseCG));
+    return;
+  }
+
+  llvm_unreachable(
+      "We should have handled all AnalysisType values in the switch above");
+}
+
+auto LLVMUnionFindAliasSet::getEmptyAliasSet() -> BoxedPtr<AliasSetTy> {
+  static AliasSetTy EmptySet{};
+  static AliasSetTy *EmptySetPtr = &EmptySet;
+  return &EmptySetPtr;
+}

From 095e15751fe601c419d311d8b66fa9c8b6bbcef5 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Tue, 27 Jan 2026 15:18:04 +0100
Subject: [PATCH 29/75] Continue with LLVMUnionFindAliasSet

---
 .../PhasarLLVM/Pointer/LLVMUnionFindAA.h      | 15 +++++++++++--
 .../Pointer/LLVMUnionFindAliasSet.h           | 12 +++++++++-
 include/phasar/Pointer/AliasInfoBase.h        | 16 +++++++++-----
 include/phasar/Pointer/AliasIterator.h        |  2 +-
 lib/PhasarLLVM/Pointer/AliasAnalysisView.cpp  |  7 ++++++
 .../Pointer/LLVMUnionFindAliasSet.cpp         | 22 +++++++++++++++++--
 6 files changed, 62 insertions(+), 12 deletions(-)

diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
index 743b08b6d9..157c3e47a2 100644
--- a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
@@ -15,6 +15,9 @@
 #include "phasar/Utils/Utilities.h"
 #include "phasar/Utils/ValueCompressor.h"
 
+#include "llvm/IR/Instructions.h"
+#include "llvm/Support/Casting.h"
+
 #include <memory>
 #include <type_traits>
 
@@ -115,7 +118,11 @@ struct LLVMUnionFindAliasIteratorMixin {
       return AliasResult::NoAlias;
     }
     if (*ValId1 == *ValId2) {
-      return AliasResult::MustAlias;
+      // TODO: Check exactly the conditions for must alias!
+      return !llvm::isa<llvm::LoadInst>(Ptr1) &&
+                     !llvm::isa<llvm::LoadInst>(Ptr2)
+                 ? AliasResult::MustAlias
+                 : AliasResult::MayAlias;
     }
     return mayAlias(*ValId1, *ValId2, AtInstruction) ? AliasResult::MayAlias
                                                      : AliasResult::NoAlias;
@@ -252,7 +259,11 @@ class LLVMLocalUnionFindAliasIteratorMixin
       return AliasResult::NoAlias;
     }
     if (*ValId1 == *ValId2) {
-      return AliasResult::MustAlias;
+      // TODO: Check exactly the conditions for must alias!
+      return !llvm::isa<llvm::LoadInst>(Ptr1) &&
+                     !llvm::isa<llvm::LoadInst>(Ptr2)
+                 ? AliasResult::MustAlias
+                 : AliasResult::MayAlias;
     }
     return mayAlias(*ValId1, *ValId2, AtInstruction) ? AliasResult::MayAlias
                                                      : AliasResult::NoAlias;
diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h
index 3454f11e5a..363bd58b34 100644
--- a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h
@@ -66,7 +66,7 @@ class LLVMUnionFindAliasSet
   explicit LLVMUnionFindAliasSet(const LLVMProjectIRDB *IRDB)
       : LLVMUnionFindAliasSet(IRDB, Config{}, nullptr) {}
 
-  [[nodiscard]] constexpr std::false_type isInterProcedural() const noexcept {
+  [[nodiscard]] constexpr std::true_type isInterProcedural() const noexcept {
     return {};
   };
 
@@ -82,15 +82,18 @@ class LLVMUnionFindAliasSet
   }
 
   [[nodiscard]] constexpr AliasResult alias(v_t V1, v_t V2, n_t I) const {
+    assert(isValid());
     return AARes->alias(V1, V2, I);
   }
 
   void foreachAliasOf(v_t V, n_t I,
                       llvm::function_ref<void(v_t)> WithAlias) const {
+    assert(isValid());
     AARes->forallAliasesOf(V, I, WithAlias);
   }
 
   [[nodiscard]] AliasSetPtrTy getAliasSet(v_t V, n_t I) {
+    assert(isValid());
     auto ValId = AARes->VC->getOrNull(V);
     if (!ValId) {
       return getEmptyAliasSet();
@@ -106,6 +109,7 @@ class LLVMUnionFindAliasSet
 
   [[nodiscard]] AllocationSiteSetPtrTy
   getReachableAllocationSites(v_t V, bool IntraProcOnly, n_t I) const {
+    assert(isValid());
     auto ValId = AARes->VC->getOrNull(V);
     if (!ValId) {
       return std::make_unique<AliasSetTy>();
@@ -117,6 +121,7 @@ class LLVMUnionFindAliasSet
   [[nodiscard]] bool isInReachableAllocationSites(
       const llvm::Value *V, const llvm::Value *PotentialValue,
       bool IntraProcOnly, const llvm::Instruction *I) const {
+    assert(isValid());
     if (!psr::isInterestingPointer(V)) {
       return false;
     }
@@ -129,6 +134,11 @@ class LLVMUnionFindAliasSet
     return alias(V, PotentialValue, I) != AliasResult::NoAlias;
   }
 
+  [[nodiscard]] bool isValid() const noexcept {
+    return AARes != nullptr && Props != AnalysisProperties::None &&
+           AARes->VC != nullptr && AARes->VC->size() == AliasSets.size();
+  }
+
 private:
   struct UnionFindAAResultConcept {
     MaybeUniquePtr<const ValueCompressor<PAGVariable>> VC;
diff --git a/include/phasar/Pointer/AliasInfoBase.h b/include/phasar/Pointer/AliasInfoBase.h
index 0892b92171..f93020c921 100644
--- a/include/phasar/Pointer/AliasInfoBase.h
+++ b/include/phasar/Pointer/AliasInfoBase.h
@@ -43,8 +43,10 @@ concept IsAliasInfo =
       MutVal.mergeWith(MutVal);
       MutVal.introduceAlias(Ptr, Ptr, Inst, AliasResult{});
 
-      { CVal.isInterProcedural() } -> std::convertible_to<bool>;
-      { CVal.getAliasAnalysisType() } -> std::same_as<AliasAnalysisType>;
+      { CVal.isInterProcedural() } noexcept -> std::convertible_to<bool>;
+      {
+        CVal.getAliasAnalysisType()
+      } noexcept -> std::convertible_to<AliasAnalysisType>;
       { MutVal.alias(Ptr, Ptr, Inst) } -> std::same_as<AliasResult>;
       {
         MutVal.getAliasSet(Ptr, Inst)
@@ -55,10 +57,12 @@ concept IsAliasInfo =
       {
         MutVal.isInReachableAllocationSites(Ptr, Ptr, bool{}, Inst)
       } -> std::convertible_to<bool>;
-      { CVal.getAnalysisProperties() } -> std::same_as<AnalysisProperties>;
-      { CVal.isContextSensitive() } -> std::convertible_to<bool>;
-      { CVal.isFieldSensitive() } -> std::convertible_to<bool>;
-      { CVal.isFlowSensitive() } -> std::convertible_to<bool>;
+      {
+        CVal.getAnalysisProperties()
+      } noexcept -> std::convertible_to<AnalysisProperties>;
+      { CVal.isContextSensitive() } noexcept -> std::convertible_to<bool>;
+      { CVal.isFieldSensitive() } noexcept -> std::convertible_to<bool>;
+      { CVal.isFlowSensitive() } noexcept -> std::convertible_to<bool>;
     };
 
 } // namespace psr
diff --git a/include/phasar/Pointer/AliasIterator.h b/include/phasar/Pointer/AliasIterator.h
index 1e139c88f0..f3944e81f9 100644
--- a/include/phasar/Pointer/AliasIterator.h
+++ b/include/phasar/Pointer/AliasIterator.h
@@ -34,7 +34,7 @@ concept IsAliasIteratorFor =
 
 template <typename T>
 concept HasAlias = requires(T &AS, typename T::v_t Ptr, typename T::n_t Inst) {
-  { AS.alias(Ptr, Ptr, Inst) } -> std::same_as<AliasResult>;
+  { AS.alias(Ptr, Ptr, Inst) } -> std::convertible_to<AliasResult>;
 };
 
 template <typename T>
diff --git a/lib/PhasarLLVM/Pointer/AliasAnalysisView.cpp b/lib/PhasarLLVM/Pointer/AliasAnalysisView.cpp
index 0ecf705e40..31fba0689c 100644
--- a/lib/PhasarLLVM/Pointer/AliasAnalysisView.cpp
+++ b/lib/PhasarLLVM/Pointer/AliasAnalysisView.cpp
@@ -1,6 +1,9 @@
 #include "phasar/PhasarLLVM/Pointer/AliasAnalysisView.h"
 
 #include "phasar/Config/phasar-config.h" // for PHASAR_USE_SVF
+#include "phasar/Pointer/AliasAnalysisType.h"
+
+#include "llvm/Support/ErrorHandling.h"
 
 #ifdef PHASAR_USE_SVF
 #include "SVF/SVFBasedAliasAnalysis.h"
@@ -21,6 +24,10 @@ AliasAnalysisView::create(LLVMProjectIRDB &IRDB, bool UseLazyEvaluation,
   case AliasAnalysisType::SVFVFS:
     return createSVFVFSAnalysis(IRDB);
 #endif
+  case AliasAnalysisType::UnionFind:
+    llvm::report_fatal_error(
+        "Cannot use AliasAnalysisType::UnionFind with LLVMAliasSet. Use "
+        "LLVMUnionFindAliasSet instead!");
   default:
     return createLLVMBasedAnalysis(IRDB, UseLazyEvaluation, PATy);
   }
diff --git a/lib/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.cpp b/lib/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.cpp
index 588f9682cf..af8f9288b2 100644
--- a/lib/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.cpp
+++ b/lib/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.cpp
@@ -11,7 +11,10 @@
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
 #include "phasar/Pointer/RawAliasSet.h"
 #include "phasar/Pointer/UnionFindAA.h"
+#include "phasar/Utils/AnalysisProperties.h"
+#include "phasar/Utils/EnumFlags.h"
 #include "phasar/Utils/MaybeUniquePtr.h"
+#include "phasar/Utils/Utilities.h"
 #include "phasar/Utils/ValueCompressor.h"
 
 #include "llvm/IR/Argument.h"
@@ -22,8 +25,6 @@
 #include <memory>
 #include <type_traits>
 
-#include <llvm-16/llvm/Support/ErrorHandling.h>
-
 using namespace psr;
 
 static inline bool isPotentialAllocSite(const llvm::Value *Val) {
@@ -142,20 +143,37 @@ LLVMUnionFindAliasSet::LLVMUnionFindAliasSet(const LLVMProjectIRDB *IRDB,
   const auto BaseCG = buildLLVMBasedCallGraph(
       *IRDB, Res, getEntryFunctions(*IRDB, getDefaultEntryPoints(*IRDB)));
 
+  scope_exit ResizeAliasSetCache = [&] {
+    if (!AARes) {
+      // Something went wrong and we hopefully have an in-flight
+      // exception...
+      return;
+    }
+
+    AliasSets.resize(AARes->VC->size());
+  };
+
   switch (Cfg.AType) {
   case AnalysisType::CtxSens:
+    Props = AnalysisProperties::ContextSensitive;
     AARes = MakeAAResModel(computeCtxSensUnionFindAARaw(*IRDB, BaseCG));
     return;
   case AnalysisType::IndSens:
+    Props = AnalysisProperties::FieldSensitive;
     AARes = MakeAAResModel(computeIndSensUnionFindAARaw(*IRDB, BaseCG));
     return;
   case AnalysisType::CtxIndSens:
+    Props = AnalysisProperties::ContextSensitive |
+            AnalysisProperties::FieldSensitive;
     AARes = MakeAAResModel(computeCtxIndSensUnionFindAARaw(*IRDB, BaseCG));
     return;
   case AnalysisType::BotCtxSens:
+    Props = AnalysisProperties::ContextSensitive;
     AARes = MakeAAResModel(computeBotCtxSensUnionFindAARaw(*IRDB, BaseCG));
     return;
   case AnalysisType::BotCtxIndSens:
+    Props = AnalysisProperties::ContextSensitive |
+            AnalysisProperties::FieldSensitive;
     AARes = MakeAAResModel(computeBotCtxIndSensUnionFindAARaw(*IRDB, BaseCG));
     return;
   }

From 6219e669792a2871f258e1c645114eed3bad0cf4 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Mon, 2 Feb 2026 16:11:11 +0100
Subject: [PATCH 30/75] Integrate Union-Find-AA into phasar-cli

---
 include/phasar/PhasarLLVM/HelperAnalyses.h    |   7 +-
 .../phasar/PhasarLLVM/HelperAnalysisConfig.h  |   2 +
 .../PhasarLLVM/Pointer/LLVMUnionFindAA.h      |  57 ++++++----
 .../Pointer/LLVMUnionFindAliasSet.h           |  26 +++--
 .../PhasarLLVM/SimpleAnalysisConstructor.h    |  22 ++--
 include/phasar/Pointer/AliasInfo.h            |  27 +++--
 include/phasar/Pointer/AliasInfoBase.h        |   4 +-
 include/phasar/Pointer/UnionFindAAType.def    |  20 ++++
 .../Pointer/UnionFindAliasAnalysisType.h      |  29 +++++
 lib/PhasarLLVM/HelperAnalyses.cpp             |  17 ++-
 lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp    |  75 +++++++------
 .../Pointer/LLVMUnionFindAliasSet.cpp         | 104 +++++++++++++-----
 lib/Pointer/UnionFindAA.cpp                   |   2 +-
 .../AnalysisControllerInternalIDE.h           |   2 +-
 tools/phasar-cli/phasar-cli.cpp               |  48 +++++---
 15 files changed, 304 insertions(+), 138 deletions(-)
 create mode 100644 include/phasar/Pointer/UnionFindAAType.def
 create mode 100644 include/phasar/Pointer/UnionFindAliasAnalysisType.h

diff --git a/include/phasar/PhasarLLVM/HelperAnalyses.h b/include/phasar/PhasarLLVM/HelperAnalyses.h
index 63b9044444..156e1622bf 100644
--- a/include/phasar/PhasarLLVM/HelperAnalyses.h
+++ b/include/phasar/PhasarLLVM/HelperAnalyses.h
@@ -13,7 +13,9 @@
 #include "phasar/ControlFlow/CallGraphAnalysisType.h"
 #include "phasar/ControlFlow/CallGraphData.h"
 #include "phasar/PhasarLLVM/HelperAnalysisConfig.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasSetData.h"
+#include "phasar/Pointer/UnionFindAliasAnalysisType.h"
 
 #include "llvm/ADT/Twine.h"
 
@@ -60,14 +62,14 @@ class HelperAnalyses { // NOLINT(cppcoreguidelines-special-member-functions)
   ~HelperAnalyses() noexcept;
 
   [[nodiscard]] LLVMProjectIRDB &getProjectIRDB();
-  [[nodiscard]] LLVMAliasSet &getAliasInfo();
+  [[nodiscard]] LLVMAliasInfoRef getAliasInfo();
   [[nodiscard]] DIBasedTypeHierarchy &getTypeHierarchy();
   [[nodiscard]] LLVMBasedICFG &getICFG();
   [[nodiscard]] LLVMBasedCFG &getCFG();
 
 private:
   std::unique_ptr<LLVMProjectIRDB> IRDB;
-  std::unique_ptr<LLVMAliasSet> PT;
+  LLVMAliasInfo PT{};
   std::unique_ptr<DIBasedTypeHierarchy> TH;
   std::unique_ptr<LLVMBasedICFG> ICF;
   std::unique_ptr<LLVMBasedCFG> CFG;
@@ -78,6 +80,7 @@ class HelperAnalyses { // NOLINT(cppcoreguidelines-special-member-functions)
   // PTS
   std::optional<LLVMAliasSetData> PrecomputedPTS;
   AliasAnalysisType PTATy{};
+  UnionFindAliasAnalysisType UFAATy{};
   bool AllowLazyPTS{};
 
   // ICF
diff --git a/include/phasar/PhasarLLVM/HelperAnalysisConfig.h b/include/phasar/PhasarLLVM/HelperAnalysisConfig.h
index be3427667b..d29c12c68d 100644
--- a/include/phasar/PhasarLLVM/HelperAnalysisConfig.h
+++ b/include/phasar/PhasarLLVM/HelperAnalysisConfig.h
@@ -14,6 +14,7 @@
 #include "phasar/ControlFlow/CallGraphData.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasSetData.h"
 #include "phasar/Pointer/AliasAnalysisType.h"
+#include "phasar/Pointer/UnionFindAliasAnalysisType.h"
 #include "phasar/Utils/Soundness.h"
 
 #include <optional>
@@ -23,6 +24,7 @@ struct HelperAnalysisConfig {
   std::optional<LLVMAliasSetData> PrecomputedPTS = std::nullopt;
   std::optional<CallGraphData> PrecomputedCG = std::nullopt;
   AliasAnalysisType PTATy = AliasAnalysisType::CFLAnders;
+  UnionFindAliasAnalysisType UFAATy = UnionFindAliasAnalysisType::CtxIndSens;
   CallGraphAnalysisType CGTy = CallGraphAnalysisType::OTF;
   Soundness SoundnessLevel = Soundness::Soundy;
   bool AutoGlobalSupport = true;
diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
index 157c3e47a2..1a64df20c2 100644
--- a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
@@ -71,6 +71,8 @@ struct LLVMUnionFindAliasIteratorMixin {
     return AARes.getRawAliasSet(ValId);
   }
 
+  [[nodiscard]] const auto &base() const noexcept { return AARes; }
+
   void
   forallAliasesOf(ValueId VId, const auto & /*Inst*/,
                   std::invocable<const llvm::Value *> auto Callback) const {
@@ -189,6 +191,8 @@ class LLVMLocalUnionFindAliasIteratorMixin
     return Vars;
   }
 
+  [[nodiscard]] const auto &base() const noexcept { return AARes; }
+
   [[nodiscard]] auto getRawAliasSet(ValueId ValId,
                                     const llvm::Instruction *Context) const {
     return getRawAliasSet(ValId, getFunction(Context));
@@ -328,23 +332,25 @@ computeUnionFindAARaw(const LLVMProjectIRDB &IRDB, AnalysisT &&Ana,
   return computeUnionFindAARaw(IRDB, Strategy, std::move(VC), std::move(Impl));
 }
 
-[[nodiscard]] CallingContextSensUnionFindAAResult
-computeCtxSensUnionFindAARaw(const LLVMProjectIRDB &IRDB,
-                             const LLVMBasedCallGraph &CG);
-[[nodiscard]] BasicUnionFindAAResult
-computeBotCtxSensUnionFindAARaw(const LLVMProjectIRDB &IRDB,
-                                const LLVMBasedCallGraph &CG);
-[[nodiscard]] BasicUnionFindAAResult
-computeIndSensUnionFindAARaw(const LLVMProjectIRDB &IRDB,
-                             const LLVMBasedCallGraph &CG);
+[[nodiscard]] CallingContextSensUnionFindAAResult computeCtxSensUnionFindAARaw(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr);
+[[nodiscard]] BasicUnionFindAAResult computeBotCtxSensUnionFindAARaw(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr);
+[[nodiscard]] BasicUnionFindAAResult computeIndSensUnionFindAARaw(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr);
 [[nodiscard]] UnionFindAAResultIntersection<CallingContextSensUnionFindAAResult,
                                             BasicUnionFindAAResult>
-computeCtxIndSensUnionFindAARaw(const LLVMProjectIRDB &IRDB,
-                                const LLVMBasedCallGraph &CG);
+computeCtxIndSensUnionFindAARaw(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr);
 [[nodiscard]] UnionFindAAResultIntersection<BasicUnionFindAAResult,
                                             BasicUnionFindAAResult>
-computeBotCtxIndSensUnionFindAARaw(const LLVMProjectIRDB &IRDB,
-                                   const LLVMBasedCallGraph &CG);
+computeBotCtxIndSensUnionFindAARaw(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr);
 
 template <pag::PBStrategy AnalysisT,
           std::derived_from<PAGBuilder<LLVMPAGDomain>> PAGBuilderImpl =
@@ -381,21 +387,26 @@ computeUnionFindAA(const LLVMProjectIRDB &IRDB, AnalysisT &&Ana,
 }
 
 [[nodiscard]] LLVMUnionFindAliasIterator<CallingContextSensUnionFindAAResult>
-computeCtxSensUnionFindAA(const LLVMProjectIRDB &IRDB,
-                          const LLVMBasedCallGraph &CG);
+computeCtxSensUnionFindAA(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr);
 [[nodiscard]] LLVMUnionFindAliasIterator<BasicUnionFindAAResult>
-computeBotCtxSensUnionFindAA(const LLVMProjectIRDB &IRDB,
-                             const LLVMBasedCallGraph &CG);
+computeBotCtxSensUnionFindAA(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr);
 [[nodiscard]] LLVMUnionFindAliasIterator<BasicUnionFindAAResult>
-computeIndSensUnionFindAA(const LLVMProjectIRDB &IRDB,
-                          const LLVMBasedCallGraph &CG);
+computeIndSensUnionFindAA(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr);
 [[nodiscard]] LLVMUnionFindAliasIterator<UnionFindAAResultIntersection<
     CallingContextSensUnionFindAAResult, BasicUnionFindAAResult>>
-computeCtxIndSensUnionFindAA(const LLVMProjectIRDB &IRDB,
-                             const LLVMBasedCallGraph &CG);
+computeCtxIndSensUnionFindAA(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr);
 [[nodiscard]] LLVMUnionFindAliasIterator<UnionFindAAResultIntersection<
     BasicUnionFindAAResult, BasicUnionFindAAResult>>
-computeBotCtxIndSensUnionFindAA(const LLVMProjectIRDB &IRDB,
-                                const LLVMBasedCallGraph &CG);
+computeBotCtxIndSensUnionFindAA(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr);
 
 } // namespace psr
diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h
index 363bd58b34..e454b0aa7d 100644
--- a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h
@@ -8,6 +8,7 @@
 #include "phasar/Pointer/AliasResult.h"
 #include "phasar/Pointer/AliasSetOwner.h"
 #include "phasar/Pointer/RawAliasSet.h"
+#include "phasar/Pointer/UnionFindAliasAnalysisType.h"
 #include "phasar/Utils/AnalysisProperties.h"
 #include "phasar/Utils/TypedVector.h"
 #include "phasar/Utils/ValueCompressor.h"
@@ -39,23 +40,15 @@ class LLVMUnionFindAliasSet
   using AliasSetTy = traits_t::AliasSetTy;
   using AliasSetPtrTy = traits_t::AliasSetPtrTy;
   using AllocationSiteSetPtrTy = traits_t::AllocationSiteSetPtrTy;
-  using AliasSetMap = llvm::DenseMap<const llvm::Value *, BoxedPtr<AliasSetTy>>;
-
-  enum class AnalysisType {
-    CtxSens,
-    IndSens,
-    CtxIndSens,
-    BotCtxSens,
-    BotCtxIndSens,
-  };
 
-  enum class AnalysisLocality {
+  enum class AnalysisLocality : uint8_t {
     Global,
     FunctionLocal,
   };
 
   struct Config {
-    AnalysisType AType = AnalysisType::BotCtxIndSens;
+    UnionFindAliasAnalysisType AType =
+        UnionFindAliasAnalysisType::BotCtxIndSens;
     AnalysisLocality ALocality = AnalysisLocality::Global;
   };
 
@@ -134,6 +127,9 @@ class LLVMUnionFindAliasSet
     return alias(V, PotentialValue, I) != AliasResult::NoAlias;
   }
 
+  void print(llvm::raw_ostream &OS) const;
+  void printAsJson(llvm::raw_ostream &OS) const;
+
   [[nodiscard]] bool isValid() const noexcept {
     return AARes != nullptr && Props != AnalysisProperties::None &&
            AARes->VC != nullptr && AARes->VC->size() == AliasSets.size();
@@ -161,6 +157,8 @@ class LLVMUnionFindAliasSet
     virtual AllocationSiteSetPtrTy
     constructReachableAllocSites(v_t V, ValueId ValId, bool IntraProcOnly,
                                  n_t Inst) = 0;
+
+    virtual void print(llvm::raw_ostream &OS, Config Cfg) const = 0;
   };
 
   template <template <typename, typename> typename AAResIterT, typename AAResT>
@@ -168,11 +166,17 @@ class LLVMUnionFindAliasSet
 
   [[nodiscard]] static BoxedPtr<AliasSetTy> getEmptyAliasSet();
 
+  // --- data members:
+
   std::unique_ptr<UnionFindAAResultConcept> AARes{};
   AnalysisProperties Props{};
+  Config Cfg{};
 
   AliasSetOwner<AliasSetTy>::memory_resource_type MRes{};
   AliasSetOwner<AliasSetTy> Owner{&MRes};
   TypedVector<ValueId, AliasSetPtrTy> AliasSets;
 };
+
+[[nodiscard]] llvm::StringRef
+to_string(LLVMUnionFindAliasSet::AnalysisLocality ALoc) noexcept;
 } // namespace psr
diff --git a/include/phasar/PhasarLLVM/SimpleAnalysisConstructor.h b/include/phasar/PhasarLLVM/SimpleAnalysisConstructor.h
index e6e80094a9..51a450c3c6 100644
--- a/include/phasar/PhasarLLVM/SimpleAnalysisConstructor.h
+++ b/include/phasar/PhasarLLVM/SimpleAnalysisConstructor.h
@@ -17,7 +17,6 @@
 
 namespace psr {
 class LLVMProjectIRDB;
-class LLVMAliasSet;
 class LLVMBasedICFG;
 class DIBasedTypeHierarchy;
 
@@ -36,26 +35,27 @@ ProblemTy createAnalysisProblem(HelperAnalyses &HA, ArgTys &&...Args) {
                      std::forward<ArgTys>(Args)...);
   } else if constexpr (std::is_constructible_v<ProblemTy,
                                                const LLVMProjectIRDB *,
-                                               LLVMAliasSet *, ArgTys...>) {
-    return ProblemTy(&HA.getProjectIRDB(), &HA.getAliasInfo(),
+                                               LLVMAliasInfoRef, ArgTys...>) {
+    return ProblemTy(&HA.getProjectIRDB(), HA.getAliasInfo(),
                      std::forward<ArgTys>(Args)...);
-  } else if constexpr (std::is_constructible_v<
-                           ProblemTy, const LLVMProjectIRDB *,
-                           const LLVMBasedICFG *, LLVMAliasSet *, ArgTys...>) {
-    return ProblemTy(&HA.getProjectIRDB(), &HA.getICFG(), &HA.getAliasInfo(),
+  } else if constexpr (std::is_constructible_v<ProblemTy,
+                                               const LLVMProjectIRDB *,
+                                               const LLVMBasedICFG *,
+                                               LLVMAliasInfoRef, ArgTys...>) {
+    return ProblemTy(&HA.getProjectIRDB(), &HA.getICFG(), HA.getAliasInfo(),
                      std::forward<ArgTys>(Args)...);
   } else if constexpr (std::is_constructible_v<
                            ProblemTy, const LLVMProjectIRDB *,
                            const DIBasedTypeHierarchy *, const LLVMBasedCFG *,
-                           LLVMAliasSet *, ArgTys...>) {
+                           LLVMAliasInfoRef, ArgTys...>) {
     return ProblemTy(&HA.getProjectIRDB(), &HA.getTypeHierarchy(), &HA.getCFG(),
-                     &HA.getAliasInfo(), std::forward<ArgTys>(Args)...);
+                     HA.getAliasInfo(), std::forward<ArgTys>(Args)...);
   } else if constexpr (std::is_constructible_v<
                            ProblemTy, const LLVMProjectIRDB *,
                            const DIBasedTypeHierarchy *, const LLVMBasedICFG *,
-                           LLVMAliasSet *, ArgTys...>) {
+                           LLVMAliasInfoRef, ArgTys...>) {
     return ProblemTy(&HA.getProjectIRDB(), &HA.getTypeHierarchy(),
-                     &HA.getICFG(), &HA.getAliasInfo(),
+                     &HA.getICFG(), HA.getAliasInfo(),
                      std::forward<ArgTys>(Args)...);
   } else {
     static_assert(
diff --git a/include/phasar/Pointer/AliasInfo.h b/include/phasar/Pointer/AliasInfo.h
index bd2daa3314..67fecbc82d 100644
--- a/include/phasar/Pointer/AliasInfo.h
+++ b/include/phasar/Pointer/AliasInfo.h
@@ -232,10 +232,10 @@ class [[gsl::Pointer]] AliasInfoRef
         return static_cast<ConcreteAA *>(AA)->alias(Pointer1, Pointer2,
                                                     AtInstruction);
       },
-      [](const void *AA) noexcept {
+      [](const void *AA) noexcept -> bool {
         return static_cast<const ConcreteAA *>(AA)->isInterProcedural();
       },
-      [](const void *AA) noexcept {
+      [](const void *AA) noexcept -> AliasAnalysisType {
         return static_cast<const ConcreteAA *>(AA)->getAliasAnalysisType();
       },
       [](void *AA, ByConstRef<v_t> Pointer, ByConstRef<n_t> AtInstruction) {
@@ -259,15 +259,28 @@ class [[gsl::Pointer]] AliasInfoRef
         static_cast<const ConcreteAA *>(AA)->printAsJson(OS);
       },
       [](void *AA, void *Other) {
-        static_cast<ConcreteAA *>(AA)->mergeWith(
-            *static_cast<ConcreteAA *>(Other));
+        if constexpr (requires(ConcreteAA &CAA) { CAA.mergeWith(CAA); }) {
+          static_cast<ConcreteAA *>(AA)->mergeWith(
+              *static_cast<ConcreteAA *>(Other));
+        } else {
+          llvm::report_fatal_error(llvm::getTypeName<ConcreteAA>() +
+                                   " does not support mergeWith()");
+        }
       },
       [](void *AA, ByConstRef<v_t> Pointer1, ByConstRef<v_t> Pointer2,
          ByConstRef<n_t> AtInstruction, AliasResult Kind) {
-        static_cast<ConcreteAA *>(AA)->introduceAlias(Pointer1, Pointer2,
-                                                      AtInstruction, Kind);
+        if constexpr (requires(ConcreteAA &CAA) {
+                        CAA.introduceAlias(Pointer1, Pointer2, AtInstruction,
+                                           Kind);
+                      }) {
+          static_cast<ConcreteAA *>(AA)->introduceAlias(Pointer1, Pointer2,
+                                                        AtInstruction, Kind);
+        } else {
+          llvm::report_fatal_error(llvm::getTypeName<ConcreteAA>() +
+                                   " does not support introduceAlias()");
+        }
       },
-      [](const void *AA) noexcept {
+      [](const void *AA) noexcept -> AnalysisProperties {
         return static_cast<const ConcreteAA *>(AA)->getAnalysisProperties();
       },
       []() noexcept { return llvm::getTypeName<ConcreteAA>(); },
diff --git a/include/phasar/Pointer/AliasInfoBase.h b/include/phasar/Pointer/AliasInfoBase.h
index f93020c921..1cc740e077 100644
--- a/include/phasar/Pointer/AliasInfoBase.h
+++ b/include/phasar/Pointer/AliasInfoBase.h
@@ -40,8 +40,8 @@ concept IsAliasInfo =
              typename AliasInfoTraits<T>::n_t Inst) {
       CVal.print(llvm::outs());
       CVal.printAsJson(llvm::outs());
-      MutVal.mergeWith(MutVal);
-      MutVal.introduceAlias(Ptr, Ptr, Inst, AliasResult{});
+      // MutVal.mergeWith(MutVal);
+      // MutVal.introduceAlias(Ptr, Ptr, Inst, AliasResult{});
 
       { CVal.isInterProcedural() } noexcept -> std::convertible_to<bool>;
       {
diff --git a/include/phasar/Pointer/UnionFindAAType.def b/include/phasar/Pointer/UnionFindAAType.def
new file mode 100644
index 0000000000..0a486a0584
--- /dev/null
+++ b/include/phasar/Pointer/UnionFindAAType.def
@@ -0,0 +1,20 @@
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#ifndef UNIONFIND_ALIAS_ANALYSIS_TYPE
+#define UNIONFIND_ALIAS_ANALYSIS_TYPE(NAME, CMDFLAG, DESC)
+#endif
+
+UNIONFIND_ALIAS_ANALYSIS_TYPE(CtxSens, "ctx-sens", "Context-sensitive analysis with k=1 heap-cloning")
+UNIONFIND_ALIAS_ANALYSIS_TYPE(IndSens, "ind-sens", "Pointer-indirection-sensitive analysis with k=5 heap-cloning")
+UNIONFIND_ALIAS_ANALYSIS_TYPE(CtxIndSens, "ctx-ind-sens", "Intersection of ctx-sens and ind-sens")
+UNIONFIND_ALIAS_ANALYSIS_TYPE(BotCtxSens, "botctx-sens", "Unbounded context-sensitive analysis, but only provides function-local results")
+UNIONFIND_ALIAS_ANALYSIS_TYPE(BotCtxIndSens, "botctx-ind-sens", "Intersection of botctx-sens and ind-sens")
+
+#undef UNIONFIND_ALIAS_ANALYSIS_TYPE
diff --git a/include/phasar/Pointer/UnionFindAliasAnalysisType.h b/include/phasar/Pointer/UnionFindAliasAnalysisType.h
new file mode 100644
index 0000000000..dec47142fa
--- /dev/null
+++ b/include/phasar/Pointer/UnionFindAliasAnalysisType.h
@@ -0,0 +1,29 @@
+#pragma once
+
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#include "llvm/ADT/StringRef.h"
+
+namespace psr {
+enum class UnionFindAliasAnalysisType : uint8_t {
+#define UNIONFIND_ALIAS_ANALYSIS_TYPE(NAME, CMDFLAG, DESC) NAME,
+#include "phasar/Pointer/UnionFindAAType.def"
+};
+
+[[nodiscard]] constexpr llvm::StringRef
+to_string(UnionFindAliasAnalysisType AType) noexcept {
+  switch (AType) {
+#define UNIONFIND_ALIAS_ANALYSIS_TYPE(NAME, CMDFLAG, DESC)                     \
+  case UnionFindAliasAnalysisType::NAME:                                       \
+    return CMDFLAG;
+#include "phasar/Pointer/UnionFindAAType.def"
+  }
+}
+} // namespace psr
diff --git a/lib/PhasarLLVM/HelperAnalyses.cpp b/lib/PhasarLLVM/HelperAnalyses.cpp
index 355d77cdc8..3946ef5a5d 100644
--- a/lib/PhasarLLVM/HelperAnalyses.cpp
+++ b/lib/PhasarLLVM/HelperAnalyses.cpp
@@ -4,7 +4,9 @@
 #include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasSetData.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h"
 #include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
+#include "phasar/Pointer/AliasAnalysisType.h"
 
 #include <memory>
 #include <string>
@@ -29,7 +31,7 @@ HelperAnalyses::HelperAnalyses(std::string IRFile,
                                HelperAnalysisConfig Config) noexcept
     : IRFile(std::move(IRFile)),
       PrecomputedPTS(std::move(Config.PrecomputedPTS)), PTATy(Config.PTATy),
-      AllowLazyPTS(Config.AllowLazyPTS),
+      UFAATy(Config.UFAATy), AllowLazyPTS(Config.AllowLazyPTS),
       PrecomputedCG(std::move(Config.PrecomputedCG)),
       EntryPoints(std::move(EntryPoints)), CGTy(Config.CGTy),
       SoundnessLevel(Config.SoundnessLevel),
@@ -68,16 +70,23 @@ LLVMProjectIRDB &HelperAnalyses::getProjectIRDB() {
   return *IRDB;
 }
 
-LLVMAliasSet &HelperAnalyses::getAliasInfo() {
+LLVMAliasInfoRef HelperAnalyses::getAliasInfo() {
   if (!PT) {
     if (PrecomputedPTS.has_value()) {
       PT = std::make_unique<LLVMAliasSet>(&getProjectIRDB(), *PrecomputedPTS);
+    } else if (PTATy == AliasAnalysisType::UnionFind) {
+      PT = std::make_unique<LLVMUnionFindAliasSet>(
+          &getProjectIRDB(),
+          LLVMUnionFindAliasSet::Config{
+              .AType = UFAATy,
+              .ALocality = LLVMUnionFindAliasSet::AnalysisLocality::Global,
+          });
     } else {
       PT = std::make_unique<LLVMAliasSet>(&getProjectIRDB(), AllowLazyPTS,
                                           PTATy);
     }
   }
-  return *PT;
+  return PT.get();
 }
 
 DIBasedTypeHierarchy &HelperAnalyses::getTypeHierarchy() {
@@ -94,7 +103,7 @@ LLVMBasedICFG &HelperAnalyses::getICFG() {
     } else {
       ICF = std::make_unique<LLVMBasedICFG>(
           &getProjectIRDB(), CGTy, std::move(EntryPoints), &getTypeHierarchy(),
-          needsAliasInfo(CGTy) ? &getAliasInfo() : nullptr, SoundnessLevel,
+          needsAliasInfo(CGTy) ? getAliasInfo() : nullptr, SoundnessLevel,
           AutoGlobalSupport);
     }
   }
diff --git a/lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp b/lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp
index a2eb40e84b..cd0a5ecb41 100644
--- a/lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp
+++ b/lib/PhasarLLVM/Pointer/LLVMUnionFindAA.cpp
@@ -5,6 +5,8 @@
 #include "phasar/Pointer/UnionFindAA.h"
 #include "phasar/Utils/ValueCompressor.h"
 
+#include <utility>
+
 namespace psr {
 
 template class CallingContextSensUnionFindAA<LLVMPAGDomain>;
@@ -36,42 +38,43 @@ detail::LLVMLocalUnionFindAliasIteratorBase::
 
 using namespace psr;
 
-CallingContextSensUnionFindAAResult
-psr::computeCtxSensUnionFindAARaw(const LLVMProjectIRDB &IRDB,
-                                  const LLVMBasedCallGraph &CG) {
+CallingContextSensUnionFindAAResult psr::computeCtxSensUnionFindAARaw(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC) {
   auto Strategy = CallingContextSensUnionFindAA<LLVMPAGDomain>{
       &CG,
       &IRDB,
   };
-  return computeUnionFindAARaw(IRDB, std::move(Strategy));
+  return computeUnionFindAARaw(IRDB, std::move(Strategy), std::move(VC));
 }
 
-BasicUnionFindAAResult
-psr::computeBotCtxSensUnionFindAARaw(const LLVMProjectIRDB &IRDB,
-                                     const LLVMBasedCallGraph &CG) {
+BasicUnionFindAAResult psr::computeBotCtxSensUnionFindAARaw(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC) {
   auto Strategy = BottomupUnionFindAA<LLVMPAGDomain>{
       ReverseCGGraph{
           &CG,
           &IRDB,
       },
   };
-  return computeUnionFindAARaw(IRDB, std::move(Strategy));
+  return computeUnionFindAARaw(IRDB, std::move(Strategy), std::move(VC));
 }
 
-BasicUnionFindAAResult
-psr::computeIndSensUnionFindAARaw(const LLVMProjectIRDB &IRDB,
-                                  const LLVMBasedCallGraph &CG) {
+BasicUnionFindAAResult psr::computeIndSensUnionFindAARaw(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC) {
   auto Strategy = pag::PBMixin{
       IndirectionSensUnionFindAA<LLVMPAGDomain>{},
       pag::LLVMCGProvider{&CG},
   };
-  return computeUnionFindAARaw(IRDB, std::move(Strategy));
+  return computeUnionFindAARaw(IRDB, std::move(Strategy), std::move(VC));
 }
 
 UnionFindAAResultIntersection<CallingContextSensUnionFindAAResult,
                               BasicUnionFindAAResult>
-psr::computeCtxIndSensUnionFindAARaw(const LLVMProjectIRDB &IRDB,
-                                     const LLVMBasedCallGraph &CG) {
+psr::computeCtxIndSensUnionFindAARaw(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC) {
   auto Strategy = UnionFindAACombinator{
       CallingContextSensUnionFindAA<LLVMPAGDomain>{
           &CG,
@@ -79,12 +82,13 @@ psr::computeCtxIndSensUnionFindAARaw(const LLVMProjectIRDB &IRDB,
       },
       IndirectionSensUnionFindAA<LLVMPAGDomain>{},
   };
-  return computeUnionFindAARaw(IRDB, std::move(Strategy));
+  return computeUnionFindAARaw(IRDB, std::move(Strategy), std::move(VC));
 }
 
 UnionFindAAResultIntersection<BasicUnionFindAAResult, BasicUnionFindAAResult>
-psr::computeBotCtxIndSensUnionFindAARaw(const LLVMProjectIRDB &IRDB,
-                                        const LLVMBasedCallGraph &CG) {
+psr::computeBotCtxIndSensUnionFindAARaw(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC) {
   auto Strategy = UnionFindAACombinator{
       BottomupUnionFindAA<LLVMPAGDomain>{
           ReverseCGGraph{
@@ -94,45 +98,49 @@ psr::computeBotCtxIndSensUnionFindAARaw(const LLVMProjectIRDB &IRDB,
       },
       IndirectionSensUnionFindAA<LLVMPAGDomain>{},
   };
-  return computeUnionFindAARaw(IRDB, std::move(Strategy));
+  return computeUnionFindAARaw(IRDB, std::move(Strategy), std::move(VC));
 }
 
 LLVMUnionFindAliasIterator<CallingContextSensUnionFindAAResult>
-psr::computeCtxSensUnionFindAA(const LLVMProjectIRDB &IRDB,
-                               const LLVMBasedCallGraph &CG) {
+psr::computeCtxSensUnionFindAA(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC) {
   auto Strategy = CallingContextSensUnionFindAA<LLVMPAGDomain>{
       &CG,
       &IRDB,
   };
-  return computeUnionFindAA(IRDB, std::move(Strategy));
+  return computeUnionFindAA(IRDB, std::move(Strategy), std::move(VC));
 }
 
 LLVMUnionFindAliasIterator<BasicUnionFindAAResult>
-psr::computeBotCtxSensUnionFindAA(const LLVMProjectIRDB &IRDB,
-                                  const LLVMBasedCallGraph &CG) {
+psr::computeBotCtxSensUnionFindAA(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC) {
   auto Strategy = BottomupUnionFindAA<LLVMPAGDomain>{
       ReverseCGGraph{
           &CG,
           &IRDB,
       },
   };
-  return computeUnionFindAA(IRDB, std::move(Strategy));
+  return computeUnionFindAA(IRDB, std::move(Strategy), std::move(VC));
 }
 
 LLVMUnionFindAliasIterator<BasicUnionFindAAResult>
-psr::computeIndSensUnionFindAA(const LLVMProjectIRDB &IRDB,
-                               const LLVMBasedCallGraph &CG) {
+psr::computeIndSensUnionFindAA(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC) {
   auto Strategy = pag::PBMixin{
       IndirectionSensUnionFindAA<LLVMPAGDomain>{},
       pag::LLVMCGProvider{&CG},
   };
-  return computeUnionFindAA(IRDB, std::move(Strategy));
+  return computeUnionFindAA(IRDB, std::move(Strategy), std::move(VC));
 }
 
 LLVMUnionFindAliasIterator<UnionFindAAResultIntersection<
     CallingContextSensUnionFindAAResult, BasicUnionFindAAResult>>
-psr::computeCtxIndSensUnionFindAA(const LLVMProjectIRDB &IRDB,
-                                  const LLVMBasedCallGraph &CG) {
+psr::computeCtxIndSensUnionFindAA(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC) {
   auto Strategy = UnionFindAACombinator{
       CallingContextSensUnionFindAA<LLVMPAGDomain>{
           &CG,
@@ -140,13 +148,14 @@ psr::computeCtxIndSensUnionFindAA(const LLVMProjectIRDB &IRDB,
       },
       IndirectionSensUnionFindAA<LLVMPAGDomain>{},
   };
-  return computeUnionFindAA(IRDB, std::move(Strategy));
+  return computeUnionFindAA(IRDB, std::move(Strategy), std::move(VC));
 }
 
 LLVMUnionFindAliasIterator<UnionFindAAResultIntersection<
     BasicUnionFindAAResult, BasicUnionFindAAResult>>
-psr::computeBotCtxIndSensUnionFindAA(const LLVMProjectIRDB &IRDB,
-                                     const LLVMBasedCallGraph &CG) {
+psr::computeBotCtxIndSensUnionFindAA(
+    const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
+    MaybeUniquePtr<ValueCompressor<PAGVariable>> VC) {
   auto Strategy = UnionFindAACombinator{
       BottomupUnionFindAA<LLVMPAGDomain>{
           ReverseCGGraph{
@@ -156,5 +165,5 @@ psr::computeBotCtxIndSensUnionFindAA(const LLVMProjectIRDB &IRDB,
       },
       IndirectionSensUnionFindAA<LLVMPAGDomain>{},
   };
-  return computeUnionFindAA(IRDB, std::move(Strategy));
+  return computeUnionFindAA(IRDB, std::move(Strategy), std::move(VC));
 }
diff --git a/lib/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.cpp b/lib/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.cpp
index af8f9288b2..fb5980ca4c 100644
--- a/lib/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.cpp
+++ b/lib/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.cpp
@@ -9,11 +9,13 @@
 #include "phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h"
 #include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
+#include "phasar/Pointer/AliasInfoBase.h"
 #include "phasar/Pointer/RawAliasSet.h"
-#include "phasar/Pointer/UnionFindAA.h"
 #include "phasar/Utils/AnalysisProperties.h"
 #include "phasar/Utils/EnumFlags.h"
+#include "phasar/Utils/Fn.h"
 #include "phasar/Utils/MaybeUniquePtr.h"
+#include "phasar/Utils/StrongTypeDef.h"
 #include "phasar/Utils/Utilities.h"
 #include "phasar/Utils/ValueCompressor.h"
 
@@ -23,10 +25,11 @@
 #include "llvm/Support/Casting.h"
 
 #include <memory>
-#include <type_traits>
 
 using namespace psr;
 
+static_assert(IsAliasInfo<LLVMUnionFindAliasSet>);
+
 static inline bool isPotentialAllocSite(const llvm::Value *Val) {
   if (!Val->getType()->isPointerTy()) {
     return false;
@@ -112,6 +115,28 @@ struct [[clang::internal_linkage]] LLVMUnionFindAliasSet::UnionFindAAResultModel
 
     return Ret;
   }
+
+  void print(llvm::raw_ostream &OS, Config Cfg) const override {
+    OS << "LLVMUnionFindAliasSet(" << to_string(Cfg.ALocality) << ", "
+       << to_string(Cfg.AType) << ") {\n";
+
+    for (auto ValId : iota<ValueId>(VC->size())) {
+      OS << "  #" << psr::to_underlying(ValId) << ": {";
+      bool First = true;
+      const auto &Aliases = this->base_t::getRawAliasSet(ValId);
+      Aliases.foreach ([&](auto AliasId) {
+        if (First) {
+          First = false;
+        } else {
+          OS << ", ";
+        }
+
+        OS << psr::to_underlying(AliasId);
+      });
+      OS << "}\n";
+    }
+    OS << "}\n";
+  };
 };
 
 LLVMUnionFindAliasSet::LLVMUnionFindAliasSet(const LLVMProjectIRDB *IRDB,
@@ -122,27 +147,30 @@ LLVMUnionFindAliasSet::LLVMUnionFindAliasSet(const LLVMProjectIRDB *IRDB,
     VCOwn = std::make_unique<ValueCompressor<PAGVariable>>();
   }
 
-  const auto MakeAAResModel =
-      [Cfg, &VC]<UnionFindAAResult AAResT>(
-          AAResT &&AARes) -> std::unique_ptr<UnionFindAAResultConcept> {
-    if (Cfg.ALocality == AnalysisLocality::FunctionLocal) {
-      const auto &VCRef = *VC;
-      return std::make_unique<UnionFindAAResultModel<
-          LLVMLocalUnionFindAliasIteratorMixin, std::remove_cvref_t<AAResT>>>(
-          std::move(VC), PSR_FWD(AARes), VCRef);
-    }
-
-    return std::make_unique<UnionFindAAResultModel<
-        LLVMUnionFindAliasIteratorMixin, std::remove_cvref_t<AAResT>>>(
-        std::move(VC), PSR_FWD(AARes));
-  };
-
   auto VTP = LLVMVFTableProvider(*IRDB);
   auto TH = DIBasedTypeHierarchy(*IRDB);
   auto Res = RTAResolver(IRDB, &VTP, &TH);
   const auto BaseCG = buildLLVMBasedCallGraph(
       *IRDB, Res, getEntryFunctions(*IRDB, getDefaultEntryPoints(*IRDB)));
 
+  auto MakeAAResModel =
+      [&, IRDB, Cfg, VCOwn = std::move(VCOwn)](
+          auto AAResCtor) mutable -> std::unique_ptr<UnionFindAAResultConcept> {
+    auto AARes = AAResCtor(*IRDB, BaseCG, VCOwn.get());
+    using AAResT = decltype(AARes);
+
+    if (Cfg.ALocality == AnalysisLocality::FunctionLocal) {
+      const auto &VCRef = *VCOwn;
+      return std::make_unique<
+          UnionFindAAResultModel<LLVMLocalUnionFindAliasIteratorMixin, AAResT>>(
+          std::move(VCOwn), PSR_FWD(AARes), VCRef);
+    }
+
+    return std::make_unique<
+        UnionFindAAResultModel<LLVMUnionFindAliasIteratorMixin, AAResT>>(
+        std::move(VCOwn), PSR_FWD(AARes));
+  };
+
   scope_exit ResizeAliasSetCache = [&] {
     if (!AARes) {
       // Something went wrong and we hopefully have an in-flight
@@ -154,27 +182,27 @@ LLVMUnionFindAliasSet::LLVMUnionFindAliasSet(const LLVMProjectIRDB *IRDB,
   };
 
   switch (Cfg.AType) {
-  case AnalysisType::CtxSens:
+  case UnionFindAliasAnalysisType::CtxSens:
     Props = AnalysisProperties::ContextSensitive;
-    AARes = MakeAAResModel(computeCtxSensUnionFindAARaw(*IRDB, BaseCG));
+    AARes = MakeAAResModel(fn<computeCtxSensUnionFindAARaw>);
     return;
-  case AnalysisType::IndSens:
+  case UnionFindAliasAnalysisType::IndSens:
     Props = AnalysisProperties::FieldSensitive;
-    AARes = MakeAAResModel(computeIndSensUnionFindAARaw(*IRDB, BaseCG));
+    AARes = MakeAAResModel(fn<computeIndSensUnionFindAARaw>);
     return;
-  case AnalysisType::CtxIndSens:
+  case UnionFindAliasAnalysisType::CtxIndSens:
     Props = AnalysisProperties::ContextSensitive |
             AnalysisProperties::FieldSensitive;
-    AARes = MakeAAResModel(computeCtxIndSensUnionFindAARaw(*IRDB, BaseCG));
+    AARes = MakeAAResModel(fn<computeCtxIndSensUnionFindAARaw>);
     return;
-  case AnalysisType::BotCtxSens:
+  case UnionFindAliasAnalysisType::BotCtxSens:
     Props = AnalysisProperties::ContextSensitive;
-    AARes = MakeAAResModel(computeBotCtxSensUnionFindAARaw(*IRDB, BaseCG));
+    AARes = MakeAAResModel(fn<computeBotCtxSensUnionFindAARaw>);
     return;
-  case AnalysisType::BotCtxIndSens:
+  case UnionFindAliasAnalysisType::BotCtxIndSens:
     Props = AnalysisProperties::ContextSensitive |
             AnalysisProperties::FieldSensitive;
-    AARes = MakeAAResModel(computeBotCtxIndSensUnionFindAARaw(*IRDB, BaseCG));
+    AARes = MakeAAResModel(fn<computeBotCtxIndSensUnionFindAARaw>);
     return;
   }
 
@@ -187,3 +215,25 @@ auto LLVMUnionFindAliasSet::getEmptyAliasSet() -> BoxedPtr<AliasSetTy> {
   static AliasSetTy *EmptySetPtr = &EmptySet;
   return &EmptySetPtr;
 }
+
+void LLVMUnionFindAliasSet::print(llvm::raw_ostream &OS) const {
+  assert(isValid());
+  AARes->print(OS, Cfg);
+}
+
+void LLVMUnionFindAliasSet::printAsJson(llvm::raw_ostream &OS) const {
+  // TODO
+  OS << "{}\n";
+}
+
+[[nodiscard]] llvm::StringRef
+psr::to_string(LLVMUnionFindAliasSet::AnalysisLocality Loc) noexcept {
+  switch (Loc) {
+  case LLVMUnionFindAliasSet::AnalysisLocality::Global:
+    return "global";
+  case LLVMUnionFindAliasSet::AnalysisLocality::FunctionLocal:
+    return "local";
+  }
+  llvm_unreachable(
+      "All analysis-localities should be handled in the switch above");
+}
diff --git a/lib/Pointer/UnionFindAA.cpp b/lib/Pointer/UnionFindAA.cpp
index 3800d533d6..a14d6cfcdf 100644
--- a/lib/Pointer/UnionFindAA.cpp
+++ b/lib/Pointer/UnionFindAA.cpp
@@ -1,7 +1,7 @@
 
 #include "phasar/Pointer/UnionFindAA.h"
 
-#include "phasar/Utils/StrongTypeDef.h"
+#include "phasar/Utils/StrongTypeDef.h" // for to_underlying
 
 using namespace psr;
 
diff --git a/tools/phasar-cli/Controller/AnalysisControllerInternalIDE.h b/tools/phasar-cli/Controller/AnalysisControllerInternalIDE.h
index 789157a75e..80b9c3ef82 100644
--- a/tools/phasar-cli/Controller/AnalysisControllerInternalIDE.h
+++ b/tools/phasar-cli/Controller/AnalysisControllerInternalIDE.h
@@ -56,7 +56,7 @@ template <typename SolverTy, typename ProblemTy, typename... ArgTys>
 static void executeSparseIfdsIdeAnalysis(AnalysisController &Data,
                                          ArgTys &&...Args) {
 
-  SparseLLVMBasedICFGView SVFG(&Data.HA->getICFG(), &Data.HA->getAliasInfo());
+  SparseLLVMBasedICFGView SVFG(&Data.HA->getICFG(), Data.HA->getAliasInfo());
   executeIfdsIdeAnalysisImpl<SolverTy, ProblemTy>(
       Data, SVFG, std::forward<ArgTys>(Args)...);
 }
diff --git a/tools/phasar-cli/phasar-cli.cpp b/tools/phasar-cli/phasar-cli.cpp
index 0169441aae..e5d5e90d6e 100644
--- a/tools/phasar-cli/phasar-cli.cpp
+++ b/tools/phasar-cli/phasar-cli.cpp
@@ -13,10 +13,11 @@
 #include "phasar/ControlFlow/CallGraphData.h"
 #include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
 #include "phasar/PhasarLLVM/HelperAnalyses.h"
+#include "phasar/PhasarLLVM/HelperAnalysisConfig.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasSetData.h"
 #include "phasar/PhasarLLVM/Utils/DataFlowAnalysisType.h"
 #include "phasar/Pointer/AliasAnalysisType.h"
-#include "phasar/Utils/IO.h"
+#include "phasar/Pointer/UnionFindAliasAnalysisType.h"
 #include "phasar/Utils/InitPhasar.h"
 #include "phasar/Utils/Logger.h"
 #include "phasar/Utils/Soundness.h"
@@ -118,6 +119,16 @@ cl::opt<AliasAnalysisType> AliasTypeOpt(
 cl::alias AliasTypeAlias("P", cl::aliasopt(AliasTypeOpt),
                          cl::desc("Alias for --alias-analysis"),
                          cl::cat(PsrCat));
+cl::opt<UnionFindAliasAnalysisType> UFAliasTypeOpt(
+    "union-find-aa",
+    cl::desc(
+        "The union-find alias analysis type to use (default: ctx-ind-sens)"),
+    cl::init(UnionFindAliasAnalysisType::CtxIndSens), cl::cat(PsrCat),
+    values({
+#define UNIONFIND_ALIAS_ANALYSIS_TYPE(NAME, CMDFLAG, DESC)                     \
+  clEnumValN(UnionFindAliasAnalysisType::NAME, CMDFLAG, DESC),
+#include "phasar/Pointer/UnionFindAAType.def"
+    }));
 
 cl::opt<CallGraphAnalysisType>
     CGTypeOpt("call-graph-analysis",
@@ -460,27 +471,32 @@ int main(int Argc, const char **Argv) {
     EntryOpt.push_back("main");
   }
 
-  // setup IRDB as source code manager
-  HelperAnalyses HA(std::move(ModuleOpt.getValue()),
-                    std::move(PrecomputedAliasSet), AliasTypeOpt,
-                    !AnalysisController::needsToEmitPTA(EmitterOptions),
-                    EntryOpt, std::move(PrecomputedCallGraph), CGTypeOpt,
-                    SoundnessOpt, AutoGlobalsOpt);
+  HelperAnalysisConfig HAConfig{
+      .PrecomputedCG = std::move(PrecomputedCallGraph),
+      .PTATy = AliasTypeOpt,
+      .UFAATy = UFAliasTypeOpt,
+      .CGTy = CGTypeOpt,
+      .SoundnessLevel = SoundnessOpt,
+      .AutoGlobalSupport = AutoGlobalsOpt,
+      .AllowLazyPTS = !AnalysisController::needsToEmitPTA(EmitterOptions),
+  };
+  HelperAnalyses HA(std::move(ModuleOpt.getValue()), EntryOpt,
+                    std::move(HAConfig));
   if (!HA.getProjectIRDB().isValid()) {
     // Note: Error message has already been printed
     return 1;
   }
 
   AnalysisController Controller{
-      &HA,
-      DataFlowAnalysisOpt,
-      {AnalysisConfigOpt.getValue()},
-      EntryOpt,
-      StrategyOpt,
-      EmitterOptions,
-      SolverConfig,
-      ProjectIdOpt.getValue(),
-      OutDirOpt.getValue(),
+      .HA = &HA,
+      .DataFlowAnalyses = DataFlowAnalysisOpt,
+      .AnalysisConfigs = {AnalysisConfigOpt.getValue()},
+      .EntryPoints = EntryOpt,
+      .Strategy = StrategyOpt,
+      .EmitterOptions = EmitterOptions,
+      .SolverConfig = SolverConfig,
+      .ProjectID = ProjectIdOpt.getValue(),
+      .ResultDirectory = OutDirOpt.getValue(),
   };
   if (!OutDirOpt.empty()) {
     // create directory for results

From 511201cfaa617a166a919d86af44612166507d59 Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Mon, 2 Feb 2026 16:32:01 +0100
Subject: [PATCH 31/75] debug information

---
 test/llvm_test_code/pointers/CMakeLists.txt   |    1 +
 test/llvm_test_code/pointers/indirection_01.c |   11 +-
 test/llvm_test_code/pointers/indirection_02.c |   21 +
 .../Pointer/LLVMUnionFindAATest.cpp           | 1691 ++++++++++++-----
 4 files changed, 1290 insertions(+), 434 deletions(-)
 create mode 100644 test/llvm_test_code/pointers/indirection_02.c

diff --git a/test/llvm_test_code/pointers/CMakeLists.txt b/test/llvm_test_code/pointers/CMakeLists.txt
index a6af1568f3..00f874a5ec 100644
--- a/test/llvm_test_code/pointers/CMakeLists.txt
+++ b/test/llvm_test_code/pointers/CMakeLists.txt
@@ -29,6 +29,7 @@ set(lca_files
   context_13_0.c
   context_13_1.c
   indirection_01.c
+  indirection_02.c
 )
 
 set(lca_files_mem2reg
diff --git a/test/llvm_test_code/pointers/indirection_01.c b/test/llvm_test_code/pointers/indirection_01.c
index 32d6d99c8a..fb00571431 100644
--- a/test/llvm_test_code/pointers/indirection_01.c
+++ b/test/llvm_test_code/pointers/indirection_01.c
@@ -8,14 +8,5 @@ int main() {
   LinkedList Foo;
   Foo = (LinkedList){0, &Foo};
 
-  LinkedList Bar;
-  Bar = (LinkedList){42, &Foo};
-
-  LinkedList Baz = Bar;
-  LinkedList Boar = Baz;
-
-  Boar.Next = &Bar;
-  Baz.Next = &Boar;
-
-  return (int)Boar.Next;
+  return (int)Foo.Next;
 }
diff --git a/test/llvm_test_code/pointers/indirection_02.c b/test/llvm_test_code/pointers/indirection_02.c
new file mode 100644
index 0000000000..32d6d99c8a
--- /dev/null
+++ b/test/llvm_test_code/pointers/indirection_02.c
@@ -0,0 +1,21 @@
+
+typedef struct _LinkedList {
+  int Val;
+  struct _LinkedList *Next;
+} LinkedList;
+
+int main() {
+  LinkedList Foo;
+  Foo = (LinkedList){0, &Foo};
+
+  LinkedList Bar;
+  Bar = (LinkedList){42, &Foo};
+
+  LinkedList Baz = Bar;
+  LinkedList Boar = Baz;
+
+  Boar.Next = &Bar;
+  Baz.Next = &Boar;
+
+  return (int)Boar.Next;
+}
diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index cee3e0895a..6cba8ac8c7 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -215,6 +215,93 @@ TEST(CtxSensUnionFindAATest, Basic02) {
 }
 
 TEST(CtxSensUnionFindAATest, Basic03) {
+  /*
+
+  Note: only relevant lines were pasted here
+
+  ValueCompressor:
+  #1:
+    @"_ZTIZ4mainE3$_0" = internal constant { ptr, ptr } { ptr getelementptr
+  inbounds (ptr, ptr @_ZTVN10__cxxabiv117__class_type_infoE, i64 2), ptr
+  @"_ZTSZ4mainE3$_0" }, align 8, !psr.id !2 | ID: 2
+  #11:
+    %0 = load ptr, ptr %FuncPtr, align 8, !dbg !415, !psr.id !416 | ID: 13
+  #46:
+    %3 = extractvalue { ptr, i32 } %2, 0, !dbg !538, !psr.id !550 | ID: 76
+
+  --- ---
+
+  #1: <6, 10, 21, 22, 24, 56, 58, 88>
+  #11: <8, 15, 31, 33, 160, 161, 163, 181, 183, 209>
+  #46: <46, 47, 59, 141, 184, 253>
+
+  --- for #1: <6, 10, 21, 22, 24, 56, 58, 88> ---
+
+  #6:
+    %ref.tmp = alloca %class.anon, align 1, !psr.id !402 | ID: 6
+  #10:
+    ptr %__f | ID: _ZNSt8functionIFivEEC2IZ4mainE3$_0vEEOT_.1
+  #21:
+    %1 = load ptr, ptr %__f.addr, align 8, !dbg !448, !psr.id !451 | ID: 29
+    %2 = load ptr, ptr %__f.addr, align 8, !dbg !459, !psr.id !460 | ID: 33
+  #22:
+    ptr %0 | ID:
+  _ZNSt14_Function_base13_Base_managerIZ4mainE3$_0E21_M_not_empty_functionIS1_EEbRKT_.0
+  #24:
+    ptr %__f | ID:
+  _ZNSt14_Function_base13_Base_managerIZ4mainE3$_0E15_M_init_functorIS1_EEvRSt9_Any_dataOT_.1
+  #56:
+    %1 = load ptr, ptr %__f.addr, align 8, !dbg !647, !psr.id !648 | ID: 103
+  #58:
+    ptr %__f | ID:
+  _ZNSt14_Function_base13_Base_managerIZ4mainE3$_0E9_M_createIS1_EEvRSt9_Any_dataOT_St17integral_constantIbLb1EE.1
+  #88:
+    %2 = load ptr, ptr %__f.addr, align 8, !dbg !752, !psr.id !753 | ID: 154
+
+  --- for #11: <8, 15, 31, 33, 160, 161, 163, 181, 183, 209> ---
+
+  #8:
+    %ref.tmp1 = alloca %class.anon.0, align 1, !psr.id !404 | ID: 8
+  #15:
+    ptr %__f | ID:
+  _ZNSt8functionIFivEEaSIZ4mainE3$_1EENSt9enable_ifIXsrNS1_9_CallableIT_NS4_IXntsr7is_sameINSt9remove_cvINSt16remove_referenceIS6_E4typeEE4typeES1_EE5valueESt5decayIS6_EE4type4typeESt15__invoke_resultIRSH_JEEEE5valueERS1_E4typeEOS6_.1
+  #31:
+    %0 = load ptr, ptr %__f.addr, align 8, !dbg !500, !psr.id !501 | ID: 49
+  #33:
+    ptr %__f | ID: _ZNSt8functionIFivEEC2IZ4mainE3$_1vEEOT_.1
+  #160:
+    %1 = load ptr, ptr %__f.addr, align 8, !dbg !1063, !psr.id !1066 | ID: 300
+    %2 = load ptr, ptr %__f.addr, align 8, !dbg !1074, !psr.id !1075 | ID: 304
+  #161:
+    ptr %0 | ID:
+  _ZNSt14_Function_base13_Base_managerIZ4mainE3$_1E21_M_not_empty_functionIS1_EEbRKT_.0
+  #163:
+    ptr %__f | ID:
+  _ZNSt14_Function_base13_Base_managerIZ4mainE3$_1E15_M_init_functorIS1_EEvRSt9_Any_dataOT_.1
+  #181:
+    %1 = load ptr, ptr %__f.addr, align 8, !dbg !1170, !psr.id !1171 | ID: 344
+  #183:
+    ptr %__f | ID:
+  _ZNSt14_Function_base13_Base_managerIZ4mainE3$_1E9_M_createIS1_EEvRSt9_Any_dataOT_St17integral_constantIbLb1EE.1
+  #209:
+    %2 = load ptr, ptr %__f.addr, align 8, !dbg !1275, !psr.id !1276 | ID: 395
+
+  --- for #46: <46, 47, 59, 141, 184, 253> ---
+
+  #46:
+    %3 = extractvalue { ptr, i32 } %2, 0, !dbg !538, !psr.id !550 | ID: 76
+  #47:
+    ptr %0 | ID: __clang_call_terminate.0
+  #59:
+    %3 = extractvalue { ptr, i32 } %2, 0, !dbg !649, !psr.id !654 | ID: 107
+  #141:
+    %3 = extractvalue { ptr, i32 } %2, 0, !dbg !976, !psr.id !981 | ID: 259
+  #184:
+    %3 = extractvalue { ptr, i32 } %2, 0, !dbg !1172, !psr.id !1177 | ID: 348
+  #253:
+    %3 = extractvalue { ptr, i32 } %2, 0, !dbg !1458, !psr.id !1463 | ID: 482
+
+  */
   GTMap GT = {{LineColFunOp{.Line = 4,
                             .Col = 0,
                             .InFunction = "main",
@@ -1823,34 +1910,59 @@ TEST(IndirectionSensUnionFindAATest, Basic01) {
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {
-                   LineColFunOp{.Line = 3,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Alloca},
-                   LineColFunOp{.Line = 5,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Load},
-               }}};
+               {LineColFunOp{.Line = 3,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
   doAnalysisAndCompareResults("basic_01_c_dbg.ll", GT, IndAABuilder);
+
+  psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
+                                      "IndirectionSensUnionFindAA");
 }
 
 TEST(IndirectionSensUnionFindAATest, Basic02) {
-  GTMap GT = {{LineColFunOp{.Line = 3,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {
-                   LineColFunOp{.Line = 3,
+  GTMap GT = {{
+                  LineColFunOp{.Line = 3,
+                               .Col = 0,
+                               .InFunction = "main",
+                               .OpCode = llvm::Instruction::Alloca},
+                  {LineColFunOp{.Line = 3,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Alloca},
                    LineColFunOp{.Line = 6,
+                                .Col = 4,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load}},
+              },
+              {
+                  LineColFunOp{.Line = 4,
+                               .Col = 0,
+                               .InFunction = "main",
+                               .OpCode = llvm::Instruction::Alloca},
+                  {LineColFunOp{.Line = 4,
                                 .Col = 0,
                                 .InFunction = "main",
-                                .OpCode = llvm::Instruction::Load},
-               }}};
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 6,
+                                .Col = 5,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load}},
+              },
+              {
+                  LineColFunOp{.Line = 4,
+                               .Col = 0,
+                               .InFunction = "main",
+                               .OpCode = llvm::Instruction::Alloca},
+                  {LineColFunOp{.Line = 4,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 6,
+                                .Col = 5,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load}},
+              }};
 
   doAnalysisAndCompareResults("basic_02_c_dbg.ll", GT, IndAABuilder);
 }
@@ -1875,72 +1987,225 @@ TEST(IndirectionSensUnionFindAATest, Basic03) {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context01) {
-  GTMap GT = {
-      {LineColFunOp{.Line = 5,
-                    .Col = 0,
-                    .InFunction = "main",
-                    .OpCode = llvm::Instruction::Alloca},
-       {
-           LineColFunOp{.Line = 5,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 8,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 11,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Load},
-           ArgInFun{.Idx = 0, .InFunction = "id"},
-       }},
-      {LineColFunOp{.Line = 6,
-                    .Col = 0,
-                    .InFunction = "main",
-                    .OpCode = llvm::Instruction::Alloca},
-       {
-           LineColFunOp{.Line = 6,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 9,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           ArgInFun{.Idx = 0, .InFunction = "id"},
-       }},
-      {ArgInFun{.Idx = 0, .InFunction = "id"},
-       {
-           LineColFunOp{.Line = 5,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 6,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 8,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 9,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 11,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Load},
-           ArgInFun{.Idx = 0, .InFunction = "id"},
-       }},
-  };
+  /*
+  ValueCompressor: {
+    #0:
+      %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
+    #1:
+      ptr %p | ID: id.0
+    #2:
+      %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
+    #3:
+      fun @id.<ret>
+    #4:
+      %retval = alloca i32, align 4, !psr.id !29 | ID: 5
+    #5:
+      %x = alloca i32, align 4, !psr.id !30 | ID: 6
+    #6:
+      %y = alloca i32, align 4, !psr.id !31 | ID: 7
+    #7:
+      %xx = alloca ptr, align 8, !psr.id !32 | ID: 8
+    #8:
+      %yy = alloca ptr, align 8, !psr.id !33 | ID: 9
+    #9:
+      %call = call ptr @id(ptr noundef %x), !dbg !46, !psr.id !47 | ID: 16
+    #10:
+      %call1 = call ptr @id(ptr noundef %y), !dbg !52, !psr.id !53 | ID: 19
+    #11:
+      %0 = load ptr, ptr %xx, align 8, !dbg !55, !psr.id !56 | ID: 21
+  }
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1, 2, 3, 5, 6, 9, 10, 11>
+  #6: <>
+  #7: <>
+  #8: <>
+  #9: <>
+  #10: <4>
+  #11: <>
+  #12: <>
+  #13: <>
+  #14: <>
+  #15: <7>
+  #16: <>
+  #17: <>
+  #18: <>
+  #19: <>
+  #20: <8>
+  #21: <>
+  #22: <>
+  #23: <>
+  #24: <>
+}
+  */
+  /*
+    TODO: talk with fabian about the following:
+
+    UnionFindAAResult has itself in it, but if I put in ground truth, it
+    doesn't work. LineColFunOp{.Line = 5,...
+    -> LineColFunOp{.Line = 5, ...
+    -> LineColFunOp{.Line = 2,
+                             .Col = 14,
+
+    Shouldn't the result be something like:
+
+    #5: <1, 2, 3, 5, 9, 11>
+    #6: <6, 10>
+
+    ?
+  */
+
+  GTMap GT = {{// #5: %x = alloca i32, align 4, !psr.id !30 | ID: 6
+               LineColFunOp{.Line = 5,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {// #1: ptr %p | ID: id.0
+                LineColFunOp{.Line = 2,
+                             .Col = 14,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                // #2: %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id
+                // !23 | ID: 3
+                LineColFunOp{.Line = 2,
+                             .Col = 26,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                // #3: fun @id.<ret>
+                LineColFunOp{.Line = 2,
+                             .Col = 19,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {// #6: %y = alloca i32, align 4, !psr.id !31 | ID: 7
+               LineColFunOp{.Line = 6,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {// #10: %call1 = call ptr @id(ptr noundef %y), !dbg !52, !psr.id
+                // !53 | ID: 19
+                LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
   doAnalysisAndCompareResults("context_01_c_dbg.ll", GT, IndAABuilder);
 }
 
 TEST(IndirectionSensUnionFindAATest, Context02) {
+  /*
+  ValueCompressor: {
+  #0:
+    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    ptr %p | ID: id1.0
+  #2:
+    %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
+  #3:
+    fun @id1.<ret>
+  #4:
+    %q.addr = alloca ptr, align 8, !psr.id !27 | ID: 5
+  #5:
+    ptr %q | ID: id2.0
+  #6:
+    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 8
+  #7:
+    fun @id2.<ret>
+  #8:
+    %retval = alloca i32, align 4, !psr.id !39 | ID: 10
+  #9:
+    %x = alloca i32, align 4, !psr.id !40 | ID: 11
+  #10:
+    %y = alloca i32, align 4, !psr.id !41 | ID: 12
+  #11:
+    %xx1 = alloca ptr, align 8, !psr.id !42 | ID: 13
+  #12:
+    %xx2 = alloca ptr, align 8, !psr.id !43 | ID: 14
+  #13:
+    %yy1 = alloca ptr, align 8, !psr.id !44 | ID: 15
+  #14:
+    %yy2 = alloca ptr, align 8, !psr.id !45 | ID: 16
+  #15:
+    %call = call ptr @id1(ptr noundef %x), !dbg !58, !psr.id !59 | ID: 23
+  #16:
+    %call1 = call ptr @id1(ptr noundef %x), !dbg !64, !psr.id !65 | ID: 26
+  #17:
+    %call2 = call ptr @id2(ptr noundef %y), !dbg !70, !psr.id !71 | ID: 29
+  #18:
+    %call3 = call ptr @id2(ptr noundef %y), !dbg !76, !psr.id !77 | ID: 32
+  #19:
+    %0 = load ptr, ptr %xx1, align 8, !dbg !79, !psr.id !80 | ID: 34
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1, 2, 3, 9, 15, 16, 19>
+  #6: <>
+  #7: <>
+  #8: <>
+  #9: <>
+  #10: <4>
+  #11: <>
+  #12: <>
+  #13: <>
+  #14: <>
+  #15: <5, 6, 7, 10, 17, 18>
+  #16: <>
+  #17: <>
+  #18: <>
+  #19: <>
+  #20: <8>
+  #21: <>
+  #22: <>
+  #23: <>
+  #24: <>
+  #25: <11>
+  #26: <>
+  #27: <>
+  #28: <>
+  #29: <>
+  #30: <12>
+  #31: <>
+  #32: <>
+  #33: <>
+  #34: <>
+  #35: <13>
+  #36: <>
+  #37: <>
+  #38: <>
+  #39: <>
+  #40: <14>
+  #41: <>
+  #42: <>
+  #43: <>
+  #44: <>
+}
+
+Relevant lines:
+
+  #5: <1, 2, 3, 9, 15, 16, 19>
+  #15: <5, 6, 7, 10, 17, 18>
+
+
+  // TODO: talk with Fabian about the same points as in comment in Context01
+  unittest
+
+  // TODO: talk with fabian on why it's #5 and #15 here?
+
+  // TODO: ask fabian if my following expected result would be correct:
+
+  #9: <1, 2, 3, 11, 12, 19>
+  #10: <5, 6, 7, 13, 14>
+
+  */
   GTMap GT = {
-      {LineColFunOp{.Line = 6,
+      {// #9: %x = alloca i32, align 4, !psr.id !40 | ID: 11
+       LineColFunOp{.Line = 6,
                     .Col = 0,
                     .InFunction = "main",
                     .OpCode = llvm::Instruction::Alloca},
@@ -1962,7 +2227,8 @@ TEST(IndirectionSensUnionFindAATest, Context02) {
                         .InFunction = "main",
                         .OpCode = llvm::Instruction::Load},
        }},
-      {LineColFunOp{.Line = 7,
+      {// #10: %y = alloca i32, align 4, !psr.id !41 | ID: 12
+       LineColFunOp{.Line = 7,
                     .Col = 0,
                     .InFunction = "main",
                     .OpCode = llvm::Instruction::Alloca},
@@ -1986,6 +2252,79 @@ TEST(IndirectionSensUnionFindAATest, Context02) {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context03) {
+  /*
+  ValueCompressor: {
+  #0:
+    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    ptr %p | ID: id1.0
+  #2:
+    %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
+  #3:
+    fun @id1.<ret>
+  #4:
+    %q.addr = alloca ptr, align 8, !psr.id !27 | ID: 5
+  #5:
+    ptr %q | ID: id2.0
+  #6:
+    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 8
+  #7:
+    %call = call ptr @id1(ptr noundef %0), !dbg !34, !psr.id !35 | ID: 9
+  #8:
+    fun @id2.<ret>
+  #9:
+    %retval = alloca i32, align 4, !psr.id !41 | ID: 11
+  #10:
+    %x = alloca i32, align 4, !psr.id !42 | ID: 12
+  #11:
+    %xx1 = alloca ptr, align 8, !psr.id !43 | ID: 13
+  #12:
+    %xx2 = alloca ptr, align 8, !psr.id !44 | ID: 14
+  #13:
+    %call = call ptr @id2(ptr noundef %x), !dbg !53, !psr.id !54 | ID: 19
+  #14:
+    %call1 = call ptr @id2(ptr noundef %x), !dbg !59, !psr.id !60 | ID: 22
+  #15:
+    %0 = load ptr, ptr %xx1, align 8, !dbg !62, !psr.id !63 | ID: 24
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1, 2, 3, 5, 6, 7, 8, 10, 13, 14, 15>
+  #6: <>
+  #7: <>
+  #8: <>
+  #9: <>
+  #10: <4>
+  #11: <>
+  #12: <>
+  #13: <>
+  #14: <>
+  #15: <9>
+  #16: <>
+  #17: <>
+  #18: <>
+  #19: <>
+  #20: <11>
+  #21: <>
+  #22: <>
+  #23: <>
+  #24: <>
+  #25: <12>
+  #26: <>
+  #27: <>
+  #28: <>
+  #29: <>
+}
+
+// TODO: talk with Fabian about the same points as in comment in Context01
+unittest
+
+  */
+
   GTMap GT = {{LineColFunOp{.Line = 6,
                             .Col = 0,
                             .InFunction = "main",
@@ -2013,6 +2352,91 @@ TEST(IndirectionSensUnionFindAATest, Context03) {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context04_0) {
+  /*
+  ValueCompressor: {
+  #0:
+    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    ptr %p | ID: id1.0
+  #2:
+    %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
+  #3:
+    fun @id1.<ret>
+  #4:
+    %q.addr = alloca ptr, align 8, !psr.id !27 | ID: 5
+  #5:
+    ptr %q | ID: id2.0
+  #6:
+    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 8
+  #7:
+    %call = call ptr @id1(ptr noundef %0), !dbg !34, !psr.id !35 | ID: 9
+  #8:
+    fun @id2.<ret>
+  #9:
+    %r.addr = alloca ptr, align 8, !psr.id !39 | ID: 11
+  #10:
+    ptr %r | ID: id3.0
+  #11:
+    %0 = load ptr, ptr %r.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
+  #12:
+    %call = call ptr @id2(ptr noundef %0), !dbg !46, !psr.id !47 | ID: 15
+  #13:
+    fun @id3.<ret>
+  #14:
+    %retval = alloca i32, align 4, !psr.id !53 | ID: 17
+  #15:
+    %x = alloca i32, align 4, !psr.id !54 | ID: 18
+  #16:
+    %xx1 = alloca ptr, align 8, !psr.id !55 | ID: 19
+  #17:
+    %xx2 = alloca ptr, align 8, !psr.id !56 | ID: 20
+  #18:
+    %call = call ptr @id3(ptr noundef %x), !dbg !65, !psr.id !66 | ID: 25
+  #19:
+    %call1 = call ptr @id3(ptr noundef %x), !dbg !71, !psr.id !72 | ID: 28
+  #20:
+    %0 = load ptr, ptr %xx1, align 8, !dbg !74, !psr.id !75 | ID: 30
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 18, 19, 20>
+  #6: <>
+  #7: <>
+  #8: <>
+  #9: <>
+  #10: <4>
+  #11: <>
+  #12: <>
+  #13: <>
+  #14: <>
+  #15: <9>
+  #16: <>
+  #17: <>
+  #18: <>
+  #19: <>
+  #20: <14>
+  #21: <>
+  #22: <>
+  #23: <>
+  #24: <>
+  #25: <16>
+  #26: <>
+  #27: <>
+  #28: <>
+  #29: <>
+  #30: <17>
+  #31: <>
+  #32: <>
+  #33: <>
+  #34: <>
+}
+// TODO: talk with Fabian about the same points as in comment in Context01
+unittest
+  */
   GTMap GT = {{LineColFunOp{.Line = 7,
                             .Col = 0,
                             .InFunction = "main",
@@ -2040,6 +2464,111 @@ TEST(IndirectionSensUnionFindAATest, Context04_0) {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context04_1) {
+  /*
+  ValueCompressor: {
+  #0:
+    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    ptr %p | ID: id1.0
+  #2:
+    %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
+  #3:
+    fun @id1.<ret>
+  #4:
+    %q.addr = alloca ptr, align 8, !psr.id !27 | ID: 5
+  #5:
+    ptr %q | ID: id2.0
+  #6:
+    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 8
+  #7:
+    %call = call ptr @id1(ptr noundef %0), !dbg !34, !psr.id !35 | ID: 9
+  #8:
+    fun @id2.<ret>
+  #9:
+    %r.addr = alloca ptr, align 8, !psr.id !39 | ID: 11
+  #10:
+    ptr %r | ID: id3.0
+  #11:
+    %0 = load ptr, ptr %r.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
+  #12:
+    %call = call ptr @id2(ptr noundef %0), !dbg !46, !psr.id !47 | ID: 15
+  #13:
+    fun @id3.<ret>
+  #14:
+    %retval = alloca i32, align 4, !psr.id !53 | ID: 17
+  #15:
+    %x = alloca i32, align 4, !psr.id !54 | ID: 18
+  #16:
+    %y = alloca i32, align 4, !psr.id !55 | ID: 19
+  #17:
+    %xx1 = alloca ptr, align 8, !psr.id !56 | ID: 20
+  #18:
+    %xx2 = alloca ptr, align 8, !psr.id !57 | ID: 21
+  #19:
+    %yy1 = alloca ptr, align 8, !psr.id !58 | ID: 22
+  #20:
+    %yy2 = alloca ptr, align 8, !psr.id !59 | ID: 23
+  #21:
+    %call = call ptr @id3(ptr noundef %x), !dbg !72, !psr.id !73 | ID: 30
+  #22:
+    %call1 = call ptr @id3(ptr noundef %x), !dbg !78, !psr.id !79 | ID: 33
+  #23:
+    %call2 = call ptr @id3(ptr noundef %y), !dbg !84, !psr.id !85 | ID: 36
+  #24:
+    %call3 = call ptr @id3(ptr noundef %y), !dbg !90, !psr.id !91 | ID: 39
+  #25:
+    %0 = load ptr, ptr %xx1, align 8, !dbg !93, !psr.id !94 | ID: 41
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25>
+  #6: <>
+  #7: <>
+  #8: <>
+  #9: <>
+  #10: <4>
+  #11: <>
+  #12: <>
+  #13: <>
+  #14: <>
+  #15: <9>
+  #16: <>
+  #17: <>
+  #18: <>
+  #19: <>
+  #20: <14>
+  #21: <>
+  #22: <>
+  #23: <>
+  #24: <>
+  #25: <17>
+  #26: <>
+  #27: <>
+  #28: <>
+  #29: <>
+  #30: <18>
+  #31: <>
+  #32: <>
+  #33: <>
+  #34: <>
+  #35: <19>
+  #36: <>
+  #37: <>
+  #38: <>
+  #39: <>
+  #40: <20>
+  #41: <>
+  #42: <>
+  #43: <>
+  #44: <>
+}
+// TODO: talk with Fabian about the same points as in comment in Context01
+unittest
+  */
   GTMap GT = {{LineColFunOp{.Line = 7,
                             .Col = 0,
                             .InFunction = "main",
@@ -2083,6 +2612,106 @@ TEST(IndirectionSensUnionFindAATest, Context04_1) {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context05_0) {
+  /*
+  ValueCompressor: {
+  #0:
+    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    ptr %p | ID: id1.0
+  #2:
+    %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
+  #3:
+    fun @id1.<ret>
+  #4:
+    %q.addr = alloca ptr, align 8, !psr.id !27 | ID: 5
+  #5:
+    ptr %q | ID: id2.0
+  #6:
+    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 8
+  #7:
+    %call = call ptr @id1(ptr noundef %0), !dbg !34, !psr.id !35 | ID: 9
+  #8:
+    fun @id2.<ret>
+  #9:
+    %r.addr = alloca ptr, align 8, !psr.id !39 | ID: 11
+  #10:
+    ptr %r | ID: id3.0
+  #11:
+    %0 = load ptr, ptr %r.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
+  #12:
+    %call = call ptr @id2(ptr noundef %0), !dbg !46, !psr.id !47 | ID: 15
+  #13:
+    fun @id3.<ret>
+  #14:
+    %s.addr = alloca ptr, align 8, !psr.id !51 | ID: 17
+  #15:
+    ptr %s | ID: id4.0
+  #16:
+    %0 = load ptr, ptr %s.addr, align 8, !dbg !56, !psr.id !57 | ID: 20
+  #17:
+    %call = call ptr @id3(ptr noundef %0), !dbg !58, !psr.id !59 | ID: 21
+  #18:
+    fun @id4.<ret>
+  #19:
+    %retval = alloca i32, align 4, !psr.id !65 | ID: 23
+  #20:
+    %x = alloca i32, align 4, !psr.id !66 | ID: 24
+  #21:
+    %xx = alloca ptr, align 8, !psr.id !67 | ID: 25
+  #22:
+    %yy = alloca ptr, align 8, !psr.id !68 | ID: 26
+  #23:
+    %call = call ptr @id4(ptr noundef %x), !dbg !77, !psr.id !78 | ID: 31
+  #24:
+    %call1 = call ptr @id4(ptr noundef %x), !dbg !83, !psr.id !84 | ID: 34
+  #25:
+    %0 = load ptr, ptr %xx, align 8, !dbg !86, !psr.id !87 | ID: 36
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 17, 18, 20, 23, 24, 25>
+  #6: <>
+  #7: <>
+  #8: <>
+  #9: <>
+  #10: <4>
+  #11: <>
+  #12: <>
+  #13: <>
+  #14: <>
+  #15: <9>
+  #16: <>
+  #17: <>
+  #18: <>
+  #19: <>
+  #20: <14>
+  #21: <>
+  #22: <>
+  #23: <>
+  #24: <>
+  #25: <19>
+  #26: <>
+  #27: <>
+  #28: <>
+  #29: <>
+  #30: <21>
+  #31: <>
+  #32: <>
+  #33: <>
+  #34: <>
+  #35: <22>
+  #36: <>
+  #37: <>
+  #38: <>
+  #39: <>
+}
+// TODO: talk with Fabian about the same points as in comment in Context01
+unittest
+  */
   GTMap GT = {{LineColFunOp{.Line = 8,
                             .Col = 0,
                             .InFunction = "main",
@@ -2110,6 +2739,118 @@ TEST(IndirectionSensUnionFindAATest, Context05_0) {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context05_1) {
+  /*
+  ValueCompressor: {
+  #0:
+    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    ptr %p | ID: id1.0
+  #2:
+    %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
+  #3:
+    fun @id1.<ret>
+  #4:
+    %q.addr = alloca ptr, align 8, !psr.id !27 | ID: 5
+  #5:
+    ptr %q | ID: id2.0
+  #6:
+    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 8
+  #7:
+    %call = call ptr @id1(ptr noundef %0), !dbg !34, !psr.id !35 | ID: 9
+  #8:
+    fun @id2.<ret>
+  #9:
+    %r.addr = alloca ptr, align 8, !psr.id !39 | ID: 11
+  #10:
+    ptr %r | ID: id3.0
+  #11:
+    %0 = load ptr, ptr %r.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
+  #12:
+    %call = call ptr @id2(ptr noundef %0), !dbg !46, !psr.id !47 | ID: 15
+  #13:
+    fun @id3.<ret>
+  #14:
+    %s.addr = alloca ptr, align 8, !psr.id !51 | ID: 17
+  #15:
+    ptr %s | ID: id4.0
+  #16:
+    %0 = load ptr, ptr %s.addr, align 8, !dbg !56, !psr.id !57 | ID: 20
+  #17:
+    %call = call ptr @id3(ptr noundef %0), !dbg !58, !psr.id !59 | ID: 21
+  #18:
+    fun @id4.<ret>
+  #19:
+    %retval = alloca i32, align 4, !psr.id !65 | ID: 23
+  #20:
+    %x = alloca i32, align 4, !psr.id !66 | ID: 24
+  #21:
+    %y = alloca i32, align 4, !psr.id !67 | ID: 25
+  #22:
+    %xx1 = alloca ptr, align 8, !psr.id !68 | ID: 26
+  #23:
+    %xx2 = alloca ptr, align 8, !psr.id !69 | ID: 27
+  #24:
+    %yy1 = alloca ptr, align 8, !psr.id !70 | ID: 28
+  #25:
+    %yy2 = alloca ptr, align 8, !psr.id !71 | ID: 29
+  #26:
+    %call = call ptr @id4(ptr noundef %x), !dbg !84, !psr.id !85 | ID: 36
+  #27:
+    %call1 = call ptr @id4(ptr noundef %x), !dbg !90, !psr.id !91 | ID: 39
+  #28:
+    %call2 = call ptr @id4(ptr noundef %y), !dbg !96, !psr.id !97 | ID: 42
+  #29:
+    %call3 = call ptr @id4(ptr noundef %y), !dbg !102, !psr.id !103 | ID: 45
+  #30:
+    %0 = load ptr, ptr %xx2, align 8, !dbg !105, !psr.id !106 | ID: 47
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 17, 18, 20, 21, 26, 27, 28,
+29, 30> #6: <> #7: <> #8: <> #9: <> #10: <4> #11: <> #12: <> #13: <> #14: <>
+  #15: <9>
+  #16: <>
+  #17: <>
+  #18: <>
+  #19: <>
+  #20: <14>
+  #21: <>
+  #22: <>
+  #23: <>
+  #24: <>
+  #25: <19>
+  #26: <>
+  #27: <>
+  #28: <>
+  #29: <>
+  #30: <22>
+  #31: <>
+  #32: <>
+  #33: <>
+  #34: <>
+  #35: <23>
+  #36: <>
+  #37: <>
+  #38: <>
+  #39: <>
+  #40: <24>
+  #41: <>
+  #42: <>
+  #43: <>
+  #44: <>
+  #45: <25>
+  #46: <>
+  #47: <>
+  #48: <>
+  #49: <>
+}
+// TODO: talk with Fabian about the same points as in comment in Context01
+unittest
+  */
   GTMap GT = {{LineColFunOp{.Line = 8,
                             .Col = 0,
                             .InFunction = "main",
@@ -2153,6 +2894,115 @@ TEST(IndirectionSensUnionFindAATest, Context05_1) {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context06_0) {
+  /*
+  ValueCompressor: {
+  #0:
+    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    ptr %p | ID: id1.0
+  #2:
+    %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
+  #3:
+    fun @id1.<ret>
+  #4:
+    %q.addr = alloca ptr, align 8, !psr.id !27 | ID: 5
+  #5:
+    ptr %q | ID: id2.0
+  #6:
+    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 8
+  #7:
+    %call = call ptr @id1(ptr noundef %0), !dbg !34, !psr.id !35 | ID: 9
+  #8:
+    fun @id2.<ret>
+  #9:
+    %r.addr = alloca ptr, align 8, !psr.id !39 | ID: 11
+  #10:
+    ptr %r | ID: id3.0
+  #11:
+    %0 = load ptr, ptr %r.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
+  #12:
+    %call = call ptr @id2(ptr noundef %0), !dbg !46, !psr.id !47 | ID: 15
+  #13:
+    fun @id3.<ret>
+  #14:
+    %s.addr = alloca ptr, align 8, !psr.id !51 | ID: 17
+  #15:
+    ptr %s | ID: id4.0
+  #16:
+    %0 = load ptr, ptr %s.addr, align 8, !dbg !56, !psr.id !57 | ID: 20
+  #17:
+    %call = call ptr @id3(ptr noundef %0), !dbg !58, !psr.id !59 | ID: 21
+  #18:
+    fun @id4.<ret>
+  #19:
+    %t.addr = alloca ptr, align 8, !psr.id !63 | ID: 23
+  #20:
+    ptr %t | ID: id5.0
+  #21:
+    %0 = load ptr, ptr %t.addr, align 8, !dbg !68, !psr.id !69 | ID: 26
+  #22:
+    %call = call ptr @id4(ptr noundef %0), !dbg !70, !psr.id !71 | ID: 27
+  #23:
+    fun @id5.<ret>
+  #24:
+    %retval = alloca i32, align 4, !psr.id !77 | ID: 29
+  #25:
+    %x = alloca i32, align 4, !psr.id !78 | ID: 30
+  #26:
+    %xx = alloca ptr, align 8, !psr.id !79 | ID: 31
+  #27:
+    %yy = alloca ptr, align 8, !psr.id !80 | ID: 32
+  #28:
+    %call = call ptr @id5(ptr noundef %x), !dbg !89, !psr.id !90 | ID: 37
+  #29:
+    %call1 = call ptr @id5(ptr noundef %x), !dbg !95, !psr.id !96 | ID: 40
+  #30:
+    %0 = load ptr, ptr %xx, align 8, !dbg !98, !psr.id !99 | ID: 42
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 17, 18, 20, 21, 22, 23, 25,
+28, 29, 30> #6: <> #7: <> #8: <> #9: <> #10: <4> #11: <> #12: <> #13: <> #14: <>
+  #15: <9>
+  #16: <>
+  #17: <>
+  #18: <>
+  #19: <>
+  #20: <14>
+  #21: <>
+  #22: <>
+  #23: <>
+  #24: <>
+  #25: <19>
+  #26: <>
+  #27: <>
+  #28: <>
+  #29: <>
+  #30: <24>
+  #31: <>
+  #32: <>
+  #33: <>
+  #34: <>
+  #35: <26>
+  #36: <>
+  #37: <>
+  #38: <>
+  #39: <>
+  #40: <27>
+  #41: <>
+  #42: <>
+  #43: <>
+  #44: <>
+}
+// TODO: talk with Fabian about the same points as in comment in Context01
+unittest.
+
+// TODO: why is result broken in #5? Was that a copy paste error?
+  */
   GTMap GT = {{LineColFunOp{.Line = 9,
                             .Col = 0,
                             .InFunction = "main",
@@ -2180,6 +3030,135 @@ TEST(IndirectionSensUnionFindAATest, Context06_0) {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context06_1) {
+  /*
+  ValueCompressor: {
+  #0:
+    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    ptr %p | ID: id1.0
+  #2:
+    %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
+  #3:
+    fun @id1.<ret>
+  #4:
+    %q.addr = alloca ptr, align 8, !psr.id !27 | ID: 5
+  #5:
+    ptr %q | ID: id2.0
+  #6:
+    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 8
+  #7:
+    %call = call ptr @id1(ptr noundef %0), !dbg !34, !psr.id !35 | ID: 9
+  #8:
+    fun @id2.<ret>
+  #9:
+    %r.addr = alloca ptr, align 8, !psr.id !39 | ID: 11
+  #10:
+    ptr %r | ID: id3.0
+  #11:
+    %0 = load ptr, ptr %r.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
+  #12:
+    %call = call ptr @id2(ptr noundef %0), !dbg !46, !psr.id !47 | ID: 15
+  #13:
+    fun @id3.<ret>
+  #14:
+    %s.addr = alloca ptr, align 8, !psr.id !51 | ID: 17
+  #15:
+    ptr %s | ID: id4.0
+  #16:
+    %0 = load ptr, ptr %s.addr, align 8, !dbg !56, !psr.id !57 | ID: 20
+  #17:
+    %call = call ptr @id3(ptr noundef %0), !dbg !58, !psr.id !59 | ID: 21
+  #18:
+    fun @id4.<ret>
+  #19:
+    %t.addr = alloca ptr, align 8, !psr.id !63 | ID: 23
+  #20:
+    ptr %t | ID: id5.0
+  #21:
+    %0 = load ptr, ptr %t.addr, align 8, !dbg !68, !psr.id !69 | ID: 26
+  #22:
+    %call = call ptr @id4(ptr noundef %0), !dbg !70, !psr.id !71 | ID: 27
+  #23:
+    fun @id5.<ret>
+  #24:
+    %retval = alloca i32, align 4, !psr.id !77 | ID: 29
+  #25:
+    %x = alloca i32, align 4, !psr.id !78 | ID: 30
+  #26:
+    %y = alloca i32, align 4, !psr.id !79 | ID: 31
+  #27:
+    %xx1 = alloca ptr, align 8, !psr.id !80 | ID: 32
+  #28:
+    %xx2 = alloca ptr, align 8, !psr.id !81 | ID: 33
+  #29:
+    %yy1 = alloca ptr, align 8, !psr.id !82 | ID: 34
+  #30:
+    %yy2 = alloca ptr, align 8, !psr.id !83 | ID: 35
+  #31:
+    %call = call ptr @id5(ptr noundef %x), !dbg !96, !psr.id !97 | ID: 42
+  #32:
+    %call1 = call ptr @id5(ptr noundef %x), !dbg !102, !psr.id !103 | ID: 45
+  #33:
+    %call2 = call ptr @id5(ptr noundef %y), !dbg !108, !psr.id !109 | ID: 48
+  #34:
+    %call3 = call ptr @id5(ptr noundef %y), !dbg !114, !psr.id !115 | ID: 51
+  #35:
+    %0 = load ptr, ptr %yy1, align 8, !dbg !117, !psr.id !118 | ID: 53
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 17, 18, 20, 21, 22, 23, 25,
+26, 31, 32, 33, 34, 35> #6: <> #7: <> #8: <> #9: <> #10: <4> #11: <> #12: <>
+  #13: <>
+  #14: <>
+  #15: <9>
+  #16: <>
+  #17: <>
+  #18: <>
+  #19: <>
+  #20: <14>
+  #21: <>
+  #22: <>
+  #23: <>
+  #24: <>
+  #25: <19>
+  #26: <>
+  #27: <>
+  #28: <>
+  #29: <>
+  #30: <24>
+  #31: <>
+  #32: <>
+  #33: <>
+  #34: <>
+  #35: <27>
+  #36: <>
+  #37: <>
+  #38: <>
+  #39: <>
+  #40: <28>
+  #41: <>
+  #42: <>
+  #43: <>
+  #44: <>
+  #45: <29>
+  #46: <>
+  #47: <>
+  #48: <>
+  #49: <>
+  #50: <30>
+  #51: <>
+  #52: <>
+  #53: <>
+  #54: <>
+}
+// TODO: talk with Fabian about the same points as in comment in Context01
+unittest
+  */
   GTMap GT = {{LineColFunOp{.Line = 9,
                             .Col = 0,
                             .InFunction = "main",
@@ -2223,6 +3202,108 @@ TEST(IndirectionSensUnionFindAATest, Context06_1) {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context07) {
+  /*
+  ValueCompressor: {
+  #0:
+    %s.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    ptr %s | ID: buzz.0
+  #2:
+    %0 = load ptr, ptr %s.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
+  #3:
+    fun @buzz.<ret>
+  #4:
+    %r.addr = alloca ptr, align 8, !psr.id !27 | ID: 5
+  #5:
+    ptr %r | ID: baz.0
+  #6:
+    %0 = load ptr, ptr %r.addr, align 8, !dbg !32, !psr.id !33 | ID: 8
+  #7:
+    %call = call ptr @buzz(ptr noundef %0), !dbg !34, !psr.id !35 | ID: 9
+  #8:
+    fun @baz.<ret>
+  #9:
+    %q.addr = alloca ptr, align 8, !psr.id !39 | ID: 11
+  #10:
+    ptr %q | ID: bar.0
+  #11:
+    %0 = load ptr, ptr %q.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
+  #12:
+    %call = call ptr @baz(ptr noundef %0), !dbg !46, !psr.id !47 | ID: 15
+  #13:
+    fun @bar.<ret>
+  #14:
+    %p.addr = alloca ptr, align 8, !psr.id !51 | ID: 17
+  #15:
+    ptr %p | ID: foo.0
+  #16:
+    %0 = load ptr, ptr %p.addr, align 8, !dbg !56, !psr.id !57 | ID: 20
+  #17:
+    %call = call ptr @bar(ptr noundef %0), !dbg !58, !psr.id !59 | ID: 21
+  #18:
+    fun @foo.<ret>
+  #19:
+    %retval = alloca i32, align 4, !psr.id !65 | ID: 23
+  #20:
+    %x = alloca i32, align 4, !psr.id !66 | ID: 24
+  #21:
+    %y = alloca i32, align 4, !psr.id !67 | ID: 25
+  #22:
+    %xx = alloca ptr, align 8, !psr.id !68 | ID: 26
+  #23:
+    %yy = alloca ptr, align 8, !psr.id !69 | ID: 27
+  #24:
+    %call = call ptr @foo(ptr noundef %x), !dbg !82, !psr.id !83 | ID: 34
+  #25:
+    %call1 = call ptr @foo(ptr noundef %y), !dbg !88, !psr.id !89 | ID: 37
+  #26:
+    %0 = load ptr, ptr %xx, align 8, !dbg !91, !psr.id !92 | ID: 39
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 17, 18, 20, 21, 24, 25, 26>
+  #6: <>
+  #7: <>
+  #8: <>
+  #9: <>
+  #10: <4>
+  #11: <>
+  #12: <>
+  #13: <>
+  #14: <>
+  #15: <9>
+  #16: <>
+  #17: <>
+  #18: <>
+  #19: <>
+  #20: <14>
+  #21: <>
+  #22: <>
+  #23: <>
+  #24: <>
+  #25: <19>
+  #26: <>
+  #27: <>
+  #28: <>
+  #29: <>
+  #30: <22>
+  #31: <>
+  #32: <>
+  #33: <>
+  #34: <>
+  #35: <23>
+  #36: <>
+  #37: <>
+  #38: <>
+  #39: <>
+}
+// TODO: talk with Fabian about the same points as in comment in Context01
+unittest
+  */
   GTMap GT = {
       {LineColFunOp{.Line = 8,
                     .Col = 0,
@@ -2262,6 +3343,73 @@ TEST(IndirectionSensUnionFindAATest, Context07) {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context08) {
+  /*
+  ValueCompressor: {
+  #0:
+    %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
+  #2:
+    ptr %Ptr | ID: selfRecursion.0
+  #3:
+    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
+    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
+    %3 = load ptr, ptr %Ptr.addr, align 8, !dbg !38, !psr.id !39 | ID: 11
+    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
+    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !48, !psr.id !49 | ID: 16
+  #4:
+    %call = call ptr @selfRecursion(ptr noundef %6), !dbg !50, !psr.id !51 | ID:
+17 #5: fun @selfRecursion.<ret> #6: %7 = load ptr, ptr %retval, align 8, !dbg
+!55, !psr.id !56 | ID: 20 #7: %retval = alloca i32, align 4, !psr.id !61 | ID:
+22 #8: %k = alloca i32, align 4, !psr.id !62 | ID: 23 #9: %kptr = alloca ptr,
+align 8, !psr.id !63 | ID: 24 #10: %x = alloca ptr, align 8, !psr.id !64 | ID:
+25 #11: %y = alloca ptr, align 8, !psr.id !65 | ID: 26 #12: %0 = load ptr, ptr
+%kptr, align 8, !dbg !78, !psr.id !79 | ID: 33 %1 = load ptr, ptr %kptr, align
+8, !dbg !88, !psr.id !89 | ID: 38 #13: %call = call ptr @selfRecursion(ptr
+noundef %0), !dbg !80, !psr.id !81 | ID: 34 #14: %call1 = call ptr
+@selfRecursion(ptr noundef %1), !dbg !90, !psr.id !91 | ID: 39 #15: %2 = load
+ptr, ptr %x, align 8, !dbg !93, !psr.id !94 | ID: 41
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1>
+  #6: <>
+  #7: <>
+  #8: <>
+  #9: <>
+  #10: <2, 3, 4, 5, 6, 8, 12, 13, 14, 15>
+  #11: <>
+  #12: <>
+  #13: <>
+  #14: <>
+  #15: <7>
+  #16: <>
+  #17: <>
+  #18: <>
+  #19: <>
+  #20: <9>
+  #21: <>
+  #22: <>
+  #23: <>
+  #24: <>
+  #25: <10>
+  #26: <>
+  #27: <>
+  #28: <>
+  #29: <>
+  #30: <11>
+  #31: <>
+  #32: <>
+  #33: <>
+  #34: <>
+}
+// TODO: talk with Fabian about the same points as in comment in Context01
+unittest
+  */
   GTMap GT = {{LineColFunOp{.Line = 12,
                             .Col = 0,
                             .InFunction = "main",
@@ -2271,402 +3419,97 @@ TEST(IndirectionSensUnionFindAATest, Context08) {
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Alloca},
-                   LineColFunOp{.Line = 15,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 19,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 21,
-                                .Col = 0,
-                                .InFunction = "main",
+                   LineColFunOp{.Line = 7,
+                                .Col = 11,
+                                .InFunction = "selfRecursion",
                                 .OpCode = llvm::Instruction::Load},
                }}};
 
+  psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
+                                      "IndirectionSensUnionFindAA");
+
   doAnalysisAndCompareResults("context_08_c_dbg.ll", GT, IndAABuilder);
 }
 
 TEST(IndirectionSensUnionFindAATest, Context09_0) {
-  GTMap GT = {{LineColFunOp{.Line = 12,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 12,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 15,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call}}},
-              {LineColFunOp{.Line = 13,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 13,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 16,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 18,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load}}}};
+  // TODO: create ground truth after talking with fabian on how to construct it
+  // correctly/check if the UnionFindAAResults are correct or not.
+  GTMap GT{};
 
   doAnalysisAndCompareResults("context_09_0_c_dbg.ll", GT, IndAABuilder);
 }
 
 TEST(IndirectionSensUnionFindAATest, Context09_1) {
-  GTMap GT = {{LineColFunOp{.Line = 12,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 12,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 15,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 17,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call}}},
-              {LineColFunOp{.Line = 13,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 13,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 18,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 20,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 22,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load}}}};
+  // TODO: create ground truth after talking with fabian on how to construct it
+  // correctly/check if the UnionFindAAResults are correct or not.
+  GTMap GT{};
 
   doAnalysisAndCompareResults("context_09_1_c_dbg.ll", GT, IndAABuilder);
 }
 
 TEST(IndirectionSensUnionFindAATest, Context10_0) {
-  GTMap GT = {{LineColFunOp{.Line = 24,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 24,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 26,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 30,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 32,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load}}}};
+  // TODO: create ground truth after talking with fabian on how to construct it
+  // correctly/check if the UnionFindAAResults are correct or not.
+  GTMap GT{};
 
   doAnalysisAndCompareResults("context_10_0_c_dbg.ll", GT, IndAABuilder);
 }
 
 TEST(IndirectionSensUnionFindAATest, Context10_1) {
-  GTMap GT = {{LineColFunOp{.Line = 24,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 24,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 27,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 29,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 35,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load}}},
-              {LineColFunOp{.Line = 25,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 25,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 31,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 33,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call}}}};
+  // TODO: create ground truth after talking with fabian on how to construct it
+  // correctly/check if the UnionFindAAResults are correct or not.
+  GTMap GT{};
 
   doAnalysisAndCompareResults("context_10_1_c_dbg.ll", GT, IndAABuilder);
 }
 
 TEST(IndirectionSensUnionFindAATest, Context11_0) {
-  GTMap GT{{LineColFunOp{.Line = 33,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 33,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 36,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 39,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Load}}},
-           {LineColFunOp{.Line = 34,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 34,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 37,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 39,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Load}}}};
+  // TODO: create ground truth after talking with fabian on how to construct it
+  // correctly/check if the UnionFindAAResults are correct or not.
+  GTMap GT{};
 
   doAnalysisAndCompareResults("context_11_0_c_dbg.ll", GT, IndAABuilder);
 }
 
 TEST(IndirectionSensUnionFindAATest, Context11_1) {
-  GTMap GT{{LineColFunOp{.Line = 33,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 33,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 36,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 37,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 41,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Load}}},
-           {LineColFunOp{.Line = 34,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 34,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 38,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 39,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call}}}};
+  // TODO: create ground truth after talking with fabian on how to construct it
+  // correctly/check if the UnionFindAAResults are correct or not.
+  GTMap GT{};
 
   doAnalysisAndCompareResults("context_11_1_c_dbg.ll", GT, IndAABuilder);
 }
 
 TEST(IndirectionSensUnionFindAATest, Context12_0) {
-  GTMap GT{{LineColFunOp{.Line = 5,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 5,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 8,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 9,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 13,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Load}}},
-
-           {LineColFunOp{.Line = 6,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 6,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 10,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 11,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call}}}};
+  // TODO: create ground truth after talking with fabian on how to construct it
+  // correctly/check if the UnionFindAAResults are correct or not.
+  GTMap GT{};
 
   doAnalysisAndCompareResults("context_12_0_c_dbg.ll", GT, IndAABuilder);
 }
 
 TEST(IndirectionSensUnionFindAATest, Context12_1) {
-  GTMap GT{{LineColFunOp{.Line = 5,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 5,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 8,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 11,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Load}}},
-           {LineColFunOp{.Line = 6,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 6,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 9,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call}}}};
+  // TODO: create ground truth after talking with fabian on how to construct it
+  // correctly/check if the UnionFindAAResults are correct or not.
+  GTMap GT{};
 
   doAnalysisAndCompareResults("context_12_1_c_dbg.ll", GT, IndAABuilder);
 }
 
 TEST(IndirectionSensUnionFindAATest, Context13_0) {
-  GTMap GT{{LineColFunOp{.Line = 5,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 5,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 8,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 9,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 10,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 11,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 17,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Load}}},
-           {LineColFunOp{.Line = 6,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 6,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 12,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 13,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 14,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 15,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call}}}};
+  // TODO: create ground truth after talking with fabian on how to construct it
+  // correctly/check if the UnionFindAAResults are correct or not.
+  GTMap GT{};
 
   doAnalysisAndCompareResults("context_13_0_c_dbg.ll", GT, IndAABuilder);
 }
 
 TEST(IndirectionSensUnionFindAATest, Context13_1) {
-  GTMap GT{{LineColFunOp{.Line = 5,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 5,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 8,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call}}},
-           {LineColFunOp{.Line = 6,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 6,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 9,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 11,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Load}}}};
+  // TODO: create ground truth after talking with fabian on how to construct it
+  // correctly/check if the UnionFindAAResults are correct or not.
+  GTMap GT{};
+
+  // psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
+  //                                     "IndirectionSensUnionFindAA");
 
   doAnalysisAndCompareResults("context_13_1_c_dbg.ll", GT, IndAABuilder);
 }

From 70deb006bac4a13e423ee51740020e6f053d7dfb Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Mon, 2 Feb 2026 16:36:03 +0100
Subject: [PATCH 32/75] disabled context_01 indir test due to a crash

---
 unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index 6cba8ac8c7..c34e92ef64 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -1986,6 +1986,8 @@ TEST(IndirectionSensUnionFindAATest, Basic03) {
   doAnalysisAndCompareResults("basic_03_cpp_dbg.ll", GT, IndAABuilder);
 }
 
+#if false
+
 TEST(IndirectionSensUnionFindAATest, Context01) {
   /*
   ValueCompressor: {
@@ -2093,6 +2095,7 @@ UnionFindAAResult {
                              .OpCode = llvm::Instruction::Alloca}}}};
   doAnalysisAndCompareResults("context_01_c_dbg.ll", GT, IndAABuilder);
 }
+#endif
 
 TEST(IndirectionSensUnionFindAATest, Context02) {
   /*

From 44ba4070842117f443b33423f95b6b2991161832 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Mon, 2 Feb 2026 17:29:47 +0100
Subject: [PATCH 33/75] Add library summar to PAG

---
 BreakingChanges.md                            |  1 +
 .../IfdsIde/LLVMFunctionDataFlowFacts.h       | 89 -------------------
 .../IfdsIde/Problems/IFDSTaintAnalysis.h      |  2 +-
 .../Utils/LLVMFunctionDataFlowFacts.h         | 86 ++++++++++++++++++
 .../IfdsIde => Utils}/FunctionDataFlowFacts.h |  5 ++
 .../DataFlow/IfdsIde => Utils}/LibCSummary.h  |  0
 .../IfdsIde/LLVMFunctionDataFlowFacts.cpp     | 18 ----
 .../IfdsIde/Problems/IFDSTaintAnalysis.cpp    |  6 +-
 .../Pointer/LLVMPointerAssignmentGraph.cpp    | 82 ++++++++++++++++-
 .../IfdsIde => Utils}/LibCSummary.cpp         |  4 +-
 10 files changed, 177 insertions(+), 116 deletions(-)
 delete mode 100644 include/phasar/PhasarLLVM/DataFlow/IfdsIde/LLVMFunctionDataFlowFacts.h
 create mode 100644 include/phasar/PhasarLLVM/Utils/LLVMFunctionDataFlowFacts.h
 rename include/phasar/{PhasarLLVM/DataFlow/IfdsIde => Utils}/FunctionDataFlowFacts.h (95%)
 rename include/phasar/{PhasarLLVM/DataFlow/IfdsIde => Utils}/LibCSummary.h (100%)
 delete mode 100644 lib/PhasarLLVM/DataFlow/IfdsIde/LLVMFunctionDataFlowFacts.cpp
 rename lib/{PhasarLLVM/DataFlow/IfdsIde => Utils}/LibCSummary.cpp (99%)

diff --git a/BreakingChanges.md b/BreakingChanges.md
index acb51fa4a9..0ae1744340 100644
--- a/BreakingChanges.md
+++ b/BreakingChanges.md
@@ -2,6 +2,7 @@
 
 ## development HEAD
 
+- The location of the library summary `FunctionDataFlowFacts` and `LLVMFunctionDataFlowFacts` has moved to `phasar/Utils/` and `phasar/PhasarLLVM/Utils`, respectively.
 - Requiring C++20 instead of C++17
   - Type-traits and other templates that are specialized now use `requires` instead of `enable_if`, wherever possible. This may reduce the number of (defaulted) template parameters in some cases.
 - The `AdjacencyList` struct now now has one more template argument to denote the intege-like `vertex_t` type. It is the second template argument (which previously was the EdgeType). The edge-type is now denoted by the *third* template argument.
diff --git a/include/phasar/PhasarLLVM/DataFlow/IfdsIde/LLVMFunctionDataFlowFacts.h b/include/phasar/PhasarLLVM/DataFlow/IfdsIde/LLVMFunctionDataFlowFacts.h
deleted file mode 100644
index da04b93b1b..0000000000
--- a/include/phasar/PhasarLLVM/DataFlow/IfdsIde/LLVMFunctionDataFlowFacts.h
+++ /dev/null
@@ -1,89 +0,0 @@
-/******************************************************************************
- * Copyright (c) 2025 Fabian Schiebel.
- * All rights reserved. This program and the accompanying materials are made
- * available under the terms of LICENSE.txt.
- *
- * Contributors:
- *     Fabian Schiebel, bulletspace and others
- *****************************************************************************/
-
-#ifndef PHASAR_PHASARLLVM_DATAFLOW_IFDSIDE_LLVMFUNCTIONDATAFLOWFACTS_H
-#define PHASAR_PHASARLLVM_DATAFLOW_IFDSIDE_LLVMFUNCTIONDATAFLOWFACTS_H
-
-#include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
-#include "phasar/PhasarLLVM/DataFlow/IfdsIde/FunctionDataFlowFacts.h"
-#include "phasar/Utils/DefaultValue.h"
-
-#include "llvm/IR/Argument.h"
-#include "llvm/IR/Function.h"
-
-#include <unordered_map>
-#include <vector>
-
-namespace psr::library_summary {
-
-class LLVMFunctionDataFlowFacts;
-[[nodiscard]] LLVMFunctionDataFlowFacts
-readFromFDFF(const FunctionDataFlowFacts &Fdff, const LLVMProjectIRDB &Irdb);
-
-/// @brief A LLVM-specific mapping of FunctionDataFlowFacts
-class LLVMFunctionDataFlowFacts {
-public:
-  LLVMFunctionDataFlowFacts() noexcept = default;
-  using ParameterMappingTy = FunctionDataFlowFacts::ParameterMappingTy;
-
-  /// insert a set of data flow facts
-  void insertSet(const llvm::Function *Fun, uint32_t Index,
-                 std::vector<DataFlowFact> OutSet) {
-
-    LLVMFdff[Fun].try_emplace(Index, std::move(OutSet));
-  }
-  void insertSet(const llvm::Function *Fun, const llvm::Argument *Arg,
-                 std::vector<DataFlowFact> OutSet) {
-
-    insertSet(Fun, Arg->getArgNo(), std::move(OutSet));
-  }
-
-  void addElement(const llvm::Function *Fun, uint32_t Index, DataFlowFact Out) {
-    LLVMFdff[Fun][Index].emplace_back(Out);
-  }
-  void addElement(const llvm::Function *Fun, const llvm::Argument *Arg,
-                  DataFlowFact Out) {
-    addElement(Fun, Arg->getArgNo(), Out);
-  }
-
-  [[nodiscard]] bool contains(const llvm::Function *Fn) {
-    return LLVMFdff.count(Fn);
-  }
-
-  [[nodiscard]] const std::vector<DataFlowFact> &
-  getFacts(const llvm::Function *Fun, uint32_t Index) {
-    auto Iter = LLVMFdff.find(Fun);
-    if (Iter != LLVMFdff.end()) {
-      return Iter->second[Index];
-    }
-    return getDefaultValue<std::vector<DataFlowFact>>();
-  }
-  [[nodiscard]] const std::vector<DataFlowFact> &
-  getFacts(const llvm::Function *Fun, const llvm::Argument *Arg) {
-    return getFacts(Fun, Arg->getArgNo());
-  }
-
-  [[nodiscard]] const ParameterMappingTy &
-  getFactsForFunction(const llvm::Function *Fun) {
-    auto Iter = LLVMFdff.find(Fun);
-    if (Iter != LLVMFdff.end()) {
-      return Iter->second;
-    }
-    return getDefaultValue<ParameterMappingTy>();
-  }
-
-  friend LLVMFunctionDataFlowFacts
-  readFromFDFF(const FunctionDataFlowFacts &Fdff, const LLVMProjectIRDB &Irdb);
-
-private:
-  std::unordered_map<const llvm::Function *, ParameterMappingTy> LLVMFdff;
-};
-} // namespace psr::library_summary
-
-#endif // PHASAR_PHASARLLVM_DATAFLOW_IFDSIDE_LLVMFUNCTIONDATAFLOWFACTS_H
diff --git a/include/phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSTaintAnalysis.h b/include/phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSTaintAnalysis.h
index c9e03340ab..acb5b07baa 100644
--- a/include/phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSTaintAnalysis.h
+++ b/include/phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSTaintAnalysis.h
@@ -11,9 +11,9 @@
 #define PHASAR_PHASARLLVM_DATAFLOW_IFDSIDE_PROBLEMS_IFDSTAINTANALYSIS_H
 
 #include "phasar/DataFlow/IfdsIde/IFDSTabulationProblem.h"
-#include "phasar/PhasarLLVM/DataFlow/IfdsIde/LLVMFunctionDataFlowFacts.h"
 #include "phasar/PhasarLLVM/Domain/LLVMAnalysisDomain.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h"
+#include "phasar/PhasarLLVM/Utils/LLVMFunctionDataFlowFacts.h"
 
 #include <map>
 #include <set>
diff --git a/include/phasar/PhasarLLVM/Utils/LLVMFunctionDataFlowFacts.h b/include/phasar/PhasarLLVM/Utils/LLVMFunctionDataFlowFacts.h
new file mode 100644
index 0000000000..3ec7914f8e
--- /dev/null
+++ b/include/phasar/PhasarLLVM/Utils/LLVMFunctionDataFlowFacts.h
@@ -0,0 +1,86 @@
+/******************************************************************************
+ * Copyright (c) 2025 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel, bulletspace and others
+ *****************************************************************************/
+
+#ifndef PHASAR_PHASARLLVM_DATAFLOW_IFDSIDE_LLVMFUNCTIONDATAFLOWFACTS_H
+#define PHASAR_PHASARLLVM_DATAFLOW_IFDSIDE_LLVMFUNCTIONDATAFLOWFACTS_H
+
+#include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
+#include "phasar/Utils/DefaultValue.h"
+#include "phasar/Utils/FunctionDataFlowFacts.h"
+#include "phasar/Utils/MapUtils.h"
+
+#include "llvm/IR/Argument.h"
+#include "llvm/IR/Function.h"
+
+#include <vector>
+
+namespace psr::library_summary {
+
+class LLVMFunctionDataFlowFacts;
+[[nodiscard]] LLVMFunctionDataFlowFacts
+readFromFDFF(const FunctionDataFlowFacts &Fdff,
+             std::invocable<llvm::StringRef> auto GetFunctionByNameOrNull);
+
+/// @brief A LLVM-specific mapping of FunctionDataFlowFacts
+class LLVMFunctionDataFlowFacts {
+public:
+  LLVMFunctionDataFlowFacts() noexcept = default;
+  using ParameterMappingTy = FunctionDataFlowFacts::ParameterMappingTy;
+
+  [[nodiscard]] bool contains(const llvm::Function *Fn) const {
+    return LLVMFdff.count(Fn);
+  }
+
+  [[nodiscard]] const std::vector<DataFlowFact> &
+  getFacts(const llvm::Function *Fun, uint32_t Index) const {
+    if (const auto *Iter = getOrDefault(LLVMFdff, Fun)) {
+      return getOrDefault(*Iter, Index);
+    }
+    return default_value();
+  }
+  [[nodiscard]] const std::vector<DataFlowFact> &
+  getFacts(const llvm::Function *Fun, const llvm::Argument *Arg) const {
+    return getFacts(Fun, Arg->getArgNo());
+  }
+
+  [[nodiscard]] const ParameterMappingTy &
+  getFactsForFunction(const llvm::Function *Fun) const {
+    if (const auto *Iter = getOrDefault(LLVMFdff, Fun)) {
+      return *Iter;
+    }
+    return default_value();
+  }
+
+  [[nodiscard]] const ParameterMappingTy *
+  getFactsForFunctionOrNull(const llvm::Function *Fun) const {
+    return getOrDefault(LLVMFdff, Fun);
+  }
+
+  [[nodiscard]] friend LLVMFunctionDataFlowFacts
+  readFromFDFF(const FunctionDataFlowFacts &Fdff,
+               std::invocable<llvm::StringRef> auto GetFunctionByNameOrNull) {
+    LLVMFunctionDataFlowFacts Ret{};
+    Ret.LLVMFdff.reserve(Fdff.size());
+
+    for (const auto &Elem : Fdff) {
+      if (const auto *Fun =
+              std::invoke(GetFunctionByNameOrNull, Elem.getKey())) {
+        Ret.LLVMFdff.try_emplace(Fun, &Elem.getValue());
+      }
+    }
+
+    return Ret;
+  }
+
+private:
+  llvm::DenseMap<const llvm::Function *, const ParameterMappingTy *> LLVMFdff;
+};
+} // namespace psr::library_summary
+
+#endif // PHASAR_PHASARLLVM_DATAFLOW_IFDSIDE_LLVMFUNCTIONDATAFLOWFACTS_H
diff --git a/include/phasar/PhasarLLVM/DataFlow/IfdsIde/FunctionDataFlowFacts.h b/include/phasar/Utils/FunctionDataFlowFacts.h
similarity index 95%
rename from include/phasar/PhasarLLVM/DataFlow/IfdsIde/FunctionDataFlowFacts.h
rename to include/phasar/Utils/FunctionDataFlowFacts.h
index ccb4c6b7c2..2d0afa8d8f 100644
--- a/include/phasar/PhasarLLVM/DataFlow/IfdsIde/FunctionDataFlowFacts.h
+++ b/include/phasar/Utils/FunctionDataFlowFacts.h
@@ -31,6 +31,11 @@ struct DataFlowFact {
   DataFlowFact(Parameter Param) noexcept : Fact(Param) {}
   DataFlowFact(ReturnValue Ret) noexcept : Fact(Ret) {}
 
+  template <typename T>
+  [[nodiscard]] constexpr const auto *dyn_cast() const noexcept {
+    return std::get_if<T>(&Fact);
+  }
+
   std::variant<Parameter, ReturnValue> Fact;
 };
 
diff --git a/include/phasar/PhasarLLVM/DataFlow/IfdsIde/LibCSummary.h b/include/phasar/Utils/LibCSummary.h
similarity index 100%
rename from include/phasar/PhasarLLVM/DataFlow/IfdsIde/LibCSummary.h
rename to include/phasar/Utils/LibCSummary.h
diff --git a/lib/PhasarLLVM/DataFlow/IfdsIde/LLVMFunctionDataFlowFacts.cpp b/lib/PhasarLLVM/DataFlow/IfdsIde/LLVMFunctionDataFlowFacts.cpp
deleted file mode 100644
index fdd60c7271..0000000000
--- a/lib/PhasarLLVM/DataFlow/IfdsIde/LLVMFunctionDataFlowFacts.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "phasar/PhasarLLVM/DataFlow/IfdsIde/LLVMFunctionDataFlowFacts.h"
-
-using namespace psr;
-using namespace psr::library_summary;
-
-LLVMFunctionDataFlowFacts
-library_summary::readFromFDFF(const FunctionDataFlowFacts &Fdff,
-                              const LLVMProjectIRDB &Irdb) {
-  LLVMFunctionDataFlowFacts Llvmfdff;
-  Llvmfdff.LLVMFdff.reserve(Fdff.size());
-
-  for (const auto &It : Fdff) {
-    if (const llvm::Function *Fun = Irdb.getFunction(It.first())) {
-      Llvmfdff.LLVMFdff.try_emplace(Fun, It.second);
-    }
-  }
-  return Llvmfdff;
-}
diff --git a/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSTaintAnalysis.cpp b/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSTaintAnalysis.cpp
index 28b8b65f0a..8809e452a3 100644
--- a/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSTaintAnalysis.cpp
+++ b/lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IFDSTaintAnalysis.cpp
@@ -15,13 +15,13 @@
 #include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/LLVMFlowFunctions.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/LLVMZeroValue.h"
-#include "phasar/PhasarLLVM/DataFlow/IfdsIde/LibCSummary.h"
 #include "phasar/PhasarLLVM/Domain/LLVMAnalysisDomain.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h"
 #include "phasar/PhasarLLVM/TaintConfig/TaintConfigUtilities.h"
 #include "phasar/PhasarLLVM/Utils/DataFlowAnalysisType.h"
 #include "phasar/PhasarLLVM/Utils/LLVMIRToSrc.h"
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
+#include "phasar/Utils/LibCSummary.h"
 #include "phasar/Utils/Logger.h"
 
 #include "llvm/ADT/ArrayRef.h"
@@ -48,7 +48,9 @@ IFDSTaintAnalysis::IFDSTaintAnalysis(const LLVMProjectIRDB *IRDB,
                                      bool TaintMainArgs)
     : IFDSTabulationProblem(IRDB, std::move(EntryPoints), createZeroValue()),
       Config(Config), PT(PT), TaintMainArgs(TaintMainArgs),
-      Llvmfdff(library_summary::readFromFDFF(getLibCSummary(), *IRDB)) {
+      Llvmfdff(library_summary::readFromFDFF(
+          getLibCSummary(),
+          [IRDB](llvm::StringRef FName) { return IRDB->getFunction(FName); })) {
   assert(Config != nullptr);
   assert(PT);
 }
diff --git a/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp b/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp
index 33f67eea69..70287f3ec8 100644
--- a/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp
+++ b/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp
@@ -1,8 +1,11 @@
 #include "phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h"
 
 #include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
+#include "phasar/PhasarLLVM/Utils/LLVMFunctionDataFlowFacts.h"
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
+#include "phasar/Pointer/PointerAssignmentGraph.h"
 #include "phasar/Utils/BitSet.h"
+#include "phasar/Utils/LibCSummary.h"
 #include "phasar/Utils/MapUtils.h"
 #include "phasar/Utils/ValueCompressor.h"
 
@@ -14,6 +17,7 @@
 #include "llvm/IR/Operator.h"
 
 #include <concepts>
+#include <functional>
 
 using namespace psr;
 using namespace psr::pag;
@@ -96,11 +100,44 @@ struct GlobalCache {
     return Vec;
   }
 };
+
+struct PAGMappedLibrarySummary {
+  library_summary::LLVMFunctionDataFlowFacts Facts;
+
+  bool
+  mapFunctionSummary(const llvm::Function *Fun,
+                     std::invocable<uint32_t, library_summary::DataFlowFact,
+                                    pag::Edge> auto AddEdge) const {
+    const auto *LibSum = Facts.getFactsForFunctionOrNull(Fun);
+    if (!LibSum) {
+      return false;
+    }
+
+    const size_t NumParams = Fun->arg_size();
+
+    for (const auto &[ParamFact, Pts] : *LibSum) {
+      if (ParamFact >= NumParams ||
+          !Fun->getArg(ParamFact)->getType()->isPointerTy()) {
+        continue;
+      }
+
+      for (const auto &DestFact : Pts) {
+        auto E = DestFact.dyn_cast<library_summary::Parameter>()
+                     ? pag::Edge(pag::StorePOI{})
+                     : pag::Assign{};
+        std::invoke(AddEdge, ParamFact, DestFact, E);
+      }
+    }
+    return true;
+  }
+};
+
 } // namespace
 
 struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
-  const llvm::DataLayout &DL; // NOLINT
-  ValueCompressor<v_t> &VC;   // NOLINT
+  const llvm::DataLayout &DL;           // NOLINT
+  ValueCompressor<v_t> &VC;             // NOLINT
+  const PAGMappedLibrarySummary &MLSum; // NOLINT
 
   llvm::DenseMap<ValueId, ValueId> TheOneLoad{};
   BitSet<ValueId> OnlyIncomingStoresAndOutgoingLoads{};
@@ -449,7 +486,32 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
                         const llvm::Function *Callee,
                         llvm::ArrayRef<llvm::SmallDenseSet<ValueId>> Args,
                         std::optional<ValueId> CSVal) {
-    // TODO: Handle library summaries here!
+    const bool HasLibrarySummary = MLSum.mapFunctionSummary(
+        Callee, [&](uint32_t ParamIdx, library_summary::DataFlowFact Dest,
+                    pag::Edge E) {
+          if (ParamIdx > Args.size()) {
+            return;
+          }
+          const auto HandleArgs = [&](ValueId DestVal) {
+            for (auto FromVal : Args[ParamIdx]) {
+              addEdge(Strategy, FromVal, DestVal, E, Call);
+            }
+          };
+          if (const auto *DestParam =
+                  Dest.dyn_cast<library_summary::Parameter>()) {
+            for (const auto &DestVal : Args[DestParam->Index]) {
+              HandleArgs(DestVal);
+            }
+          } else {
+            if (CSVal) {
+              HandleArgs(*CSVal);
+            }
+          }
+        });
+    if (HasLibrarySummary) {
+      return;
+    }
+
     if (Callee->isDeclaration()) {
       return;
     }
@@ -491,6 +553,7 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
         ArgVal.insert(getVariable(ArgOp, Strategy));
       });
     }
+
     std::optional<ValueId> CSVal;
     if (Call->getType()->isPointerTy()) {
       CSVal = getVariable(Call, Strategy);
@@ -571,7 +634,18 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
 void psr::LLVMPAGBuilder::buildPAG(const LLVMProjectIRDB &IRDB,
                                    ValueCompressor<v_t> &VC,
                                    LLVMPBStrategyRef Strategy) {
-  PAGBuildData BData{IRDB.getModule()->getDataLayout(), VC};
+
+  const auto &LibSum = getLibCSummary();
+  const PAGMappedLibrarySummary MLSum{
+      {library_summary::readFromFDFF(LibSum, [&IRDB](llvm::StringRef FName) {
+        return IRDB.getFunction(FName);
+      })}};
+
+  PAGBuildData BData{
+      .DL = IRDB.getModule()->getDataLayout(),
+      .VC = VC,
+      .MLSum = MLSum,
+  };
 
   const size_t NumPossibleValues = Strategy.getNumPossibleValues(IRDB);
   const size_t NumPresentValues = VC.size();
diff --git a/lib/PhasarLLVM/DataFlow/IfdsIde/LibCSummary.cpp b/lib/Utils/LibCSummary.cpp
similarity index 99%
rename from lib/PhasarLLVM/DataFlow/IfdsIde/LibCSummary.cpp
rename to lib/Utils/LibCSummary.cpp
index aa6c64f1bc..ac47eb44be 100644
--- a/lib/PhasarLLVM/DataFlow/IfdsIde/LibCSummary.cpp
+++ b/lib/Utils/LibCSummary.cpp
@@ -1,6 +1,6 @@
-#include "phasar/PhasarLLVM/DataFlow/IfdsIde/LibCSummary.h"
+#include "phasar/Utils/LibCSummary.h"
 
-#include "phasar/PhasarLLVM/DataFlow/IfdsIde/FunctionDataFlowFacts.h"
+#include "phasar/Utils/FunctionDataFlowFacts.h"
 
 using namespace psr;
 using namespace psr::library_summary;

From cd14392072d22d37c9ac40a75a78809f8621ea96 Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Tue, 3 Feb 2026 13:24:03 +0100
Subject: [PATCH 34/75] fixed Indir Context01

---
 .../Pointer/LLVMUnionFindAATest.cpp           | 45 ++++++++-----------
 1 file changed, 19 insertions(+), 26 deletions(-)

diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index c34e92ef64..b67aa23b17 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -1986,8 +1986,6 @@ TEST(IndirectionSensUnionFindAATest, Basic03) {
   doAnalysisAndCompareResults("basic_03_cpp_dbg.ll", GT, IndAABuilder);
 }
 
-#if false
-
 TEST(IndirectionSensUnionFindAATest, Context01) {
   /*
   ValueCompressor: {
@@ -2055,47 +2053,42 @@ UnionFindAAResult {
 
     Shouldn't the result be something like:
 
-    #5: <1, 2, 3, 5, 9, 11>
-    #6: <6, 10>
 
     ?
   */
 
-  GTMap GT = {{// #5: %x = alloca i32, align 4, !psr.id !30 | ID: 6
-               LineColFunOp{.Line = 5,
+  GTMap GT = {{LineColFunOp{.Line = 5,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {// #1: ptr %p | ID: id.0
+               {ArgInFun{.Idx = 0, .InFunction = "id"},
                 LineColFunOp{.Line = 2,
-                             .Col = 14,
+                             .Col = 26,
+                             .InFunction = "id",
+                             .OpCode = llvm::Instruction::Load},
+                RetVal{.InFunction = "id"},
+                LineColFunOp{.Line = 5,
+                             .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
-                // #2: %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id
-                // !23 | ID: 3
-                LineColFunOp{.Line = 2,
-                             .Col = 26,
+                LineColFunOp{.Line = 6,
+                             .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
-                // #3: fun @id.<ret>
-                LineColFunOp{.Line = 2,
-                             .Col = 19,
+                LineColFunOp{.Line = 8,
+                             .Col = 13,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {// #6: %y = alloca i32, align 4, !psr.id !31 | ID: 7
-               LineColFunOp{.Line = 6,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {// #10: %call1 = call ptr @id(ptr noundef %y), !dbg !52, !psr.id
-                // !53 | ID: 19
+                             .OpCode = llvm::Instruction::Call},
                 LineColFunOp{.Line = 9,
-                             .Col = 0,
+                             .Col = 13,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}}};
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 11,
+                             .Col = 11,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}}};
   doAnalysisAndCompareResults("context_01_c_dbg.ll", GT, IndAABuilder);
 }
-#endif
 
 TEST(IndirectionSensUnionFindAATest, Context02) {
   /*

From cdfd410383bc5b691c17662ad049fb8e6f6a980d Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Tue, 3 Feb 2026 13:34:10 +0100
Subject: [PATCH 35/75] fixed LLVMAliasSet tests

---
 unittests/PhasarLLVM/Pointer/LLVMAliasSetSerializationTest.cpp | 2 +-
 unittests/PhasarLLVM/Pointer/LLVMAliasSetTest.cpp              | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/unittests/PhasarLLVM/Pointer/LLVMAliasSetSerializationTest.cpp b/unittests/PhasarLLVM/Pointer/LLVMAliasSetSerializationTest.cpp
index 496aeff6b1..7755eddc6c 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMAliasSetSerializationTest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMAliasSetSerializationTest.cpp
@@ -94,7 +94,7 @@ static void analyze(llvm::StringRef File, const GroundTruthTy &Gt,
 }
 
 TEST(LLVMAliasSetSerializationTest, Ser_Intra01) {
-  analyze("pointers/basic_01_cpp.ll", {{{"1"}, {"0", "3"}}, {"main"}});
+  analyze("pointers/basic_01_c.ll", {{{"1"}, {"0", "3"}}, {"main"}});
 }
 
 TEST(LLVMAliasSetSerializationTest, Ser_Inter01) {
diff --git a/unittests/PhasarLLVM/Pointer/LLVMAliasSetTest.cpp b/unittests/PhasarLLVM/Pointer/LLVMAliasSetTest.cpp
index 15208cccc5..88e9abcb44 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMAliasSetTest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMAliasSetTest.cpp
@@ -18,8 +18,7 @@ using namespace psr;
 
 TEST(LLVMAliasSet, Intra_01) {
   ValueAnnotationPass::resetValueID();
-  LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
-                       "pointers/basic_01_cpp.ll");
+  LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles + "pointers/basic_01_c.ll");
 
   LLVMAliasSet PTS(&IRDB, false);
   const auto *Main = IRDB.getFunctionDefinition("main");

From c4e15e8534bdcf1579d735b9af8ab3d64fbb4209 Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Tue, 3 Feb 2026 13:57:03 +0100
Subject: [PATCH 36/75] Fixed Indir Context02, 03 and 04_0

---
 .../Pointer/LLVMUnionFindAATest.cpp           | 59 ++++++++++++++-----
 1 file changed, 44 insertions(+), 15 deletions(-)

diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index b67aa23b17..05968571c0 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -2187,25 +2187,19 @@ Relevant lines:
   #5: <1, 2, 3, 9, 15, 16, 19>
   #15: <5, 6, 7, 10, 17, 18>
 
-
-  // TODO: talk with Fabian about the same points as in comment in Context01
-  unittest
-
-  // TODO: talk with fabian on why it's #5 and #15 here?
-
-  // TODO: ask fabian if my following expected result would be correct:
-
-  #9: <1, 2, 3, 11, 12, 19>
-  #10: <5, 6, 7, 13, 14>
-
   */
   GTMap GT = {
-      {// #9: %x = alloca i32, align 4, !psr.id !40 | ID: 11
-       LineColFunOp{.Line = 6,
+      {LineColFunOp{.Line = 6,
                     .Col = 0,
                     .InFunction = "main",
                     .OpCode = llvm::Instruction::Alloca},
        {
+           ArgInFun{.Idx = 0, .InFunction = "id1"},
+           LineColFunOp{.Line = 2,
+                        .Col = 27,
+                        .InFunction = "id1",
+                        .OpCode = llvm::Instruction::Load},
+           RetVal{.InFunction = "id1"},
            LineColFunOp{.Line = 6,
                         .Col = 0,
                         .InFunction = "main",
@@ -2223,12 +2217,17 @@ Relevant lines:
                         .InFunction = "main",
                         .OpCode = llvm::Instruction::Load},
        }},
-      {// #10: %y = alloca i32, align 4, !psr.id !41 | ID: 12
-       LineColFunOp{.Line = 7,
+      {LineColFunOp{.Line = 7,
                     .Col = 0,
                     .InFunction = "main",
                     .OpCode = llvm::Instruction::Alloca},
        {
+           ArgInFun{.Idx = 0, .InFunction = "id2"},
+           LineColFunOp{.Line = 3,
+                        .Col = 27,
+                        .InFunction = "id2",
+                        .OpCode = llvm::Instruction::Load},
+           RetVal{.InFunction = "id2"},
            LineColFunOp{.Line = 7,
                         .Col = 0,
                         .InFunction = "main",
@@ -2326,6 +2325,18 @@ unittest
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
                {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 27,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 27,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id2"},
                    LineColFunOp{.Line = 6,
                                 .Col = 0,
                                 .InFunction = "main",
@@ -2438,6 +2449,24 @@ unittest
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
                {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 27,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 27,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id2"},
+                   ArgInFun{.Idx = 0, .InFunction = "id3"},
+                   LineColFunOp{.Line = 4,
+                                .Col = 27,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id3"},
                    LineColFunOp{.Line = 7,
                                 .Col = 0,
                                 .InFunction = "main",

From 7c6d3da4ba234a73df195787804fced971fcc87a Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Tue, 3 Feb 2026 16:10:10 +0100
Subject: [PATCH 37/75] Enable passing LLVMFunctionDataFlowFacts into
 LLVMPAGBuilder

---
 .../Pointer/LLVMPointerAssignmentGraph.h      | 11 ++++++++++
 .../Pointer/LLVMPointerAssignmentGraph.cpp    | 21 ++++++++++++-------
 2 files changed, 25 insertions(+), 7 deletions(-)

diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h b/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
index 9ee309b535..98539a23da 100644
--- a/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
@@ -12,6 +12,10 @@ class Function;
 
 namespace psr {
 
+namespace library_summary {
+class LLVMFunctionDataFlowFacts;
+} // namespace library_summary
+
 /// The PAG-node used for LLVM-based pointer-assignment graphs. It consists of
 /// regular LLVM values + special return-slots per non-void function. In that
 /// case, the stored pointer is the corresponding function.
@@ -84,11 +88,18 @@ struct LLVMPAGDomain : LLVMAnalysisDomainDefault {
 
 class LLVMPAGBuilder : public PAGBuilder<LLVMPAGDomain> {
 public:
+  constexpr LLVMPAGBuilder() noexcept = default;
+  constexpr LLVMPAGBuilder(
+      const library_summary::LLVMFunctionDataFlowFacts *MLSum) noexcept
+      : MLSum(MLSum) {}
+
   void buildPAG(const LLVMProjectIRDB &IRDB, ValueCompressor<v_t> &VC,
                 pag::PBStrategyRef<LLVMPAGDomain> Strategy) override;
 
 private:
   struct PAGBuildData;
+
+  const library_summary::LLVMFunctionDataFlowFacts *MLSum{};
 };
 
 } // namespace psr
diff --git a/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp b/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp
index 70287f3ec8..758bff8ff2 100644
--- a/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp
+++ b/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp
@@ -102,7 +102,7 @@ struct GlobalCache {
 };
 
 struct PAGMappedLibrarySummary {
-  library_summary::LLVMFunctionDataFlowFacts Facts;
+  const library_summary::LLVMFunctionDataFlowFacts &Facts; // NOLINT
 
   bool
   mapFunctionSummary(const llvm::Function *Fun,
@@ -631,20 +631,27 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
   }
 };
 
+static const auto &getMappedLibSum(
+    std::optional<library_summary::LLVMFunctionDataFlowFacts> &MLSumBuf,
+    const LLVMProjectIRDB &IRDB) {
+  MLSumBuf.emplace(library_summary::readFromFDFF(
+      getLibCSummary(),
+      [&IRDB](llvm::StringRef FName) { return IRDB.getFunction(FName); }));
+  return *MLSumBuf;
+}
+
 void psr::LLVMPAGBuilder::buildPAG(const LLVMProjectIRDB &IRDB,
                                    ValueCompressor<v_t> &VC,
                                    LLVMPBStrategyRef Strategy) {
 
-  const auto &LibSum = getLibCSummary();
-  const PAGMappedLibrarySummary MLSum{
-      {library_summary::readFromFDFF(LibSum, [&IRDB](llvm::StringRef FName) {
-        return IRDB.getFunction(FName);
-      })}};
+  std::optional<library_summary::LLVMFunctionDataFlowFacts> MLSumBuf{};
+  const auto &MLSum =
+      this->MLSum ? *this->MLSum : getMappedLibSum(MLSumBuf, IRDB);
 
   PAGBuildData BData{
       .DL = IRDB.getModule()->getDataLayout(),
       .VC = VC,
-      .MLSum = MLSum,
+      .MLSum = {MLSum},
   };
 
   const size_t NumPossibleValues = Strategy.getNumPossibleValues(IRDB);

From df65742b416de5c7c3afc1f22f9a840532f2a832 Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Tue, 3 Feb 2026 16:30:49 +0100
Subject: [PATCH 38/75] added missing allocas to ground truths 01 - 04_0

---
 .../Pointer/LLVMUnionFindAATest.cpp           | 192 ++++++++++++------
 1 file changed, 135 insertions(+), 57 deletions(-)

diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index 05968571c0..d63e0775b2 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -2086,7 +2086,23 @@ UnionFindAAResult {
                 LineColFunOp{.Line = 11,
                              .Col = 11,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load}}}};
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
   doAnalysisAndCompareResults("context_01_c_dbg.ll", GT, IndAABuilder);
 }
 
@@ -2188,60 +2204,90 @@ Relevant lines:
   #15: <5, 6, 7, 10, 17, 18>
 
   */
-  GTMap GT = {
-      {LineColFunOp{.Line = 6,
-                    .Col = 0,
-                    .InFunction = "main",
-                    .OpCode = llvm::Instruction::Alloca},
-       {
-           ArgInFun{.Idx = 0, .InFunction = "id1"},
-           LineColFunOp{.Line = 2,
-                        .Col = 27,
-                        .InFunction = "id1",
-                        .OpCode = llvm::Instruction::Load},
-           RetVal{.InFunction = "id1"},
-           LineColFunOp{.Line = 6,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 9,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 10,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 14,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Load},
-       }},
-      {LineColFunOp{.Line = 7,
-                    .Col = 0,
-                    .InFunction = "main",
-                    .OpCode = llvm::Instruction::Alloca},
-       {
-           ArgInFun{.Idx = 0, .InFunction = "id2"},
-           LineColFunOp{.Line = 3,
-                        .Col = 27,
-                        .InFunction = "id2",
-                        .OpCode = llvm::Instruction::Load},
-           RetVal{.InFunction = "id2"},
-           LineColFunOp{.Line = 7,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 11,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 12,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-       }},
-  };
+  GTMap GT = {{LineColFunOp{.Line = 6,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 27,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   LineColFunOp{.Line = 6,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 14,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 7,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 27,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id2"},
+                   LineColFunOp{.Line = 7,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+               }},
+              {LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 10,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 10,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 11,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("context_02_c_dbg.ll", GT, IndAABuilder);
 }
@@ -2353,7 +2399,23 @@ unittest
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Load},
-               }}};
+               }},
+              {LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("context_03_c_dbg.ll", GT, IndAABuilder);
 }
@@ -2483,7 +2545,23 @@ unittest
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Load},
-               }}};
+               }},
+              {LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 10,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 10,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("context_04_0_c_dbg.ll", GT, IndAABuilder);
 }

From a6f8ede243840f3eaca2be2b8bbaaad5f1293476 Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Tue, 3 Feb 2026 17:57:44 +0100
Subject: [PATCH 39/75] Fixed ground truth of Indir Context Tests til 08

---
 .../Pointer/LLVMUnionFindAATest.cpp           | 453 ++++++++++++++----
 1 file changed, 360 insertions(+), 93 deletions(-)

diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index d63e0775b2..16073612b5 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -2042,20 +2042,6 @@ UnionFindAAResult {
   #24: <>
 }
   */
-  /*
-    TODO: talk with fabian about the following:
-
-    UnionFindAAResult has itself in it, but if I put in ground truth, it
-    doesn't work. LineColFunOp{.Line = 5,...
-    -> LineColFunOp{.Line = 5, ...
-    -> LineColFunOp{.Line = 2,
-                             .Col = 14,
-
-    Shouldn't the result be something like:
-
-
-    ?
-  */
 
   GTMap GT = {{LineColFunOp{.Line = 5,
                             .Col = 0,
@@ -2197,12 +2183,6 @@ UnionFindAAResult {
   #43: <>
   #44: <>
 }
-
-Relevant lines:
-
-  #5: <1, 2, 3, 9, 15, 16, 19>
-  #15: <5, 6, 7, 10, 17, 18>
-
   */
   GTMap GT = {{LineColFunOp{.Line = 6,
                             .Col = 0,
@@ -2360,10 +2340,6 @@ UnionFindAAResult {
   #28: <>
   #29: <>
 }
-
-// TODO: talk with Fabian about the same points as in comment in Context01
-unittest
-
   */
 
   GTMap GT = {{LineColFunOp{.Line = 6,
@@ -2503,8 +2479,7 @@ UnionFindAAResult {
   #33: <>
   #34: <>
 }
-// TODO: talk with Fabian about the same points as in comment in Context01
-unittest
+
   */
   GTMap GT = {{LineColFunOp{.Line = 7,
                             .Col = 0,
@@ -2669,18 +2644,39 @@ UnionFindAAResult {
   #43: <>
   #44: <>
 }
-// TODO: talk with Fabian about the same points as in comment in Context01
-unittest
+
   */
   GTMap GT = {{LineColFunOp{.Line = 7,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
                {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 27,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 27,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id2"},
+                   ArgInFun{.Idx = 0, .InFunction = "id3"},
+                   LineColFunOp{.Line = 4,
+                                .Col = 27,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id3"},
                    LineColFunOp{.Line = 7,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
                    LineColFunOp{.Line = 10,
                                 .Col = 0,
                                 .InFunction = "main",
@@ -2689,27 +2685,51 @@ unittest
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 13,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
                    LineColFunOp{.Line = 15,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Load},
                }},
-              {LineColFunOp{.Line = 8,
+              {LineColFunOp{.Line = 10,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 8,
+               {LineColFunOp{.Line = 10,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 12,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 11,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 11,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 13,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call}}}};
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("context_04_1_c_dbg.ll", GT, IndAABuilder);
 }
@@ -2812,14 +2832,37 @@ UnionFindAAResult {
   #38: <>
   #39: <>
 }
-// TODO: talk with Fabian about the same points as in comment in Context01
-unittest
+
   */
   GTMap GT = {{LineColFunOp{.Line = 8,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
                {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 27,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 27,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id2"},
+                   ArgInFun{.Idx = 0, .InFunction = "id3"},
+                   LineColFunOp{.Line = 4,
+                                .Col = 27,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id3"},
+                   ArgInFun{.Idx = 0, .InFunction = "id4"},
+                   LineColFunOp{.Line = 5,
+                                .Col = 27,
+                                .InFunction = "id4",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id4"},
                    LineColFunOp{.Line = 8,
                                 .Col = 0,
                                 .InFunction = "main",
@@ -2836,7 +2879,23 @@ unittest
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Load},
-               }}};
+               }},
+              {LineColFunOp{.Line = 10,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 10,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 11,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("context_05_0_c_dbg.ll", GT, IndAABuilder);
 }
@@ -2951,18 +3010,45 @@ UnionFindAAResult {
   #48: <>
   #49: <>
 }
-// TODO: talk with Fabian about the same points as in comment in Context01
-unittest
+
   */
   GTMap GT = {{LineColFunOp{.Line = 8,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
                {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 27,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 27,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id2"},
+                   ArgInFun{.Idx = 0, .InFunction = "id3"},
+                   LineColFunOp{.Line = 4,
+                                .Col = 27,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id3"},
+                   ArgInFun{.Idx = 0, .InFunction = "id4"},
+                   LineColFunOp{.Line = 5,
+                                .Col = 27,
+                                .InFunction = "id4",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id4"},
                    LineColFunOp{.Line = 8,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
                    LineColFunOp{.Line = 11,
                                 .Col = 0,
                                 .InFunction = "main",
@@ -2971,27 +3057,51 @@ unittest
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 13,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 14,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
                    LineColFunOp{.Line = 16,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Load},
                }},
-              {LineColFunOp{.Line = 9,
+              {LineColFunOp{.Line = 11,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 9,
+               {LineColFunOp{.Line = 11,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 13,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 14,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call}}}};
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 14,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("context_05_1_c_dbg.ll", GT, IndAABuilder);
 }
@@ -3101,16 +3211,42 @@ UnionFindAAResult {
   #43: <>
   #44: <>
 }
-// TODO: talk with Fabian about the same points as in comment in Context01
-unittest.
-
-// TODO: why is result broken in #5? Was that a copy paste error?
   */
   GTMap GT = {{LineColFunOp{.Line = 9,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
                {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 27,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 27,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id2"},
+                   ArgInFun{.Idx = 0, .InFunction = "id3"},
+                   LineColFunOp{.Line = 4,
+                                .Col = 27,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id3"},
+                   ArgInFun{.Idx = 0, .InFunction = "id4"},
+                   LineColFunOp{.Line = 5,
+                                .Col = 27,
+                                .InFunction = "id4",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id4"},
+                   ArgInFun{.Idx = 0, .InFunction = "id5"},
+                   LineColFunOp{.Line = 6,
+                                .Col = 27,
+                                .InFunction = "id5",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "id5"},
                    LineColFunOp{.Line = 9,
                                 .Col = 0,
                                 .InFunction = "main",
@@ -3127,7 +3263,23 @@ unittest.
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Load},
-               }}};
+               }},
+              {LineColFunOp{.Line = 11,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("context_06_0_c_dbg.ll", GT, IndAABuilder);
 }
@@ -3259,14 +3411,47 @@ UnionFindAAResult {
   #53: <>
   #54: <>
 }
-// TODO: talk with Fabian about the same points as in comment in Context01
-unittest
+
   */
   GTMap GT = {{LineColFunOp{.Line = 9,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 9,
+               {ArgInFun{.Idx = 0, .InFunction = "id1"},
+                LineColFunOp{.Line = 2,
+                             .Col = 27,
+                             .InFunction = "id1",
+                             .OpCode = llvm::Instruction::Load},
+                RetVal{.InFunction = "id1"},
+                ArgInFun{.Idx = 0, .InFunction = "id2"},
+                LineColFunOp{.Line = 3,
+                             .Col = 27,
+                             .InFunction = "id2",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "id2"},
+                ArgInFun{.Idx = 0, .InFunction = "id3"},
+                LineColFunOp{.Line = 4,
+                             .Col = 27,
+                             .InFunction = "id3",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "id3"},
+                ArgInFun{.Idx = 0, .InFunction = "id4"},
+                LineColFunOp{.Line = 5,
+                             .Col = 27,
+                             .InFunction = "id4",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "id4"},
+                ArgInFun{.Idx = 0, .InFunction = "id5"},
+                LineColFunOp{.Line = 6,
+                             .Col = 27,
+                             .InFunction = "id5",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "id5"},
+                LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 10,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
@@ -3277,29 +3462,51 @@ unittest
                 LineColFunOp{.Line = 13,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call}}},
-              {LineColFunOp{.Line = 10,
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 17,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 12,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {
-                   LineColFunOp{.Line = 10,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Alloca},
-                   LineColFunOp{.Line = 14,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 15,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 17,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Load},
-               }}};
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 14,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 15,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("context_06_1_c_dbg.ll", GT, IndAABuilder);
 }
@@ -3404,8 +3611,7 @@ UnionFindAAResult {
   #38: <>
   #39: <>
 }
-// TODO: talk with Fabian about the same points as in comment in Context01
-unittest
+
   */
   GTMap GT = {
       {LineColFunOp{.Line = 8,
@@ -3413,33 +3619,67 @@ unittest
                     .InFunction = "main",
                     .OpCode = llvm::Instruction::Alloca},
        {
+           ArgInFun{.Idx = 0, .InFunction = "buzz"},
+           LineColFunOp{.Line = 2,
+                        .Col = 28,
+                        .InFunction = "buzz",
+                        .OpCode = llvm::Instruction::Load},
+           RetVal{.InFunction = "buzz"},
+           ArgInFun{.Idx = 0, .InFunction = "baz"},
+           LineColFunOp{.Line = 3,
+                        .Col = 27,
+                        .InFunction = "baz",
+                        .OpCode = llvm::Instruction::Call},
+           RetVal{.InFunction = "baz"},
+           ArgInFun{.Idx = 0, .InFunction = "bar"},
+           LineColFunOp{.Line = 4,
+                        .Col = 27,
+                        .InFunction = "bar",
+                        .OpCode = llvm::Instruction::Call},
+           RetVal{.InFunction = "bar"},
+           ArgInFun{.Idx = 0, .InFunction = "foo"},
+           LineColFunOp{.Line = 5,
+                        .Col = 27,
+                        .InFunction = "foo",
+                        .OpCode = llvm::Instruction::Call},
+           RetVal{.InFunction = "foo"},
            LineColFunOp{.Line = 8,
                         .Col = 0,
                         .InFunction = "main",
                         .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 9,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
            LineColFunOp{.Line = 11,
                         .Col = 0,
                         .InFunction = "main",
                         .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 12,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
            LineColFunOp{.Line = 14,
                         .Col = 0,
                         .InFunction = "main",
                         .OpCode = llvm::Instruction::Load},
        }},
-      {LineColFunOp{.Line = 9,
+      {LineColFunOp{.Line = 11,
                     .Col = 0,
                     .InFunction = "main",
                     .OpCode = llvm::Instruction::Alloca},
-       {
-           LineColFunOp{.Line = 9,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 12,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-       }},
+       {LineColFunOp{.Line = 11,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca}}},
+      {LineColFunOp{.Line = 12,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {LineColFunOp{.Line = 12,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca}}},
   };
 
   doAnalysisAndCompareResults("context_07_c_dbg.ll", GT, IndAABuilder);
@@ -3510,21 +3750,48 @@ UnionFindAAResult {
   #33: <>
   #34: <>
 }
-// TODO: talk with Fabian about the same points as in comment in Context01
-unittest
+
+#10: <2, 3, 4, 5, 6, 8, 12, 13, 14, 15>
+
   */
   GTMap GT = {{LineColFunOp{.Line = 12,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
                {
+                   ArgInFun{.Idx = 0, .InFunction = "selfRecursion"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 8,
+                                .InFunction = "selfRecursion",
+                                .OpCode = llvm::Instruction::Load},
+                   LineColFunOp{.Line = 4,
+                                .Col = 12,
+                                .InFunction = "selfRecursion",
+                                .OpCode = llvm::Instruction::Load},
+                   LineColFunOp{.Line = 7,
+                                .Col = 11,
+                                .InFunction = "selfRecursion",
+                                .OpCode = llvm::Instruction::Load},
+                   LineColFunOp{.Line = 8,
+                                .Col = 10,
+                                .InFunction = "selfRecursion",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "selfRecursion"},
                    LineColFunOp{.Line = 12,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Alloca},
-                   LineColFunOp{.Line = 7,
-                                .Col = 11,
-                                .InFunction = "selfRecursion",
+                   LineColFunOp{.Line = 15,
+                                .Col = 12,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 19,
+                                .Col = 12,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 21,
+                                .Col = 0,
+                                .InFunction = "main",
                                 .OpCode = llvm::Instruction::Load},
                }}};
 

From 98964c4206e02c170fe91ccfa5c72ea469c03f9f Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Wed, 4 Feb 2026 19:51:50 +0100
Subject: [PATCH 40/75] new basic03, added basic04, gt fixes til 10_1

---
 test/llvm_test_code/pointers/CMakeLists.txt   |    6 +-
 test/llvm_test_code/pointers/basic_03.c       |   10 +
 test/llvm_test_code/pointers/basic_03.cpp     |    7 -
 test/llvm_test_code/pointers/basic_04.c       |   13 +
 .../Pointer/LLVMUnionFindAATest.cpp           | 1433 ++++++++++++++++-
 5 files changed, 1397 insertions(+), 72 deletions(-)
 create mode 100644 test/llvm_test_code/pointers/basic_03.c
 delete mode 100644 test/llvm_test_code/pointers/basic_03.cpp
 create mode 100644 test/llvm_test_code/pointers/basic_04.c

diff --git a/test/llvm_test_code/pointers/CMakeLists.txt b/test/llvm_test_code/pointers/CMakeLists.txt
index 00f874a5ec..da5da760b0 100644
--- a/test/llvm_test_code/pointers/CMakeLists.txt
+++ b/test/llvm_test_code/pointers/CMakeLists.txt
@@ -1,7 +1,8 @@
 set(lca_files
   basic_01.c
   basic_02.c
-  basic_03.cpp
+  basic_03.c
+  basic_04.c
   call_01.cpp
   dynamic_01.cpp
   global_01.cpp
@@ -35,7 +36,8 @@ set(lca_files
 set(lca_files_mem2reg
   basic_01.c
   basic_02.c
-  basic_03.cpp
+  basic_03.c
+  basic_04.c
   dynamic_01.cpp
   inter_dynamic_01.cpp
   inter_dynamic_02.cpp
diff --git a/test/llvm_test_code/pointers/basic_03.c b/test/llvm_test_code/pointers/basic_03.c
new file mode 100644
index 0000000000..0f2c01ef95
--- /dev/null
+++ b/test/llvm_test_code/pointers/basic_03.c
@@ -0,0 +1,10 @@
+
+int Func() { return 1; }
+
+int main() {
+  int (*FuncPtr)();
+
+  FuncPtr = &Func;
+
+  return FuncPtr();
+}
diff --git a/test/llvm_test_code/pointers/basic_03.cpp b/test/llvm_test_code/pointers/basic_03.cpp
deleted file mode 100644
index 3a725dea94..0000000000
--- a/test/llvm_test_code/pointers/basic_03.cpp
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <functional>
-
-int main() {
-  std::function<int()> Func = []() { return 1; };
-  auto *FuncPtr = &Func;
-  *FuncPtr = []() { return 2; };
-}
diff --git a/test/llvm_test_code/pointers/basic_04.c b/test/llvm_test_code/pointers/basic_04.c
new file mode 100644
index 0000000000..78081b32da
--- /dev/null
+++ b/test/llvm_test_code/pointers/basic_04.c
@@ -0,0 +1,13 @@
+
+int Func() { return 1; }
+
+int main() {
+  int (*FuncPtr)();
+
+  int (**FuncPtr2)();
+
+  FuncPtr = &Func;
+  FuncPtr2 = &FuncPtr;
+
+  return (*FuncPtr2)();
+}
diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index 16073612b5..9952e8e976 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -317,7 +317,7 @@ TEST(CtxSensUnionFindAATest, Basic03) {
                                 .OpCode = llvm::Instruction::Load},
                }}};
 
-  doAnalysisAndCompareResults("basic_03_cpp_dbg.ll", GT, ContextAABuilder);
+  doAnalysisAndCompareResults("basic_03_c_dbg.ll", GT, ContextAABuilder);
 }
 
 TEST(CtxSensUnionFindAATest, Context01) {
@@ -1983,7 +1983,26 @@ TEST(IndirectionSensUnionFindAATest, Basic03) {
                                 .OpCode = llvm::Instruction::Load},
                }}};
 
-  doAnalysisAndCompareResults("basic_03_cpp_dbg.ll", GT, IndAABuilder);
+  doAnalysisAndCompareResults("basic_03_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Basic04) {
+  GTMap GT = {{LineColFunOp{.Line = 4,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 4,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 6,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("basic_04_c_dbg.ll", GT, IndAABuilder);
 }
 
 TEST(IndirectionSensUnionFindAATest, Context01) {
@@ -3802,84 +3821,1372 @@ UnionFindAAResult {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context09_0) {
-  // TODO: create ground truth after talking with fabian on how to construct it
-  // correctly/check if the UnionFindAAResults are correct or not.
-  GTMap GT{};
-
-  doAnalysisAndCompareResults("context_09_0_c_dbg.ll", GT, IndAABuilder);
-}
 
-TEST(IndirectionSensUnionFindAATest, Context09_1) {
-  // TODO: create ground truth after talking with fabian on how to construct it
-  // correctly/check if the UnionFindAAResults are correct or not.
-  GTMap GT{};
-
-  doAnalysisAndCompareResults("context_09_1_c_dbg.ll", GT, IndAABuilder);
+  /*
+ValueCompressor: {
+  #0:
+    %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
+  #2:
+    ptr %Ptr | ID: selfRecursion.0
+  #3:
+    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
+    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
+    %3 = load ptr, ptr %Ptr.addr, align 8, !dbg !38, !psr.id !39 | ID: 11
+    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
+    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !48, !psr.id !49 | ID: 16
+  #4:
+    %call = call ptr @selfRecursion(ptr noundef %6), !dbg !50, !psr.id !51 | ID:
+17 #5: fun @selfRecursion.<ret> #6: %7 = load ptr, ptr %retval, align 8, !dbg
+!55, !psr.id !56 | ID: 20 #7: %retval = alloca i32, align 4, !psr.id !61 | ID:
+22 #8: %k = alloca i32, align 4, !psr.id !62 | ID: 23 #9: %l = alloca i32, align
+4, !psr.id !63 | ID: 24 #10: %x = alloca ptr, align 8, !psr.id !64 | ID: 25 #11:
+    %y = alloca ptr, align 8, !psr.id !65 | ID: 26
+  #12:
+    %call = call ptr @selfRecursion(ptr noundef %k), !dbg !78, !psr.id !79 | ID:
+33 #13: %call1 = call ptr @selfRecursion(ptr noundef %l), !dbg !84, !psr.id !85
+| ID: 36 #14: %0 = load ptr, ptr %y, align 8, !dbg !87, !psr.id !88 | ID: 38
 }
-
-TEST(IndirectionSensUnionFindAATest, Context10_0) {
-  // TODO: create ground truth after talking with fabian on how to construct it
-  // correctly/check if the UnionFindAAResults are correct or not.
-  GTMap GT{};
-
-  doAnalysisAndCompareResults("context_10_0_c_dbg.ll", GT, IndAABuilder);
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1>
+  #6: <>
+  #7: <>
+  #8: <>
+  #9: <>
+  #10: <2, 3, 4, 5, 6, 8, 9, 12, 13, 14>
+  #11: <>
+  #12: <>
+  #13: <>
+  #14: <>
+  #15: <7>
+  #16: <>
+  #17: <>
+  #18: <>
+  #19: <>
+  #20: <10>
+  #21: <>
+  #22: <>
+  #23: <>
+  #24: <>
+  #25: <11>
+  #26: <>
+  #27: <>
+  #28: <>
+  #29: <>
 }
+  */
 
-TEST(IndirectionSensUnionFindAATest, Context10_1) {
-  // TODO: create ground truth after talking with fabian on how to construct it
-  // correctly/check if the UnionFindAAResults are correct or not.
-  GTMap GT{};
-
-  doAnalysisAndCompareResults("context_10_1_c_dbg.ll", GT, IndAABuilder);
-}
+  // TODO: missing other entries. like x and y
 
-TEST(IndirectionSensUnionFindAATest, Context11_0) {
-  // TODO: create ground truth after talking with fabian on how to construct it
-  // correctly/check if the UnionFindAAResults are correct or not.
-  GTMap GT{};
+  GTMap GT{{LineColFunOp{.Line = 12,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                ArgInFun{.Idx = 0, .InFunction = "selfRecursion"},
+                LineColFunOp{.Line = 3,
+                             .Col = 8,
+                             .InFunction = "selfRecursion",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 4,
+                             .Col = 12,
+                             .InFunction = "selfRecursion",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 7,
+                             .Col = 11,
+                             .InFunction = "selfRecursion",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 8,
+                             .Col = 10,
+                             .InFunction = "selfRecursion",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "selfRecursion"},
+                LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 15,
+                             .Col = 12,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 16,
+                             .Col = 12,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 15,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 16,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 16,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
 
-  doAnalysisAndCompareResults("context_11_0_c_dbg.ll", GT, IndAABuilder);
+  doAnalysisAndCompareResults("context_09_0_c_dbg.ll", GT, IndAABuilder);
 }
 
-TEST(IndirectionSensUnionFindAATest, Context11_1) {
-  // TODO: create ground truth after talking with fabian on how to construct it
-  // correctly/check if the UnionFindAAResults are correct or not.
-  GTMap GT{};
+TEST(IndirectionSensUnionFindAATest, Context09_1) {
 
-  doAnalysisAndCompareResults("context_11_1_c_dbg.ll", GT, IndAABuilder);
-}
+  /*
+  ValueCompressor: {
+    #0:
+      %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
+    #1:
+      %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
+    #2:
+      ptr %Ptr | ID: selfRecursion.0
+    #3:
+      %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
+      %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
+      %3 = load ptr, ptr %Ptr.addr, align 8, !dbg !38, !psr.id !39 | ID: 11
+      %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
+      %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !48, !psr.id !49 | ID: 16
+    #4:
+      %call = call ptr @selfRecursion(ptr noundef %6), !dbg !50, !psr.id !51 |
+  ID: 17 #5: fun @selfRecursion.<ret> #6: %7 = load ptr, ptr %retval, align 8,
+  !dbg !55, !psr.id !56 | ID: 20 #7: %retval = alloca i32, align 4, !psr.id !61
+  | ID: 22 #8: %k = alloca i32, align 4, !psr.id !62 | ID: 23 #9: %l = alloca
+  i32, align 4, !psr.id !63 | ID: 24 #10: %xx1 = alloca ptr, align 8, !psr.id
+  !64 | ID: 25 #11: %xx2 = alloca ptr, align 8, !psr.id !65 | ID: 26 #12: %yy1 =
+  alloca ptr, align 8, !psr.id !66 | ID: 27 #13: %yy2 = alloca ptr, align 8,
+  !psr.id !67 | ID: 28 #14: %call = call ptr @selfRecursion(ptr noundef %k),
+  !dbg !80, !psr.id !81 | ID: 35 #15: %call1 = call ptr @selfRecursion(ptr
+  noundef %k), !dbg !88, !psr.id !89 | ID: 39 #16: %call2 = call ptr
+  @selfRecursion(ptr noundef %l), !dbg !94, !psr.id !95 | ID: 42 #17: %call3 =
+  call ptr @selfRecursion(ptr noundef %l), !dbg !102, !psr.id !103 | ID: 46 #18:
+      %0 = load ptr, ptr %yy2, align 8, !dbg !105, !psr.id !106 | ID: 48
+  }
+  UnionFindAAResult {
+    #0: <0>
+    #1: <>
+    #2: <>
+    #3: <>
+    #4: <>
+    #5: <1>
+    #6: <>
+    #7: <>
+    #8: <>
+    #9: <>
+    #10: <2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18>
+    #11: <>
+    #12: <>
+    #13: <>
+    #14: <>
+    #15: <7>
+    #16: <>
+    #17: <>
+    #18: <>
+    #19: <>
+    #20: <10>
+    #21: <>
+    #22: <>
+    #23: <>
+    #24: <>
+    #25: <11>
+    #26: <>
+    #27: <>
+    #28: <>
+    #29: <>
+    #30: <12>
+    #31: <>
+    #32: <>
+    #33: <>
+    #34: <>
+    #35: <13>
+    #36: <>
+    #37: <>
+    #38: <>
+    #39: <>
+  }
+  */
 
-TEST(IndirectionSensUnionFindAATest, Context12_0) {
-  // TODO: create ground truth after talking with fabian on how to construct it
-  // correctly/check if the UnionFindAAResults are correct or not.
-  GTMap GT{};
+  GTMap GT{{LineColFunOp{.Line = 12,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                ArgInFun{.Idx = 0, .InFunction = "selfRecursion"},
+                LineColFunOp{.Line = 3,
+                             .Col = 8,
+                             .InFunction = "selfRecursion",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 4,
+                             .Col = 12,
+                             .InFunction = "selfRecursion",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 7,
+                             .Col = 11,
+                             .InFunction = "selfRecursion",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 8,
+                             .Col = 10,
+                             .InFunction = "selfRecursion",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "selfRecursion"},
+                LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 15,
+                             .Col = 14,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 17,
+                             .Col = 14,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 18,
+                             .Col = 14,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 20,
+                             .Col = 14,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 15,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 17,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 17,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 18,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 20,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
 
-  doAnalysisAndCompareResults("context_12_0_c_dbg.ll", GT, IndAABuilder);
+  doAnalysisAndCompareResults("context_09_1_c_dbg.ll", GT, IndAABuilder);
 }
 
-TEST(IndirectionSensUnionFindAATest, Context12_1) {
-  // TODO: create ground truth after talking with fabian on how to construct it
-  // correctly/check if the UnionFindAAResults are correct or not.
-  GTMap GT{};
-
-  doAnalysisAndCompareResults("context_12_1_c_dbg.ll", GT, IndAABuilder);
+TEST(IndirectionSensUnionFindAATest, Context10_0) {
+  /*
+  ValueCompressor: {
+  #0:
+    %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
+  #2:
+    ptr %Ptr | ID: Forth.0
+  #3:
+    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
+    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
+    %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !39, !psr.id !40 | ID: 11
+    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !43, !psr.id !44 | ID: 13
+    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !50, !psr.id !51 | ID: 17
+  #4:
+    %call = call ptr @Back(ptr noundef %5), !dbg !45, !psr.id !46 | ID: 14
+  #5:
+    fun @Back.<ret>
+  #6:
+    ptr %Ptr | ID: Back.0
+  #7:
+    %7 = load ptr, ptr %retval, align 8, !dbg !55, !psr.id !56 | ID: 20
+  #8:
+    fun @Forth.<ret>
+  #9:
+    %retval = alloca ptr, align 8, !psr.id !59 | ID: 22
+  #10:
+    %Ptr.addr = alloca ptr, align 8, !psr.id !60 | ID: 23
+  #11:
+    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !65, !psr.id !67 | ID: 26
+    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !74, !psr.id !76 | ID: 30
+    %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !81, !psr.id !82 | ID: 33
+    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !85, !psr.id !86 | ID: 35
+    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !92, !psr.id !93 | ID: 39
+  #12:
+    %call = call ptr @Forth(ptr noundef %5), !dbg !87, !psr.id !88 | ID: 36
+  #13:
+    %7 = load ptr, ptr %retval, align 8, !dbg !97, !psr.id !98 | ID: 42
+  #14:
+    %retval = alloca i32, align 4, !psr.id !103 | ID: 44
+  #15:
+    %k = alloca i32, align 4, !psr.id !104 | ID: 45
+  #16:
+    %x = alloca ptr, align 8, !psr.id !105 | ID: 46
+  #17:
+    %y = alloca ptr, align 8, !psr.id !106 | ID: 47
+  #18:
+    %call = call ptr @Back(ptr noundef %k), !dbg !115, !psr.id !116 | ID: 52
+  #19:
+    %call1 = call ptr @Back(ptr noundef %k), !dbg !123, !psr.id !124 | ID: 56
+  #20:
+    %0 = load ptr, ptr %x, align 8, !dbg !126, !psr.id !127 | ID: 58
 }
-
-TEST(IndirectionSensUnionFindAATest, Context13_0) {
-  // TODO: create ground truth after talking with fabian on how to construct it
-  // correctly/check if the UnionFindAAResults are correct or not.
-  GTMap GT{};
-
-  doAnalysisAndCompareResults("context_13_0_c_dbg.ll", GT, IndAABuilder);
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1>
+  #6: <>
+  #7: <>
+  #8: <>
+  #9: <>
+  #10: <2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20>
+  #11: <>
+  #12: <>
+  #13: <>
+  #14: <>
+  #15: <9>
+  #16: <>
+  #17: <>
+  #18: <>
+  #19: <>
+  #20: <10>
+  #21: <>
+  #22: <>
+  #23: <>
+  #24: <>
+  #25: <14>
+  #26: <>
+  #27: <>
+  #28: <>
+  #29: <>
+  #30: <16>
+  #31: <>
+  #32: <>
+  #33: <>
+  #34: <>
+  #35: <17>
+  #36: <>
+  #37: <>
+  #38: <>
+  #39: <>
+}
+  */
+  GTMap GT{{LineColFunOp{.Line = 24,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                ArgInFun{.Idx = 0, .InFunction = "Forth"},
+                LineColFunOp{.Line = 5,
+                             .Col = 8,
+                             .InFunction = "Forth",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 6,
+                             .Col = 13,
+                             .InFunction = "Forth",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 7,
+                             .Col = 12,
+                             .InFunction = "Forth",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "Forth"},
+                ArgInFun{.Idx = 0, .InFunction = "Back"},
+                LineColFunOp{.Line = 14,
+                             .Col = 8,
+                             .InFunction = "Back",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 15,
+                             .Col = 13,
+                             .InFunction = "Back",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 16,
+                             .Col = 12,
+                             .InFunction = "Back",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "Back"},
+                LineColFunOp{.Line = 24,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 26,
+                             .Col = 12,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 30,
+                             .Col = 12,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 26,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 26,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 30,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("context_10_0_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context10_1) {
+  /*
+  ValueCompressor: {
+    #0:
+      %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
+    #1:
+      %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
+    #2:
+      ptr %Ptr | ID: Forth.0
+    #3:
+      %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
+      %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
+      %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !39, !psr.id !40 | ID: 11
+      %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !43, !psr.id !44 | ID: 13
+      %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !50, !psr.id !51 | ID: 17
+    #4:
+      %call = call ptr @Back(ptr noundef %5), !dbg !45, !psr.id !46 | ID: 14
+    #5:
+      fun @Back.<ret>
+    #6:
+      ptr %Ptr | ID: Back.0
+    #7:
+      %7 = load ptr, ptr %retval, align 8, !dbg !55, !psr.id !56 | ID: 20
+    #8:
+      fun @Forth.<ret>
+    #9:
+      %retval = alloca ptr, align 8, !psr.id !59 | ID: 22
+    #10:
+      %Ptr.addr = alloca ptr, align 8, !psr.id !60 | ID: 23
+    #11:
+      %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !65, !psr.id !67 | ID: 26
+      %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !74, !psr.id !76 | ID: 30
+      %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !81, !psr.id !82 | ID: 33
+      %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !85, !psr.id !86 | ID: 35
+      %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !92, !psr.id !93 | ID: 39
+    #12:
+      %call = call ptr @Forth(ptr noundef %5), !dbg !87, !psr.id !88 | ID: 36
+    #13:
+      %7 = load ptr, ptr %retval, align 8, !dbg !97, !psr.id !98 | ID: 42
+    #14:
+      %retval = alloca i32, align 4, !psr.id !103 | ID: 44
+    #15:
+      %k = alloca i32, align 4, !psr.id !104 | ID: 45
+    #16:
+      %l = alloca i32, align 4, !psr.id !105 | ID: 46
+    #17:
+      %xx1 = alloca ptr, align 8, !psr.id !106 | ID: 47
+    #18:
+      %xx2 = alloca ptr, align 8, !psr.id !107 | ID: 48
+    #19:
+      %yy1 = alloca ptr, align 8, !psr.id !108 | ID: 49
+    #20:
+      %yy2 = alloca ptr, align 8, !psr.id !109 | ID: 50
+    #21:
+      %call = call ptr @Back(ptr noundef %k), !dbg !122, !psr.id !123 | ID: 57
+    #22:
+      %call1 = call ptr @Back(ptr noundef %k), !dbg !130, !psr.id !131 | ID: 61
+    #23:
+      %call2 = call ptr @Back(ptr noundef %l), !dbg !136, !psr.id !137 | ID: 64
+    #24:
+      %call3 = call ptr @Back(ptr noundef %l), !dbg !144, !psr.id !145 | ID: 68
+    #25:
+      %0 = load ptr, ptr %xx1, align 8, !dbg !147, !psr.id !148 | ID: 70
+  }
+  UnionFindAAResult {
+    #0: <0>
+    #1: <>
+    #2: <>
+    #3: <>
+    #4: <>
+    #5: <1>
+    #6: <>
+    #7: <>
+    #8: <>
+    #9: <>
+    #10: <2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25>
+    #11: <>
+    #12: <>
+    #13: <>
+    #14: <>
+    #15: <9>
+    #16: <>
+    #17: <>
+    #18: <>
+    #19: <>
+    #20: <10>
+    #21: <>
+    #22: <>
+    #23: <>
+    #24: <>
+    #25: <14>
+    #26: <>
+    #27: <>
+    #28: <>
+    #29: <>
+    #30: <17>
+    #31: <>
+    #32: <>
+    #33: <>
+    #34: <>
+    #35: <18>
+    #36: <>
+    #37: <>
+    #38: <>
+    #39: <>
+    #40: <19>
+    #41: <>
+    #42: <>
+    #43: <>
+    #44: <>
+    #45: <20>
+    #46: <>
+    #47: <>
+    #48: <>
+    #49: <>
+  }
+  */
+  GTMap GT{{LineColFunOp{.Line = 24,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                ArgInFun{.Idx = 0, .InFunction = "Forth"},
+                LineColFunOp{.Line = 5,
+                             .Col = 8,
+                             .InFunction = "Forth",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 6,
+                             .Col = 13,
+                             .InFunction = "Forth",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 7,
+                             .Col = 12,
+                             .InFunction = "Forth",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "Forth"},
+                ArgInFun{.Idx = 0, .InFunction = "Back"},
+                LineColFunOp{.Line = 14,
+                             .Col = 8,
+                             .InFunction = "Back",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 15,
+                             .Col = 13,
+                             .InFunction = "Back",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 16,
+                             .Col = 12,
+                             .InFunction = "Back",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "Back"},
+                LineColFunOp{.Line = 24,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 25,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 27,
+                             .Col = 14,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 29,
+                             .Col = 14,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 31,
+                             .Col = 14,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 33,
+                             .Col = 14,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 35,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 27,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 27,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 29,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 29,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 31,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 31,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 33,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("context_10_1_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context11_0) {
+  /*
+  ValueCompressor: {
+    #0:
+      %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
+    #1:
+      %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
+    #2:
+      ptr %Ptr | ID: Forth.0
+    #3:
+      %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
+      %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
+      %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !39, !psr.id !40 | ID: 11
+      %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !43, !psr.id !44 | ID: 13
+      %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !50, !psr.id !51 | ID: 17
+    #4:
+      %call = call ptr @Stop(ptr noundef %5), !dbg !45, !psr.id !46 | ID: 14
+    #5:
+      fun @Stop.<ret>
+    #6:
+      ptr %Ptr | ID: Stop.0
+    #7:
+      %7 = load ptr, ptr %retval, align 8, !dbg !55, !psr.id !56 | ID: 20
+    #8:
+      fun @Forth.<ret>
+    #9:
+      %retval = alloca ptr, align 8, !psr.id !59 | ID: 22
+    #10:
+      %Ptr.addr = alloca ptr, align 8, !psr.id !60 | ID: 23
+    #11:
+      %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !65, !psr.id !67 | ID: 26
+      %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !76, !psr.id !78 | ID: 31
+      %3 = load ptr, ptr %Ptr.addr, align 8, !dbg !84, !psr.id !85 | ID: 35
+    #12:
+      %call = call ptr @Forth(ptr noundef %2), !dbg !79, !psr.id !80 | ID: 32
+    #13:
+      %call1 = call ptr @Back(ptr noundef %3), !dbg !86, !psr.id !87 | ID: 36
+    #14:
+      fun @Back.<ret>
+    #15:
+      ptr %Ptr | ID: Back.0
+    #16:
+      %4 = load ptr, ptr %retval, align 8, !dbg !91, !psr.id !92 | ID: 39
+    #17:
+      %retval = alloca ptr, align 8, !psr.id !95 | ID: 41
+    #18:
+      %Ptr.addr = alloca ptr, align 8, !psr.id !96 | ID: 42
+    #19:
+      %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !101, !psr.id !103 | ID: 45
+      %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !110, !psr.id !112 | ID: 49
+      %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !117, !psr.id !118 | ID: 52
+      %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !121, !psr.id !122 | ID: 54
+      %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !128, !psr.id !129 | ID: 58
+    #20:
+      %call = call ptr @Stop(ptr noundef %5), !dbg !123, !psr.id !124 | ID: 55
+    #21:
+      %7 = load ptr, ptr %retval, align 8, !dbg !133, !psr.id !134 | ID: 61
+    #22:
+      %retval = alloca i32, align 4, !psr.id !139 | ID: 63
+    #23:
+      %k = alloca i32, align 4, !psr.id !140 | ID: 64
+    #24:
+      %l = alloca i32, align 4, !psr.id !141 | ID: 65
+    #25:
+      %x = alloca ptr, align 8, !psr.id !142 | ID: 66
+    #26:
+      %y = alloca ptr, align 8, !psr.id !143 | ID: 67
+    #27:
+      %call = call ptr @Back(ptr noundef %k), !dbg !156, !psr.id !157 | ID: 74
+    #28:
+      %call1 = call ptr @Forth(ptr noundef %l), !dbg !162, !psr.id !163 | ID: 77
+    #29:
+      %0 = load ptr, ptr %x, align 8, !dbg !165, !psr.id !166 | ID: 79
+  }
+  UnionFindAAResult {
+    #0: <0>
+    #1: <>
+    #2: <>
+    #3: <>
+    #4: <>
+    #5: <1>
+    #6: <>
+    #7: <>
+    #8: <>
+    #9: <>
+    #10: <2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 14, 15, 16, 19, 20, 21, 23, 24, 27,
+  28, 29> #11: <> #12: <> #13: <> #14: <> #15: <9> #16: <> #17: <> #18: <> #19:
+  <> #20: <10> #21: <> #22: <> #23: <> #24: <> #25: <17> #26: <> #27: <> #28: <>
+    #29: <>
+    #30: <18>
+    #31: <>
+    #32: <>
+    #33: <>
+    #34: <>
+    #35: <22>
+    #36: <>
+    #37: <>
+    #38: <>
+    #39: <>
+    #40: <25>
+    #41: <>
+    #42: <>
+    #43: <>
+    #44: <>
+    #45: <26>
+    #46: <>
+    #47: <>
+    #48: <>
+    #49: <>
+  }
+  */
+  GTMap GT{{LineColFunOp{.Line = 33,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 36,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("context_11_0_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context11_1) {
+  /*
+  ValueCompressor: {
+  #0:
+    %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
+  #2:
+    ptr %Ptr | ID: Forth.0
+  #3:
+    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
+    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
+    %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !39, !psr.id !40 | ID: 11
+    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !43, !psr.id !44 | ID: 13
+    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !50, !psr.id !51 | ID: 17
+  #4:
+    %call = call ptr @Stop(ptr noundef %5), !dbg !45, !psr.id !46 | ID: 14
+  #5:
+    fun @Stop.<ret>
+  #6:
+    ptr %Ptr | ID: Stop.0
+  #7:
+    %7 = load ptr, ptr %retval, align 8, !dbg !55, !psr.id !56 | ID: 20
+  #8:
+    fun @Forth.<ret>
+  #9:
+    %retval = alloca ptr, align 8, !psr.id !59 | ID: 22
+  #10:
+    %Ptr.addr = alloca ptr, align 8, !psr.id !60 | ID: 23
+  #11:
+    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !65, !psr.id !67 | ID: 26
+    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !76, !psr.id !78 | ID: 31
+    %3 = load ptr, ptr %Ptr.addr, align 8, !dbg !84, !psr.id !85 | ID: 35
+  #12:
+    %call = call ptr @Forth(ptr noundef %2), !dbg !79, !psr.id !80 | ID: 32
+  #13:
+    %call1 = call ptr @Back(ptr noundef %3), !dbg !86, !psr.id !87 | ID: 36
+  #14:
+    fun @Back.<ret>
+  #15:
+    ptr %Ptr | ID: Back.0
+  #16:
+    %4 = load ptr, ptr %retval, align 8, !dbg !91, !psr.id !92 | ID: 39
+  #17:
+    %retval = alloca ptr, align 8, !psr.id !95 | ID: 41
+  #18:
+    %Ptr.addr = alloca ptr, align 8, !psr.id !96 | ID: 42
+  #19:
+    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !101, !psr.id !103 | ID: 45
+    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !110, !psr.id !112 | ID: 49
+    %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !117, !psr.id !118 | ID: 52
+    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !121, !psr.id !122 | ID: 54
+    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !128, !psr.id !129 | ID: 58
+  #20:
+    %call = call ptr @Stop(ptr noundef %5), !dbg !123, !psr.id !124 | ID: 55
+  #21:
+    %7 = load ptr, ptr %retval, align 8, !dbg !133, !psr.id !134 | ID: 61
+  #22:
+    %retval = alloca i32, align 4, !psr.id !139 | ID: 63
+  #23:
+    %k = alloca i32, align 4, !psr.id !140 | ID: 64
+  #24:
+    %l = alloca i32, align 4, !psr.id !141 | ID: 65
+  #25:
+    %xx1 = alloca ptr, align 8, !psr.id !142 | ID: 66
+  #26:
+    %xx2 = alloca ptr, align 8, !psr.id !143 | ID: 67
+  #27:
+    %yy1 = alloca ptr, align 8, !psr.id !144 | ID: 68
+  #28:
+    %yy2 = alloca ptr, align 8, !psr.id !145 | ID: 69
+  #29:
+    %call = call ptr @Back(ptr noundef %k), !dbg !158, !psr.id !159 | ID: 76
+  #30:
+    %call1 = call ptr @Back(ptr noundef %k), !dbg !164, !psr.id !165 | ID: 79
+  #31:
+    %call2 = call ptr @Forth(ptr noundef %l), !dbg !170, !psr.id !171 | ID: 82
+  #32:
+    %call3 = call ptr @Forth(ptr noundef %l), !dbg !176, !psr.id !177 | ID: 85
+  #33:
+    %0 = load ptr, ptr %xx2, align 8, !dbg !179, !psr.id !180 | ID: 87
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1>
+  #6: <>
+  #7: <>
+  #8: <>
+  #9: <>
+  #10: <2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 14, 15, 16, 19, 20, 21, 23, 24, 29, 30,
+31, 32, 33> #11: <> #12: <> #13: <> #14: <> #15: <9> #16: <> #17: <> #18: <>
+  #19: <>
+  #20: <10>
+  #21: <>
+  #22: <>
+  #23: <>
+  #24: <>
+  #25: <17>
+  #26: <>
+  #27: <>
+  #28: <>
+  #29: <>
+  #30: <18>
+  #31: <>
+  #32: <>
+  #33: <>
+  #34: <>
+  #35: <22>
+  #36: <>
+  #37: <>
+  #38: <>
+  #39: <>
+  #40: <25>
+  #41: <>
+  #42: <>
+  #43: <>
+  #44: <>
+  #45: <26>
+  #46: <>
+  #47: <>
+  #48: <>
+  #49: <>
+  #50: <27>
+  #51: <>
+  #52: <>
+  #53: <>
+  #54: <>
+  #55: <28>
+  #56: <>
+  #57: <>
+  #58: <>
+  #59: <>
+}
+  */
+  GTMap GT{{LineColFunOp{.Line = 33,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 36,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("context_11_1_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context12_0) {
+  /*
+  ValueCompressor: {
+  #0:
+    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    %q.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
+  #2:
+    ptr %p | ID: argretq.0
+  #3:
+    ptr %q | ID: argretq.1
+  #4:
+    %0 = load ptr, ptr %q.addr, align 8, !dbg !27, !psr.id !28 | ID: 6
+  #5:
+    fun @argretq.<ret>
+  #6:
+    %retval = alloca i32, align 4, !psr.id !34 | ID: 8
+  #7:
+    %x = alloca i32, align 4, !psr.id !35 | ID: 9
+  #8:
+    %y = alloca i32, align 4, !psr.id !36 | ID: 10
+  #9:
+    %xx1 = alloca ptr, align 8, !psr.id !37 | ID: 11
+  #10:
+    %xx2 = alloca ptr, align 8, !psr.id !38 | ID: 12
+  #11:
+    %yy1 = alloca ptr, align 8, !psr.id !39 | ID: 13
+  #12:
+    %yy2 = alloca ptr, align 8, !psr.id !40 | ID: 14
+  #13:
+    %call = call ptr @argretq(ptr noundef %y, ptr noundef %x), !dbg !53, !psr.id
+!54 | ID: 21 #14: %call1 = call ptr @argretq(ptr noundef %y, ptr noundef %x),
+!dbg !59, !psr.id !60 | ID: 24 #15: %call2 = call ptr @argretq(ptr noundef %x,
+ptr noundef %y), !dbg !65, !psr.id !66 | ID: 27 #16: %call3 = call ptr
+@argretq(ptr noundef %x, ptr noundef %y), !dbg !71, !psr.id !72 | ID: 30 #17: %0
+= load ptr, ptr %xx1, align 8, !dbg !74, !psr.id !75 | ID: 32
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1>
+  #6: <>
+  #7: <>
+  #8: <>
+  #9: <>
+  #10: <2, 3, 4, 5, 7, 8, 13, 14, 15, 16, 17>
+  #11: <>
+  #12: <>
+  #13: <>
+  #14: <>
+  #15: <6>
+  #16: <>
+  #17: <>
+  #18: <>
+  #19: <>
+  #20: <9>
+  #21: <>
+  #22: <>
+  #23: <>
+  #24: <>
+  #25: <10>
+  #26: <>
+  #27: <>
+  #28: <>
+  #29: <>
+  #30: <11>
+  #31: <>
+  #32: <>
+  #33: <>
+  #34: <>
+  #35: <12>
+  #36: <>
+  #37: <>
+  #38: <>
+  #39: <>
+}
+  */
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_12_0_c_dbg.ll", GT, IndAABuilder);
 }
 
-TEST(IndirectionSensUnionFindAATest, Context13_1) {
-  // TODO: create ground truth after talking with fabian on how to construct it
-  // correctly/check if the UnionFindAAResults are correct or not.
-  GTMap GT{};
+TEST(IndirectionSensUnionFindAATest, Context12_1) {
+  /*
+  ValueCompressor: {
+  #0:
+    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    %q.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
+  #2:
+    ptr %p | ID: argretq.0
+  #3:
+    ptr %q | ID: argretq.1
+  #4:
+    %0 = load ptr, ptr %q.addr, align 8, !dbg !27, !psr.id !28 | ID: 6
+  #5:
+    fun @argretq.<ret>
+  #6:
+    %retval = alloca i32, align 4, !psr.id !34 | ID: 8
+  #7:
+    %x = alloca i32, align 4, !psr.id !35 | ID: 9
+  #8:
+    %y = alloca i32, align 4, !psr.id !36 | ID: 10
+  #9:
+    %xx1 = alloca ptr, align 8, !psr.id !37 | ID: 11
+  #10:
+    %yy1 = alloca ptr, align 8, !psr.id !38 | ID: 12
+  #11:
+    %call = call ptr @argretq(ptr noundef %y, ptr noundef %x), !dbg !51, !psr.id
+!52 | ID: 19 #12: %call1 = call ptr @argretq(ptr noundef %x, ptr noundef %y),
+!dbg !57, !psr.id !58 | ID: 22 #13: %0 = load ptr, ptr %xx1, align 8, !dbg !60,
+!psr.id !61 | ID: 24
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1>
+  #6: <>
+  #7: <>
+  #8: <>
+  #9: <>
+  #10: <2, 3, 4, 5, 7, 8, 11, 12, 13>
+  #11: <>
+  #12: <>
+  #13: <>
+  #14: <>
+  #15: <6>
+  #16: <>
+  #17: <>
+  #18: <>
+  #19: <>
+  #20: <9>
+  #21: <>
+  #22: <>
+  #23: <>
+  #24: <>
+  #25: <10>
+  #26: <>
+  #27: <>
+  #28: <>
+  #29: <>
+}
+  */
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("context_12_1_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context13_0) {
+
+  /*
+  ValueCompressor: {
+  #0:
+    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    %q.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
+  #2:
+    %r.addr = alloca ptr, align 8, !psr.id !19 | ID: 2
+  #3:
+    ptr %p | ID: argretq.0
+  #4:
+    ptr %q | ID: argretq.1
+  #5:
+    ptr %r | ID: argretq.2
+  #6:
+    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 9
+  #7:
+    fun @argretq.<ret>
+  #8:
+    %retval = alloca i32, align 4, !psr.id !39 | ID: 11
+  #9:
+    %x = alloca i32, align 4, !psr.id !40 | ID: 12
+  #10:
+    %y = alloca i32, align 4, !psr.id !41 | ID: 13
+  #11:
+    %xx1 = alloca ptr, align 8, !psr.id !42 | ID: 14
+  #12:
+    %xx2 = alloca ptr, align 8, !psr.id !43 | ID: 15
+  #13:
+    %xx3 = alloca ptr, align 8, !psr.id !44 | ID: 16
+  #14:
+    %xx4 = alloca ptr, align 8, !psr.id !45 | ID: 17
+  #15:
+    %yy1 = alloca ptr, align 8, !psr.id !46 | ID: 18
+  #16:
+    %yy2 = alloca ptr, align 8, !psr.id !47 | ID: 19
+  #17:
+    %yy3 = alloca ptr, align 8, !psr.id !48 | ID: 20
+  #18:
+    %yy4 = alloca ptr, align 8, !psr.id !49 | ID: 21
+  #19:
+    %call = call ptr @argretq(ptr noundef %x, ptr noundef %x, ptr noundef %x),
+!dbg !62, !psr.id !63 | ID: 28 #20: %call1 = call ptr @argretq(ptr noundef %x,
+ptr noundef %x, ptr noundef %y), !dbg !68, !psr.id !69 | ID: 31 #21: %call2 =
+call ptr @argretq(ptr noundef %y, ptr noundef %x, ptr noundef %y), !dbg !74,
+!psr.id !75 | ID: 34 #22: %call3 = call ptr @argretq(ptr noundef %y, ptr noundef
+%x, ptr noundef %x), !dbg !80, !psr.id !81 | ID: 37 #23: %call4 = call ptr
+@argretq(ptr noundef %x, ptr noundef %y, ptr noundef %x), !dbg !86, !psr.id !87
+| ID: 40 #24: %call5 = call ptr @argretq(ptr noundef %x, ptr noundef %y, ptr
+noundef %y), !dbg !92, !psr.id !93 | ID: 43 #25: %call6 = call ptr @argretq(ptr
+noundef %y, ptr noundef %y, ptr noundef %y), !dbg !98, !psr.id !99 | ID: 46 #26:
+    %call7 = call ptr @argretq(ptr noundef %y, ptr noundef %y, ptr noundef %x),
+!dbg !104, !psr.id !105 | ID: 49 #27: %0 = load ptr, ptr %xx1, align 8, !dbg
+!107, !psr.id !108 | ID: 51
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1>
+  #6: <>
+  #7: <>
+  #8: <>
+  #9: <>
+  #10: <2>
+  #11: <>
+  #12: <>
+  #13: <>
+  #14: <>
+  #15: <3, 4, 5, 6, 7, 9, 10, 19, 20, 21, 22, 23, 24, 25, 26, 27>
+  #16: <>
+  #17: <>
+  #18: <>
+  #19: <>
+  #20: <8>
+  #21: <>
+  #22: <>
+  #23: <>
+  #24: <>
+  #25: <11>
+  #26: <>
+  #27: <>
+  #28: <>
+  #29: <>
+  #30: <12>
+  #31: <>
+  #32: <>
+  #33: <>
+  #34: <>
+  #35: <13>
+  #36: <>
+  #37: <>
+  #38: <>
+  #39: <>
+  #40: <14>
+  #41: <>
+  #42: <>
+  #43: <>
+  #44: <>
+  #45: <15>
+  #46: <>
+  #47: <>
+  #48: <>
+  #49: <>
+  #50: <16>
+  #51: <>
+  #52: <>
+  #53: <>
+  #54: <>
+  #55: <17>
+  #56: <>
+  #57: <>
+  #58: <>
+  #59: <>
+  #60: <18>
+  #61: <>
+  #62: <>
+  #63: <>
+  #64: <>
+}
+  */
+
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("context_13_0_c_dbg.ll", GT, IndAABuilder);
+}
 
-  // psr::Logger::initializeStderrLogger(psr::SeverityLevel::DEBUG,
-  //                                     "IndirectionSensUnionFindAA");
+TEST(IndirectionSensUnionFindAATest, Context13_1) {
+  /*
+ValueCompressor: {
+  #0:
+    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    %q.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
+  #2:
+    %r.addr = alloca ptr, align 8, !psr.id !19 | ID: 2
+  #3:
+    ptr %p | ID: argretq.0
+  #4:
+    ptr %q | ID: argretq.1
+  #5:
+    ptr %r | ID: argretq.2
+  #6:
+    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 9
+  #7:
+    fun @argretq.<ret>
+  #8:
+    %retval = alloca i32, align 4, !psr.id !39 | ID: 11
+  #9:
+    %x = alloca i32, align 4, !psr.id !40 | ID: 12
+  #10:
+    %y = alloca i32, align 4, !psr.id !41 | ID: 13
+  #11:
+    %xx1 = alloca ptr, align 8, !psr.id !42 | ID: 14
+  #12:
+    %yy1 = alloca ptr, align 8, !psr.id !43 | ID: 15
+  #13:
+    %call = call ptr @argretq(ptr noundef %x, ptr noundef %x, ptr noundef %x),
+!dbg !56, !psr.id !57 | ID: 22 #14: %call1 = call ptr @argretq(ptr noundef %y,
+ptr noundef %y, ptr noundef %y), !dbg !62, !psr.id !63 | ID: 25 #15: %0 = load
+ptr, ptr %yy1, align 8, !dbg !65, !psr.id !66 | ID: 27
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1>
+  #6: <>
+  #7: <>
+  #8: <>
+  #9: <>
+  #10: <2>
+  #11: <>
+  #12: <>
+  #13: <>
+  #14: <>
+  #15: <3, 4, 5, 6, 7, 9, 10, 13, 14, 15>
+  #16: <>
+  #17: <>
+  #18: <>
+  #19: <>
+  #20: <8>
+  #21: <>
+  #22: <>
+  #23: <>
+  #24: <>
+  #25: <11>
+  #26: <>
+  #27: <>
+  #28: <>
+  #29: <>
+  #30: <12>
+  #31: <>
+  #32: <>
+  #33: <>
+  #34: <>
+}
+  */
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
 
   doAnalysisAndCompareResults("context_13_1_c_dbg.ll", GT, IndAABuilder);
 }

From 5d0e90abaa7529ae01115342c7a8fe084d76d7b6 Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Fri, 6 Feb 2026 16:22:43 +0100
Subject: [PATCH 41/75] Last of Indir Context tests fixed

---
 .../Pointer/LLVMUnionFindAATest.cpp           | 453 +++++++++++++++++-
 1 file changed, 450 insertions(+), 3 deletions(-)

diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index 9952e8e976..d16d5c70a8 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -4633,7 +4633,85 @@ TEST(IndirectionSensUnionFindAATest, Context11_0) {
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
             {
+                ArgInFun{.Idx = 0, .InFunction = "Forth"},
+                LineColFunOp{.Line = 6,
+                             .Col = 8,
+                             .InFunction = "Forth",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 7,
+                             .Col = 13,
+                             .InFunction = "Forth",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 8,
+                             .Col = 12,
+                             .InFunction = "Forth",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "Forth"},
+                ArgInFun{.Idx = 0, .InFunction = "Back"},
+                LineColFunOp{.Line = 15,
+                             .Col = 8,
+                             .InFunction = "Back",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 16,
+                             .Col = 13,
+                             .InFunction = "Back",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 17,
+                             .Col = 12,
+                             .InFunction = "Back",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "Back"},
+                ArgInFun{.Idx = 0, .InFunction = "Stop"},
+                LineColFunOp{.Line = 24,
+                             .Col = 8,
+                             .InFunction = "Stop",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 25,
+                             .Col = 12,
+                             .InFunction = "Stop",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 28,
+                             .Col = 10,
+                             .InFunction = "Stop",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "Stop"},
+                LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
                 LineColFunOp{.Line = 36,
+                             .Col = 12,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 37,
+                             .Col = 12,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 36,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 36,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 37,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 37,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
@@ -4785,7 +4863,113 @@ UnionFindAAResult {
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
             {
+                ArgInFun{.Idx = 0, .InFunction = "Forth"},
+                LineColFunOp{.Line = 6,
+                             .Col = 8,
+                             .InFunction = "Forth",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 7,
+                             .Col = 13,
+                             .InFunction = "Forth",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 8,
+                             .Col = 12,
+                             .InFunction = "Forth",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "Forth"},
+                ArgInFun{.Idx = 0, .InFunction = "Back"},
+                LineColFunOp{.Line = 15,
+                             .Col = 8,
+                             .InFunction = "Back",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 16,
+                             .Col = 13,
+                             .InFunction = "Back",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 17,
+                             .Col = 12,
+                             .InFunction = "Back",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "Back"},
+                ArgInFun{.Idx = 0, .InFunction = "Stop"},
+                LineColFunOp{.Line = 24,
+                             .Col = 8,
+                             .InFunction = "Stop",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 25,
+                             .Col = 12,
+                             .InFunction = "Stop",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 28,
+                             .Col = 10,
+                             .InFunction = "Stop",
+                             .OpCode = llvm::Instruction::Call},
+                RetVal{.InFunction = "Stop"},
+                LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
                 LineColFunOp{.Line = 36,
+                             .Col = 14,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 37,
+                             .Col = 14,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 38,
+                             .Col = 14,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 39,
+                             .Col = 14,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 41,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 36,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 36,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 37,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 37,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 38,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 38,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 39,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 39,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
@@ -4878,10 +5062,77 @@ UnionFindAAResult {
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 8,
+            {ArgInFun{.Idx = 0, .InFunction = "argretq"},
+             ArgInFun{.Idx = 1, .InFunction = "argretq"},
+             RetVal{.InFunction = "argretq"},
+             LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 6,
                           .Col = 0,
                           .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca}}}};
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 9,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 10,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 13,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 8,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 9,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 10,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 10,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 11,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
 
   doAnalysisAndCompareResults("context_12_0_c_dbg.ll", GT, IndAABuilder);
 }
@@ -4954,11 +5205,48 @@ UnionFindAAResult {
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
+            {ArgInFun{.Idx = 0, .InFunction = "argretq"},
+             ArgInFun{.Idx = 1, .InFunction = "argretq"},
+             RetVal{.InFunction = "argretq"},
+             LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 9,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 8,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
             {
                 LineColFunOp{.Line = 8,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 9,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
             }}};
 
   doAnalysisAndCompareResults("context_12_1_c_dbg.ll", GT, IndAABuilder);
@@ -5089,16 +5377,137 @@ UnionFindAAResult {
   #64: <>
 }
   */
-
   GTMap GT{{LineColFunOp{.Line = 5,
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
+            {ArgInFun{.Idx = 0, .InFunction = "argretq"},
+             ArgInFun{.Idx = 1, .InFunction = "argretq"},
+             ArgInFun{.Idx = 2, .InFunction = "argretq"},
+             RetVal{.InFunction = "argretq"},
+             LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 9,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 10,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 12,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 13,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 14,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 15,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 17,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 8,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
             {
                 LineColFunOp{.Line = 8,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 9,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 10,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 10,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 11,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 12,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 13,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 14,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 15,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
             }}};
 
   doAnalysisAndCompareResults("context_13_0_c_dbg.ll", GT, IndAABuilder);
@@ -5181,11 +5590,49 @@ UnionFindAAResult {
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
+            {ArgInFun{.Idx = 0, .InFunction = "argretq"},
+             ArgInFun{.Idx = 1, .InFunction = "argretq"},
+             ArgInFun{.Idx = 2, .InFunction = "argretq"},
+             RetVal{.InFunction = "argretq"},
+             LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 9,
+                          .Col = 14,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 8,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
             {
                 LineColFunOp{.Line = 8,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
+            }},
+           {LineColFunOp{.Line = 9,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
             }}};
 
   doAnalysisAndCompareResults("context_13_1_c_dbg.ll", GT, IndAABuilder);

From 2fdec14b76266cff9f0251b95b112a018923c96e Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Tue, 10 Feb 2026 16:13:43 +0100
Subject: [PATCH 42/75] New tests

---
 test/llvm_test_code/pointers/CMakeLists.txt   | 12 ++++
 test/llvm_test_code/pointers/context_14_0.c   | 12 ++++
 test/llvm_test_code/pointers/context_14_1.c   | 16 +++++
 test/llvm_test_code/pointers/context_14_2.c   | 20 ++++++
 test/llvm_test_code/pointers/indirection_01.c |  4 +-
 test/llvm_test_code/pointers/indirection_02.c |  7 +-
 test/llvm_test_code/pointers/indirection_03.c | 27 ++++++++
 test/llvm_test_code/pointers/indirection_04.c | 37 ++++++++++
 test/llvm_test_code/pointers/indirection_05.c | 47 +++++++++++++
 test/llvm_test_code/pointers/indirection_06.c | 57 ++++++++++++++++
 test/llvm_test_code/pointers/indirection_07.c | 67 +++++++++++++++++++
 .../pointers/indirection_08.cpp               | 20 ++++++
 .../pointers/indirection_09.cpp               | 27 ++++++++
 .../pointers/indirection_10.cpp               | 34 ++++++++++
 .../pointers/indirection_11.cpp               | 41 ++++++++++++
 15 files changed, 426 insertions(+), 2 deletions(-)
 create mode 100644 test/llvm_test_code/pointers/context_14_0.c
 create mode 100644 test/llvm_test_code/pointers/context_14_1.c
 create mode 100644 test/llvm_test_code/pointers/context_14_2.c
 create mode 100644 test/llvm_test_code/pointers/indirection_03.c
 create mode 100644 test/llvm_test_code/pointers/indirection_04.c
 create mode 100644 test/llvm_test_code/pointers/indirection_05.c
 create mode 100644 test/llvm_test_code/pointers/indirection_06.c
 create mode 100644 test/llvm_test_code/pointers/indirection_07.c
 create mode 100644 test/llvm_test_code/pointers/indirection_08.cpp
 create mode 100644 test/llvm_test_code/pointers/indirection_09.cpp
 create mode 100644 test/llvm_test_code/pointers/indirection_10.cpp
 create mode 100644 test/llvm_test_code/pointers/indirection_11.cpp

diff --git a/test/llvm_test_code/pointers/CMakeLists.txt b/test/llvm_test_code/pointers/CMakeLists.txt
index da5da760b0..a34a2cf889 100644
--- a/test/llvm_test_code/pointers/CMakeLists.txt
+++ b/test/llvm_test_code/pointers/CMakeLists.txt
@@ -29,8 +29,20 @@ set(lca_files
   context_12_1.c
   context_13_0.c
   context_13_1.c
+  context_14_0.c
+  context_14_1.c
+  context_14_2.c
   indirection_01.c
   indirection_02.c
+  indirection_03.c
+  indirection_04.c
+  indirection_05.c
+  indirection_06.c
+  indirection_07.c
+  indirection_08.c
+  indirection_09.c
+  indirection_10.c
+  indirection_11.c
 )
 
 set(lca_files_mem2reg
diff --git a/test/llvm_test_code/pointers/context_14_0.c b/test/llvm_test_code/pointers/context_14_0.c
new file mode 100644
index 0000000000..c8fc5c24ac
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_14_0.c
@@ -0,0 +1,12 @@
+
+int ret0() { return 0; }
+
+int callback(int (*Func)()) { return (*Func)(); }
+
+int main() {
+  int (*FuncPtr)() = &ret0;
+
+  int Zero = callback(FuncPtr);
+
+  return 0;
+}
diff --git a/test/llvm_test_code/pointers/context_14_1.c b/test/llvm_test_code/pointers/context_14_1.c
new file mode 100644
index 0000000000..fb04c335a8
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_14_1.c
@@ -0,0 +1,16 @@
+
+int ret0() { return 0; }
+
+int ret1() { return 1; }
+
+int (*callback(int (*Func)()))() { return Func; }
+
+int main() {
+  int (*FuncPtrZero)() = &ret0;
+  int (*FuncPtrOne)() = &ret1;
+
+  FuncPtrZero = callback(&ret1);
+  FuncPtrOne = callback(&ret0);
+
+  return 0;
+}
diff --git a/test/llvm_test_code/pointers/context_14_2.c b/test/llvm_test_code/pointers/context_14_2.c
new file mode 100644
index 0000000000..aa0b519768
--- /dev/null
+++ b/test/llvm_test_code/pointers/context_14_2.c
@@ -0,0 +1,20 @@
+
+int ret0() { return 0; }
+
+int ret1() { return 1; }
+
+int ret2() { return 1; }
+
+int (*callback(int (*Func)()))() { return Func; }
+
+int main() {
+  int (*FuncPtrZero)() = &ret0;
+  int (*FuncPtrOne)() = &ret1;
+  int (*FuncPtrTwo)() = &ret2;
+
+  FuncPtrZero = callback(&ret2);
+  FuncPtrOne = callback(&ret0);
+  FuncPtrTwo = callback(&ret1);
+
+  return 0;
+}
diff --git a/test/llvm_test_code/pointers/indirection_01.c b/test/llvm_test_code/pointers/indirection_01.c
index fb00571431..04cbec9efb 100644
--- a/test/llvm_test_code/pointers/indirection_01.c
+++ b/test/llvm_test_code/pointers/indirection_01.c
@@ -8,5 +8,7 @@ int main() {
   LinkedList Foo;
   Foo = (LinkedList){0, &Foo};
 
-  return (int)Foo.Next;
+  LinkedList *Alias = Foo.Next;
+
+  return 0;
 }
diff --git a/test/llvm_test_code/pointers/indirection_02.c b/test/llvm_test_code/pointers/indirection_02.c
index 32d6d99c8a..f73aee5e16 100644
--- a/test/llvm_test_code/pointers/indirection_02.c
+++ b/test/llvm_test_code/pointers/indirection_02.c
@@ -17,5 +17,10 @@ int main() {
   Boar.Next = &Bar;
   Baz.Next = &Boar;
 
-  return (int)Boar.Next;
+  LinkedList *AliasOne = Foo.Next;
+  LinkedList *AliasTwo = Bar.Next;
+  LinkedList *AliasThree = Baz.Next;
+  LinkedList *AliasFour = Boar.Next;
+
+  return 0;
 }
diff --git a/test/llvm_test_code/pointers/indirection_03.c b/test/llvm_test_code/pointers/indirection_03.c
new file mode 100644
index 0000000000..7ab9f3f11e
--- /dev/null
+++ b/test/llvm_test_code/pointers/indirection_03.c
@@ -0,0 +1,27 @@
+
+typedef struct _LinkedListOne {
+  int Val;
+  struct _LinkedListOne *Next;
+} LinkedListOne;
+
+typedef struct _LinkedListTwo {
+  int Val;
+  struct _LinkedListOne *Next;
+} LinkedListTwo;
+
+int main() {
+  LinkedListOne Foo;
+  Foo = (LinkedListOne){0, &Foo};
+  LinkedListTwo Bar;
+  Bar = (LinkedListTwo){42, &Foo};
+
+  LinkedListOne Baz = Foo;
+  LinkedListTwo Boar = Bar;
+
+  LinkedListOne *AliasOne = Foo.Next;
+  LinkedListOne *AliasTwo = Bar.Next;
+  LinkedListOne *AliasThree = Baz.Next;
+  LinkedListOne *AliasFour = Boar.Next;
+
+  return 0;
+}
diff --git a/test/llvm_test_code/pointers/indirection_04.c b/test/llvm_test_code/pointers/indirection_04.c
new file mode 100644
index 0000000000..1427dfcdb8
--- /dev/null
+++ b/test/llvm_test_code/pointers/indirection_04.c
@@ -0,0 +1,37 @@
+
+typedef struct _LinkedListOne {
+  int Val;
+  struct _LinkedListOne *Next;
+} LinkedListOne;
+
+typedef struct _LinkedListTwo {
+  int Val;
+  struct _LinkedListOne *Next;
+} LinkedListTwo;
+
+typedef struct _LinkedListThree {
+  int Val;
+  struct _LinkedListTwo *Next;
+} LinkedListThree;
+
+int main() {
+  LinkedListOne Foo;
+  Foo = (LinkedListOne){0, &Foo};
+  LinkedListTwo Bar;
+  Bar = (LinkedListTwo){42, &Foo};
+  LinkedListThree Baz;
+  Baz = (LinkedListThree){42, &Bar};
+
+  LinkedListOne One = Foo;
+  LinkedListTwo Two = Bar;
+  LinkedListThree Three = Baz;
+
+  LinkedListOne *AliasOne = One.Next;
+  LinkedListOne *AliasTwo = Two.Next;
+  LinkedListTwo *AliasThree = Three.Next;
+  LinkedListOne *AliasFour = Foo.Next;
+  LinkedListOne *AliasFive = Bar.Next;
+  LinkedListTwo *AliasSix = Baz.Next;
+
+  return 0;
+}
diff --git a/test/llvm_test_code/pointers/indirection_05.c b/test/llvm_test_code/pointers/indirection_05.c
new file mode 100644
index 0000000000..0259262280
--- /dev/null
+++ b/test/llvm_test_code/pointers/indirection_05.c
@@ -0,0 +1,47 @@
+
+typedef struct _LinkedListOne {
+  int Val;
+  struct _LinkedListOne *Next;
+} LinkedListOne;
+
+typedef struct _LinkedListTwo {
+  int Val;
+  struct _LinkedListOne *Next;
+} LinkedListTwo;
+
+typedef struct _LinkedListThree {
+  int Val;
+  struct _LinkedListTwo *Next;
+} LinkedListThree;
+
+typedef struct _LinkedListFour {
+  int Val;
+  struct _LinkedListThree *Next;
+} LinkedListFour;
+
+int main() {
+  LinkedListOne Foo;
+  Foo = (LinkedListOne){0, &Foo};
+  LinkedListTwo Bar;
+  Bar = (LinkedListTwo){42, &Foo};
+  LinkedListThree Baz;
+  Baz = (LinkedListThree){42, &Bar};
+  LinkedListFour Boar;
+  Boar = (LinkedListFour){42, &Baz};
+
+  LinkedListOne One = Foo;
+  LinkedListTwo Two = Bar;
+  LinkedListThree Three = Baz;
+  LinkedListFour Four = Boar;
+
+  LinkedListOne *AliasOne = One.Next;
+  LinkedListOne *AliasTwo = Two.Next;
+  LinkedListTwo *AliasThree = Three.Next;
+  LinkedListThree *AliasFour = Four.Next;
+  LinkedListOne *AliasFive = Foo.Next;
+  LinkedListOne *AliasSix = Bar.Next;
+  LinkedListTwo *AliasSeven = Baz.Next;
+  LinkedListThree *AliasEight = Boar.Next;
+
+  return 0;
+}
diff --git a/test/llvm_test_code/pointers/indirection_06.c b/test/llvm_test_code/pointers/indirection_06.c
new file mode 100644
index 0000000000..6bb0ce57c1
--- /dev/null
+++ b/test/llvm_test_code/pointers/indirection_06.c
@@ -0,0 +1,57 @@
+
+typedef struct _LinkedListOne {
+  int Val;
+  struct _LinkedListOne *Next;
+} LinkedListOne;
+
+typedef struct _LinkedListTwo {
+  int Val;
+  struct _LinkedListOne *Next;
+} LinkedListTwo;
+
+typedef struct _LinkedListThree {
+  int Val;
+  struct _LinkedListTwo *Next;
+} LinkedListThree;
+
+typedef struct _LinkedListFour {
+  int Val;
+  struct _LinkedListThree *Next;
+} LinkedListFour;
+
+typedef struct _LinkedListFive {
+  int Val;
+  struct _LinkedListFour *Next;
+} LinkedListFive;
+
+int main() {
+  LinkedListOne Foo;
+  Foo = (LinkedListOne){0, &Foo};
+  LinkedListTwo Bar;
+  Bar = (LinkedListTwo){42, &Foo};
+  LinkedListThree Baz;
+  Baz = (LinkedListThree){42, &Bar};
+  LinkedListFour Boar;
+  Boar = (LinkedListFour){42, &Baz};
+  LinkedListFive Far;
+  Far = (LinkedListFive){42, &Boar};
+
+  LinkedListOne One = Foo;
+  LinkedListTwo Two = Bar;
+  LinkedListThree Three = Baz;
+  LinkedListFour Four = Boar;
+  LinkedListFive Five = Far;
+
+  LinkedListOne *AliasOne = One.Next;
+  LinkedListOne *AliasTwo = Two.Next;
+  LinkedListTwo *AliasThree = Three.Next;
+  LinkedListThree *AliasFour = Four.Next;
+  LinkedListFour *AliasFive = Five.Next;
+  LinkedListOne *AliasSix = Foo.Next;
+  LinkedListOne *AliasSeven = Bar.Next;
+  LinkedListTwo *AliasEight = Baz.Next;
+  LinkedListThree *AliasNine = Boar.Next;
+  LinkedListFour *AliasTen = Far.Next;
+
+  return 0;
+}
diff --git a/test/llvm_test_code/pointers/indirection_07.c b/test/llvm_test_code/pointers/indirection_07.c
new file mode 100644
index 0000000000..495be86420
--- /dev/null
+++ b/test/llvm_test_code/pointers/indirection_07.c
@@ -0,0 +1,67 @@
+
+typedef struct _LinkedListOne {
+  int Val;
+  struct _LinkedListOne *Next;
+} LinkedListOne;
+
+typedef struct _LinkedListTwo {
+  int Val;
+  struct _LinkedListOne *Next;
+} LinkedListTwo;
+
+typedef struct _LinkedListThree {
+  int Val;
+  struct _LinkedListTwo *Next;
+} LinkedListThree;
+
+typedef struct _LinkedListFour {
+  int Val;
+  struct _LinkedListThree *Next;
+} LinkedListFour;
+
+typedef struct _LinkedListFive {
+  int Val;
+  struct _LinkedListFour *Next;
+} LinkedListFive;
+
+typedef struct _LinkedListSix {
+  int Val;
+  struct _LinkedListFive *Next;
+} LinkedListSix;
+
+int main() {
+  LinkedListOne Foo;
+  Foo = (LinkedListOne){0, &Foo};
+  LinkedListTwo Bar;
+  Bar = (LinkedListTwo){42, &Foo};
+  LinkedListThree Baz;
+  Baz = (LinkedListThree){42, &Bar};
+  LinkedListFour Boar;
+  Boar = (LinkedListFour){42, &Baz};
+  LinkedListFive Far;
+  Far = (LinkedListFive){42, &Boar};
+  LinkedListSix Faz;
+  Faz = (LinkedListSix){42, &Far};
+
+  LinkedListOne One = Foo;
+  LinkedListTwo Two = Bar;
+  LinkedListThree Three = Baz;
+  LinkedListFour Four = Boar;
+  LinkedListFive Five = Far;
+  LinkedListSix Six = Faz;
+
+  LinkedListOne *AliasOne = One.Next;
+  LinkedListOne *AliasTwo = Two.Next;
+  LinkedListTwo *AliasThree = Three.Next;
+  LinkedListThree *AliasFour = Four.Next;
+  LinkedListFour *AliasFive = Five.Next;
+  LinkedListFive *AliasSix = Six.Next;
+  LinkedListOne *AliasSeven = Foo.Next;
+  LinkedListOne *AliasEight = Bar.Next;
+  LinkedListTwo *AliasNine = Baz.Next;
+  LinkedListThree *AliasTen = Boar.Next;
+  LinkedListFour *AliasEleven = Far.Next;
+  LinkedListFive *AliasTwelve = Faz.Next;
+
+  return 0;
+}
diff --git a/test/llvm_test_code/pointers/indirection_08.cpp b/test/llvm_test_code/pointers/indirection_08.cpp
new file mode 100644
index 0000000000..7bd9117b94
--- /dev/null
+++ b/test/llvm_test_code/pointers/indirection_08.cpp
@@ -0,0 +1,20 @@
+
+class Foo {
+public:
+  virtual int Func() { return 0; };
+};
+
+class Bar : public Foo {
+public:
+  int Func() override { return 1; };
+};
+
+int main() {
+  Foo First;
+  Bar Second;
+
+  int x = First.Func();
+  int y = Second.Func();
+
+  return 0;
+}
diff --git a/test/llvm_test_code/pointers/indirection_09.cpp b/test/llvm_test_code/pointers/indirection_09.cpp
new file mode 100644
index 0000000000..4b9edc2119
--- /dev/null
+++ b/test/llvm_test_code/pointers/indirection_09.cpp
@@ -0,0 +1,27 @@
+
+class Foo {
+public:
+  virtual int Func() { return 0; };
+};
+
+class Bar : public Foo {
+public:
+  int Func() override { return 1; };
+};
+
+class Baz : public Bar {
+public:
+  int Func() override { return 2; };
+};
+
+int main() {
+  Foo First;
+  Bar Second;
+  Baz Third;
+
+  int x = First.Func();
+  int y = Second.Func();
+  int z = Third.Func();
+
+  return 0;
+}
diff --git a/test/llvm_test_code/pointers/indirection_10.cpp b/test/llvm_test_code/pointers/indirection_10.cpp
new file mode 100644
index 0000000000..6699edfcbb
--- /dev/null
+++ b/test/llvm_test_code/pointers/indirection_10.cpp
@@ -0,0 +1,34 @@
+
+class Foo {
+public:
+  virtual int Func() { return 0; };
+};
+
+class Bar : public Foo {
+public:
+  int Func() override { return 1; };
+};
+
+class Baz : public Bar {
+public:
+  int Func() override { return 2; };
+};
+
+class Boar : public Baz {
+public:
+  int Func() override { return 3; };
+};
+
+int main() {
+  Foo First;
+  Bar Second;
+  Baz Third;
+  Boar Fourth;
+
+  int x = First.Func();
+  int y = Second.Func();
+  int z = Third.Func();
+  int a = Fourth.Func();
+
+  return 0;
+}
diff --git a/test/llvm_test_code/pointers/indirection_11.cpp b/test/llvm_test_code/pointers/indirection_11.cpp
new file mode 100644
index 0000000000..276b8b3255
--- /dev/null
+++ b/test/llvm_test_code/pointers/indirection_11.cpp
@@ -0,0 +1,41 @@
+
+class Foo {
+public:
+  virtual int Func() { return 0; };
+};
+
+class Bar : public Foo {
+public:
+  int Func() override { return 1; };
+};
+
+class Baz : public Bar {
+public:
+  int Func() override { return 2; };
+};
+
+class Boar : public Baz {
+public:
+  int Func() override { return 3; };
+};
+
+class Far : public Boar {
+public:
+  int Func() override { return 4; };
+};
+
+int main() {
+  Foo First;
+  Bar Second;
+  Baz Third;
+  Boar Fourth;
+  Far Fifth;
+
+  int x = First.Func();
+  int y = Second.Func();
+  int z = Third.Func();
+  int a = Fourth.Func();
+  int b = Fifth.Func();
+
+  return 0;
+}

From 7f1d7f918bd9b397d9304267dc18b337b031613f Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Tue, 10 Feb 2026 16:17:34 +0100
Subject: [PATCH 43/75] fixed cmakelists for cpp tests

---
 test/llvm_test_code/pointers/CMakeLists.txt   |  8 +--
 .../Pointer/LLVMUnionFindAATest.cpp           | 64 +++++++++++++++++++
 2 files changed, 68 insertions(+), 4 deletions(-)

diff --git a/test/llvm_test_code/pointers/CMakeLists.txt b/test/llvm_test_code/pointers/CMakeLists.txt
index a34a2cf889..ab5d4ce829 100644
--- a/test/llvm_test_code/pointers/CMakeLists.txt
+++ b/test/llvm_test_code/pointers/CMakeLists.txt
@@ -39,10 +39,10 @@ set(lca_files
   indirection_05.c
   indirection_06.c
   indirection_07.c
-  indirection_08.c
-  indirection_09.c
-  indirection_10.c
-  indirection_11.c
+  indirection_08.cpp
+  indirection_09.cpp
+  indirection_10.cpp
+  indirection_11.cpp
 )
 
 set(lca_files_mem2reg
diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index d16d5c70a8..209fde6993 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -5638,6 +5638,70 @@ UnionFindAAResult {
   doAnalysisAndCompareResults("context_13_1_c_dbg.ll", GT, IndAABuilder);
 }
 
+TEST(IndirectionSensUnionFindAATest, Context14_0) {
+  /*
+  ValueCompressor: {
+  #0:
+    %Func.addr = alloca ptr, align 8, !psr.id !24 | ID: 1
+  #1:
+    ptr %Func | ID: callback.0
+  #2:
+    %0 = load ptr, ptr %Func.addr, align 8, !dbg !29, !psr.id !30 | ID: 4
+  #3:
+    %retval = alloca i32, align 4, !psr.id !36 | ID: 7
+  #4:
+    %FuncPtr = alloca ptr, align 8, !psr.id !37 | ID: 8
+  #5:
+    %Zero = alloca i32, align 4, !psr.id !38 | ID: 9
+  #6:
+    fun @ret0
+  #7:
+    %0 = load ptr, ptr %FuncPtr, align 8, !dbg !47, !psr.id !48 | ID: 14
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1, 2, 6, 7>
+  #6: <>
+  #7: <>
+  #8: <>
+  #9: <>
+  #10: <3>
+  #11: <>
+  #12: <>
+  #13: <>
+  #14: <>
+  #15: <4>
+  #16: <>
+  #17: <>
+  #18: <>
+  #19: <>
+  #20: <5>
+  #21: <>
+  #22: <>
+  #23: <>
+  #24: <>
+}
+  */
+  GTMap GT{{LineColFunOp{.Line = 7,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 7,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_14_0_c_dbg.ll", GT, IndAABuilder);
+}
+
 } // namespace
 
 int main(int Argc, char **Argv) {

From 2c8d8aa73245784aff8230ef06e923ca5e200f96 Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Tue, 10 Feb 2026 19:57:03 +0100
Subject: [PATCH 44/75] Indir Unittests output comments + 01, 02 half done

---
 .../pointers/indirection_08.cpp               |    4 +-
 .../pointers/indirection_09.cpp               |    6 +-
 .../pointers/indirection_10.cpp               |    8 +-
 .../pointers/indirection_11.cpp               |   10 +-
 .../Pointer/LLVMUnionFindAATest.cpp           | 1727 +++++++++++++++++
 5 files changed, 1741 insertions(+), 14 deletions(-)

diff --git a/test/llvm_test_code/pointers/indirection_08.cpp b/test/llvm_test_code/pointers/indirection_08.cpp
index 7bd9117b94..8df8113c10 100644
--- a/test/llvm_test_code/pointers/indirection_08.cpp
+++ b/test/llvm_test_code/pointers/indirection_08.cpp
@@ -10,8 +10,8 @@ class Bar : public Foo {
 };
 
 int main() {
-  Foo First;
-  Bar Second;
+  Foo First{};
+  Bar Second{};
 
   int x = First.Func();
   int y = Second.Func();
diff --git a/test/llvm_test_code/pointers/indirection_09.cpp b/test/llvm_test_code/pointers/indirection_09.cpp
index 4b9edc2119..8a2a5a84ae 100644
--- a/test/llvm_test_code/pointers/indirection_09.cpp
+++ b/test/llvm_test_code/pointers/indirection_09.cpp
@@ -15,9 +15,9 @@ class Baz : public Bar {
 };
 
 int main() {
-  Foo First;
-  Bar Second;
-  Baz Third;
+  Foo First{};
+  Bar Second{};
+  Baz Third{};
 
   int x = First.Func();
   int y = Second.Func();
diff --git a/test/llvm_test_code/pointers/indirection_10.cpp b/test/llvm_test_code/pointers/indirection_10.cpp
index 6699edfcbb..c863f0d1ee 100644
--- a/test/llvm_test_code/pointers/indirection_10.cpp
+++ b/test/llvm_test_code/pointers/indirection_10.cpp
@@ -20,10 +20,10 @@ class Boar : public Baz {
 };
 
 int main() {
-  Foo First;
-  Bar Second;
-  Baz Third;
-  Boar Fourth;
+  Foo First{};
+  Bar Second{};
+  Baz Third{};
+  Boar Fourth{};
 
   int x = First.Func();
   int y = Second.Func();
diff --git a/test/llvm_test_code/pointers/indirection_11.cpp b/test/llvm_test_code/pointers/indirection_11.cpp
index 276b8b3255..4af366255b 100644
--- a/test/llvm_test_code/pointers/indirection_11.cpp
+++ b/test/llvm_test_code/pointers/indirection_11.cpp
@@ -25,11 +25,11 @@ class Far : public Boar {
 };
 
 int main() {
-  Foo First;
-  Bar Second;
-  Baz Third;
-  Boar Fourth;
-  Far Fifth;
+  Foo First{};
+  Bar Second{};
+  Baz Third{};
+  Boar Fourth{};
+  Far Fifth{};
 
   int x = First.Func();
   int y = Second.Func();
diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index 209fde6993..32344c7416 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -5702,6 +5702,1733 @@ UnionFindAAResult {
   doAnalysisAndCompareResults("context_14_0_c_dbg.ll", GT, IndAABuilder);
 }
 
+TEST(IndirectionSensUnionFindAATest, Context14_1) {
+  /*
+ValueCompressor: {
+  #0:
+    %Func.addr = alloca ptr, align 8, !psr.id !27 | ID: 2
+  #1:
+    ptr %Func | ID: callback.0
+  #2:
+    %0 = load ptr, ptr %Func.addr, align 8, !dbg !32, !psr.id !33 | ID: 5
+  #3:
+    fun @callback.<ret>
+  #4:
+    %retval = alloca i32, align 4, !psr.id !37 | ID: 7
+  #5:
+    %FuncPtrZero = alloca ptr, align 8, !psr.id !38 | ID: 8
+  #6:
+    %FuncPtrOne = alloca ptr, align 8, !psr.id !39 | ID: 9
+  #7:
+    fun @ret0
+  #8:
+    fun @ret1
+  #9:
+    %call = call ptr @callback(ptr noundef @ret1), !dbg !49, !psr.id !50 | ID:
+15 #10: %call1 = call ptr @callback(ptr noundef @ret0), !dbg !53, !psr.id !54 |
+ID: 17
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1, 2, 3, 7, 8, 9, 10>
+  #6: <>
+  #7: <>
+  #8: <>
+  #9: <>
+  #10: <4>
+  #11: <>
+  #12: <>
+  #13: <>
+  #14: <>
+  #15: <5>
+  #16: <>
+  #17: <>
+  #18: <>
+  #19: <>
+  #20: <6>
+  #21: <>
+  #22: <>
+  #23: <>
+  #24: <>
+}
+  */
+  GTMap GT{{LineColFunOp{.Line = 9,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("context_14_1_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Context14_2) {
+  /*
+ValueCompressor: {
+  #0:
+    %Func.addr = alloca ptr, align 8, !psr.id !30 | ID: 3
+  #1:
+    ptr %Func | ID: callback.0
+  #2:
+    %0 = load ptr, ptr %Func.addr, align 8, !dbg !35, !psr.id !36 | ID: 6
+  #3:
+    fun @callback.<ret>
+  #4:
+    %retval = alloca i32, align 4, !psr.id !40 | ID: 8
+  #5:
+    %FuncPtrZero = alloca ptr, align 8, !psr.id !41 | ID: 9
+  #6:
+    %FuncPtrOne = alloca ptr, align 8, !psr.id !42 | ID: 10
+  #7:
+    %FuncPtrTwo = alloca ptr, align 8, !psr.id !43 | ID: 11
+  #8:
+    fun @ret0
+  #9:
+    fun @ret1
+  #10:
+    fun @ret2
+  #11:
+    %call = call ptr @callback(ptr noundef @ret2), !dbg !57, !psr.id !58 | ID:
+19 #12: %call1 = call ptr @callback(ptr noundef @ret0), !dbg !61, !psr.id !62 |
+ID: 21 #13: %call2 = call ptr @callback(ptr noundef @ret1), !dbg !65, !psr.id
+!66 | ID: 23
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1, 2, 3, 8, 9, 10, 11, 12, 13>
+  #6: <>
+  #7: <>
+  #8: <>
+  #9: <>
+  #10: <4>
+  #11: <>
+  #12: <>
+  #13: <>
+  #14: <>
+  #15: <5>
+  #16: <>
+  #17: <>
+  #18: <>
+  #19: <>
+  #20: <6>
+  #21: <>
+  #22: <>
+  #23: <>
+  #24: <>
+  #25: <7>
+  #26: <>
+  #27: <>
+  #28: <>
+  #29: <>
+}
+  */
+  GTMap GT{{LineColFunOp{.Line = 11,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                RetVal{.InFunction = "callback"},
+                LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("context_14_2_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Indirection01) {
+  /*
+ValueCompressor: {
+  #0:
+    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
+  #1:
+    %Foo = alloca %struct._LinkedList, align 8, !psr.id !17 | ID: 1
+    %Next1 = getelementptr inbounds %struct._LinkedList, ptr %Foo, i32 0, i32 1,
+!dbg !41, !psr.id !42 | ID: 12 #2:
+    %.compoundliteral = alloca %struct._LinkedList, align 8, !psr.id !18 | ID: 2
+    %Val = getelementptr inbounds %struct._LinkedList, ptr %.compoundliteral,
+i32 0, i32 0, !dbg !30, !psr.id !31 | ID: 6 %Next = getelementptr inbounds
+%struct._LinkedList, ptr %.compoundliteral, i32 0, i32 1, !dbg !30, !psr.id !33
+| ID: 8 #3: %Alias = alloca ptr, align 8, !psr.id !19 | ID: 3 #4: %0 = load ptr,
+ptr %Next1, align 8, !dbg !41, !psr.id !43 | ID: 13
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1, 4>
+  #6: <2>
+  #7: <3>
+  #8: <>
+  #9: <>
+  #10: <>
+  #11: <>
+}
+  */
+  GTMap GT{{LineColFunOp{.Line = 8,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 11,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("indirection_01_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Indirection02) {
+  /*
+ValueCompressor: {
+  #0:
+    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
+  #1:
+    %Foo = alloca %struct._LinkedList, align 8, !psr.id !17 | ID: 1
+    %Next6 = getelementptr inbounds %struct._LinkedList, ptr %Foo, i32 0, i32 1,
+!dbg !76, !psr.id !77 | ID: 33
+  #2:
+    %.compoundliteral = alloca %struct._LinkedList, align 8, !psr.id !18 | ID: 2
+    %Val = getelementptr inbounds %struct._LinkedList, ptr %.compoundliteral,
+i32 0, i32 0, !dbg !37, !psr.id !38 | ID: 13 %Next = getelementptr inbounds
+%struct._LinkedList, ptr %.compoundliteral, i32 0, i32 1, !dbg !37, !psr.id !40
+| ID: 15
+  #3: %Bar = alloca %struct._LinkedList, align 8, !psr.id !19 | ID: 3
+    %Next7 = getelementptr inbounds %struct._LinkedList, ptr %Bar, i32 0, i32 1,
+!dbg !83, !psr.id !84 | ID: 37
+  #4:
+    %.compoundliteral1 = alloca %struct._LinkedList, align 8, !psr.id !20 | ID:
+4 %Val2 = getelementptr inbounds %struct._LinkedList, ptr %.compoundliteral1,
+i32 0, i32 0, !dbg !47, !psr.id !48 | ID: 19 %Next3 = getelementptr inbounds
+%struct._LinkedList, ptr %.compoundliteral1, i32 0, i32 1, !dbg !47, !psr.id !50
+| ID: 21
+  #5: %Baz = alloca %struct._LinkedList, align 8, !psr.id !21 | ID: 5
+    %Next5 = getelementptr inbounds %struct._LinkedList, ptr %Baz, i32 0, i32 1,
+!dbg !68, !psr.id !69 | ID: 30 %Next8 = getelementptr inbounds
+%struct._LinkedList, ptr %Baz, i32 0, i32 1, !dbg !90, !psr.id !91 | ID: 41
+  #6:
+    %Boar = alloca %struct._LinkedList, align 8, !psr.id !22 | ID: 6
+    %Next4 = getelementptr inbounds %struct._LinkedList, ptr %Boar, i32 0, i32
+1, !dbg !64, !psr.id !65 | ID: 28 %Next9 = getelementptr inbounds
+%struct._LinkedList, ptr %Boar, i32 0, i32 1, !dbg !97, !psr.id !98 | ID: 45
+  #7:
+    %AliasOne = alloca ptr, align 8, !psr.id !23 | ID: 7
+  #8:
+    %AliasTwo = alloca ptr, align 8, !psr.id !24 | ID: 8
+  #9:
+    %AliasThree = alloca ptr, align 8, !psr.id !25 | ID: 9
+  #10:
+    %AliasFour = alloca ptr, align 8, !psr.id !26 | ID: 10
+  #11:
+    %0 = load ptr, ptr %Next6, align 8, !dbg !76, !psr.id !78 | ID: 34
+  #12:
+    %1 = load ptr, ptr %Next7, align 8, !dbg !83, !psr.id !85 | ID: 38
+  #13:
+    %2 = load ptr, ptr %Next8, align 8, !dbg !90, !psr.id !92 | ID: 42
+  #14:
+    %3 = load ptr, ptr %Next9, align 8, !dbg !97, !psr.id !99 | ID: 46
+}
+PhASAR v2510
+A LLVM-based static analysis framework
+LLVMUnionFindAliasSet(global, botctx-ind-sens) {
+  #0: {0}
+  #1: {1, 3, 6, 11, 12, 13, 14}
+  #2: {2}
+  #3: {1, 3, 6, 11, 12, 13, 14}
+  #4: {4}
+  #5: {5}
+  #6: {1, 3, 6, 11, 12, 13, 14}
+  #7: {7}
+  #8: {8}
+  #9: {9}
+  #10: {10}
+  #11: {1, 3, 6, 11, 12, 13, 14}
+  #12: {1, 3, 6, 11, 12, 13, 14}
+  #13: {1, 3, 6, 11, 12, 13, 14}
+  #14: {1, 3, 6, 11, 12, 13, 14}
+
+  TODO: ask Fabian if the output of the analysis is correct here/what the GT
+should look like.
+}
+  */
+  GTMap GT{{LineColFunOp{.Line = 8,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }}};
+
+  doAnalysisAndCompareResults("indirection_02_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Indirection03) {
+  /*
+ValueCompressor: {
+  #0:
+    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
+  #1:
+    %Foo = alloca %struct._LinkedListOne, align 8, !psr.id !17 | ID: 1
+    %Next4 = getelementptr inbounds %struct._LinkedListOne, ptr %Foo, i32 0, i32
+1, !dbg !73, !psr.id !74 | ID: 29 #2:
+    %.compoundliteral = alloca %struct._LinkedListOne, align 8, !psr.id !18 |
+ID: 2 %Val = getelementptr inbounds %struct._LinkedListOne, ptr
+%.compoundliteral, i32 0, i32 0, !dbg !37, !psr.id !38 | ID: 13 %Next =
+getelementptr inbounds %struct._LinkedListOne, ptr %.compoundliteral, i32 0, i32
+1, !dbg !37, !psr.id !40 | ID: 15 #3: %Bar = alloca %struct._LinkedListTwo,
+align 8, !psr.id !19 | ID: 3 %Next5 = getelementptr inbounds
+%struct._LinkedListTwo, ptr %Bar, i32 0, i32 1, !dbg !80, !psr.id !81 | ID: 33
+  #4:
+    %.compoundliteral1 = alloca %struct._LinkedListTwo, align 8, !psr.id !20 |
+ID: 4 %Val2 = getelementptr inbounds %struct._LinkedListTwo, ptr
+%.compoundliteral1, i32 0, i32 0, !dbg !52, !psr.id !53 | ID: 19 %Next3 =
+getelementptr inbounds %struct._LinkedListTwo, ptr %.compoundliteral1, i32 0,
+i32 1, !dbg !52, !psr.id !55 | ID: 21 #5: %Baz = alloca %struct._LinkedListOne,
+align 8, !psr.id !21 | ID: 5 %Next6 = getelementptr inbounds
+%struct._LinkedListOne, ptr %Baz, i32 0, i32 1, !dbg !87, !psr.id !88 | ID: 37
+  #6:
+    %Boar = alloca %struct._LinkedListTwo, align 8, !psr.id !22 | ID: 6
+    %Next7 = getelementptr inbounds %struct._LinkedListTwo, ptr %Boar, i32 0,
+i32 1, !dbg !94, !psr.id !95 | ID: 41 #7: %AliasOne = alloca ptr, align 8,
+!psr.id !23 | ID: 7 #8: %AliasTwo = alloca ptr, align 8, !psr.id !24 | ID: 8 #9:
+    %AliasThree = alloca ptr, align 8, !psr.id !25 | ID: 9
+  #10:
+    %AliasFour = alloca ptr, align 8, !psr.id !26 | ID: 10
+  #11:
+    %0 = load ptr, ptr %Next4, align 8, !dbg !73, !psr.id !75 | ID: 30
+  #12:
+    %1 = load ptr, ptr %Next5, align 8, !dbg !80, !psr.id !82 | ID: 34
+  #13:
+    %2 = load ptr, ptr %Next6, align 8, !dbg !87, !psr.id !89 | ID: 38
+  #14:
+    %3 = load ptr, ptr %Next7, align 8, !dbg !94, !psr.id !96 | ID: 42
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1, 11, 12, 13, 14>
+  #6: <2>
+  #7: <3>
+  #8: <4>
+  #9: <5>
+  #10: <6>
+  #11: <7>
+  #12: <>
+  #13: <>
+  #14: <>
+  #15: <>
+  #16: <8>
+  #17: <>
+  #18: <>
+  #19: <>
+  #20: <>
+  #21: <9>
+  #22: <>
+  #23: <>
+  #24: <>
+  #25: <>
+  #26: <10>
+  #27: <>
+  #28: <>
+  #29: <>
+  #30: <>
+}
+  */
+  GTMap GT{{LineColFunOp{.Line = 13,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("indirection_03_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Indirection04) {
+  /*
+ValueCompressor: {
+  #0:
+    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
+  #1:
+    %Foo = alloca %struct._LinkedListOne, align 8, !psr.id !17 | ID: 1
+    %Next10 = getelementptr inbounds %struct._LinkedListOne, ptr %Foo, i32 0,
+i32 1, !dbg !121, !psr.id !122 | ID: 54 #2:
+    %.compoundliteral = alloca %struct._LinkedListOne, align 8, !psr.id !18 |
+ID: 2 %Val = getelementptr inbounds %struct._LinkedListOne, ptr
+%.compoundliteral, i32 0, i32 0, !dbg !42, !psr.id !43 | ID: 18 %Next =
+getelementptr inbounds %struct._LinkedListOne, ptr %.compoundliteral, i32 0, i32
+1, !dbg !42, !psr.id !45 | ID: 20 #3: %Bar = alloca %struct._LinkedListTwo,
+align 8, !psr.id !19 | ID: 3 %Next11 = getelementptr inbounds
+%struct._LinkedListTwo, ptr %Bar, i32 0, i32 1, !dbg !128, !psr.id !129 | ID: 58
+  #4:
+    %.compoundliteral1 = alloca %struct._LinkedListTwo, align 8, !psr.id !20 |
+ID: 4 %Val2 = getelementptr inbounds %struct._LinkedListTwo, ptr
+%.compoundliteral1, i32 0, i32 0, !dbg !57, !psr.id !58 | ID: 24 %Next3 =
+getelementptr inbounds %struct._LinkedListTwo, ptr %.compoundliteral1, i32 0,
+i32 1, !dbg !57, !psr.id !60 | ID: 26 #5: %Baz = alloca
+%struct._LinkedListThree, align 8, !psr.id !21 | ID: 5 %Next12 = getelementptr
+inbounds %struct._LinkedListThree, ptr %Baz, i32 0, i32 1, !dbg !135, !psr.id
+!136 | ID: 62 #6:
+    %.compoundliteral4 = alloca %struct._LinkedListThree, align 8, !psr.id !22 |
+ID: 6 %Val5 = getelementptr inbounds %struct._LinkedListThree, ptr
+%.compoundliteral4, i32 0, i32 0, !dbg !73, !psr.id !74 | ID: 30 %Next6 =
+getelementptr inbounds %struct._LinkedListThree, ptr %.compoundliteral4, i32 0,
+i32 1, !dbg !73, !psr.id !76 | ID: 32 #7: %One = alloca %struct._LinkedListOne,
+align 8, !psr.id !23 | ID: 7 %Next7 = getelementptr inbounds
+%struct._LinkedListOne, ptr %One, i32 0, i32 1, !dbg !99, !psr.id !100 | ID: 42
+  #8:
+    %Two = alloca %struct._LinkedListTwo, align 8, !psr.id !24 | ID: 8
+    %Next8 = getelementptr inbounds %struct._LinkedListTwo, ptr %Two, i32 0, i32
+1, !dbg !106, !psr.id !107 | ID: 46 #9: %Three = alloca
+%struct._LinkedListThree, align 8, !psr.id !25 | ID: 9 %Next9 = getelementptr
+inbounds %struct._LinkedListThree, ptr %Three, i32 0, i32 1, !dbg !114, !psr.id
+!115 | ID: 50 #10: %AliasOne = alloca ptr, align 8, !psr.id !26 | ID: 10 #11:
+    %AliasTwo = alloca ptr, align 8, !psr.id !27 | ID: 11
+  #12:
+    %AliasThree = alloca ptr, align 8, !psr.id !28 | ID: 12
+  #13:
+    %AliasFour = alloca ptr, align 8, !psr.id !29 | ID: 13
+  #14:
+    %AliasFive = alloca ptr, align 8, !psr.id !30 | ID: 14
+  #15:
+    %AliasSix = alloca ptr, align 8, !psr.id !31 | ID: 15
+  #16:
+    %0 = load ptr, ptr %Next7, align 8, !dbg !99, !psr.id !101 | ID: 43
+  #17:
+    %1 = load ptr, ptr %Next8, align 8, !dbg !106, !psr.id !108 | ID: 47
+  #18:
+    %2 = load ptr, ptr %Next9, align 8, !dbg !114, !psr.id !116 | ID: 51
+  #19:
+    %3 = load ptr, ptr %Next10, align 8, !dbg !121, !psr.id !123 | ID: 55
+  #20:
+    %4 = load ptr, ptr %Next11, align 8, !dbg !128, !psr.id !130 | ID: 59
+  #21:
+    %5 = load ptr, ptr %Next12, align 8, !dbg !135, !psr.id !137 | ID: 63
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1, 16, 17, 19, 20>
+  #6: <2>
+  #7: <3, 18, 21>
+  #8: <4>
+  #9: <5>
+  #10: <6>
+  #11: <7>
+  #12: <8>
+  #13: <9>
+  #14: <10>
+  #15: <>
+  #16: <>
+  #17: <>
+  #18: <>
+  #19: <11>
+  #20: <>
+  #21: <>
+  #22: <>
+  #23: <>
+  #24: <12>
+  #25: <>
+  #26: <>
+  #27: <>
+  #28: <>
+  #29: <13>
+  #30: <>
+  #31: <>
+  #32: <>
+  #33: <>
+  #34: <14>
+  #35: <>
+  #36: <>
+  #37: <>
+  #38: <>
+  #39: <15>
+  #40: <>
+  #41: <>
+  #42: <>
+  #43: <>
+}
+  */
+  GTMap GT{{LineColFunOp{.Line = 18,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 29,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("indirection_04_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Indirection05) {
+  /*
+ValueCompressor: {
+  #0:
+    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
+  #1:
+    %Foo = alloca %struct._LinkedListOne, align 8, !psr.id !17 | ID: 1
+    %Next14 = getelementptr inbounds %struct._LinkedListOne, ptr %Foo, i32 0,
+i32 1, !dbg !155, !psr.id !156 | ID: 71 #2:
+    %.compoundliteral = alloca %struct._LinkedListOne, align 8, !psr.id !18 |
+ID: 2 %Val = getelementptr inbounds %struct._LinkedListOne, ptr
+%.compoundliteral, i32 0, i32 0, !dbg !47, !psr.id !48 | ID: 23 %Next =
+getelementptr inbounds %struct._LinkedListOne, ptr %.compoundliteral, i32 0, i32
+1, !dbg !47, !psr.id !50 | ID: 25 #3: %Bar = alloca %struct._LinkedListTwo,
+align 8, !psr.id !19 | ID: 3 %Next15 = getelementptr inbounds
+%struct._LinkedListTwo, ptr %Bar, i32 0, i32 1, !dbg !162, !psr.id !163 | ID: 75
+  #4:
+    %.compoundliteral1 = alloca %struct._LinkedListTwo, align 8, !psr.id !20 |
+ID: 4 %Val2 = getelementptr inbounds %struct._LinkedListTwo, ptr
+%.compoundliteral1, i32 0, i32 0, !dbg !62, !psr.id !63 | ID: 29 %Next3 =
+getelementptr inbounds %struct._LinkedListTwo, ptr %.compoundliteral1, i32 0,
+i32 1, !dbg !62, !psr.id !65 | ID: 31 #5: %Baz = alloca
+%struct._LinkedListThree, align 8, !psr.id !21 | ID: 5 %Next16 = getelementptr
+inbounds %struct._LinkedListThree, ptr %Baz, i32 0, i32 1, !dbg !169, !psr.id
+!170 | ID: 79 #6:
+    %.compoundliteral4 = alloca %struct._LinkedListThree, align 8, !psr.id !22 |
+ID: 6 %Val5 = getelementptr inbounds %struct._LinkedListThree, ptr
+%.compoundliteral4, i32 0, i32 0, !dbg !78, !psr.id !79 | ID: 35 %Next6 =
+getelementptr inbounds %struct._LinkedListThree, ptr %.compoundliteral4, i32 0,
+i32 1, !dbg !78, !psr.id !81 | ID: 37 #7: %Boar = alloca
+%struct._LinkedListFour, align 8, !psr.id !23 | ID: 7 %Next17 = getelementptr
+inbounds %struct._LinkedListFour, ptr %Boar, i32 0, i32 1, !dbg !176, !psr.id
+!177 | ID: 83 #8:
+    %.compoundliteral7 = alloca %struct._LinkedListFour, align 8, !psr.id !24 |
+ID: 8 %Val8 = getelementptr inbounds %struct._LinkedListFour, ptr
+%.compoundliteral7, i32 0, i32 0, !dbg !94, !psr.id !95 | ID: 41 %Next9 =
+getelementptr inbounds %struct._LinkedListFour, ptr %.compoundliteral7, i32 0,
+i32 1, !dbg !94, !psr.id !97 | ID: 43 #9: %One = alloca %struct._LinkedListOne,
+align 8, !psr.id !25 | ID: 9 %Next10 = getelementptr inbounds
+%struct._LinkedListOne, ptr %One, i32 0, i32 1, !dbg !125, !psr.id !126 | ID: 55
+  #10:
+    %Two = alloca %struct._LinkedListTwo, align 8, !psr.id !26 | ID: 10
+    %Next11 = getelementptr inbounds %struct._LinkedListTwo, ptr %Two, i32 0,
+i32 1, !dbg !132, !psr.id !133 | ID: 59 #11: %Three = alloca
+%struct._LinkedListThree, align 8, !psr.id !27 | ID: 11 %Next12 = getelementptr
+inbounds %struct._LinkedListThree, ptr %Three, i32 0, i32 1, !dbg !140, !psr.id
+!141 | ID: 63 #12: %Four = alloca %struct._LinkedListFour, align 8, !psr.id !28
+| ID: 12 %Next13 = getelementptr inbounds %struct._LinkedListFour, ptr %Four,
+i32 0, i32 1, !dbg !148, !psr.id !149 | ID: 67 #13: %AliasOne = alloca ptr,
+align 8, !psr.id !29 | ID: 13 #14: %AliasTwo = alloca ptr, align 8, !psr.id !30
+| ID: 14 #15: %AliasThree = alloca ptr, align 8, !psr.id !31 | ID: 15 #16:
+    %AliasFour = alloca ptr, align 8, !psr.id !32 | ID: 16
+  #17:
+    %AliasFive = alloca ptr, align 8, !psr.id !33 | ID: 17
+  #18:
+    %AliasSix = alloca ptr, align 8, !psr.id !34 | ID: 18
+  #19:
+    %AliasSeven = alloca ptr, align 8, !psr.id !35 | ID: 19
+  #20:
+    %AliasEight = alloca ptr, align 8, !psr.id !36 | ID: 20
+  #21:
+    %0 = load ptr, ptr %Next10, align 8, !dbg !125, !psr.id !127 | ID: 56
+  #22:
+    %1 = load ptr, ptr %Next11, align 8, !dbg !132, !psr.id !134 | ID: 60
+  #23:
+    %2 = load ptr, ptr %Next12, align 8, !dbg !140, !psr.id !142 | ID: 64
+  #24:
+    %3 = load ptr, ptr %Next13, align 8, !dbg !148, !psr.id !150 | ID: 68
+  #25:
+    %4 = load ptr, ptr %Next14, align 8, !dbg !155, !psr.id !157 | ID: 72
+  #26:
+    %5 = load ptr, ptr %Next15, align 8, !dbg !162, !psr.id !164 | ID: 76
+  #27:
+    %6 = load ptr, ptr %Next16, align 8, !dbg !169, !psr.id !171 | ID: 80
+  #28:
+    %7 = load ptr, ptr %Next17, align 8, !dbg !176, !psr.id !178 | ID: 84
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1, 21, 22, 25, 26>
+  #6: <2>
+  #7: <3, 23, 27>
+  #8: <4>
+  #9: <5, 24, 28>
+  #10: <6>
+  #11: <7>
+  #12: <8>
+  #13: <9>
+  #14: <10>
+  #15: <11>
+  #16: <12>
+  #17: <13>
+  #18: <>
+  #19: <>
+  #20: <>
+  #21: <>
+  #22: <14>
+  #23: <>
+  #24: <>
+  #25: <>
+  #26: <>
+  #27: <15>
+  #28: <>
+  #29: <>
+  #30: <>
+  #31: <>
+  #32: <16>
+  #33: <>
+  #34: <>
+  #35: <>
+  #36: <>
+  #37: <17>
+  #38: <>
+  #39: <>
+  #40: <>
+  #41: <>
+  #42: <18>
+  #43: <>
+  #44: <>
+  #45: <>
+  #46: <>
+  #47: <19>
+  #48: <>
+  #49: <>
+  #50: <>
+  #51: <>
+  #52: <20>
+  #53: <>
+  #54: <>
+  #55: <>
+  #56: <>
+}
+  */
+  GTMap GT{{LineColFunOp{.Line = 23,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 37,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("indirection_05_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Indirection06) {
+  /*
+ValueCompressor: {
+  #0:
+    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
+  #1:
+    %Foo = alloca %struct._LinkedListOne, align 8, !psr.id !17 | ID: 1
+    %Next18 = getelementptr inbounds %struct._LinkedListOne, ptr %Foo, i32 0,
+i32 1, !dbg !189, !psr.id !190 | ID: 88 #2:
+    %.compoundliteral = alloca %struct._LinkedListOne, align 8, !psr.id !18 |
+ID: 2 %Val = getelementptr inbounds %struct._LinkedListOne, ptr
+%.compoundliteral, i32 0, i32 0, !dbg !52, !psr.id !53 | ID: 28 %Next =
+getelementptr inbounds %struct._LinkedListOne, ptr %.compoundliteral, i32 0, i32
+1, !dbg !52, !psr.id !55 | ID: 30 #3: %Bar = alloca %struct._LinkedListTwo,
+align 8, !psr.id !19 | ID: 3 %Next19 = getelementptr inbounds
+%struct._LinkedListTwo, ptr %Bar, i32 0, i32 1, !dbg !196, !psr.id !197 | ID: 92
+  #4:
+    %.compoundliteral1 = alloca %struct._LinkedListTwo, align 8, !psr.id !20 |
+ID: 4 %Val2 = getelementptr inbounds %struct._LinkedListTwo, ptr
+%.compoundliteral1, i32 0, i32 0, !dbg !67, !psr.id !68 | ID: 34 %Next3 =
+getelementptr inbounds %struct._LinkedListTwo, ptr %.compoundliteral1, i32 0,
+i32 1, !dbg !67, !psr.id !70 | ID: 36 #5: %Baz = alloca
+%struct._LinkedListThree, align 8, !psr.id !21 | ID: 5 %Next20 = getelementptr
+inbounds %struct._LinkedListThree, ptr %Baz, i32 0, i32 1, !dbg !203, !psr.id
+!204 | ID: 96 #6:
+    %.compoundliteral4 = alloca %struct._LinkedListThree, align 8, !psr.id !22 |
+ID: 6 %Val5 = getelementptr inbounds %struct._LinkedListThree, ptr
+%.compoundliteral4, i32 0, i32 0, !dbg !83, !psr.id !84 | ID: 40 %Next6 =
+getelementptr inbounds %struct._LinkedListThree, ptr %.compoundliteral4, i32 0,
+i32 1, !dbg !83, !psr.id !86 | ID: 42 #7: %Boar = alloca
+%struct._LinkedListFour, align 8, !psr.id !23 | ID: 7 %Next21 = getelementptr
+inbounds %struct._LinkedListFour, ptr %Boar, i32 0, i32 1, !dbg !210, !psr.id
+!211 | ID: 100 #8:
+    %.compoundliteral7 = alloca %struct._LinkedListFour, align 8, !psr.id !24 |
+ID: 8 %Val8 = getelementptr inbounds %struct._LinkedListFour, ptr
+%.compoundliteral7, i32 0, i32 0, !dbg !99, !psr.id !100 | ID: 46 %Next9 =
+getelementptr inbounds %struct._LinkedListFour, ptr %.compoundliteral7, i32 0,
+i32 1, !dbg !99, !psr.id !102 | ID: 48 #9: %Far = alloca
+%struct._LinkedListFive, align 8, !psr.id !25 | ID: 9 %Next22 = getelementptr
+inbounds %struct._LinkedListFive, ptr %Far, i32 0, i32 1, !dbg !217, !psr.id
+!218 | ID: 104 #10:
+    %.compoundliteral10 = alloca %struct._LinkedListFive, align 8, !psr.id !26 |
+ID: 10 %Val11 = getelementptr inbounds %struct._LinkedListFive, ptr
+%.compoundliteral10, i32 0, i32 0, !dbg !115, !psr.id !116 | ID: 52 %Next12 =
+getelementptr inbounds %struct._LinkedListFive, ptr %.compoundliteral10, i32 0,
+i32 1, !dbg !115, !psr.id !118 | ID: 54 #11: %One = alloca
+%struct._LinkedListOne, align 8, !psr.id !27 | ID: 11 %Next13 = getelementptr
+inbounds %struct._LinkedListOne, ptr %One, i32 0, i32 1, !dbg !151, !psr.id !152
+| ID: 68 #12: %Two = alloca %struct._LinkedListTwo, align 8, !psr.id !28 | ID:
+12 %Next14 = getelementptr inbounds %struct._LinkedListTwo, ptr %Two, i32 0, i32
+1, !dbg !158, !psr.id !159 | ID: 72 #13: %Three = alloca
+%struct._LinkedListThree, align 8, !psr.id !29 | ID: 13 %Next15 = getelementptr
+inbounds %struct._LinkedListThree, ptr %Three, i32 0, i32 1, !dbg !166, !psr.id
+!167 | ID: 76 #14: %Four = alloca %struct._LinkedListFour, align 8, !psr.id !30
+| ID: 14 %Next16 = getelementptr inbounds %struct._LinkedListFour, ptr %Four,
+i32 0, i32 1, !dbg !174, !psr.id !175 | ID: 80 #15: %Five = alloca
+%struct._LinkedListFive, align 8, !psr.id !31 | ID: 15 %Next17 = getelementptr
+inbounds %struct._LinkedListFive, ptr %Five, i32 0, i32 1, !dbg !182, !psr.id
+!183 | ID: 84 #16: %AliasOne = alloca ptr, align 8, !psr.id !32 | ID: 16 #17:
+    %AliasTwo = alloca ptr, align 8, !psr.id !33 | ID: 17
+  #18:
+    %AliasThree = alloca ptr, align 8, !psr.id !34 | ID: 18
+  #19:
+    %AliasFour = alloca ptr, align 8, !psr.id !35 | ID: 19
+  #20:
+    %AliasFive = alloca ptr, align 8, !psr.id !36 | ID: 20
+  #21:
+    %AliasSix = alloca ptr, align 8, !psr.id !37 | ID: 21
+  #22:
+    %AliasSeven = alloca ptr, align 8, !psr.id !38 | ID: 22
+  #23:
+    %AliasEight = alloca ptr, align 8, !psr.id !39 | ID: 23
+  #24:
+    %AliasNine = alloca ptr, align 8, !psr.id !40 | ID: 24
+  #25:
+    %AliasTen = alloca ptr, align 8, !psr.id !41 | ID: 25
+  #26:
+    %0 = load ptr, ptr %Next13, align 8, !dbg !151, !psr.id !153 | ID: 69
+  #27:
+    %1 = load ptr, ptr %Next14, align 8, !dbg !158, !psr.id !160 | ID: 73
+  #28:
+    %2 = load ptr, ptr %Next15, align 8, !dbg !166, !psr.id !168 | ID: 77
+  #29:
+    %3 = load ptr, ptr %Next16, align 8, !dbg !174, !psr.id !176 | ID: 81
+  #30:
+    %4 = load ptr, ptr %Next17, align 8, !dbg !182, !psr.id !184 | ID: 85
+  #31:
+    %5 = load ptr, ptr %Next18, align 8, !dbg !189, !psr.id !191 | ID: 89
+  #32:
+    %6 = load ptr, ptr %Next19, align 8, !dbg !196, !psr.id !198 | ID: 93
+  #33:
+    %7 = load ptr, ptr %Next20, align 8, !dbg !203, !psr.id !205 | ID: 97
+  #34:
+    %8 = load ptr, ptr %Next21, align 8, !dbg !210, !psr.id !212 | ID: 101
+  #35:
+    %9 = load ptr, ptr %Next22, align 8, !dbg !217, !psr.id !219 | ID: 105
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1, 26, 27, 31, 32>
+  #6: <2>
+  #7: <3, 28, 33>
+  #8: <4>
+  #9: <5, 29, 34>
+  #10: <6>
+  #11: <7, 30, 35>
+  #12: <8>
+  #13: <9>
+  #14: <10>
+  #15: <11>
+  #16: <12>
+  #17: <13>
+  #18: <14>
+  #19: <15>
+  #20: <16>
+  #21: <>
+  #22: <>
+  #23: <>
+  #24: <>
+  #25: <17>
+  #26: <>
+  #27: <>
+  #28: <>
+  #29: <>
+  #30: <18>
+  #31: <>
+  #32: <>
+  #33: <>
+  #34: <>
+  #35: <19>
+  #36: <>
+  #37: <>
+  #38: <>
+  #39: <>
+  #40: <20>
+  #41: <>
+  #42: <>
+  #43: <>
+  #44: <>
+  #45: <21>
+  #46: <>
+  #47: <>
+  #48: <>
+  #49: <>
+  #50: <22>
+  #51: <>
+  #52: <>
+  #53: <>
+  #54: <>
+  #55: <23>
+  #56: <>
+  #57: <>
+  #58: <>
+  #59: <>
+  #60: <24>
+  #61: <>
+  #62: <>
+  #63: <>
+  #64: <>
+  #65: <25>
+  #66: <>
+  #67: <>
+  #68: <>
+  #69: <>
+}
+  */
+  GTMap GT{{LineColFunOp{.Line = 28,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 45,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("indirection_06_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Indirection07) {
+  /*
+ValueCompressor: {
+  #0:
+    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
+  #1:
+    %Foo = alloca %struct._LinkedListOne, align 8, !psr.id !17 | ID: 1
+    %Next22 = getelementptr inbounds %struct._LinkedListOne, ptr %Foo, i32 0,
+i32 1, !dbg !223, !psr.id !224 | ID: 105 #2:
+    %.compoundliteral = alloca %struct._LinkedListOne, align 8, !psr.id !18 |
+ID: 2 %Val = getelementptr inbounds %struct._LinkedListOne, ptr
+%.compoundliteral, i32 0, i32 0, !dbg !57, !psr.id !58 | ID: 33 %Next =
+getelementptr inbounds %struct._LinkedListOne, ptr %.compoundliteral, i32 0, i32
+1, !dbg !57, !psr.id !60 | ID: 35 #3: %Bar = alloca %struct._LinkedListTwo,
+align 8, !psr.id !19 | ID: 3 %Next23 = getelementptr inbounds
+%struct._LinkedListTwo, ptr %Bar, i32 0, i32 1, !dbg !230, !psr.id !231 | ID:
+109 #4:
+    %.compoundliteral1 = alloca %struct._LinkedListTwo, align 8, !psr.id !20 |
+ID: 4 %Val2 = getelementptr inbounds %struct._LinkedListTwo, ptr
+%.compoundliteral1, i32 0, i32 0, !dbg !72, !psr.id !73 | ID: 39 %Next3 =
+getelementptr inbounds %struct._LinkedListTwo, ptr %.compoundliteral1, i32 0,
+i32 1, !dbg !72, !psr.id !75 | ID: 41 #5: %Baz = alloca
+%struct._LinkedListThree, align 8, !psr.id !21 | ID: 5 %Next24 = getelementptr
+inbounds %struct._LinkedListThree, ptr %Baz, i32 0, i32 1, !dbg !237, !psr.id
+!238 | ID: 113 #6:
+    %.compoundliteral4 = alloca %struct._LinkedListThree, align 8, !psr.id !22 |
+ID: 6 %Val5 = getelementptr inbounds %struct._LinkedListThree, ptr
+%.compoundliteral4, i32 0, i32 0, !dbg !88, !psr.id !89 | ID: 45 %Next6 =
+getelementptr inbounds %struct._LinkedListThree, ptr %.compoundliteral4, i32 0,
+i32 1, !dbg !88, !psr.id !91 | ID: 47 #7: %Boar = alloca
+%struct._LinkedListFour, align 8, !psr.id !23 | ID: 7 %Next25 = getelementptr
+inbounds %struct._LinkedListFour, ptr %Boar, i32 0, i32 1, !dbg !244, !psr.id
+!245 | ID: 117 #8:
+    %.compoundliteral7 = alloca %struct._LinkedListFour, align 8, !psr.id !24 |
+ID: 8 %Val8 = getelementptr inbounds %struct._LinkedListFour, ptr
+%.compoundliteral7, i32 0, i32 0, !dbg !104, !psr.id !105 | ID: 51 %Next9 =
+getelementptr inbounds %struct._LinkedListFour, ptr %.compoundliteral7, i32 0,
+i32 1, !dbg !104, !psr.id !107 | ID: 53 #9: %Far = alloca
+%struct._LinkedListFive, align 8, !psr.id !25 | ID: 9 %Next26 = getelementptr
+inbounds %struct._LinkedListFive, ptr %Far, i32 0, i32 1, !dbg !251, !psr.id
+!252 | ID: 121 #10:
+    %.compoundliteral10 = alloca %struct._LinkedListFive, align 8, !psr.id !26 |
+ID: 10 %Val11 = getelementptr inbounds %struct._LinkedListFive, ptr
+%.compoundliteral10, i32 0, i32 0, !dbg !120, !psr.id !121 | ID: 57 %Next12 =
+getelementptr inbounds %struct._LinkedListFive, ptr %.compoundliteral10, i32 0,
+i32 1, !dbg !120, !psr.id !123 | ID: 59 #11: %Faz = alloca
+%struct._LinkedListSix, align 8, !psr.id !27 | ID: 11 %Next27 = getelementptr
+inbounds %struct._LinkedListSix, ptr %Faz, i32 0, i32 1, !dbg !258, !psr.id !259
+| ID: 125 #12:
+    %.compoundliteral13 = alloca %struct._LinkedListSix, align 8, !psr.id !28 |
+ID: 12 %Val14 = getelementptr inbounds %struct._LinkedListSix, ptr
+%.compoundliteral13, i32 0, i32 0, !dbg !136, !psr.id !137 | ID: 63 %Next15 =
+getelementptr inbounds %struct._LinkedListSix, ptr %.compoundliteral13, i32 0,
+i32 1, !dbg !136, !psr.id !139 | ID: 65 #13: %One = alloca
+%struct._LinkedListOne, align 8, !psr.id !29 | ID: 13 %Next16 = getelementptr
+inbounds %struct._LinkedListOne, ptr %One, i32 0, i32 1, !dbg !177, !psr.id !178
+| ID: 81 #14: %Two = alloca %struct._LinkedListTwo, align 8, !psr.id !30 | ID:
+14 %Next17 = getelementptr inbounds %struct._LinkedListTwo, ptr %Two, i32 0, i32
+1, !dbg !184, !psr.id !185 | ID: 85 #15: %Three = alloca
+%struct._LinkedListThree, align 8, !psr.id !31 | ID: 15 %Next18 = getelementptr
+inbounds %struct._LinkedListThree, ptr %Three, i32 0, i32 1, !dbg !192, !psr.id
+!193 | ID: 89 #16: %Four = alloca %struct._LinkedListFour, align 8, !psr.id !32
+| ID: 16 %Next19 = getelementptr inbounds %struct._LinkedListFour, ptr %Four,
+i32 0, i32 1, !dbg !200, !psr.id !201 | ID: 93 #17: %Five = alloca
+%struct._LinkedListFive, align 8, !psr.id !33 | ID: 17 %Next20 = getelementptr
+inbounds %struct._LinkedListFive, ptr %Five, i32 0, i32 1, !dbg !208, !psr.id
+!209 | ID: 97 #18: %Six = alloca %struct._LinkedListSix, align 8, !psr.id !34 |
+ID: 18 %Next21 = getelementptr inbounds %struct._LinkedListSix, ptr %Six, i32 0,
+i32 1, !dbg !216, !psr.id !217 | ID: 101 #19: %AliasOne = alloca ptr, align 8,
+!psr.id !35 | ID: 19 #20: %AliasTwo = alloca ptr, align 8, !psr.id !36 | ID: 20
+  #21:
+    %AliasThree = alloca ptr, align 8, !psr.id !37 | ID: 21
+  #22:
+    %AliasFour = alloca ptr, align 8, !psr.id !38 | ID: 22
+  #23:
+    %AliasFive = alloca ptr, align 8, !psr.id !39 | ID: 23
+  #24:
+    %AliasSix = alloca ptr, align 8, !psr.id !40 | ID: 24
+  #25:
+    %AliasSeven = alloca ptr, align 8, !psr.id !41 | ID: 25
+  #26:
+    %AliasEight = alloca ptr, align 8, !psr.id !42 | ID: 26
+  #27:
+    %AliasNine = alloca ptr, align 8, !psr.id !43 | ID: 27
+  #28:
+    %AliasTen = alloca ptr, align 8, !psr.id !44 | ID: 28
+  #29:
+    %AliasEleven = alloca ptr, align 8, !psr.id !45 | ID: 29
+  #30:
+    %AliasTwelve = alloca ptr, align 8, !psr.id !46 | ID: 30
+  #31:
+    %0 = load ptr, ptr %Next16, align 8, !dbg !177, !psr.id !179 | ID: 82
+  #32:
+    %1 = load ptr, ptr %Next17, align 8, !dbg !184, !psr.id !186 | ID: 86
+  #33:
+    %2 = load ptr, ptr %Next18, align 8, !dbg !192, !psr.id !194 | ID: 90
+  #34:
+    %3 = load ptr, ptr %Next19, align 8, !dbg !200, !psr.id !202 | ID: 94
+  #35:
+    %4 = load ptr, ptr %Next20, align 8, !dbg !208, !psr.id !210 | ID: 98
+  #36:
+    %5 = load ptr, ptr %Next21, align 8, !dbg !216, !psr.id !218 | ID: 102
+  #37:
+    %6 = load ptr, ptr %Next22, align 8, !dbg !223, !psr.id !225 | ID: 106
+  #38:
+    %7 = load ptr, ptr %Next23, align 8, !dbg !230, !psr.id !232 | ID: 110
+  #39:
+    %8 = load ptr, ptr %Next24, align 8, !dbg !237, !psr.id !239 | ID: 114
+  #40:
+    %9 = load ptr, ptr %Next25, align 8, !dbg !244, !psr.id !246 | ID: 118
+  #41:
+    %10 = load ptr, ptr %Next26, align 8, !dbg !251, !psr.id !253 | ID: 122
+  #42:
+    %11 = load ptr, ptr %Next27, align 8, !dbg !258, !psr.id !260 | ID: 126
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <>
+  #2: <>
+  #3: <>
+  #4: <>
+  #5: <1, 3, 31, 32, 33, 37, 38, 39>
+  #6: <2>
+  #7: <4>
+  #8: <5, 34, 40>
+  #9: <6>
+  #10: <7, 35, 41>
+  #11: <8>
+  #12: <9, 36, 42>
+  #13: <10>
+  #14: <11>
+  #15: <12>
+  #16: <13>
+  #17: <14>
+  #18: <15>
+  #19: <16>
+  #20: <17>
+  #21: <18>
+  #22: <19>
+  #23: <>
+  #24: <>
+  #25: <>
+  #26: <>
+  #27: <20>
+  #28: <>
+  #29: <>
+  #30: <>
+  #31: <>
+  #32: <21>
+  #33: <>
+  #34: <>
+  #35: <>
+  #36: <>
+  #37: <22>
+  #38: <>
+  #39: <>
+  #40: <>
+  #41: <>
+  #42: <23>
+  #43: <>
+  #44: <>
+  #45: <>
+  #46: <>
+  #47: <24>
+  #48: <>
+  #49: <>
+  #50: <>
+  #51: <>
+  #52: <25>
+  #53: <>
+  #54: <>
+  #55: <>
+  #56: <>
+  #57: <26>
+  #58: <>
+  #59: <>
+  #60: <>
+  #61: <>
+  #62: <27>
+  #63: <>
+  #64: <>
+  #65: <>
+  #66: <>
+  #67: <28>
+  #68: <>
+  #69: <>
+  #70: <>
+  #71: <>
+  #72: <29>
+  #73: <>
+  #74: <>
+  #75: <>
+  #76: <>
+  #77: <30>
+  #78: <>
+  #79: <>
+  #80: <>
+  #81: <>
+}
+  */
+  GTMap GT{{LineColFunOp{.Line = 33,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 53,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("indirection_07_c_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Indirection08) {
+  /*
+ValueCompressor: {
+  #0:
+    @_ZTV3Foo = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
+x ptr] [ptr null, ptr @_ZTI3Foo, ptr @_ZN3Foo4FuncEv] }, comdat, align 8,
+!psr.id !0 | ID: 0 #1:
+    @_ZTI3Foo = linkonce_odr dso_local constant { ptr, ptr } { ptr getelementptr
+inbounds (ptr, ptr @_ZTVN10__cxxabiv117__class_type_infoE, i64 2), ptr @_ZTS3Foo
+}, comdat, align 8, !psr.id !3 | ID: 3 #2: fun @_ZN3Foo4FuncEv #3:
+    @_ZTS3Foo = linkonce_odr dso_local constant [5 x i8] c"3Foo\00", comdat,
+align 1, !psr.id !2 | ID: 2 #4:
+    @_ZTVN10__cxxabiv117__class_type_infoE = external global ptr, !psr.id !1 |
+ID: 1 #5:
+    @_ZTV3Bar = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
+x ptr] [ptr null, ptr @_ZTI3Bar, ptr @_ZN3Bar4FuncEv] }, comdat, align 8,
+!psr.id !4 | ID: 4 #6:
+    @_ZTI3Bar = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
+getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
+2), ptr @_ZTS3Bar, ptr @_ZTI3Foo }, comdat, align 8, !psr.id !7 | ID: 7 #7: fun
+@_ZN3Bar4FuncEv #8:
+    @_ZTS3Bar = linkonce_odr dso_local constant [5 x i8] c"3Bar\00", comdat,
+align 1, !psr.id !6 | ID: 6 #9:
+    @_ZTVN10__cxxabiv120__si_class_type_infoE = external global ptr, !psr.id !5
+| ID: 5 #10: %retval = alloca i32, align 4, !psr.id !24 | ID: 8 #11: %First =
+alloca %class.Foo, align 8, !psr.id !25 | ID: 9 #12: %Second = alloca
+%class.Bar, align 8, !psr.id !26 | ID: 10 #13: %x = alloca i32, align 4, !psr.id
+!27 | ID: 11 #14: %y = alloca i32, align 4, !psr.id !28 | ID: 12 #15: ptr %this
+| ID: _ZN3FooC2Ev.0 #16: ptr %this | ID: _ZN3BarC2Ev.0 #17: ptr %this | ID:
+_ZN3Foo4FuncEv.0 #18: ptr %this | ID: _ZN3Bar4FuncEv.0 #19: %this.addr = alloca
+ptr, align 8, !psr.id !74 | ID: 27 #20: %this1 = load ptr, ptr %this.addr, align
+8, !psr.id !80 | ID: 30 #21: %this.addr = alloca ptr, align 8, !psr.id !88 | ID:
+33 #22: %this1 = load ptr, ptr %this.addr, align 8, !psr.id !94 | ID: 36 #23:
+    %this.addr = alloca ptr, align 8, !psr.id !100 | ID: 40
+  #24:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !105 | ID: 43
+  #25:
+    %this.addr = alloca ptr, align 8, !psr.id !109 | ID: 45
+  #26:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !114 | ID: 48
+}
+UnionFindAAResult {
+  #0: <0, 5>
+  #1: <1, 2, 3, 4, 6, 7, 8, 9>
+  #2: <10>
+  #3: <>
+  #4: <>
+  #5: <>
+  #6: <>
+  #7: <11, 12, 15, 16, 17, 18, 20, 22, 24, 26>
+  #8: <13>
+  #9: <>
+  #10: <>
+  #11: <>
+  #12: <>
+  #13: <14>
+  #14: <>
+  #15: <>
+  #16: <>
+  #17: <>
+  #18: <19>
+  #19: <>
+  #20: <>
+  #21: <>
+  #22: <>
+  #23: <21>
+  #24: <>
+  #25: <>
+  #26: <>
+  #27: <>
+  #28: <23>
+  #29: <>
+  #30: <>
+  #31: <>
+  #32: <>
+  #33: <25>
+  #34: <>
+  #35: <>
+  #36: <>
+  #37: <>
+}
+  */
+  GTMap GT{{LineColFunOp{.Line = 13,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 16,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("indirection_08_cpp_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Indirection09) {
+  /*
+ValueCompressor: {
+  #0:
+    @_ZTV3Foo = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
+x ptr] [ptr null, ptr @_ZTI3Foo, ptr @_ZN3Foo4FuncEv] }, comdat, align 8,
+!psr.id !0 | ID: 0 #1:
+    @_ZTI3Foo = linkonce_odr dso_local constant { ptr, ptr } { ptr getelementptr
+inbounds (ptr, ptr @_ZTVN10__cxxabiv117__class_type_infoE, i64 2), ptr @_ZTS3Foo
+}, comdat, align 8, !psr.id !3 | ID: 3 #2: fun @_ZN3Foo4FuncEv #3:
+    @_ZTS3Foo = linkonce_odr dso_local constant [5 x i8] c"3Foo\00", comdat,
+align 1, !psr.id !2 | ID: 2 #4:
+    @_ZTVN10__cxxabiv117__class_type_infoE = external global ptr, !psr.id !1 |
+ID: 1 #5:
+    @_ZTV3Bar = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
+x ptr] [ptr null, ptr @_ZTI3Bar, ptr @_ZN3Bar4FuncEv] }, comdat, align 8,
+!psr.id !4 | ID: 4 #6:
+    @_ZTI3Bar = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
+getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
+2), ptr @_ZTS3Bar, ptr @_ZTI3Foo }, comdat, align 8, !psr.id !7 | ID: 7 #7: fun
+@_ZN3Bar4FuncEv #8:
+    @_ZTS3Bar = linkonce_odr dso_local constant [5 x i8] c"3Bar\00", comdat,
+align 1, !psr.id !6 | ID: 6 #9:
+    @_ZTVN10__cxxabiv120__si_class_type_infoE = external global ptr, !psr.id !5
+| ID: 5 #10:
+    @_ZTV3Baz = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
+x ptr] [ptr null, ptr @_ZTI3Baz, ptr @_ZN3Baz4FuncEv] }, comdat, align 8,
+!psr.id !8 | ID: 8 #11:
+    @_ZTI3Baz = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
+getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
+2), ptr @_ZTS3Baz, ptr @_ZTI3Bar }, comdat, align 8, !psr.id !10 | ID: 10 #12:
+    fun @_ZN3Baz4FuncEv
+  #13:
+    @_ZTS3Baz = linkonce_odr dso_local constant [5 x i8] c"3Baz\00", comdat,
+align 1, !psr.id !9 | ID: 9 #14: %retval = alloca i32, align 4, !psr.id !27 |
+ID: 11 #15: %First = alloca %class.Foo, align 8, !psr.id !28 | ID: 12 #16:
+    %Second = alloca %class.Bar, align 8, !psr.id !29 | ID: 13
+  #17:
+    %Third = alloca %class.Baz, align 8, !psr.id !30 | ID: 14
+  #18:
+    %x = alloca i32, align 4, !psr.id !31 | ID: 15
+  #19:
+    %y = alloca i32, align 4, !psr.id !32 | ID: 16
+  #20:
+    %z = alloca i32, align 4, !psr.id !33 | ID: 17
+  #21:
+    ptr %this | ID: _ZN3FooC2Ev.0
+  #22:
+    ptr %this | ID: _ZN3BarC2Ev.0
+  #23:
+    ptr %this | ID: _ZN3BazC2Ev.0
+  #24:
+    ptr %this | ID: _ZN3Foo4FuncEv.0
+  #25:
+    ptr %this | ID: _ZN3Bar4FuncEv.0
+  #26:
+    ptr %this | ID: _ZN3Baz4FuncEv.0
+  #27:
+    %this.addr = alloca ptr, align 8, !psr.id !94 | ID: 35
+  #28:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !100 | ID: 38
+  #29:
+    %this.addr = alloca ptr, align 8, !psr.id !108 | ID: 41
+  #30:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !114 | ID: 44
+  #31:
+    %this.addr = alloca ptr, align 8, !psr.id !123 | ID: 48
+  #32:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !129 | ID: 51
+  #33:
+    %this.addr = alloca ptr, align 8, !psr.id !135 | ID: 55
+  #34:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !140 | ID: 58
+  #35:
+    %this.addr = alloca ptr, align 8, !psr.id !144 | ID: 60
+  #36:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !149 | ID: 63
+  #37:
+    %this.addr = alloca ptr, align 8, !psr.id !153 | ID: 65
+  #38:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !158 | ID: 68
+}
+UnionFindAAResult {
+  #0: <0, 5, 10>
+  #1: <1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13>
+  #2: <14>
+  #3: <>
+  #4: <>
+  #5: <>
+  #6: <>
+  #7: <15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38>
+  #8: <18>
+  #9: <>
+  #10: <>
+  #11: <>
+  #12: <>
+  #13: <19>
+  #14: <>
+  #15: <>
+  #16: <>
+  #17: <>
+  #18: <20>
+  #19: <>
+  #20: <>
+  #21: <>
+  #22: <>
+  #23: <27>
+  #24: <>
+  #25: <>
+  #26: <>
+  #27: <>
+  #28: <29>
+  #29: <>
+  #30: <>
+  #31: <>
+  #32: <>
+  #33: <31>
+  #34: <>
+  #35: <>
+  #36: <>
+  #37: <>
+  #38: <33>
+  #39: <>
+  #40: <>
+  #41: <>
+  #42: <>
+  #43: <35>
+  #44: <>
+  #45: <>
+  #46: <>
+  #47: <>
+  #48: <37>
+  #49: <>
+  #50: <>
+  #51: <>
+  #52: <>
+}
+  */
+  GTMap GT{{LineColFunOp{.Line = 18,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("indirection_09_cpp_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Indirection10) {
+  /*
+ValueCompressor: {
+  #0:
+    @_ZTV3Foo = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
+x ptr] [ptr null, ptr @_ZTI3Foo, ptr @_ZN3Foo4FuncEv] }, comdat, align 8,
+!psr.id !0 | ID: 0 #1:
+    @_ZTI3Foo = linkonce_odr dso_local constant { ptr, ptr } { ptr getelementptr
+inbounds (ptr, ptr @_ZTVN10__cxxabiv117__class_type_infoE, i64 2), ptr @_ZTS3Foo
+}, comdat, align 8, !psr.id !3 | ID: 3 #2: fun @_ZN3Foo4FuncEv #3:
+    @_ZTS3Foo = linkonce_odr dso_local constant [5 x i8] c"3Foo\00", comdat,
+align 1, !psr.id !2 | ID: 2 #4:
+    @_ZTVN10__cxxabiv117__class_type_infoE = external global ptr, !psr.id !1 |
+ID: 1 #5:
+    @_ZTV3Bar = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
+x ptr] [ptr null, ptr @_ZTI3Bar, ptr @_ZN3Bar4FuncEv] }, comdat, align 8,
+!psr.id !4 | ID: 4 #6:
+    @_ZTI3Bar = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
+getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
+2), ptr @_ZTS3Bar, ptr @_ZTI3Foo }, comdat, align 8, !psr.id !7 | ID: 7 #7: fun
+@_ZN3Bar4FuncEv #8:
+    @_ZTS3Bar = linkonce_odr dso_local constant [5 x i8] c"3Bar\00", comdat,
+align 1, !psr.id !6 | ID: 6 #9:
+    @_ZTVN10__cxxabiv120__si_class_type_infoE = external global ptr, !psr.id !5
+| ID: 5 #10:
+    @_ZTV3Baz = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
+x ptr] [ptr null, ptr @_ZTI3Baz, ptr @_ZN3Baz4FuncEv] }, comdat, align 8,
+!psr.id !8 | ID: 8 #11:
+    @_ZTI3Baz = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
+getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
+2), ptr @_ZTS3Baz, ptr @_ZTI3Bar }, comdat, align 8, !psr.id !10 | ID: 10 #12:
+    fun @_ZN3Baz4FuncEv
+  #13:
+    @_ZTS3Baz = linkonce_odr dso_local constant [5 x i8] c"3Baz\00", comdat,
+align 1, !psr.id !9 | ID: 9 #14:
+    @_ZTV4Boar = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
+x ptr] [ptr null, ptr @_ZTI4Boar, ptr @_ZN4Boar4FuncEv] }, comdat, align 8,
+!psr.id !11 | ID: 11 #15:
+    @_ZTI4Boar = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
+getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
+2), ptr @_ZTS4Boar, ptr @_ZTI3Baz }, comdat, align 8, !psr.id !13 | ID: 13 #16:
+    fun @_ZN4Boar4FuncEv
+  #17:
+    @_ZTS4Boar = linkonce_odr dso_local constant [6 x i8] c"4Boar\00", comdat,
+align 1, !psr.id !12 | ID: 12 #18: %retval = alloca i32, align 4, !psr.id !30 |
+ID: 14 #19: %First = alloca %class.Foo, align 8, !psr.id !31 | ID: 15 #20:
+    %Second = alloca %class.Bar, align 8, !psr.id !32 | ID: 16
+  #21:
+    %Third = alloca %class.Baz, align 8, !psr.id !33 | ID: 17
+  #22:
+    %Fourth = alloca %class.Boar, align 8, !psr.id !34 | ID: 18
+  #23:
+    %x = alloca i32, align 4, !psr.id !35 | ID: 19
+  #24:
+    %y = alloca i32, align 4, !psr.id !36 | ID: 20
+  #25:
+    %z = alloca i32, align 4, !psr.id !37 | ID: 21
+  #26:
+    %a = alloca i32, align 4, !psr.id !38 | ID: 22
+  #27:
+    ptr %this | ID: _ZN3FooC2Ev.0
+  #28:
+    ptr %this | ID: _ZN3BarC2Ev.0
+  #29:
+    ptr %this | ID: _ZN3BazC2Ev.0
+  #30:
+    ptr %this | ID: _ZN4BoarC2Ev.0
+  #31:
+    ptr %this | ID: _ZN3Foo4FuncEv.0
+  #32:
+    ptr %this | ID: _ZN3Bar4FuncEv.0
+  #33:
+    ptr %this | ID: _ZN3Baz4FuncEv.0
+  #34:
+    ptr %this | ID: _ZN4Boar4FuncEv.0
+  #35:
+    %this.addr = alloca ptr, align 8, !psr.id !120 | ID: 49
+  #36:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !126 | ID: 52
+  #37:
+    %this.addr = alloca ptr, align 8, !psr.id !134 | ID: 55
+  #38:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !140 | ID: 58
+  #39:
+    %this.addr = alloca ptr, align 8, !psr.id !149 | ID: 62
+  #40:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !155 | ID: 65
+  #41:
+    %this.addr = alloca ptr, align 8, !psr.id !164 | ID: 69
+  #42:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !170 | ID: 72
+  #43:
+    %this.addr = alloca ptr, align 8, !psr.id !176 | ID: 76
+  #44:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !181 | ID: 79
+  #45:
+    %this.addr = alloca ptr, align 8, !psr.id !185 | ID: 81
+  #46:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !190 | ID: 84
+  #47:
+    %this.addr = alloca ptr, align 8, !psr.id !194 | ID: 86
+  #48:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !199 | ID: 89
+  #49:
+    %this.addr = alloca ptr, align 8, !psr.id !203 | ID: 91
+  #50:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !208 | ID: 94
+}
+UnionFindAAResult {
+  #0: <0, 5, 10, 14>
+  #1: <1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17>
+  #2: <18>
+  #3: <>
+  #4: <>
+  #5: <>
+  #6: <>
+  #7: <19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36, 38, 40, 42, 44, 46,
+48, 50> #8: <23> #9: <> #10: <> #11: <> #12: <> #13: <24> #14: <> #15: <> #16:
+<> #17: <> #18: <25> #19: <> #20: <> #21: <> #22: <> #23: <26> #24: <> #25: <>
+  #26: <>
+  #27: <>
+  #28: <35>
+  #29: <>
+  #30: <>
+  #31: <>
+  #32: <>
+  #33: <37>
+  #34: <>
+  #35: <>
+  #36: <>
+  #37: <>
+  #38: <39>
+  #39: <>
+  #40: <>
+  #41: <>
+  #42: <>
+  #43: <41>
+  #44: <>
+  #45: <>
+  #46: <>
+  #47: <>
+  #48: <43>
+  #49: <>
+  #50: <>
+  #51: <>
+  #52: <>
+  #53: <45>
+  #54: <>
+  #55: <>
+  #56: <>
+  #57: <>
+  #58: <47>
+  #59: <>
+  #60: <>
+  #61: <>
+  #62: <>
+  #63: <49>
+  #64: <>
+  #65: <>
+  #66: <>
+  #67: <>
+}
+  */
+  GTMap GT{{LineColFunOp{.Line = 23,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 28,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("indirection_10_cpp_dbg.ll", GT, IndAABuilder);
+}
+
+TEST(IndirectionSensUnionFindAATest, Indirection11) {
+  /*
+ValueCompressor: {
+  #0:
+    @_ZTV3Foo = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
+x ptr] [ptr null, ptr @_ZTI3Foo, ptr @_ZN3Foo4FuncEv] }, comdat, align 8,
+!psr.id !0 | ID: 0 #1:
+    @_ZTI3Foo = linkonce_odr dso_local constant { ptr, ptr } { ptr getelementptr
+inbounds (ptr, ptr @_ZTVN10__cxxabiv117__class_type_infoE, i64 2), ptr @_ZTS3Foo
+}, comdat, align 8, !psr.id !3 | ID: 3 #2: fun @_ZN3Foo4FuncEv #3:
+    @_ZTS3Foo = linkonce_odr dso_local constant [5 x i8] c"3Foo\00", comdat,
+align 1, !psr.id !2 | ID: 2 #4:
+    @_ZTVN10__cxxabiv117__class_type_infoE = external global ptr, !psr.id !1 |
+ID: 1 #5:
+    @_ZTV3Bar = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
+x ptr] [ptr null, ptr @_ZTI3Bar, ptr @_ZN3Bar4FuncEv] }, comdat, align 8,
+!psr.id !4 | ID: 4 #6:
+    @_ZTI3Bar = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
+getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
+2), ptr @_ZTS3Bar, ptr @_ZTI3Foo }, comdat, align 8, !psr.id !7 | ID: 7 #7: fun
+@_ZN3Bar4FuncEv #8:
+    @_ZTS3Bar = linkonce_odr dso_local constant [5 x i8] c"3Bar\00", comdat,
+align 1, !psr.id !6 | ID: 6 #9:
+    @_ZTVN10__cxxabiv120__si_class_type_infoE = external global ptr, !psr.id !5
+| ID: 5 #10:
+    @_ZTV3Baz = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
+x ptr] [ptr null, ptr @_ZTI3Baz, ptr @_ZN3Baz4FuncEv] }, comdat, align 8,
+!psr.id !8 | ID: 8 #11:
+    @_ZTI3Baz = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
+getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
+2), ptr @_ZTS3Baz, ptr @_ZTI3Bar }, comdat, align 8, !psr.id !10 | ID: 10 #12:
+    fun @_ZN3Baz4FuncEv
+  #13:
+    @_ZTS3Baz = linkonce_odr dso_local constant [5 x i8] c"3Baz\00", comdat,
+align 1, !psr.id !9 | ID: 9 #14:
+    @_ZTV4Boar = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
+x ptr] [ptr null, ptr @_ZTI4Boar, ptr @_ZN4Boar4FuncEv] }, comdat, align 8,
+!psr.id !11 | ID: 11 #15:
+    @_ZTI4Boar = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
+getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
+2), ptr @_ZTS4Boar, ptr @_ZTI3Baz }, comdat, align 8, !psr.id !13 | ID: 13 #16:
+    fun @_ZN4Boar4FuncEv
+  #17:
+    @_ZTS4Boar = linkonce_odr dso_local constant [6 x i8] c"4Boar\00", comdat,
+align 1, !psr.id !12 | ID: 12 #18:
+    @_ZTV3Far = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
+x ptr] [ptr null, ptr @_ZTI3Far, ptr @_ZN3Far4FuncEv] }, comdat, align 8,
+!psr.id !14 | ID: 14 #19:
+    @_ZTI3Far = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
+getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
+2), ptr @_ZTS3Far, ptr @_ZTI4Boar }, comdat, align 8, !psr.id !16 | ID: 16 #20:
+    fun @_ZN3Far4FuncEv
+  #21:
+    @_ZTS3Far = linkonce_odr dso_local constant [5 x i8] c"3Far\00", comdat,
+align 1, !psr.id !15 | ID: 15 #22: %retval = alloca i32, align 4, !psr.id !33 |
+ID: 17 #23: %First = alloca %class.Foo, align 8, !psr.id !34 | ID: 18 #24:
+    %Second = alloca %class.Bar, align 8, !psr.id !35 | ID: 19
+  #25:
+    %Third = alloca %class.Baz, align 8, !psr.id !36 | ID: 20
+  #26:
+    %Fourth = alloca %class.Boar, align 8, !psr.id !37 | ID: 21
+  #27:
+    %Fifth = alloca %class.Far, align 8, !psr.id !38 | ID: 22
+  #28:
+    %x = alloca i32, align 4, !psr.id !39 | ID: 23
+  #29:
+    %y = alloca i32, align 4, !psr.id !40 | ID: 24
+  #30:
+    %z = alloca i32, align 4, !psr.id !41 | ID: 25
+  #31:
+    %a = alloca i32, align 4, !psr.id !42 | ID: 26
+  #32:
+    %b = alloca i32, align 4, !psr.id !43 | ID: 27
+  #33:
+    ptr %this | ID: _ZN3FooC2Ev.0
+  #34:
+    ptr %this | ID: _ZN3BarC2Ev.0
+  #35:
+    ptr %this | ID: _ZN3BazC2Ev.0
+  #36:
+    ptr %this | ID: _ZN4BoarC2Ev.0
+  #37:
+    ptr %this | ID: _ZN3FarC2Ev.0
+  #38:
+    ptr %this | ID: _ZN3Foo4FuncEv.0
+  #39:
+    ptr %this | ID: _ZN3Bar4FuncEv.0
+  #40:
+    ptr %this | ID: _ZN3Baz4FuncEv.0
+  #41:
+    ptr %this | ID: _ZN4Boar4FuncEv.0
+  #42:
+    ptr %this | ID: _ZN3Far4FuncEv.0
+  #43:
+    %this.addr = alloca ptr, align 8, !psr.id !143 | ID: 60
+  #44:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !149 | ID: 63
+  #45:
+    %this.addr = alloca ptr, align 8, !psr.id !157 | ID: 66
+  #46:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !163 | ID: 69
+  #47:
+    %this.addr = alloca ptr, align 8, !psr.id !172 | ID: 73
+  #48:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !178 | ID: 76
+  #49:
+    %this.addr = alloca ptr, align 8, !psr.id !187 | ID: 80
+  #50:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !193 | ID: 83
+  #51:
+    %this.addr = alloca ptr, align 8, !psr.id !202 | ID: 87
+  #52:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !208 | ID: 90
+  #53:
+    %this.addr = alloca ptr, align 8, !psr.id !214 | ID: 94
+  #54:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !219 | ID: 97
+  #55:
+    %this.addr = alloca ptr, align 8, !psr.id !223 | ID: 99
+  #56:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !228 | ID: 102
+  #57:
+    %this.addr = alloca ptr, align 8, !psr.id !232 | ID: 104
+  #58:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !237 | ID: 107
+  #59:
+    %this.addr = alloca ptr, align 8, !psr.id !241 | ID: 109
+  #60:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !246 | ID: 112
+  #61:
+    %this.addr = alloca ptr, align 8, !psr.id !250 | ID: 114
+  #62:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !255 | ID: 117
+}
+UnionFindAAResult {
+  #0: <0, 5, 10, 14, 18>
+  #1: <1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21>
+  #2: <22>
+  #3: <>
+  #4: <>
+  #5: <>
+  #6: <>
+  #7: <23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46, 48,
+50, 52, 54, 56, 58, 60, 62> #8: <28> #9: <> #10: <> #11: <> #12: <> #13: <29>
+  #14: <>
+  #15: <>
+  #16: <>
+  #17: <>
+  #18: <30>
+  #19: <>
+  #20: <>
+  #21: <>
+  #22: <>
+  #23: <31>
+  #24: <>
+  #25: <>
+  #26: <>
+  #27: <>
+  #28: <32>
+  #29: <>
+  #30: <>
+  #31: <>
+  #32: <>
+  #33: <43>
+  #34: <>
+  #35: <>
+  #36: <>
+  #37: <>
+  #38: <45>
+  #39: <>
+  #40: <>
+  #41: <>
+  #42: <>
+  #43: <47>
+  #44: <>
+  #45: <>
+  #46: <>
+  #47: <>
+  #48: <49>
+  #49: <>
+  #50: <>
+  #51: <>
+  #52: <>
+  #53: <51>
+  #54: <>
+  #55: <>
+  #56: <>
+  #57: <>
+  #58: <53>
+  #59: <>
+  #60: <>
+  #61: <>
+  #62: <>
+  #63: <55>
+  #64: <>
+  #65: <>
+  #66: <>
+  #67: <>
+  #68: <57>
+  #69: <>
+  #70: <>
+  #71: <>
+  #72: <>
+  #73: <59>
+  #74: <>
+  #75: <>
+  #76: <>
+  #77: <>
+  #78: <61>
+  #79: <>
+  #80: <>
+  #81: <>
+  #82: <>
+}
+  */
+  GTMap GT{{LineColFunOp{.Line = 28,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+            }}};
+
+  doAnalysisAndCompareResults("indirection_11_cpp_dbg.ll", GT, IndAABuilder);
+}
+
 } // namespace
 
 int main(int Argc, char **Argv) {

From ba9f360695a2ce67ecbe5491e46c0bd98c30b947 Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Wed, 11 Feb 2026 21:26:04 +0100
Subject: [PATCH 45/75] indir unittests

---
 .../Pointer/LLVMUnionFindAATest.cpp           | 1801 ++++++++++++-----
 1 file changed, 1242 insertions(+), 559 deletions(-)

diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index 32344c7416..43d1d97418 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -5960,6 +5960,7 @@ i32 0, i32 0, !dbg !47, !psr.id !48 | ID: 19 %Next3 = getelementptr inbounds
 }
 PhASAR v2510
 A LLVM-based static analysis framework
+LLVMUnionFindAliasSet(global, botctx-ind-sens) {
 LLVMUnionFindAliasSet(global, botctx-ind-sens) {
   #0: {0}
   #1: {1, 3, 6, 11, 12, 13, 14}
@@ -5976,9 +5977,12 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
   #12: {1, 3, 6, 11, 12, 13, 14}
   #13: {1, 3, 6, 11, 12, 13, 14}
   #14: {1, 3, 6, 11, 12, 13, 14}
+}
 
   TODO: ask Fabian if the output of the analysis is correct here/what the GT
-should look like.
+should look like. Unittest fails, but I think GT should be correct.
+Also, is it necessary to include the Bar alloca (+ the others) as a stand-alone
+with the same aliases as Foo?
 }
   */
   GTMap GT{{LineColFunOp{.Line = 8,
@@ -5994,6 +5998,14 @@ should look like.
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
                 LineColFunOp{.Line = 20,
                              .Col = 0,
                              .InFunction = "main",
@@ -6010,7 +6022,39 @@ should look like.
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Load},
-            }}};
+            }},
+           {LineColFunOp{.Line = 20,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 20,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 21,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 21,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 22,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 22,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 23,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 23,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("indirection_02_c_dbg.ll", GT, IndAABuilder);
 }
@@ -6056,38 +6100,22 @@ i32 1, !dbg !94, !psr.id !95 | ID: 41 #7: %AliasOne = alloca ptr, align 8,
   #14:
     %3 = load ptr, ptr %Next7, align 8, !dbg !94, !psr.id !96 | ID: 42
 }
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1, 11, 12, 13, 14>
-  #6: <2>
-  #7: <3>
-  #8: <4>
-  #9: <5>
-  #10: <6>
-  #11: <7>
-  #12: <>
-  #13: <>
-  #14: <>
-  #15: <>
-  #16: <8>
-  #17: <>
-  #18: <>
-  #19: <>
-  #20: <>
-  #21: <9>
-  #22: <>
-  #23: <>
-  #24: <>
-  #25: <>
-  #26: <10>
-  #27: <>
-  #28: <>
-  #29: <>
-  #30: <>
+LLVMUnionFindAliasSet(global, botctx-ind-sens) {
+  #0: {0}
+  #1: {1, 11, 12, 13, 14}
+  #2: {2}
+  #3: {3}
+  #4: {4}
+  #5: {5}
+  #6: {6}
+  #7: {7}
+  #8: {8}
+  #9: {9}
+  #10: {10}
+  #11: {1, 11, 12, 13, 14}
+  #12: {1, 11, 12, 13, 14}
+  #13: {1, 11, 12, 13, 14}
+  #14: {1, 11, 12, 13, 14}
 }
   */
   GTMap GT{{LineColFunOp{.Line = 13,
@@ -6095,11 +6123,71 @@ UnionFindAAResult {
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
             {
-                LineColFunOp{.Line = 21,
+                LineColFunOp{.Line = 13,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
-            }}};
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 19,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 24,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 21,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 21,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 22,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 22,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 23,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 23,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 24,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 24,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("indirection_03_c_dbg.ll", GT, IndAABuilder);
 }
@@ -6165,51 +6253,29 @@ inbounds %struct._LinkedListThree, ptr %Three, i32 0, i32 1, !dbg !114, !psr.id
   #21:
     %5 = load ptr, ptr %Next12, align 8, !dbg !135, !psr.id !137 | ID: 63
 }
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1, 16, 17, 19, 20>
-  #6: <2>
-  #7: <3, 18, 21>
-  #8: <4>
-  #9: <5>
-  #10: <6>
-  #11: <7>
-  #12: <8>
-  #13: <9>
-  #14: <10>
-  #15: <>
-  #16: <>
-  #17: <>
-  #18: <>
-  #19: <11>
-  #20: <>
-  #21: <>
-  #22: <>
-  #23: <>
-  #24: <12>
-  #25: <>
-  #26: <>
-  #27: <>
-  #28: <>
-  #29: <13>
-  #30: <>
-  #31: <>
-  #32: <>
-  #33: <>
-  #34: <14>
-  #35: <>
-  #36: <>
-  #37: <>
-  #38: <>
-  #39: <15>
-  #40: <>
-  #41: <>
-  #42: <>
-  #43: <>
+LLVMUnionFindAliasSet(global, botctx-ind-sens) {
+  #0: {0}
+  #1: {1, 16, 17, 19, 20}
+  #2: {2}
+  #3: {3, 18, 21}
+  #4: {4}
+  #5: {5}
+  #6: {6}
+  #7: {7}
+  #8: {8}
+  #9: {9}
+  #10: {10}
+  #11: {11}
+  #12: {12}
+  #13: {13}
+  #14: {14}
+  #15: {15}
+  #16: {1, 16, 17, 19, 20}
+  #17: {1, 16, 17, 19, 20}
+  #18: {3, 18, 21}
+  #19: {1, 16, 17, 19, 20}
+  #20: {1, 16, 17, 19, 20}
+  #21: {3, 18, 21}
 }
   */
   GTMap GT{{LineColFunOp{.Line = 18,
@@ -6217,11 +6283,103 @@ UnionFindAAResult {
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
             {
-                LineColFunOp{.Line = 29,
+                LineColFunOp{.Line = 18,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
-            }}};
+                LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 25,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 26,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 27,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 29,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 31,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 29,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 29,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 30,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 30,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 31,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 31,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 32,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 32,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 33,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 33,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 34,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 34,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("indirection_04_c_dbg.ll", GT, IndAABuilder);
 }
@@ -6303,64 +6461,36 @@ align 8, !psr.id !29 | ID: 13 #14: %AliasTwo = alloca ptr, align 8, !psr.id !30
   #28:
     %7 = load ptr, ptr %Next17, align 8, !dbg !176, !psr.id !178 | ID: 84
 }
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1, 21, 22, 25, 26>
-  #6: <2>
-  #7: <3, 23, 27>
-  #8: <4>
-  #9: <5, 24, 28>
-  #10: <6>
-  #11: <7>
-  #12: <8>
-  #13: <9>
-  #14: <10>
-  #15: <11>
-  #16: <12>
-  #17: <13>
-  #18: <>
-  #19: <>
-  #20: <>
-  #21: <>
-  #22: <14>
-  #23: <>
-  #24: <>
-  #25: <>
-  #26: <>
-  #27: <15>
-  #28: <>
-  #29: <>
-  #30: <>
-  #31: <>
-  #32: <16>
-  #33: <>
-  #34: <>
-  #35: <>
-  #36: <>
-  #37: <17>
-  #38: <>
-  #39: <>
-  #40: <>
-  #41: <>
-  #42: <18>
-  #43: <>
-  #44: <>
-  #45: <>
-  #46: <>
-  #47: <19>
-  #48: <>
-  #49: <>
-  #50: <>
-  #51: <>
-  #52: <20>
-  #53: <>
-  #54: <>
-  #55: <>
-  #56: <>
+LLVMUnionFindAliasSet(global, botctx-ind-sens) {
+  #0: {0}
+  #1: {1, 21, 22, 25, 26}
+  #2: {2}
+  #3: {3, 23, 27}
+  #4: {4}
+  #5: {5, 24, 28}
+  #6: {6}
+  #7: {7}
+  #8: {8}
+  #9: {9}
+  #10: {10}
+  #11: {11}
+  #12: {12}
+  #13: {13}
+  #14: {14}
+  #15: {15}
+  #16: {16}
+  #17: {17}
+  #18: {18}
+  #19: {19}
+  #20: {20}
+  #21: {1, 21, 22, 25, 26}
+  #22: {1, 21, 22, 25, 26}
+  #23: {3, 23, 27}
+  #24: {5, 24, 28}
+  #25: {1, 21, 22, 25, 26}
+  #26: {1, 21, 22, 25, 26}
+  #27: {3, 23, 27}
+  #28: {5, 24, 28}
 }
   */
   GTMap GT{{LineColFunOp{.Line = 23,
@@ -6368,11 +6498,135 @@ UnionFindAAResult {
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
             {
-                LineColFunOp{.Line = 37,
+                LineColFunOp{.Line = 23,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
-            }}};
+                LineColFunOp{.Line = 25,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 27,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 29,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 35,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 37,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 38,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 40,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 41,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 42,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 43,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 44,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 37,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 37,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 38,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 38,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 39,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 39,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 40,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 40,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 41,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 41,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 42,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 42,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 43,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 43,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 44,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 44,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("indirection_05_c_dbg.ll", GT, IndAABuilder);
 }
@@ -6474,77 +6728,43 @@ inbounds %struct._LinkedListFive, ptr %Five, i32 0, i32 1, !dbg !182, !psr.id
   #35:
     %9 = load ptr, ptr %Next22, align 8, !dbg !217, !psr.id !219 | ID: 105
 }
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1, 26, 27, 31, 32>
-  #6: <2>
-  #7: <3, 28, 33>
-  #8: <4>
-  #9: <5, 29, 34>
-  #10: <6>
-  #11: <7, 30, 35>
-  #12: <8>
-  #13: <9>
-  #14: <10>
-  #15: <11>
-  #16: <12>
-  #17: <13>
-  #18: <14>
-  #19: <15>
-  #20: <16>
-  #21: <>
-  #22: <>
-  #23: <>
-  #24: <>
-  #25: <17>
-  #26: <>
-  #27: <>
-  #28: <>
-  #29: <>
-  #30: <18>
-  #31: <>
-  #32: <>
-  #33: <>
-  #34: <>
-  #35: <19>
-  #36: <>
-  #37: <>
-  #38: <>
-  #39: <>
-  #40: <20>
-  #41: <>
-  #42: <>
-  #43: <>
-  #44: <>
-  #45: <21>
-  #46: <>
-  #47: <>
-  #48: <>
-  #49: <>
-  #50: <22>
-  #51: <>
-  #52: <>
-  #53: <>
-  #54: <>
-  #55: <23>
-  #56: <>
-  #57: <>
-  #58: <>
-  #59: <>
-  #60: <24>
-  #61: <>
-  #62: <>
-  #63: <>
-  #64: <>
-  #65: <25>
-  #66: <>
-  #67: <>
-  #68: <>
-  #69: <>
+LLVMUnionFindAliasSet(global, botctx-ind-sens) {
+  #0: {0}
+  #1: {1, 26, 27, 31, 32}
+  #2: {2}
+  #3: {3, 28, 33}
+  #4: {4}
+  #5: {5, 29, 34}
+  #6: {6}
+  #7: {7, 30, 35}
+  #8: {8}
+  #9: {9}
+  #10: {10}
+  #11: {11}
+  #12: {12}
+  #13: {13}
+  #14: {14}
+  #15: {15}
+  #16: {16}
+  #17: {17}
+  #18: {18}
+  #19: {19}
+  #20: {20}
+  #21: {21}
+  #22: {22}
+  #23: {23}
+  #24: {24}
+  #25: {25}
+  #26: {1, 26, 27, 31, 32}
+  #27: {1, 26, 27, 31, 32}
+  #28: {3, 28, 33}
+  #29: {5, 29, 34}
+  #30: {7, 30, 35}
+  #31: {1, 26, 27, 31, 32}
+  #32: {1, 26, 27, 31, 32}
+  #33: {3, 28, 33}
+  #34: {5, 29, 34}
+  #35: {7, 30, 35}
 }
   */
   GTMap GT{{LineColFunOp{.Line = 28,
@@ -6552,11 +6772,167 @@ UnionFindAAResult {
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
             {
-                LineColFunOp{.Line = 45,
+                LineColFunOp{.Line = 28,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
-            }}};
+                LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 36,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 40,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 41,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 42,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 43,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 45,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 46,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 47,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 48,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 49,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 50,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 51,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 52,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 53,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 54,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 45,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 45,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 46,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 46,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 47,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 47,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 48,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 48,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 49,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 49,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 50,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 50,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 51,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 51,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 52,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 52,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 53,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 53,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 54,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 54,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("indirection_06_c_dbg.ll", GT, IndAABuilder);
 }
@@ -6676,101 +7052,250 @@ i32 1, !dbg !216, !psr.id !217 | ID: 101 #19: %AliasOne = alloca ptr, align 8,
   #42:
     %11 = load ptr, ptr %Next27, align 8, !dbg !258, !psr.id !260 | ID: 126
 }
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1, 3, 31, 32, 33, 37, 38, 39>
-  #6: <2>
-  #7: <4>
-  #8: <5, 34, 40>
-  #9: <6>
-  #10: <7, 35, 41>
-  #11: <8>
-  #12: <9, 36, 42>
-  #13: <10>
-  #14: <11>
-  #15: <12>
-  #16: <13>
-  #17: <14>
-  #18: <15>
-  #19: <16>
-  #20: <17>
-  #21: <18>
-  #22: <19>
-  #23: <>
-  #24: <>
-  #25: <>
-  #26: <>
-  #27: <20>
-  #28: <>
-  #29: <>
-  #30: <>
-  #31: <>
-  #32: <21>
-  #33: <>
-  #34: <>
-  #35: <>
-  #36: <>
-  #37: <22>
-  #38: <>
-  #39: <>
-  #40: <>
-  #41: <>
-  #42: <23>
-  #43: <>
-  #44: <>
-  #45: <>
-  #46: <>
-  #47: <24>
-  #48: <>
-  #49: <>
-  #50: <>
-  #51: <>
-  #52: <25>
-  #53: <>
-  #54: <>
-  #55: <>
-  #56: <>
-  #57: <26>
-  #58: <>
-  #59: <>
-  #60: <>
-  #61: <>
-  #62: <27>
-  #63: <>
-  #64: <>
-  #65: <>
-  #66: <>
-  #67: <28>
-  #68: <>
-  #69: <>
-  #70: <>
-  #71: <>
-  #72: <29>
-  #73: <>
-  #74: <>
-  #75: <>
-  #76: <>
-  #77: <30>
-  #78: <>
-  #79: <>
-  #80: <>
-  #81: <>
-}
+LLVMUnionFindAliasSet(global, botctx-ind-sens) {
+  #0: {0}
+  #1: {1, 3, 31, 32, 33, 37, 38, 39}
+  #2: {2}
+  #3: {1, 3, 31, 32, 33, 37, 38, 39}
+  #4: {4}
+  #5: {5, 34, 40}
+  #6: {6}
+  #7: {7, 35, 41}
+  #8: {8}
+  #9: {9, 36, 42}
+  #10: {10}
+  #11: {11}
+  #12: {12}
+  #13: {13}
+  #14: {14}
+  #15: {15}
+  #16: {16}
+  #17: {17}
+  #18: {18}
+  #19: {19}
+  #20: {20}
+  #21: {21}
+  #22: {22}
+  #23: {23}
+  #24: {24}
+  #25: {25}
+  #26: {26}
+  #27: {27}
+  #28: {28}
+  #29: {29}
+  #30: {30}
+  #31: {1, 3, 31, 32, 33, 37, 38, 39}
+  #32: {1, 3, 31, 32, 33, 37, 38, 39}
+  #33: {1, 3, 31, 32, 33, 37, 38, 39}
+  #34: {5, 34, 40}
+  #35: {7, 35, 41}
+  #36: {9, 36, 42}
+  #37: {1, 3, 31, 32, 33, 37, 38, 39}
+  #38: {1, 3, 31, 32, 33, 37, 38, 39}
+  #39: {1, 3, 31, 32, 33, 37, 38, 39}
+  #40: {5, 34, 40}
+  #41: {7, 35, 41}
+  #42: {9, 36, 42}
+}
   */
   GTMap GT{{LineColFunOp{.Line = 33,
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
             {
-                LineColFunOp{.Line = 53,
+                LineColFunOp{.Line = 33,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
-            }}};
+                LineColFunOp{.Line = 35,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 37,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 41,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 43,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 46,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 47,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 48,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 49,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 50,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 51,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 53,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 54,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 55,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 56,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 57,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 58,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 59,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 60,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 61,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 62,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 63,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 64,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 53,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 53,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 54,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 54,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 55,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 55,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 56,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 56,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 57,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 57,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 58,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 58,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 59,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 59,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 60,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 60,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 61,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 61,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 62,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 62,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 63,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 63,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 64,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 64,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("indirection_07_c_dbg.ll", GT, IndAABuilder);
 }
@@ -6816,45 +7341,34 @@ ptr, align 8, !psr.id !74 | ID: 27 #20: %this1 = load ptr, ptr %this.addr, align
   #26:
     %this1 = load ptr, ptr %this.addr, align 8, !psr.id !114 | ID: 48
 }
-UnionFindAAResult {
-  #0: <0, 5>
-  #1: <1, 2, 3, 4, 6, 7, 8, 9>
-  #2: <10>
-  #3: <>
-  #4: <>
-  #5: <>
-  #6: <>
-  #7: <11, 12, 15, 16, 17, 18, 20, 22, 24, 26>
-  #8: <13>
-  #9: <>
-  #10: <>
-  #11: <>
-  #12: <>
-  #13: <14>
-  #14: <>
-  #15: <>
-  #16: <>
-  #17: <>
-  #18: <19>
-  #19: <>
-  #20: <>
-  #21: <>
-  #22: <>
-  #23: <21>
-  #24: <>
-  #25: <>
-  #26: <>
-  #27: <>
-  #28: <23>
-  #29: <>
-  #30: <>
-  #31: <>
-  #32: <>
-  #33: <25>
-  #34: <>
-  #35: <>
-  #36: <>
-  #37: <>
+LLVMUnionFindAliasSet(global, botctx-ind-sens) {
+  #0: {0, 5}
+  #1: {1, 2, 3, 4, 6, 7, 8, 9}
+  #2: {1, 2, 3, 4, 6, 7, 8, 9}
+  #3: {1, 2, 3, 4, 6, 7, 8, 9}
+  #4: {1, 2, 3, 4, 6, 7, 8, 9}
+  #5: {0, 5}
+  #6: {1, 2, 3, 4, 6, 7, 8, 9}
+  #7: {1, 2, 3, 4, 6, 7, 8, 9}
+  #8: {1, 2, 3, 4, 6, 7, 8, 9}
+  #9: {1, 2, 3, 4, 6, 7, 8, 9}
+  #10: {10}
+  #11: {11, 12, 15, 16, 17, 18, 20, 22, 24, 26}
+  #12: {11, 12, 15, 16, 17, 18, 20, 22, 24, 26}
+  #13: {13}
+  #14: {14}
+  #15: {11, 12, 15, 16, 17, 18, 20, 22, 24, 26}
+  #16: {11, 12, 15, 16, 17, 18, 20, 22, 24, 26}
+  #17: {11, 12, 15, 16, 17, 18, 20, 22, 24, 26}
+  #18: {11, 12, 15, 16, 17, 18, 20, 22, 24, 26}
+  #19: {19}
+  #20: {11, 12, 15, 16, 17, 18, 20, 22, 24, 26}
+  #21: {21}
+  #22: {11, 12, 15, 16, 17, 18, 20, 22, 24, 26}
+  #23: {23}
+  #24: {11, 12, 15, 16, 17, 18, 20, 22, 24, 26}
+  #25: {25}
+  #26: {11, 12, 15, 16, 17, 18, 20, 22, 24, 26}
 }
   */
   GTMap GT{{LineColFunOp{.Line = 13,
@@ -6862,11 +7376,39 @@ UnionFindAAResult {
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
             {
-                LineColFunOp{.Line = 16,
+                LineColFunOp{.Line = 13,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
-            }}};
+                LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 16,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 17,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+            }},
+           {LineColFunOp{.Line = 16,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 16,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 17,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 17,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("indirection_08_cpp_dbg.ll", GT, IndAABuilder);
 }
@@ -6929,84 +7471,70 @@ ID: 11 #15: %First = alloca %class.Foo, align 8, !psr.id !28 | ID: 12 #16:
   #26:
     ptr %this | ID: _ZN3Baz4FuncEv.0
   #27:
-    %this.addr = alloca ptr, align 8, !psr.id !94 | ID: 35
-  #28:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !100 | ID: 38
-  #29:
-    %this.addr = alloca ptr, align 8, !psr.id !108 | ID: 41
-  #30:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !114 | ID: 44
-  #31:
-    %this.addr = alloca ptr, align 8, !psr.id !123 | ID: 48
-  #32:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !129 | ID: 51
-  #33:
-    %this.addr = alloca ptr, align 8, !psr.id !135 | ID: 55
-  #34:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !140 | ID: 58
-  #35:
-    %this.addr = alloca ptr, align 8, !psr.id !144 | ID: 60
-  #36:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !149 | ID: 63
-  #37:
-    %this.addr = alloca ptr, align 8, !psr.id !153 | ID: 65
-  #38:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !158 | ID: 68
-}
-UnionFindAAResult {
-  #0: <0, 5, 10>
-  #1: <1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13>
-  #2: <14>
-  #3: <>
-  #4: <>
-  #5: <>
-  #6: <>
-  #7: <15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38>
-  #8: <18>
-  #9: <>
-  #10: <>
-  #11: <>
-  #12: <>
-  #13: <19>
-  #14: <>
-  #15: <>
-  #16: <>
-  #17: <>
-  #18: <20>
-  #19: <>
-  #20: <>
-  #21: <>
-  #22: <>
-  #23: <27>
-  #24: <>
-  #25: <>
-  #26: <>
-  #27: <>
-  #28: <29>
-  #29: <>
-  #30: <>
-  #31: <>
-  #32: <>
-  #33: <31>
-  #34: <>
-  #35: <>
-  #36: <>
-  #37: <>
-  #38: <33>
-  #39: <>
-  #40: <>
-  #41: <>
-  #42: <>
-  #43: <35>
-  #44: <>
-  #45: <>
-  #46: <>
-  #47: <>
-  #48: <37>
-  #49: <>
-  #50: <>
-  #51: <>
-  #52: <>
+    %this.addr = alloca ptr, align 8, !psr.id !94 | ID: 35
+  #28:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !100 | ID: 38
+  #29:
+    %this.addr = alloca ptr, align 8, !psr.id !108 | ID: 41
+  #30:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !114 | ID: 44
+  #31:
+    %this.addr = alloca ptr, align 8, !psr.id !123 | ID: 48
+  #32:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !129 | ID: 51
+  #33:
+    %this.addr = alloca ptr, align 8, !psr.id !135 | ID: 55
+  #34:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !140 | ID: 58
+  #35:
+    %this.addr = alloca ptr, align 8, !psr.id !144 | ID: 60
+  #36:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !149 | ID: 63
+  #37:
+    %this.addr = alloca ptr, align 8, !psr.id !153 | ID: 65
+  #38:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !158 | ID: 68
+}
+LLVMUnionFindAliasSet(global, botctx-ind-sens) {
+  #0: {0, 5, 10}
+  #1: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13}
+  #2: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13}
+  #3: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13}
+  #4: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13}
+  #5: {0, 5, 10}
+  #6: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13}
+  #7: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13}
+  #8: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13}
+  #9: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13}
+  #10: {0, 5, 10}
+  #11: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13}
+  #12: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13}
+  #13: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13}
+  #14: {14}
+  #15: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
+  #16: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
+  #17: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
+  #18: {18}
+  #19: {19}
+  #20: {20}
+  #21: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
+  #22: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
+  #23: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
+  #24: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
+  #25: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
+  #26: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
+  #27: {27}
+  #28: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
+  #29: {29}
+  #30: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
+  #31: {31}
+  #32: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
+  #33: {33}
+  #34: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
+  #35: {35}
+  #36: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
+  #37: {37}
+  #38: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
 }
   */
   GTMap GT{{LineColFunOp{.Line = 18,
@@ -7014,11 +7542,55 @@ UnionFindAAResult {
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
             {
-                LineColFunOp{.Line = 22,
+                LineColFunOp{.Line = 18,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
-            }}};
+                LineColFunOp{.Line = 19,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 24,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+            }},
+           {LineColFunOp{.Line = 22,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 22,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 23,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 23,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 24,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 24,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("indirection_09_cpp_dbg.ll", GT, IndAABuilder);
 }
@@ -7131,59 +7703,50 @@ ID: 14 #19: %First = alloca %class.Foo, align 8, !psr.id !31 | ID: 15 #20:
   #50:
     %this1 = load ptr, ptr %this.addr, align 8, !psr.id !208 | ID: 94
 }
-UnionFindAAResult {
-  #0: <0, 5, 10, 14>
-  #1: <1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17>
-  #2: <18>
-  #3: <>
-  #4: <>
-  #5: <>
-  #6: <>
-  #7: <19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36, 38, 40, 42, 44, 46,
-48, 50> #8: <23> #9: <> #10: <> #11: <> #12: <> #13: <24> #14: <> #15: <> #16:
-<> #17: <> #18: <25> #19: <> #20: <> #21: <> #22: <> #23: <26> #24: <> #25: <>
-  #26: <>
-  #27: <>
-  #28: <35>
-  #29: <>
-  #30: <>
-  #31: <>
-  #32: <>
-  #33: <37>
-  #34: <>
-  #35: <>
-  #36: <>
-  #37: <>
-  #38: <39>
-  #39: <>
-  #40: <>
-  #41: <>
-  #42: <>
-  #43: <41>
-  #44: <>
-  #45: <>
-  #46: <>
-  #47: <>
-  #48: <43>
-  #49: <>
-  #50: <>
-  #51: <>
-  #52: <>
-  #53: <45>
-  #54: <>
-  #55: <>
-  #56: <>
-  #57: <>
-  #58: <47>
-  #59: <>
-  #60: <>
-  #61: <>
-  #62: <>
-  #63: <49>
-  #64: <>
-  #65: <>
-  #66: <>
-  #67: <>
+LLVMUnionFindAliasSet(global, botctx-ind-sens) {
+  #0: {0, 5, 10, 14}
+  #1: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
+  #2: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
+  #3: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
+  #4: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
+  #5: {0, 5, 10, 14}
+  #6: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
+  #7: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
+  #8: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
+  #9: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
+  #10: {0, 5, 10, 14}
+  #11: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
+  #12: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
+  #13: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
+  #14: {0, 5, 10, 14}
+  #15: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
+  #16: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
+  #17: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
+  #18: {18}
+  #19: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36, 38, 40, 42, 44, 46,
+48, 50} #20: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36, 38, 40, 42,
+44, 46, 48, 50} #21: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36, 38,
+40, 42, 44, 46, 48, 50} #22: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34,
+36, 38, 40, 42, 44, 46, 48, 50} #23: {23} #24: {24} #25: {25} #26: {26} #27:
+{19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36, 38, 40, 42, 44, 46, 48, 50}
+  #28: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36, 38, 40, 42, 44, 46,
+48, 50} #29: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36, 38, 40, 42,
+44, 46, 48, 50} #30: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36, 38,
+40, 42, 44, 46, 48, 50} #31: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34,
+36, 38, 40, 42, 44, 46, 48, 50} #32: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32,
+33, 34, 36, 38, 40, 42, 44, 46, 48, 50} #33: {19, 20, 21, 22, 27, 28, 29, 30,
+31, 32, 33, 34, 36, 38, 40, 42, 44, 46, 48, 50} #34: {19, 20, 21, 22, 27, 28,
+29, 30, 31, 32, 33, 34, 36, 38, 40, 42, 44, 46, 48, 50} #35: {35} #36: {19, 20,
+21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36, 38, 40, 42, 44, 46, 48, 50} #37:
+{37} #38: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36, 38, 40, 42, 44,
+46, 48, 50} #39: {39} #40: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36,
+38, 40, 42, 44, 46, 48, 50} #41: {41} #42: {19, 20, 21, 22, 27, 28, 29, 30, 31,
+32, 33, 34, 36, 38, 40, 42, 44, 46, 48, 50} #43: {43} #44: {19, 20, 21, 22, 27,
+28, 29, 30, 31, 32, 33, 34, 36, 38, 40, 42, 44, 46, 48, 50} #45: {45} #46: {19,
+20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36, 38, 40, 42, 44, 46, 48, 50} #47:
+{47} #48: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36, 38, 40, 42, 44,
+46, 48, 50} #49: {49} #50: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36,
+38, 40, 42, 44, 46, 48, 50}
 }
   */
   GTMap GT{{LineColFunOp{.Line = 23,
@@ -7191,11 +7754,71 @@ UnionFindAAResult {
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
             {
-                LineColFunOp{.Line = 28,
+                LineColFunOp{.Line = 23,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
-            }}};
+                LineColFunOp{.Line = 24,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 25,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 26,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 28,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 29,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 31,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+            }},
+           {LineColFunOp{.Line = 28,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 28,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 29,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 29,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 30,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 30,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 31,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 31,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("indirection_10_cpp_dbg.ll", GT, IndAABuilder);
 }
@@ -7334,85 +7957,69 @@ ID: 17 #23: %First = alloca %class.Foo, align 8, !psr.id !34 | ID: 18 #24:
   #62:
     %this1 = load ptr, ptr %this.addr, align 8, !psr.id !255 | ID: 117
 }
-UnionFindAAResult {
-  #0: <0, 5, 10, 14, 18>
-  #1: <1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21>
-  #2: <22>
-  #3: <>
-  #4: <>
-  #5: <>
-  #6: <>
-  #7: <23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46, 48,
-50, 52, 54, 56, 58, 60, 62> #8: <28> #9: <> #10: <> #11: <> #12: <> #13: <29>
-  #14: <>
-  #15: <>
-  #16: <>
-  #17: <>
-  #18: <30>
-  #19: <>
-  #20: <>
-  #21: <>
-  #22: <>
-  #23: <31>
-  #24: <>
-  #25: <>
-  #26: <>
-  #27: <>
-  #28: <32>
-  #29: <>
-  #30: <>
-  #31: <>
-  #32: <>
-  #33: <43>
-  #34: <>
-  #35: <>
-  #36: <>
-  #37: <>
-  #38: <45>
-  #39: <>
-  #40: <>
-  #41: <>
-  #42: <>
-  #43: <47>
-  #44: <>
-  #45: <>
-  #46: <>
-  #47: <>
-  #48: <49>
-  #49: <>
-  #50: <>
-  #51: <>
-  #52: <>
-  #53: <51>
-  #54: <>
-  #55: <>
-  #56: <>
-  #57: <>
-  #58: <53>
-  #59: <>
-  #60: <>
-  #61: <>
-  #62: <>
-  #63: <55>
-  #64: <>
-  #65: <>
-  #66: <>
-  #67: <>
-  #68: <57>
-  #69: <>
-  #70: <>
-  #71: <>
-  #72: <>
-  #73: <59>
-  #74: <>
-  #75: <>
-  #76: <>
-  #77: <>
-  #78: <61>
-  #79: <>
-  #80: <>
-  #81: <>
-  #82: <>
+LLVMUnionFindAliasSet(global, botctx-ind-sens) {
+  #0: {0, 5, 10, 14, 18}
+  #1: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
+  #2: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
+  #3: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
+  #4: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
+  #5: {0, 5, 10, 14, 18}
+  #6: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
+  #7: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
+  #8: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
+  #9: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
+  #10: {0, 5, 10, 14, 18}
+  #11: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
+  #12: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
+  #13: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
+  #14: {0, 5, 10, 14, 18}
+  #15: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
+  #16: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
+  #17: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
+  #18: {0, 5, 10, 14, 18}
+  #19: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
+  #20: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
+  #21: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
+  #22: {22}
+  #23: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46, 48,
+50, 52, 54, 56, 58, 60, 62} #24: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38,
+39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62} #25: {23, 24, 25, 26,
+27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60,
+62} #26: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46,
+48, 50, 52, 54, 56, 58, 60, 62} #27: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37,
+38, 39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62} #28: {28} #29: {29}
+  #30: {30}
+  #31: {31}
+  #32: {32}
+  #33: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46, 48,
+50, 52, 54, 56, 58, 60, 62} #34: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38,
+39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62} #35: {23, 24, 25, 26,
+27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60,
+62} #36: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46,
+48, 50, 52, 54, 56, 58, 60, 62} #37: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37,
+38, 39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62} #38: {23, 24, 25,
+26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58,
+60, 62} #39: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44,
+46, 48, 50, 52, 54, 56, 58, 60, 62} #40: {23, 24, 25, 26, 27, 33, 34, 35, 36,
+37, 38, 39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62} #41: {23, 24,
+25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56,
+58, 60, 62} #42: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
+44, 46, 48, 50, 52, 54, 56, 58, 60, 62} #43: {43} #44: {23, 24, 25, 26, 27, 33,
+34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62} #45:
+{45} #46: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46,
+48, 50, 52, 54, 56, 58, 60, 62} #47: {47} #48: {23, 24, 25, 26, 27, 33, 34, 35,
+36, 37, 38, 39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62} #49: {49}
+  #50: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46, 48,
+50, 52, 54, 56, 58, 60, 62} #51: {51} #52: {23, 24, 25, 26, 27, 33, 34, 35, 36,
+37, 38, 39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62} #53: {53} #54:
+{23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46, 48, 50, 52,
+54, 56, 58, 60, 62} #55: {55} #56: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38,
+39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62} #57: {57} #58: {23, 24,
+25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56,
+58, 60, 62} #59: {59} #60: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40,
+41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62} #61: {61} #62: {23, 24, 25, 26,
+27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60,
+62}
 }
   */
   GTMap GT{{LineColFunOp{.Line = 28,
@@ -7420,11 +8027,87 @@ UnionFindAAResult {
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
             {
-                LineColFunOp{.Line = 34,
+                LineColFunOp{.Line = 28,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
-            }}};
+                LineColFunOp{.Line = 29,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 31,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 35,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 36,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 37,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 38,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+            }},
+           {LineColFunOp{.Line = 34,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 34,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 35,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 35,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 36,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 36,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 37,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 37,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 38,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 38,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("indirection_11_cpp_dbg.ll", GT, IndAABuilder);
 }

From 674f51db850cd5e43cbfe22bb202954d89fb3482 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Mon, 16 Feb 2026 14:12:32 +0100
Subject: [PATCH 46/75] Add TracingPBStrategy to dump the PAG

---
 .../phasar/Pointer/PointerAssignmentGraph.h   | 55 ++++++++++++++++---
 .../Pointer/LLVMUnionFindAATest.cpp           | 13 ++++-
 2 files changed, 57 insertions(+), 11 deletions(-)

diff --git a/include/phasar/Pointer/PointerAssignmentGraph.h b/include/phasar/Pointer/PointerAssignmentGraph.h
index 25168859c8..59c266d40b 100644
--- a/include/phasar/Pointer/PointerAssignmentGraph.h
+++ b/include/phasar/Pointer/PointerAssignmentGraph.h
@@ -14,6 +14,7 @@
 #include <memory>
 #include <optional>
 #include <type_traits>
+#include <utility>
 #include <variant>
 
 namespace psr {
@@ -92,12 +93,15 @@ struct Edge : public std::variant<Assign, Gep, Call, Return, Load, Store,
   }
 };
 
-template <typename T>
-concept CanOnAddEdge =
+template <typename T, typename N>
+concept CanOnAddEdgeN =
     requires(T &Strategy, ValueId From, ValueId To, pag::Edge E) {
-      Strategy.onAddEdge(From, To, E, Nullable<typename T::n_t>{});
+      Strategy.onAddEdge(From, To, E, Nullable<N>{});
     };
 
+template <typename T>
+concept CanOnAddEdge = CanOnAddEdgeN<T, typename T::n_t>;
+
 template <typename T>
 concept CanWithCalleesOfCallAt =
     requires(const T &CStrategy, const typename T::n_t &Inst) {
@@ -131,11 +135,15 @@ concept CanGetNumPossibleValues =
       } noexcept -> std::convertible_to<size_t>;
     };
 
-template <PBStrategy FirstT, CanOnAddEdge SecondT>
-  requires(std::same_as<typename FirstT::n_t, typename SecondT::n_t> &&
-           std::same_as<typename FirstT::v_t, typename SecondT::v_t> &&
-           std::same_as<typename FirstT::f_t, typename SecondT::f_t> &&
-           std::same_as<typename FirstT::db_t, typename SecondT::db_t>)
+template <typename T>
+concept CanConsumeAAResults =
+    requires(T Strategy) { std::move(Strategy).consumeAAResults(size_t(0)); };
+
+template <PBStrategy FirstT, CanOnAddEdgeN<typename FirstT::n_t> SecondT>
+// requires(std::same_as<typename FirstT::n_t, typename SecondT::n_t> &&
+//          std::same_as<typename FirstT::v_t, typename SecondT::v_t> &&
+//          std::same_as<typename FirstT::f_t, typename SecondT::f_t> &&
+//          std::same_as<typename FirstT::db_t, typename SecondT::db_t>)
 struct PBStrategyCombinator {
   using n_t = typename FirstT::n_t;
   using v_t = typename FirstT::v_t;
@@ -184,6 +192,12 @@ struct PBStrategyCombinator {
       First.withCalleesOfCallAt(CS, WithCallee);
     }
   }
+
+  constexpr auto consumeAAResults(size_t NumVars) &&
+    requires(CanConsumeAAResults<FirstT> && !CanConsumeAAResults<SecondT>)
+  {
+    return std::move(First).consumeAAResults(NumVars);
+  }
 };
 
 template <CanOnAddEdge FirstT, PBStrategyBase SecondT>
@@ -210,6 +224,31 @@ struct PBMixin : public FirstT {
   }
 };
 
+struct TracingPBStrategy {
+  bool Engaged = true;
+
+  TracingPBStrategy() { llvm::errs() << "digraph PAG {\n"; }
+  ~TracingPBStrategy() {
+    if (Engaged) {
+      llvm::errs() << "}\n";
+    }
+  }
+
+  constexpr TracingPBStrategy(TracingPBStrategy &&Other) noexcept
+      : Engaged(std::exchange(Other.Engaged, false)) {}
+  constexpr TracingPBStrategy &operator=(TracingPBStrategy &&Other) noexcept {
+    Engaged = std::exchange(Other.Engaged, false);
+    return *this;
+  }
+
+  void onAddEdge(ValueId From, ValueId To, Edge E,
+                 const auto & /*AtInstruction*/) const {
+    llvm::errs() << "  " << uint32_t(From) << "->" << uint32_t(To)
+                 << "[label=\"";
+    llvm::errs().write_escaped(to_string(E)) << "\"];\n";
+  }
+};
+
 /// The main customization point for PAG building.
 /// Implement this interface to provide several callbacks to the PAGBuilder,
 /// specifying how the PAG should be built.
diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index 43d1d97418..ec2c877946 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -88,10 +88,8 @@ void doAnalysisAndCompareResults(
                                         {"main"}, TH, VTP);
 
   ValueCompressor<PAGVariable> VC;
-  auto AA = AABuilder(IRDB, BaseCG);
-
   UnionFindAAResult auto Results =
-      computeUnionFindAARaw(IRDB, std::move(AA), &VC);
+      computeUnionFindAARaw(IRDB, AABuilder(IRDB, BaseCG), &VC);
 
   for (const auto &[PtrVar, ExpectedAliasVars] : ExpectedResults) {
     const auto PtrId = asId(VC, IRDB, PtrVar);
@@ -177,6 +175,15 @@ constexpr auto BotAABuilder = [](const auto &IRDB, const auto &CG) {
   return Ret;
 };
 
+constexpr auto TracingBuilder = [](auto &&Builder) {
+  return [Builder = PSR_FWD(Builder)](const auto &IRDB, const auto &CG) {
+    return pag::PBStrategyCombinator{
+        std::invoke(Builder, IRDB, CG),
+        pag::TracingPBStrategy{},
+    };
+  };
+};
+
 TEST(CtxSensUnionFindAATest, Basic01) {
   GTMap GT = {{LineColFunOp{.Line = 3,
                             .Col = 0,

From d33f08acd6484e40768c8a389de534c613f2417a Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Tue, 17 Feb 2026 21:13:04 +0100
Subject: [PATCH 47/75] new indir tests + fixed crashes

---
 .../Pointer/LLVMUnionFindAliasSet.cpp         |    3 +-
 test/llvm_test_code/pointers/CMakeLists.txt   |    1 -
 test/llvm_test_code/pointers/basic_04.c       |    1 -
 test/llvm_test_code/pointers/context_14_0.c   |    2 +-
 .../pointers/indirection_08.cpp               |    5 +-
 .../pointers/indirection_09.cpp               |    7 +-
 .../pointers/indirection_10.cpp               |   18 +-
 .../pointers/indirection_11.cpp               |   41 -
 .../Pointer/LLVMUnionFindAATest.cpp           | 4090 +++++++++++------
 9 files changed, 2688 insertions(+), 1480 deletions(-)
 delete mode 100644 test/llvm_test_code/pointers/indirection_11.cpp

diff --git a/lib/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.cpp b/lib/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.cpp
index fb5980ca4c..6d21c2b6a4 100644
--- a/lib/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.cpp
+++ b/lib/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.cpp
@@ -141,7 +141,8 @@ struct [[clang::internal_linkage]] LLVMUnionFindAliasSet::UnionFindAAResultModel
 
 LLVMUnionFindAliasSet::LLVMUnionFindAliasSet(const LLVMProjectIRDB *IRDB,
                                              Config Cfg,
-                                             ValueCompressor<PAGVariable> *VC) {
+                                             ValueCompressor<PAGVariable> *VC)
+    : Cfg(Cfg) {
   MaybeUniquePtr<ValueCompressor<PAGVariable>> VCOwn = VC;
   if (!VC) {
     VCOwn = std::make_unique<ValueCompressor<PAGVariable>>();
diff --git a/test/llvm_test_code/pointers/CMakeLists.txt b/test/llvm_test_code/pointers/CMakeLists.txt
index ab5d4ce829..0802f9e736 100644
--- a/test/llvm_test_code/pointers/CMakeLists.txt
+++ b/test/llvm_test_code/pointers/CMakeLists.txt
@@ -42,7 +42,6 @@ set(lca_files
   indirection_08.cpp
   indirection_09.cpp
   indirection_10.cpp
-  indirection_11.cpp
 )
 
 set(lca_files_mem2reg
diff --git a/test/llvm_test_code/pointers/basic_04.c b/test/llvm_test_code/pointers/basic_04.c
index 78081b32da..eed0db4bd4 100644
--- a/test/llvm_test_code/pointers/basic_04.c
+++ b/test/llvm_test_code/pointers/basic_04.c
@@ -3,7 +3,6 @@ int Func() { return 1; }
 
 int main() {
   int (*FuncPtr)();
-
   int (**FuncPtr2)();
 
   FuncPtr = &Func;
diff --git a/test/llvm_test_code/pointers/context_14_0.c b/test/llvm_test_code/pointers/context_14_0.c
index c8fc5c24ac..fd110be6aa 100644
--- a/test/llvm_test_code/pointers/context_14_0.c
+++ b/test/llvm_test_code/pointers/context_14_0.c
@@ -1,7 +1,7 @@
 
 int ret0() { return 0; }
 
-int callback(int (*Func)()) { return (*Func)(); }
+int callback(int (*Func)()) { return Func(); }
 
 int main() {
   int (*FuncPtr)() = &ret0;
diff --git a/test/llvm_test_code/pointers/indirection_08.cpp b/test/llvm_test_code/pointers/indirection_08.cpp
index 8df8113c10..be6f36f071 100644
--- a/test/llvm_test_code/pointers/indirection_08.cpp
+++ b/test/llvm_test_code/pointers/indirection_08.cpp
@@ -13,8 +13,9 @@ int main() {
   Foo First{};
   Bar Second{};
 
-  int x = First.Func();
-  int y = Second.Func();
+  Foo &SecondAlias = Second;
+
+  SecondAlias.Func();
 
   return 0;
 }
diff --git a/test/llvm_test_code/pointers/indirection_09.cpp b/test/llvm_test_code/pointers/indirection_09.cpp
index 8a2a5a84ae..41ae31ee0c 100644
--- a/test/llvm_test_code/pointers/indirection_09.cpp
+++ b/test/llvm_test_code/pointers/indirection_09.cpp
@@ -1,3 +1,4 @@
+bool Bool = true;
 
 class Foo {
 public:
@@ -19,9 +20,7 @@ int main() {
   Bar Second{};
   Baz Third{};
 
-  int x = First.Func();
-  int y = Second.Func();
-  int z = Third.Func();
+  Foo &FooRef = Bool ? Second : Third;
 
-  return 0;
+  return FooRef.Func();
 }
diff --git a/test/llvm_test_code/pointers/indirection_10.cpp b/test/llvm_test_code/pointers/indirection_10.cpp
index c863f0d1ee..c744b1126f 100644
--- a/test/llvm_test_code/pointers/indirection_10.cpp
+++ b/test/llvm_test_code/pointers/indirection_10.cpp
@@ -6,29 +6,23 @@ class Foo {
 
 class Bar : public Foo {
 public:
+  Foo *FooPtr;
   int Func() override { return 1; };
 };
 
 class Baz : public Bar {
 public:
-  int Func() override { return 2; };
-};
-
-class Boar : public Baz {
-public:
-  int Func() override { return 3; };
+  Foo *FooPtr;
+  int Func() override { return FooPtr->Func(); };
 };
 
 int main() {
   Foo First{};
   Bar Second{};
-  Baz Third{};
-  Boar Fourth{};
 
-  int x = First.Func();
-  int y = Second.Func();
-  int z = Third.Func();
-  int a = Fourth.Func();
+  Foo &SecondAlias = Second;
+
+  SecondAlias.Func();
 
   return 0;
 }
diff --git a/test/llvm_test_code/pointers/indirection_11.cpp b/test/llvm_test_code/pointers/indirection_11.cpp
deleted file mode 100644
index 4af366255b..0000000000
--- a/test/llvm_test_code/pointers/indirection_11.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-
-class Foo {
-public:
-  virtual int Func() { return 0; };
-};
-
-class Bar : public Foo {
-public:
-  int Func() override { return 1; };
-};
-
-class Baz : public Bar {
-public:
-  int Func() override { return 2; };
-};
-
-class Boar : public Baz {
-public:
-  int Func() override { return 3; };
-};
-
-class Far : public Boar {
-public:
-  int Func() override { return 4; };
-};
-
-int main() {
-  Foo First{};
-  Bar Second{};
-  Baz Third{};
-  Boar Fourth{};
-  Far Fifth{};
-
-  int x = First.Func();
-  int y = Second.Func();
-  int z = Third.Func();
-  int a = Fourth.Func();
-  int b = Fifth.Func();
-
-  return 0;
-}
diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index 43d1d97418..d7377b45cd 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -178,6 +178,13 @@ constexpr auto BotAABuilder = [](const auto &IRDB, const auto &CG) {
 };
 
 TEST(CtxSensUnionFindAATest, Basic01) {
+  /*
+LLVMUnionFindAliasSet(global, botctx-ind-sens) {
+  #0: {0, 2}
+  #1: {1}
+  #2: {0, 2}
+}
+  */
   GTMap GT = {{LineColFunOp{.Line = 3,
                             .Col = 0,
                             .InFunction = "main",
@@ -196,6 +203,15 @@ TEST(CtxSensUnionFindAATest, Basic01) {
 }
 
 TEST(CtxSensUnionFindAATest, Basic02) {
+  /*
+LLVMUnionFindAliasSet(global, botctx-ind-sens) {
+  #0: {0, 1, 3, 4}
+  #1: {0, 1, 3, 4}
+  #2: {2}
+  #3: {0, 1, 3, 4}
+  #4: {0, 1, 3, 4}
+}
+  */
   GTMap GT = {{LineColFunOp{.Line = 3,
                             .Col = 0,
                             .InFunction = "main",
@@ -205,20 +221,54 @@ TEST(CtxSensUnionFindAATest, Basic02) {
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Alloca},
-                   LineColFunOp{.Line = 6,
+                   LineColFunOp{.Line = 4,
                                 .Col = 0,
                                 .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 6,
+                                .Col = 4,
+                                .InFunction = "main",
                                 .OpCode = llvm::Instruction::Load},
-               }}};
+                   LineColFunOp{.Line = 6,
+                                .Col = 5,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 5,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 5,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("basic_02_c_dbg.ll", GT, ContextAABuilder);
 }
 
 TEST(CtxSensUnionFindAATest, Basic03) {
   /*
+  LLVMUnionFindAliasSet(global, botctx-ind-sens) {
+  #0: {0}
+  #1: {1}
+  #2: {2, 3}
+  #3: {2, 3}
+}
+  */
+  GTMap GT = {{LineColFunOp{.Line = 5,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 5,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
 
-  Note: only relevant lines were pasted here
+  doAnalysisAndCompareResults("basic_03_c_dbg.ll", GT, ContextAABuilder);
+}
 
+TEST(CtxSensUnionFindAATest, Basic04) {
+  /*
   ValueCompressor:
   #1:
     @"_ZTIZ4mainE3$_0" = internal constant { ptr, ptr } { ptr getelementptr
@@ -229,95 +279,31 @@ TEST(CtxSensUnionFindAATest, Basic03) {
   #46:
     %3 = extractvalue { ptr, i32 } %2, 0, !dbg !538, !psr.id !550 | ID: 76
 
-  --- ---
-
-  #1: <6, 10, 21, 22, 24, 56, 58, 88>
-  #11: <8, 15, 31, 33, 160, 161, 163, 181, 183, 209>
-  #46: <46, 47, 59, 141, 184, 253>
-
-  --- for #1: <6, 10, 21, 22, 24, 56, 58, 88> ---
-
-  #6:
-    %ref.tmp = alloca %class.anon, align 1, !psr.id !402 | ID: 6
-  #10:
-    ptr %__f | ID: _ZNSt8functionIFivEEC2IZ4mainE3$_0vEEOT_.1
-  #21:
-    %1 = load ptr, ptr %__f.addr, align 8, !dbg !448, !psr.id !451 | ID: 29
-    %2 = load ptr, ptr %__f.addr, align 8, !dbg !459, !psr.id !460 | ID: 33
-  #22:
-    ptr %0 | ID:
-  _ZNSt14_Function_base13_Base_managerIZ4mainE3$_0E21_M_not_empty_functionIS1_EEbRKT_.0
-  #24:
-    ptr %__f | ID:
-  _ZNSt14_Function_base13_Base_managerIZ4mainE3$_0E15_M_init_functorIS1_EEvRSt9_Any_dataOT_.1
-  #56:
-    %1 = load ptr, ptr %__f.addr, align 8, !dbg !647, !psr.id !648 | ID: 103
-  #58:
-    ptr %__f | ID:
-  _ZNSt14_Function_base13_Base_managerIZ4mainE3$_0E9_M_createIS1_EEvRSt9_Any_dataOT_St17integral_constantIbLb1EE.1
-  #88:
-    %2 = load ptr, ptr %__f.addr, align 8, !dbg !752, !psr.id !753 | ID: 154
-
-  --- for #11: <8, 15, 31, 33, 160, 161, 163, 181, 183, 209> ---
-
-  #8:
-    %ref.tmp1 = alloca %class.anon.0, align 1, !psr.id !404 | ID: 8
-  #15:
-    ptr %__f | ID:
-  _ZNSt8functionIFivEEaSIZ4mainE3$_1EENSt9enable_ifIXsrNS1_9_CallableIT_NS4_IXntsr7is_sameINSt9remove_cvINSt16remove_referenceIS6_E4typeEE4typeES1_EE5valueESt5decayIS6_EE4type4typeESt15__invoke_resultIRSH_JEEEE5valueERS1_E4typeEOS6_.1
-  #31:
-    %0 = load ptr, ptr %__f.addr, align 8, !dbg !500, !psr.id !501 | ID: 49
-  #33:
-    ptr %__f | ID: _ZNSt8functionIFivEEC2IZ4mainE3$_1vEEOT_.1
-  #160:
-    %1 = load ptr, ptr %__f.addr, align 8, !dbg !1063, !psr.id !1066 | ID: 300
-    %2 = load ptr, ptr %__f.addr, align 8, !dbg !1074, !psr.id !1075 | ID: 304
-  #161:
-    ptr %0 | ID:
-  _ZNSt14_Function_base13_Base_managerIZ4mainE3$_1E21_M_not_empty_functionIS1_EEbRKT_.0
-  #163:
-    ptr %__f | ID:
-  _ZNSt14_Function_base13_Base_managerIZ4mainE3$_1E15_M_init_functorIS1_EEvRSt9_Any_dataOT_.1
-  #181:
-    %1 = load ptr, ptr %__f.addr, align 8, !dbg !1170, !psr.id !1171 | ID: 344
-  #183:
-    ptr %__f | ID:
-  _ZNSt14_Function_base13_Base_managerIZ4mainE3$_1E9_M_createIS1_EEvRSt9_Any_dataOT_St17integral_constantIbLb1EE.1
-  #209:
-    %2 = load ptr, ptr %__f.addr, align 8, !dbg !1275, !psr.id !1276 | ID: 395
-
-  --- for #46: <46, 47, 59, 141, 184, 253> ---
-
-  #46:
-    %3 = extractvalue { ptr, i32 } %2, 0, !dbg !538, !psr.id !550 | ID: 76
-  #47:
-    ptr %0 | ID: __clang_call_terminate.0
-  #59:
-    %3 = extractvalue { ptr, i32 } %2, 0, !dbg !649, !psr.id !654 | ID: 107
-  #141:
-    %3 = extractvalue { ptr, i32 } %2, 0, !dbg !976, !psr.id !981 | ID: 259
-  #184:
-    %3 = extractvalue { ptr, i32 } %2, 0, !dbg !1172, !psr.id !1177 | ID: 348
-  #253:
-    %3 = extractvalue { ptr, i32 } %2, 0, !dbg !1458, !psr.id !1463 | ID: 482
-
+LLVMUnionFindAliasSet(global, botctx-ind-sens) {
+  #0: {0}
+  #1: {1, 3, 4, 5}
+  #2: {2}
+  #3: {1, 3, 4, 5}
+  #4: {1, 3, 4, 5}
+  #5: {1, 3, 4, 5}
+}
   */
-  GTMap GT = {{LineColFunOp{.Line = 4,
+  GTMap GT = {{LineColFunOp{.Line = 5,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
                {
-                   LineColFunOp{.Line = 4,
+                   LineColFunOp{.Line = 5,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Alloca},
                    LineColFunOp{.Line = 6,
                                 .Col = 0,
                                 .InFunction = "main",
-                                .OpCode = llvm::Instruction::Load},
+                                .OpCode = llvm::Instruction::Alloca},
                }}};
 
-  doAnalysisAndCompareResults("basic_03_c_dbg.ll", GT, ContextAABuilder);
+  doAnalysisAndCompareResults("basic_04_c_dbg.ll", GT, ContextAABuilder);
 }
 
 TEST(CtxSensUnionFindAATest, Context01) {
@@ -1117,174 +1103,32 @@ TEST(CtxSensUnionFindAATest, Context13_1) {
   doAnalysisAndCompareResults("context_13_1_c_dbg.ll", GT, ContextAABuilder);
 }
 
-// TODO: Add more context tests
-
-// TODO: Add tests for IndirectionSensUnionFindAA
-
-TEST(BotUnionFindAATest, Context01) {
-  GTMap GT = {
-      {LineColFunOp{.Line = 5,
-                    .Col = 0,
-                    .InFunction = "main",
-                    .OpCode = llvm::Instruction::Alloca},
-       {
-           LineColFunOp{.Line = 5,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 8,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 11,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Load},
-       }},
-      {LineColFunOp{.Line = 6,
-                    .Col = 0,
-                    .InFunction = "main",
-                    .OpCode = llvm::Instruction::Alloca},
-       {
-           LineColFunOp{.Line = 6,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 9,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-       }},
-  };
-
-  doAnalysisAndCompareResults("context_01_c_dbg.ll", GT, BotAABuilder);
-}
-
-TEST(BotUnionFindAATest, Context02) {
-  GTMap GT = {
-      {LineColFunOp{.Line = 6,
-                    .Col = 0,
-                    .InFunction = "main",
-                    .OpCode = llvm::Instruction::Alloca},
-       {
-           LineColFunOp{.Line = 6,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 9,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 10,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 14,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Load},
-       }},
-      {LineColFunOp{.Line = 7,
-                    .Col = 0,
-                    .InFunction = "main",
-                    .OpCode = llvm::Instruction::Alloca},
-       {
-           LineColFunOp{.Line = 7,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 11,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 12,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-       }},
-  };
-
-  doAnalysisAndCompareResults("context_02_c_dbg.ll", GT, BotAABuilder);
-}
-
-TEST(BotUnionFindAATest, Context03) {
-  GTMap GT = {{LineColFunOp{.Line = 6,
+TEST(CtxSensUnionFindAATest, Indirection01) {
+  GTMap GT = {{LineColFunOp{.Line = 8,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {
-                   LineColFunOp{.Line = 6,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Alloca},
-                   LineColFunOp{.Line = 8,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 9,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 11,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Load},
-               }}};
-
-  doAnalysisAndCompareResults("context_03_c_dbg.ll", GT, BotAABuilder);
-}
-
-TEST(BotUnionFindAATest, Context04_0) {
-  GTMap GT = {{LineColFunOp{.Line = 7,
+               {LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 11,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {
-                   LineColFunOp{.Line = 7,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Alloca},
-                   LineColFunOp{.Line = 9,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 10,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 12,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Load},
-               }}};
-
-  doAnalysisAndCompareResults("context_04_0_c_dbg.ll", GT, BotAABuilder);
+               {LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_01_c_dbg.ll", GT, ContextAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context04_1) {
-  GTMap GT = {{LineColFunOp{.Line = 7,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {
-                   LineColFunOp{.Line = 7,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Alloca},
-                   LineColFunOp{.Line = 10,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 11,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 15,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Load},
-               }},
-              {LineColFunOp{.Line = 8,
+TEST(CtxSensUnionFindAATest, Indirection02) {
+  GTMap GT = {{LineColFunOp{.Line = 8,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
@@ -1292,615 +1136,2493 @@ TEST(BotUnionFindAATest, Context04_1) {
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 12,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 13,
+                LineColFunOp{.Line = 11,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call}}}};
-
-  doAnalysisAndCompareResults("context_04_1_c_dbg.ll", GT, BotAABuilder);
-}
-
-TEST(BotUnionFindAATest, Context05_0) {
-  GTMap GT = {{LineColFunOp{.Line = 8,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 11,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {
-                   LineColFunOp{.Line = 8,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Alloca},
-                   LineColFunOp{.Line = 10,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 11,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 13,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Load},
-               }}};
-
-  doAnalysisAndCompareResults("context_05_0_c_dbg.ll", GT, BotAABuilder);
-}
-
-TEST(BotUnionFindAATest, Context05_1) {
-  GTMap GT = {{LineColFunOp{.Line = 8,
+               {LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 14,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {
-                   LineColFunOp{.Line = 8,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Alloca},
-                   LineColFunOp{.Line = 11,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 12,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 16,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Load},
-               }},
-              {LineColFunOp{.Line = 9,
+               {LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 15,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 9,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 13,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 14,
+               {LineColFunOp{.Line = 15,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call}}}};
-
-  doAnalysisAndCompareResults("context_05_1_c_dbg.ll", GT, BotAABuilder);
-}
-
-TEST(BotUnionFindAATest, Context06_0) {
-  GTMap GT = {{LineColFunOp{.Line = 9,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 20,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {
-                   LineColFunOp{.Line = 9,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Alloca},
-                   LineColFunOp{.Line = 11,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 12,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 14,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Load},
-               }}};
-
-  doAnalysisAndCompareResults("context_06_0_c_dbg.ll", GT, BotAABuilder);
-}
-
-TEST(BotUnionFindAATest, Context06_1) {
-  GTMap GT = {{LineColFunOp{.Line = 9,
+               {LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 21,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 9,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 12,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 13,
+               {LineColFunOp{.Line = 21,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call}}},
-              {LineColFunOp{.Line = 10,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 22,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {
-                   LineColFunOp{.Line = 10,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Alloca},
-                   LineColFunOp{.Line = 14,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 15,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 17,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Load},
-               }}};
-
-  doAnalysisAndCompareResults("context_06_1_c_dbg.ll", GT, BotAABuilder);
-}
-
-TEST(BotUnionFindAATest, Context07) {
-  GTMap GT = {
-      {LineColFunOp{.Line = 8,
-                    .Col = 0,
-                    .InFunction = "main",
-                    .OpCode = llvm::Instruction::Alloca},
-       {
-           LineColFunOp{.Line = 8,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 11,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 14,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Load},
-       }},
-      {LineColFunOp{.Line = 9,
-                    .Col = 0,
-                    .InFunction = "main",
-                    .OpCode = llvm::Instruction::Alloca},
-       {
-           LineColFunOp{.Line = 9,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 12,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-       }},
-  };
-
-  doAnalysisAndCompareResults("context_07_c_dbg.ll", GT, BotAABuilder);
-}
-
-TEST(BotUnionFindAATest, Context08) {
-  GTMap GT = {{LineColFunOp{.Line = 12,
+               {LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 23,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {
-                   LineColFunOp{.Line = 12,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Alloca},
-                   LineColFunOp{.Line = 15,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 19,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 21,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Load},
-               }}};
-
-  doAnalysisAndCompareResults("context_08_c_dbg.ll", GT, BotAABuilder);
+               {LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_02_c_dbg.ll", GT, ContextAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context09_0) {
-  GTMap GT = {{LineColFunOp{.Line = 12,
+TEST(CtxSensUnionFindAATest, Indirection03) {
+  GTMap GT = {{LineColFunOp{.Line = 13,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 12,
+               {LineColFunOp{.Line = 13,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 15,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 15,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 15,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call}}},
-              {LineColFunOp{.Line = 13,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 18,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 13,
+               {LineColFunOp{.Line = 18,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 16,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 19,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 19,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 18,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 21,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 21,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load}}}};
-
-  doAnalysisAndCompareResults("context_09_0_c_dbg.ll", GT, BotAABuilder);
-}
-
-TEST(BotUnionFindAATest, Context09_1) {
-  GTMap GT = {{LineColFunOp{.Line = 12,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 22,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 12,
+               {LineColFunOp{.Line = 22,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 15,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 23,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 23,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 17,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 24,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 24,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call}}},
-              {LineColFunOp{.Line = 13,
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_03_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Indirection04) {
+  GTMap GT = {{LineColFunOp{.Line = 18,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 13,
+               {LineColFunOp{.Line = 18,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 18,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 20,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 20,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 20,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 22,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 22,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 22,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 25,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 25,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load}}}};
-
-  doAnalysisAndCompareResults("context_09_1_c_dbg.ll", GT, BotAABuilder);
-}
-
-TEST(BotUnionFindAATest, Context10_0) {
-  GTMap GT = {{LineColFunOp{.Line = 24,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 26,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 24,
+               {LineColFunOp{.Line = 26,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 26,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 27,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 27,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 30,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 29,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 29,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 32,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 30,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 30,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load}}}};
-
-  doAnalysisAndCompareResults("context_10_0_c_dbg.ll", GT, BotAABuilder);
-}
-
-TEST(BotUnionFindAATest, Context10_1) {
-  GTMap GT = {
-      {LineColFunOp{.Line = 24,
-                    .Col = 0,
-                    .InFunction = "main",
-                    .OpCode = llvm::Instruction::Alloca},
-       {
-           LineColFunOp{.Line = 24,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 27,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 29,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 35,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Load},
-       }},
-      {LineColFunOp{.Line = 25,
-                    .Col = 0,
-                    .InFunction = "main",
-                    .OpCode = llvm::Instruction::Alloca},
-       {
-           LineColFunOp{.Line = 25,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 31,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 33,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-       }},
-  };
-
-  doAnalysisAndCompareResults("context_10_1_c_dbg.ll", GT, BotAABuilder);
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 31,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 31,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 32,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 33,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 34,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_04_c_dbg.ll", GT, ContextAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context11_0) {
-  GTMap GT{{LineColFunOp{.Line = 33,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {
-                LineColFunOp{.Line = 33,
+TEST(CtxSensUnionFindAATest, Indirection05) {
+  GTMap GT = {{LineColFunOp{.Line = 23,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 23,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 36,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 25,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 25,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 39,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 27,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 27,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load},
-                LineColFunOp{.Line = 39,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 29,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 29,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load},
-            }},
-           {LineColFunOp{.Line = 34,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {
-                LineColFunOp{.Line = 34,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 32,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 32,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 37,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 33,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 33,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-            }}};
-
-  doAnalysisAndCompareResults("context_11_0_c_dbg.ll", GT, BotAABuilder);
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 34,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 35,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 35,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 37,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 37,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 38,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 38,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 39,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 40,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 40,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 41,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 41,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 42,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 42,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 43,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 43,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 44,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 44,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_05_c_dbg.ll", GT, ContextAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context11_1) {
-  GTMap GT{{LineColFunOp{.Line = 33,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 33,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 36,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 37,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 41,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Load}}},
-           {LineColFunOp{.Line = 34,
+TEST(CtxSensUnionFindAATest, Indirection06) {
+  GTMap GT = {{LineColFunOp{.Line = 28,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 28,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 30,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 32,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 34,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 36,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 36,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 39,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 40,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 40,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 41,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 41,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 42,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 42,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 43,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 43,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 45,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 45,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 46,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 46,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 47,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 47,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 48,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 48,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 49,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 49,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 50,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 50,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 51,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 51,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 52,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 52,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 53,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 53,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 54,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 54,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_06_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Indirection07) {
+  GTMap GT = {{LineColFunOp{.Line = 33,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 35,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 35,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 37,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 37,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 39,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 41,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 41,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 43,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 43,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 46,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 46,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 47,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 47,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 48,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 48,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 49,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 49,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 50,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 50,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 51,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 51,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 53,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 53,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 54,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 54,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 55,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 55,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 56,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 56,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 57,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 57,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 58,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 58,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 59,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 59,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 60,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 60,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 61,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 61,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 62,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 62,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 63,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 63,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 64,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 64,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_07_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Indirection08) {
+  GTMap GT = {{LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 16,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 16,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_08_cpp_dbg.ll", GT,
+                              ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Indirection09) {
+  GTMap GT = {{LineColFunOp{.Line = 19,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 19,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 23,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_09_cpp_dbg.ll", GT,
+                              ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Indirection10) {
+  GTMap GT = {{LineColFunOp{.Line = 20,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 23,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_10_cpp_dbg.ll", GT,
+                              ContextAABuilder);
+}
+
+TEST(BotUnionFindAATest, Basic01) {
+  /*
+
+  */
+  GTMap GT = {{LineColFunOp{.Line = 4,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 4,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("basic_01_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(BotUnionFindAATest, Basic02) {
+  /*
+
+  */
+  GTMap GT = {{LineColFunOp{.Line = 4,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 4,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("basic_02_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(BotUnionFindAATest, Basic03) {
+  /*
+
+  */
+  GTMap GT = {{LineColFunOp{.Line = 5,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 5,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("basic_03_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(BotUnionFindAATest, Basic04) {
+  /*
+   */
+  GTMap GT = {{LineColFunOp{.Line = 5,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 5,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 6,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+               }}};
+
+  doAnalysisAndCompareResults("basic_04_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context01) {
+  GTMap GT = {
+      {LineColFunOp{.Line = 5,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 5,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 8,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 11,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Load},
+       }},
+      {LineColFunOp{.Line = 6,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 6,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 9,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+       }},
+  };
+
+  doAnalysisAndCompareResults("context_01_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context02) {
+  GTMap GT = {
+      {LineColFunOp{.Line = 6,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 6,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 9,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 10,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 14,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Load},
+       }},
+      {LineColFunOp{.Line = 7,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 7,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 11,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 12,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+       }},
+  };
+
+  doAnalysisAndCompareResults("context_02_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context03) {
+  GTMap GT = {{LineColFunOp{.Line = 6,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 6,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_03_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context04_0) {
+  GTMap GT = {{LineColFunOp{.Line = 7,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 7,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_04_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context04_1) {
+  GTMap GT = {{LineColFunOp{.Line = 7,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 7,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 15,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_04_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context05_0) {
+  GTMap GT = {{LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 13,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_05_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context05_1) {
+  GTMap GT = {{LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 16,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_05_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context06_0) {
+  GTMap GT = {{LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 14,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_06_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context06_1) {
+  GTMap GT = {{LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}},
+              {LineColFunOp{.Line = 10,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 14,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 15,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 17,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_06_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context07) {
+  GTMap GT = {
+      {LineColFunOp{.Line = 8,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 8,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 11,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 14,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Load},
+       }},
+      {LineColFunOp{.Line = 9,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 9,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 12,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+       }},
+  };
+
+  doAnalysisAndCompareResults("context_07_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context08) {
+  GTMap GT = {{LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 15,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 19,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 21,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }}};
+
+  doAnalysisAndCompareResults("context_08_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context09_0) {
+  GTMap GT = {{LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}},
+              {LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 16,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}}};
+
+  doAnalysisAndCompareResults("context_09_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context09_1) {
+  GTMap GT = {{LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 17,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call}}},
+              {LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}}};
+
+  doAnalysisAndCompareResults("context_09_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context10_0) {
+  GTMap GT = {{LineColFunOp{.Line = 24,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 24,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 26,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}}};
+
+  doAnalysisAndCompareResults("context_10_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context10_1) {
+  GTMap GT = {
+      {LineColFunOp{.Line = 24,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 24,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 27,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 29,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 35,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Load},
+       }},
+      {LineColFunOp{.Line = 25,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {
+           LineColFunOp{.Line = 25,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Alloca},
+           LineColFunOp{.Line = 31,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+           LineColFunOp{.Line = 33,
+                        .Col = 0,
+                        .InFunction = "main",
+                        .OpCode = llvm::Instruction::Call},
+       }},
+  };
+
+  doAnalysisAndCompareResults("context_10_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context11_0) {
+  GTMap GT{{LineColFunOp{.Line = 33,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 36,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+            }},
+           {LineColFunOp{.Line = 34,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 37,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+            }}};
+
+  doAnalysisAndCompareResults("context_11_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context11_1) {
+  GTMap GT{{LineColFunOp{.Line = 33,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 33,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 36,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 37,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 41,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 34,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 34,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 38,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 39,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_11_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context12_0) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 13,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+
+           {LineColFunOp{.Line = 6,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 10,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_12_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context12_1) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 6,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}}};
+
+  doAnalysisAndCompareResults("context_12_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context13_0) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 10,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 17,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}},
+           {LineColFunOp{.Line = 6,
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 34,
+            {LineColFunOp{.Line = 6,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 38,
+             LineColFunOp{.Line = 12,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 39,
+             LineColFunOp{.Line = 13,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 14,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 15,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Call}}}};
 
-  doAnalysisAndCompareResults("context_11_1_c_dbg.ll", GT, BotAABuilder);
+  doAnalysisAndCompareResults("context_13_0_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Context13_1) {
+  GTMap GT{{LineColFunOp{.Line = 5,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 5,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call}}},
+           {LineColFunOp{.Line = 6,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 6,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Load}}}};
+
+  doAnalysisAndCompareResults("context_13_1_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Indirection01) {
+  GTMap GT = {{LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 11,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_01_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Indirection02) {
+  GTMap GT = {{LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 11,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 14,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 15,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 20,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 21,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 22,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 23,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_02_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Indirection03) {
+  GTMap GT = {{LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 15,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 18,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 19,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 19,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 21,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 22,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 23,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 24,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 24,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_03_c_dbg.ll", GT, BotAABuilder);
+}
+
+TEST(BotUnionFindAATest, Indirection04) {
+  GTMap GT = {{LineColFunOp{.Line = 18,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 20,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 22,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 25,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 25,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 26,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 26,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 27,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 27,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 29,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 29,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 30,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 31,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 31,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 32,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 33,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 34,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_04_c_dbg.ll", GT, BotAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context12_0) {
-  GTMap GT{{LineColFunOp{.Line = 5,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 5,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 8,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 9,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 13,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Load}}},
-
-           {LineColFunOp{.Line = 6,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 6,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 10,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 11,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call}}}};
+TEST(BotUnionFindAATest, Indirection05) {
+  GTMap GT = {{LineColFunOp{.Line = 23,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 25,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 25,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 27,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 27,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 29,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 29,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 32,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 33,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 34,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 35,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 35,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 37,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 37,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 38,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 38,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 39,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 40,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 40,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 41,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 41,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 42,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 42,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 43,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 43,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 44,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 44,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_05_c_dbg.ll", GT, BotAABuilder);
+}
 
-  doAnalysisAndCompareResults("context_12_0_c_dbg.ll", GT, BotAABuilder);
+TEST(BotUnionFindAATest, Indirection06) {
+  GTMap GT = {{LineColFunOp{.Line = 28,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 28,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 30,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 32,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 34,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 36,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 36,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 39,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 40,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 40,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 41,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 41,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 42,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 42,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 43,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 43,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 45,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 45,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 46,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 46,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 47,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 47,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 48,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 48,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 49,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 49,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 50,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 50,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 51,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 51,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 52,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 52,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 53,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 53,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 54,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 54,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_06_c_dbg.ll", GT, BotAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context12_1) {
-  GTMap GT{{LineColFunOp{.Line = 5,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 5,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 8,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 11,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Load}}},
-           {LineColFunOp{.Line = 6,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 6,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 9,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call}}}};
-
-  doAnalysisAndCompareResults("context_12_1_c_dbg.ll", GT, BotAABuilder);
+TEST(BotUnionFindAATest, Indirection07) {
+  GTMap GT = {{LineColFunOp{.Line = 33,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 35,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 35,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 37,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 37,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 39,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 41,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 41,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 43,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 43,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 46,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 46,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 47,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 47,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 48,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 48,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 49,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 49,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 50,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 50,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 51,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 51,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 53,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 53,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 54,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 54,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 55,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 55,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 56,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 56,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 57,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 57,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 58,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 58,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 59,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 59,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 60,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 60,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 61,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 61,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 62,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 62,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 63,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 63,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 64,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 64,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_07_c_dbg.ll", GT, BotAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context13_0) {
-  GTMap GT{{LineColFunOp{.Line = 5,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 5,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 8,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 9,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 10,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 11,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 17,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Load}}},
-           {LineColFunOp{.Line = 6,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 6,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 12,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 13,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 14,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 15,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call}}}};
-
-  doAnalysisAndCompareResults("context_13_0_c_dbg.ll", GT, BotAABuilder);
+TEST(BotUnionFindAATest, Indirection08) {
+  GTMap GT = {{LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 16,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 16,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_08_cpp_dbg.ll", GT, BotAABuilder);
 }
 
-TEST(BotUnionFindAATest, Context13_1) {
-  GTMap GT{{LineColFunOp{.Line = 5,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 5,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 8,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call}}},
-           {LineColFunOp{.Line = 6,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 6,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 9,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 11,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Load}}}};
+TEST(BotUnionFindAATest, Indirection09) {
+  GTMap GT = {{LineColFunOp{.Line = 19,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 19,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 23,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_09_cpp_dbg.ll", GT, BotAABuilder);
+}
 
-  doAnalysisAndCompareResults("context_13_1_c_dbg.ll", GT, BotAABuilder);
+TEST(BotUnionFindAATest, Indirection10) {
+  GTMap GT = {{LineColFunOp{.Line = 19,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 19,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 23,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_10_cpp_dbg.ll", GT, BotAABuilder);
 }
 
 // IndirectionSensUnionFindAA Tests
@@ -1968,38 +3690,32 @@ TEST(IndirectionSensUnionFindAATest, Basic02) {
 }
 
 TEST(IndirectionSensUnionFindAATest, Basic03) {
-  GTMap GT = {{LineColFunOp{.Line = 4,
+  GTMap GT = {{LineColFunOp{.Line = 5,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {
-                   LineColFunOp{.Line = 4,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Alloca},
-                   LineColFunOp{.Line = 6,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Load},
-               }}};
+               {LineColFunOp{.Line = 5,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("basic_03_c_dbg.ll", GT, IndAABuilder);
 }
 
 TEST(IndirectionSensUnionFindAATest, Basic04) {
-  GTMap GT = {{LineColFunOp{.Line = 4,
+  GTMap GT = {{LineColFunOp{.Line = 5,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
                {
-                   LineColFunOp{.Line = 4,
+                   LineColFunOp{.Line = 5,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Alloca},
                    LineColFunOp{.Line = 6,
                                 .Col = 0,
                                 .InFunction = "main",
-                                .OpCode = llvm::Instruction::Load},
+                                .OpCode = llvm::Instruction::Alloca},
                }}};
 
   doAnalysisAndCompareResults("basic_04_c_dbg.ll", GT, IndAABuilder);
@@ -7302,7 +9018,7 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
 
 TEST(IndirectionSensUnionFindAATest, Indirection08) {
   /*
-ValueCompressor: {
+  ValueCompressor: {
   #0:
     @_ZTV3Foo = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
 x ptr] [ptr null, ptr @_ZTI3Foo, ptr @_ZN3Foo4FuncEv] }, comdat, align 8,
@@ -7326,506 +9042,229 @@ align 1, !psr.id !6 | ID: 6 #9:
     @_ZTVN10__cxxabiv120__si_class_type_infoE = external global ptr, !psr.id !5
 | ID: 5 #10: %retval = alloca i32, align 4, !psr.id !24 | ID: 8 #11: %First =
 alloca %class.Foo, align 8, !psr.id !25 | ID: 9 #12: %Second = alloca
-%class.Bar, align 8, !psr.id !26 | ID: 10 #13: %x = alloca i32, align 4, !psr.id
-!27 | ID: 11 #14: %y = alloca i32, align 4, !psr.id !28 | ID: 12 #15: ptr %this
-| ID: _ZN3FooC2Ev.0 #16: ptr %this | ID: _ZN3BarC2Ev.0 #17: ptr %this | ID:
-_ZN3Foo4FuncEv.0 #18: ptr %this | ID: _ZN3Bar4FuncEv.0 #19: %this.addr = alloca
-ptr, align 8, !psr.id !74 | ID: 27 #20: %this1 = load ptr, ptr %this.addr, align
-8, !psr.id !80 | ID: 30 #21: %this.addr = alloca ptr, align 8, !psr.id !88 | ID:
-33 #22: %this1 = load ptr, ptr %this.addr, align 8, !psr.id !94 | ID: 36 #23:
-    %this.addr = alloca ptr, align 8, !psr.id !100 | ID: 40
-  #24:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !105 | ID: 43
-  #25:
-    %this.addr = alloca ptr, align 8, !psr.id !109 | ID: 45
-  #26:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !114 | ID: 48
-}
-LLVMUnionFindAliasSet(global, botctx-ind-sens) {
-  #0: {0, 5}
-  #1: {1, 2, 3, 4, 6, 7, 8, 9}
-  #2: {1, 2, 3, 4, 6, 7, 8, 9}
-  #3: {1, 2, 3, 4, 6, 7, 8, 9}
-  #4: {1, 2, 3, 4, 6, 7, 8, 9}
-  #5: {0, 5}
-  #6: {1, 2, 3, 4, 6, 7, 8, 9}
-  #7: {1, 2, 3, 4, 6, 7, 8, 9}
-  #8: {1, 2, 3, 4, 6, 7, 8, 9}
-  #9: {1, 2, 3, 4, 6, 7, 8, 9}
-  #10: {10}
-  #11: {11, 12, 15, 16, 17, 18, 20, 22, 24, 26}
-  #12: {11, 12, 15, 16, 17, 18, 20, 22, 24, 26}
-  #13: {13}
-  #14: {14}
-  #15: {11, 12, 15, 16, 17, 18, 20, 22, 24, 26}
-  #16: {11, 12, 15, 16, 17, 18, 20, 22, 24, 26}
-  #17: {11, 12, 15, 16, 17, 18, 20, 22, 24, 26}
-  #18: {11, 12, 15, 16, 17, 18, 20, 22, 24, 26}
-  #19: {19}
-  #20: {11, 12, 15, 16, 17, 18, 20, 22, 24, 26}
-  #21: {21}
-  #22: {11, 12, 15, 16, 17, 18, 20, 22, 24, 26}
-  #23: {23}
-  #24: {11, 12, 15, 16, 17, 18, 20, 22, 24, 26}
-  #25: {25}
-  #26: {11, 12, 15, 16, 17, 18, 20, 22, 24, 26}
-}
-  */
-  GTMap GT{{LineColFunOp{.Line = 13,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {
-                LineColFunOp{.Line = 13,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 14,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 16,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 17,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-            }},
-           {LineColFunOp{.Line = 16,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 16,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca}}},
-           {LineColFunOp{.Line = 17,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 17,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca}}}};
-
-  doAnalysisAndCompareResults("indirection_08_cpp_dbg.ll", GT, IndAABuilder);
-}
-
-TEST(IndirectionSensUnionFindAATest, Indirection09) {
-  /*
-ValueCompressor: {
-  #0:
-    @_ZTV3Foo = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
-x ptr] [ptr null, ptr @_ZTI3Foo, ptr @_ZN3Foo4FuncEv] }, comdat, align 8,
-!psr.id !0 | ID: 0 #1:
-    @_ZTI3Foo = linkonce_odr dso_local constant { ptr, ptr } { ptr getelementptr
-inbounds (ptr, ptr @_ZTVN10__cxxabiv117__class_type_infoE, i64 2), ptr @_ZTS3Foo
-}, comdat, align 8, !psr.id !3 | ID: 3 #2: fun @_ZN3Foo4FuncEv #3:
-    @_ZTS3Foo = linkonce_odr dso_local constant [5 x i8] c"3Foo\00", comdat,
-align 1, !psr.id !2 | ID: 2 #4:
-    @_ZTVN10__cxxabiv117__class_type_infoE = external global ptr, !psr.id !1 |
-ID: 1 #5:
-    @_ZTV3Bar = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
-x ptr] [ptr null, ptr @_ZTI3Bar, ptr @_ZN3Bar4FuncEv] }, comdat, align 8,
-!psr.id !4 | ID: 4 #6:
-    @_ZTI3Bar = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
-getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
-2), ptr @_ZTS3Bar, ptr @_ZTI3Foo }, comdat, align 8, !psr.id !7 | ID: 7 #7: fun
-@_ZN3Bar4FuncEv #8:
-    @_ZTS3Bar = linkonce_odr dso_local constant [5 x i8] c"3Bar\00", comdat,
-align 1, !psr.id !6 | ID: 6 #9:
-    @_ZTVN10__cxxabiv120__si_class_type_infoE = external global ptr, !psr.id !5
-| ID: 5 #10:
-    @_ZTV3Baz = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
-x ptr] [ptr null, ptr @_ZTI3Baz, ptr @_ZN3Baz4FuncEv] }, comdat, align 8,
-!psr.id !8 | ID: 8 #11:
-    @_ZTI3Baz = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
-getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
-2), ptr @_ZTS3Baz, ptr @_ZTI3Bar }, comdat, align 8, !psr.id !10 | ID: 10 #12:
-    fun @_ZN3Baz4FuncEv
-  #13:
-    @_ZTS3Baz = linkonce_odr dso_local constant [5 x i8] c"3Baz\00", comdat,
-align 1, !psr.id !9 | ID: 9 #14: %retval = alloca i32, align 4, !psr.id !27 |
-ID: 11 #15: %First = alloca %class.Foo, align 8, !psr.id !28 | ID: 12 #16:
-    %Second = alloca %class.Bar, align 8, !psr.id !29 | ID: 13
-  #17:
-    %Third = alloca %class.Baz, align 8, !psr.id !30 | ID: 14
-  #18:
-    %x = alloca i32, align 4, !psr.id !31 | ID: 15
-  #19:
-    %y = alloca i32, align 4, !psr.id !32 | ID: 16
-  #20:
-    %z = alloca i32, align 4, !psr.id !33 | ID: 17
+%class.Bar, align 8, !psr.id !26 | ID: 10 #13: %SecondAlias = alloca ptr, align
+8, !psr.id !27 | ID: 11 #14: ptr %this | ID: _ZN3FooC2Ev.0 #15: ptr %this | ID:
+_ZN3BarC2Ev.0 #16: %0 = load ptr, ptr %SecondAlias, align 8, !dbg !60, !psr.id
+!61 | ID: 21 #17: %vtable = load ptr, ptr %0, align 8, !dbg !62, !psr.id !63 |
+ID: 22 %vfn = getelementptr inbounds ptr, ptr %vtable, i64 0, !dbg !62, !psr.id
+!64 | ID: 23 #18: %1 = load ptr, ptr %vfn, align 8, !dbg !62, !psr.id !65 | ID:
+24 #19: ptr %this | ID: _ZN3Foo4FuncEv.0 #20: ptr %this | ID: _ZN3Bar4FuncEv.0
   #21:
-    ptr %this | ID: _ZN3FooC2Ev.0
+    %this.addr = alloca ptr, align 8, !psr.id !73 | ID: 27
   #22:
-    ptr %this | ID: _ZN3BarC2Ev.0
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !79 | ID: 30
   #23:
-    ptr %this | ID: _ZN3BazC2Ev.0
+    %this.addr = alloca ptr, align 8, !psr.id !87 | ID: 33
   #24:
-    ptr %this | ID: _ZN3Foo4FuncEv.0
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !93 | ID: 36
   #25:
-    ptr %this | ID: _ZN3Bar4FuncEv.0
+    %this.addr = alloca ptr, align 8, !psr.id !99 | ID: 40
   #26:
-    ptr %this | ID: _ZN3Baz4FuncEv.0
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !104 | ID: 43
   #27:
-    %this.addr = alloca ptr, align 8, !psr.id !94 | ID: 35
-  #28:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !100 | ID: 38
-  #29:
-    %this.addr = alloca ptr, align 8, !psr.id !108 | ID: 41
-  #30:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !114 | ID: 44
-  #31:
-    %this.addr = alloca ptr, align 8, !psr.id !123 | ID: 48
-  #32:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !129 | ID: 51
-  #33:
-    %this.addr = alloca ptr, align 8, !psr.id !135 | ID: 55
-  #34:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !140 | ID: 58
-  #35:
-    %this.addr = alloca ptr, align 8, !psr.id !144 | ID: 60
-  #36:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !149 | ID: 63
-  #37:
-    %this.addr = alloca ptr, align 8, !psr.id !153 | ID: 65
-  #38:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !158 | ID: 68
-}
-LLVMUnionFindAliasSet(global, botctx-ind-sens) {
-  #0: {0, 5, 10}
-  #1: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13}
-  #2: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13}
-  #3: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13}
-  #4: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13}
-  #5: {0, 5, 10}
-  #6: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13}
-  #7: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13}
-  #8: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13}
-  #9: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13}
-  #10: {0, 5, 10}
-  #11: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13}
-  #12: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13}
-  #13: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13}
-  #14: {14}
-  #15: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
-  #16: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
-  #17: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
-  #18: {18}
-  #19: {19}
-  #20: {20}
-  #21: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
-  #22: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
-  #23: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
-  #24: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
-  #25: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
-  #26: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
-  #27: {27}
-  #28: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
-  #29: {29}
-  #30: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
-  #31: {31}
-  #32: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
-  #33: {33}
-  #34: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
-  #35: {35}
-  #36: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
-  #37: {37}
-  #38: {15, 16, 17, 21, 22, 23, 24, 25, 26, 28, 30, 32, 34, 36, 38}
-}
-  */
-  GTMap GT{{LineColFunOp{.Line = 18,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {
-                LineColFunOp{.Line = 18,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 19,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 20,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 22,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 23,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 24,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-            }},
-           {LineColFunOp{.Line = 22,
+    %this.addr = alloca ptr, align 8, !psr.id !108 | ID: 45
+  #28:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !113 | ID: 48
+}
+
+LLVMUnionFindAliasSet(global, ind-sens) {
+  #0: {0, 5, 17}
+  #1: {1, 2, 3, 4, 6, 7, 8, 9, 18}
+  #2: {1, 2, 3, 4, 6, 7, 8, 9, 18}
+  #3: {1, 2, 3, 4, 6, 7, 8, 9, 18}
+  #4: {1, 2, 3, 4, 6, 7, 8, 9, 18}
+  #5: {0, 5, 17}
+  #6: {1, 2, 3, 4, 6, 7, 8, 9, 18}
+  #7: {1, 2, 3, 4, 6, 7, 8, 9, 18}
+  #8: {1, 2, 3, 4, 6, 7, 8, 9, 18}
+  #9: {1, 2, 3, 4, 6, 7, 8, 9, 18}
+  #10: {10}
+  #11: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
+  #12: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
+  #13: {13}
+  #14: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
+  #15: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
+  #16: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
+  #17: {0, 5, 17}
+  #18: {1, 2, 3, 4, 6, 7, 8, 9, 18}
+  #19: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
+  #20: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
+  #21: {21}
+  #22: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
+  #23: {23}
+  #24: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
+  #25: {25}
+  #26: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
+  #27: {27}
+  #28: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
+}
+  */
+  GTMap GT{{LineColFunOp{.Line = 13,
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 22,
-                          .Col = 0,
+            {LineColFunOp{.Line = 13,
+                          .Col = 7,
                           .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca}}},
-           {LineColFunOp{.Line = 23,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 23,
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 14,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca}}},
-           {LineColFunOp{.Line = 24,
+           {LineColFunOp{.Line = 16,
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 24,
+            {LineColFunOp{.Line = 16,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca}}}};
 
-  doAnalysisAndCompareResults("indirection_09_cpp_dbg.ll", GT, IndAABuilder);
+  doAnalysisAndCompareResults("indirection_08_cpp_dbg.ll", GT, IndAABuilder);
 }
 
-TEST(IndirectionSensUnionFindAATest, Indirection10) {
+TEST(IndirectionSensUnionFindAATest, Indirection09) {
   /*
 ValueCompressor: {
   #0:
     @_ZTV3Foo = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
 x ptr] [ptr null, ptr @_ZTI3Foo, ptr @_ZN3Foo4FuncEv] }, comdat, align 8,
-!psr.id !0 | ID: 0 #1:
+!psr.id !8 | ID: 1 #1:
     @_ZTI3Foo = linkonce_odr dso_local constant { ptr, ptr } { ptr getelementptr
 inbounds (ptr, ptr @_ZTVN10__cxxabiv117__class_type_infoE, i64 2), ptr @_ZTS3Foo
-}, comdat, align 8, !psr.id !3 | ID: 3 #2: fun @_ZN3Foo4FuncEv #3:
+}, comdat, align 8, !psr.id !11 | ID: 4 #2: fun @_ZN3Foo4FuncEv #3:
     @_ZTS3Foo = linkonce_odr dso_local constant [5 x i8] c"3Foo\00", comdat,
-align 1, !psr.id !2 | ID: 2 #4:
-    @_ZTVN10__cxxabiv117__class_type_infoE = external global ptr, !psr.id !1 |
-ID: 1 #5:
+align 1, !psr.id !10 | ID: 3 #4:
+    @_ZTVN10__cxxabiv117__class_type_infoE = external global ptr, !psr.id !9 |
+ID: 2 #5:
     @_ZTV3Bar = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
 x ptr] [ptr null, ptr @_ZTI3Bar, ptr @_ZN3Bar4FuncEv] }, comdat, align 8,
-!psr.id !4 | ID: 4 #6:
+!psr.id !12 | ID: 5 #6:
     @_ZTI3Bar = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
 getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
-2), ptr @_ZTS3Bar, ptr @_ZTI3Foo }, comdat, align 8, !psr.id !7 | ID: 7 #7: fun
+2), ptr @_ZTS3Bar, ptr @_ZTI3Foo }, comdat, align 8, !psr.id !15 | ID: 8 #7: fun
 @_ZN3Bar4FuncEv #8:
     @_ZTS3Bar = linkonce_odr dso_local constant [5 x i8] c"3Bar\00", comdat,
-align 1, !psr.id !6 | ID: 6 #9:
-    @_ZTVN10__cxxabiv120__si_class_type_infoE = external global ptr, !psr.id !5
-| ID: 5 #10:
+align 1, !psr.id !14 | ID: 7 #9:
+    @_ZTVN10__cxxabiv120__si_class_type_infoE = external global ptr, !psr.id !13
+| ID: 6 #10:
     @_ZTV3Baz = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
 x ptr] [ptr null, ptr @_ZTI3Baz, ptr @_ZN3Baz4FuncEv] }, comdat, align 8,
-!psr.id !8 | ID: 8 #11:
+!psr.id !16 | ID: 9 #11:
     @_ZTI3Baz = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
 getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
-2), ptr @_ZTS3Baz, ptr @_ZTI3Bar }, comdat, align 8, !psr.id !10 | ID: 10 #12:
+2), ptr @_ZTS3Baz, ptr @_ZTI3Bar }, comdat, align 8, !psr.id !18 | ID: 11 #12:
     fun @_ZN3Baz4FuncEv
   #13:
     @_ZTS3Baz = linkonce_odr dso_local constant [5 x i8] c"3Baz\00", comdat,
-align 1, !psr.id !9 | ID: 9 #14:
-    @_ZTV4Boar = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
-x ptr] [ptr null, ptr @_ZTI4Boar, ptr @_ZN4Boar4FuncEv] }, comdat, align 8,
-!psr.id !11 | ID: 11 #15:
-    @_ZTI4Boar = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
-getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
-2), ptr @_ZTS4Boar, ptr @_ZTI3Baz }, comdat, align 8, !psr.id !13 | ID: 13 #16:
-    fun @_ZN4Boar4FuncEv
+align 1, !psr.id !17 | ID: 10 #14: %retval = alloca i32, align 4, !psr.id !32 |
+ID: 12 #15: %First = alloca %class.Foo, align 8, !psr.id !33 | ID: 13 #16:
+    %Second = alloca %class.Bar, align 8, !psr.id !34 | ID: 14
   #17:
-    @_ZTS4Boar = linkonce_odr dso_local constant [6 x i8] c"4Boar\00", comdat,
-align 1, !psr.id !12 | ID: 12 #18: %retval = alloca i32, align 4, !psr.id !30 |
-ID: 14 #19: %First = alloca %class.Foo, align 8, !psr.id !31 | ID: 15 #20:
-    %Second = alloca %class.Bar, align 8, !psr.id !32 | ID: 16
-  #21:
-    %Third = alloca %class.Baz, align 8, !psr.id !33 | ID: 17
-  #22:
-    %Fourth = alloca %class.Boar, align 8, !psr.id !34 | ID: 18
-  #23:
-    %x = alloca i32, align 4, !psr.id !35 | ID: 19
-  #24:
-    %y = alloca i32, align 4, !psr.id !36 | ID: 20
-  #25:
-    %z = alloca i32, align 4, !psr.id !37 | ID: 21
-  #26:
-    %a = alloca i32, align 4, !psr.id !38 | ID: 22
-  #27:
+    %Third = alloca %class.Baz, align 8, !psr.id !35 | ID: 15
+  #18:
+    %FooRef = alloca ptr, align 8, !psr.id !36 | ID: 16
+  #19:
     ptr %this | ID: _ZN3FooC2Ev.0
-  #28:
+  #20:
     ptr %this | ID: _ZN3BarC2Ev.0
-  #29:
+  #21:
     ptr %this | ID: _ZN3BazC2Ev.0
-  #30:
-    ptr %this | ID: _ZN4BoarC2Ev.0
-  #31:
-    ptr %this | ID: _ZN3Foo4FuncEv.0
-  #32:
-    ptr %this | ID: _ZN3Bar4FuncEv.0
-  #33:
-    ptr %this | ID: _ZN3Baz4FuncEv.0
-  #34:
-    ptr %this | ID: _ZN4Boar4FuncEv.0
-  #35:
-    %this.addr = alloca ptr, align 8, !psr.id !120 | ID: 49
-  #36:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !126 | ID: 52
-  #37:
-    %this.addr = alloca ptr, align 8, !psr.id !134 | ID: 55
-  #38:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !140 | ID: 58
-  #39:
-    %this.addr = alloca ptr, align 8, !psr.id !149 | ID: 62
-  #40:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !155 | ID: 65
-  #41:
-    %this.addr = alloca ptr, align 8, !psr.id !164 | ID: 69
-  #42:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !170 | ID: 72
-  #43:
-    %this.addr = alloca ptr, align 8, !psr.id !176 | ID: 76
-  #44:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !181 | ID: 79
-  #45:
-    %this.addr = alloca ptr, align 8, !psr.id !185 | ID: 81
-  #46:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !190 | ID: 84
-  #47:
-    %this.addr = alloca ptr, align 8, !psr.id !194 | ID: 86
-  #48:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !199 | ID: 89
-  #49:
-    %this.addr = alloca ptr, align 8, !psr.id !203 | ID: 91
-  #50:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !208 | ID: 94
-}
-LLVMUnionFindAliasSet(global, botctx-ind-sens) {
-  #0: {0, 5, 10, 14}
-  #1: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
-  #2: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
-  #3: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
-  #4: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
-  #5: {0, 5, 10, 14}
-  #6: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
-  #7: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
-  #8: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
-  #9: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
-  #10: {0, 5, 10, 14}
-  #11: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
-  #12: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
-  #13: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
-  #14: {0, 5, 10, 14}
-  #15: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
-  #16: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
-  #17: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17}
+  #22:
+    %cond-lvalue = phi ptr [ %Second, %cond.true ], [ %Third, %cond.false ],
+!dbg !80, !psr.id !86 | ID: 33 #23: %1 = load ptr, ptr %FooRef, align 8, !dbg
+!88, !psr.id !89 | ID: 35 #24: %vtable = load ptr, ptr %1, align 8, !dbg !90,
+!psr.id !91 | ID: 36 %vfn = getelementptr inbounds ptr, ptr %vtable, i64 0, !dbg
+!90, !psr.id !92 | ID: 37 #25: %2 = load ptr, ptr %vfn, align 8, !dbg !90,
+!psr.id !93 | ID: 38 #26: ptr %this | ID: _ZN3Foo4FuncEv.0 #27: ptr %this | ID:
+_ZN3Bar4FuncEv.0 #28: ptr %this | ID: _ZN3Baz4FuncEv.0 #29: %this.addr = alloca
+ptr, align 8, !psr.id !101 | ID: 41 #30: %this1 = load ptr, ptr %this.addr,
+align 8, !psr.id !107 | ID: 44 #31: %this.addr = alloca ptr, align 8, !psr.id
+!115 | ID: 47 #32: %this1 = load ptr, ptr %this.addr, align 8, !psr.id !121 |
+ID: 50 #33: %this.addr = alloca ptr, align 8, !psr.id !130 | ID: 54 #34: %this1
+= load ptr, ptr %this.addr, align 8, !psr.id !136 | ID: 57 #35: %this.addr =
+alloca ptr, align 8, !psr.id !142 | ID: 61 #36: %this1 = load ptr, ptr
+%this.addr, align 8, !psr.id !147 | ID: 64 #37: %this.addr = alloca ptr, align
+8, !psr.id !151 | ID: 66 #38: %this1 = load ptr, ptr %this.addr, align 8,
+!psr.id !156 | ID: 69 #39: %this.addr = alloca ptr, align 8, !psr.id !160 | ID:
+71 #40: %this1 = load ptr, ptr %this.addr, align 8, !psr.id !165 | ID: 74
+}
+
+LLVMUnionFindAliasSet(global, ind-sens) {
+  #0: {0, 5, 10, 24}
+  #1: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25}
+  #2: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25}
+  #3: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25}
+  #4: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25}
+  #5: {0, 5, 10, 24}
+  #6: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25}
+  #7: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25}
+  #8: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25}
+  #9: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25}
+  #10: {0, 5, 10, 24}
+  #11: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25}
+  #12: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25}
+  #13: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25}
+  #14: {14}
+  #15: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
+  #16: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
+  #17: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
   #18: {18}
-  #19: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36, 38, 40, 42, 44, 46,
-48, 50} #20: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36, 38, 40, 42,
-44, 46, 48, 50} #21: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36, 38,
-40, 42, 44, 46, 48, 50} #22: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34,
-36, 38, 40, 42, 44, 46, 48, 50} #23: {23} #24: {24} #25: {25} #26: {26} #27:
-{19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36, 38, 40, 42, 44, 46, 48, 50}
-  #28: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36, 38, 40, 42, 44, 46,
-48, 50} #29: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36, 38, 40, 42,
-44, 46, 48, 50} #30: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36, 38,
-40, 42, 44, 46, 48, 50} #31: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34,
-36, 38, 40, 42, 44, 46, 48, 50} #32: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32,
-33, 34, 36, 38, 40, 42, 44, 46, 48, 50} #33: {19, 20, 21, 22, 27, 28, 29, 30,
-31, 32, 33, 34, 36, 38, 40, 42, 44, 46, 48, 50} #34: {19, 20, 21, 22, 27, 28,
-29, 30, 31, 32, 33, 34, 36, 38, 40, 42, 44, 46, 48, 50} #35: {35} #36: {19, 20,
-21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36, 38, 40, 42, 44, 46, 48, 50} #37:
-{37} #38: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36, 38, 40, 42, 44,
-46, 48, 50} #39: {39} #40: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36,
-38, 40, 42, 44, 46, 48, 50} #41: {41} #42: {19, 20, 21, 22, 27, 28, 29, 30, 31,
-32, 33, 34, 36, 38, 40, 42, 44, 46, 48, 50} #43: {43} #44: {19, 20, 21, 22, 27,
-28, 29, 30, 31, 32, 33, 34, 36, 38, 40, 42, 44, 46, 48, 50} #45: {45} #46: {19,
-20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36, 38, 40, 42, 44, 46, 48, 50} #47:
-{47} #48: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36, 38, 40, 42, 44,
-46, 48, 50} #49: {49} #50: {19, 20, 21, 22, 27, 28, 29, 30, 31, 32, 33, 34, 36,
-38, 40, 42, 44, 46, 48, 50}
+  #19: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
+  #20: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
+  #21: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
+  #22: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
+  #23: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
+  #24: {0, 5, 10, 24}
+  #25: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25}
+  #26: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
+  #27: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
+  #28: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
+  #29: {29}
+  #30: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
+  #31: {31}
+  #32: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
+  #33: {33}
+  #34: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
+  #35: {35}
+  #36: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
+  #37: {37}
+  #38: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
+  #39: {39}
+  #40: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
 }
   */
-  GTMap GT{{LineColFunOp{.Line = 23,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {
-                LineColFunOp{.Line = 23,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 24,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 25,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 26,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 28,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 29,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 30,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 31,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-            }},
-           {LineColFunOp{.Line = 28,
+  GTMap GT{{LineColFunOp{.Line = 19,
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 28,
+            {LineColFunOp{.Line = 19,
                           .Col = 0,
                           .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca}}},
-           {LineColFunOp{.Line = 29,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 29,
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 20,
                           .Col = 0,
                           .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca}}},
-           {LineColFunOp{.Line = 30,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 30,
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 21,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca}}},
-           {LineColFunOp{.Line = 31,
+           {LineColFunOp{.Line = 23,
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 31,
+            {LineColFunOp{.Line = 23,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca}}}};
 
-  doAnalysisAndCompareResults("indirection_10_cpp_dbg.ll", GT, IndAABuilder);
+  doAnalysisAndCompareResults("indirection_09_cpp_dbg.ll", GT, IndAABuilder);
 }
 
-TEST(IndirectionSensUnionFindAATest, Indirection11) {
+TEST(IndirectionSensUnionFindAATest, Indirection10) {
   /*
-ValueCompressor: {
+  ValueCompressor: {
   #0:
     @_ZTV3Foo = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
 x ptr] [ptr null, ptr @_ZTI3Foo, ptr @_ZN3Foo4FuncEv] }, comdat, align 8,
@@ -7847,269 +9286,86 @@ getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
     @_ZTS3Bar = linkonce_odr dso_local constant [5 x i8] c"3Bar\00", comdat,
 align 1, !psr.id !6 | ID: 6 #9:
     @_ZTVN10__cxxabiv120__si_class_type_infoE = external global ptr, !psr.id !5
-| ID: 5 #10:
-    @_ZTV3Baz = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
-x ptr] [ptr null, ptr @_ZTI3Baz, ptr @_ZN3Baz4FuncEv] }, comdat, align 8,
-!psr.id !8 | ID: 8 #11:
-    @_ZTI3Baz = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
-getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
-2), ptr @_ZTS3Baz, ptr @_ZTI3Bar }, comdat, align 8, !psr.id !10 | ID: 10 #12:
-    fun @_ZN3Baz4FuncEv
-  #13:
-    @_ZTS3Baz = linkonce_odr dso_local constant [5 x i8] c"3Baz\00", comdat,
-align 1, !psr.id !9 | ID: 9 #14:
-    @_ZTV4Boar = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
-x ptr] [ptr null, ptr @_ZTI4Boar, ptr @_ZN4Boar4FuncEv] }, comdat, align 8,
-!psr.id !11 | ID: 11 #15:
-    @_ZTI4Boar = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
-getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
-2), ptr @_ZTS4Boar, ptr @_ZTI3Baz }, comdat, align 8, !psr.id !13 | ID: 13 #16:
-    fun @_ZN4Boar4FuncEv
-  #17:
-    @_ZTS4Boar = linkonce_odr dso_local constant [6 x i8] c"4Boar\00", comdat,
-align 1, !psr.id !12 | ID: 12 #18:
-    @_ZTV3Far = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
-x ptr] [ptr null, ptr @_ZTI3Far, ptr @_ZN3Far4FuncEv] }, comdat, align 8,
-!psr.id !14 | ID: 14 #19:
-    @_ZTI3Far = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
-getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
-2), ptr @_ZTS3Far, ptr @_ZTI4Boar }, comdat, align 8, !psr.id !16 | ID: 16 #20:
-    fun @_ZN3Far4FuncEv
+| ID: 5 #10: %retval = alloca i32, align 4, !psr.id !24 | ID: 8 #11: %First =
+alloca %class.Foo, align 8, !psr.id !25 | ID: 9 #12: %Second = alloca
+%class.Bar, align 8, !psr.id !26 | ID: 10 #13: %SecondAlias = alloca ptr, align
+8, !psr.id !27 | ID: 11 #14: ptr %this | ID: _ZN3FooC2Ev.0 #15: ptr %this | ID:
+_ZN3BarC2Ev.0 #16: %0 = load ptr, ptr %SecondAlias, align 8, !dbg !62, !psr.id
+!63 | ID: 21 #17: %vtable = load ptr, ptr %0, align 8, !dbg !64, !psr.id !65 |
+ID: 22 %vfn = getelementptr inbounds ptr, ptr %vtable, i64 0, !dbg !64, !psr.id
+!66 | ID: 23 #18: %1 = load ptr, ptr %vfn, align 8, !dbg !64, !psr.id !67 | ID:
+24 #19: ptr %this | ID: _ZN3Bar4FuncEv.0 #20: ptr %this | ID: _ZN3Foo4FuncEv.0
   #21:
-    @_ZTS3Far = linkonce_odr dso_local constant [5 x i8] c"3Far\00", comdat,
-align 1, !psr.id !15 | ID: 15 #22: %retval = alloca i32, align 4, !psr.id !33 |
-ID: 17 #23: %First = alloca %class.Foo, align 8, !psr.id !34 | ID: 18 #24:
-    %Second = alloca %class.Bar, align 8, !psr.id !35 | ID: 19
+    %this.addr = alloca ptr, align 8, !psr.id !75 | ID: 27
+  #22:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !80 | ID: 30
+  #23:
+    %this.addr = alloca ptr, align 8, !psr.id !88 | ID: 33
+  #24:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !94 | ID: 36
   #25:
-    %Third = alloca %class.Baz, align 8, !psr.id !36 | ID: 20
+    %this.addr = alloca ptr, align 8, !psr.id !100 | ID: 40
   #26:
-    %Fourth = alloca %class.Boar, align 8, !psr.id !37 | ID: 21
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !105 | ID: 43
   #27:
-    %Fifth = alloca %class.Far, align 8, !psr.id !38 | ID: 22
+    %this.addr = alloca ptr, align 8, !psr.id !109 | ID: 45
   #28:
-    %x = alloca i32, align 4, !psr.id !39 | ID: 23
-  #29:
-    %y = alloca i32, align 4, !psr.id !40 | ID: 24
-  #30:
-    %z = alloca i32, align 4, !psr.id !41 | ID: 25
-  #31:
-    %a = alloca i32, align 4, !psr.id !42 | ID: 26
-  #32:
-    %b = alloca i32, align 4, !psr.id !43 | ID: 27
-  #33:
-    ptr %this | ID: _ZN3FooC2Ev.0
-  #34:
-    ptr %this | ID: _ZN3BarC2Ev.0
-  #35:
-    ptr %this | ID: _ZN3BazC2Ev.0
-  #36:
-    ptr %this | ID: _ZN4BoarC2Ev.0
-  #37:
-    ptr %this | ID: _ZN3FarC2Ev.0
-  #38:
-    ptr %this | ID: _ZN3Foo4FuncEv.0
-  #39:
-    ptr %this | ID: _ZN3Bar4FuncEv.0
-  #40:
-    ptr %this | ID: _ZN3Baz4FuncEv.0
-  #41:
-    ptr %this | ID: _ZN4Boar4FuncEv.0
-  #42:
-    ptr %this | ID: _ZN3Far4FuncEv.0
-  #43:
-    %this.addr = alloca ptr, align 8, !psr.id !143 | ID: 60
-  #44:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !149 | ID: 63
-  #45:
-    %this.addr = alloca ptr, align 8, !psr.id !157 | ID: 66
-  #46:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !163 | ID: 69
-  #47:
-    %this.addr = alloca ptr, align 8, !psr.id !172 | ID: 73
-  #48:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !178 | ID: 76
-  #49:
-    %this.addr = alloca ptr, align 8, !psr.id !187 | ID: 80
-  #50:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !193 | ID: 83
-  #51:
-    %this.addr = alloca ptr, align 8, !psr.id !202 | ID: 87
-  #52:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !208 | ID: 90
-  #53:
-    %this.addr = alloca ptr, align 8, !psr.id !214 | ID: 94
-  #54:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !219 | ID: 97
-  #55:
-    %this.addr = alloca ptr, align 8, !psr.id !223 | ID: 99
-  #56:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !228 | ID: 102
-  #57:
-    %this.addr = alloca ptr, align 8, !psr.id !232 | ID: 104
-  #58:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !237 | ID: 107
-  #59:
-    %this.addr = alloca ptr, align 8, !psr.id !241 | ID: 109
-  #60:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !246 | ID: 112
-  #61:
-    %this.addr = alloca ptr, align 8, !psr.id !250 | ID: 114
-  #62:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !255 | ID: 117
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !114 | ID: 48
 }
-LLVMUnionFindAliasSet(global, botctx-ind-sens) {
-  #0: {0, 5, 10, 14, 18}
-  #1: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
-  #2: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
-  #3: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
-  #4: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
-  #5: {0, 5, 10, 14, 18}
-  #6: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
-  #7: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
-  #8: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
-  #9: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
-  #10: {0, 5, 10, 14, 18}
-  #11: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
-  #12: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
-  #13: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
-  #14: {0, 5, 10, 14, 18}
-  #15: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
-  #16: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
-  #17: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
-  #18: {0, 5, 10, 14, 18}
-  #19: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
-  #20: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
-  #21: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19, 20, 21}
-  #22: {22}
-  #23: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46, 48,
-50, 52, 54, 56, 58, 60, 62} #24: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38,
-39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62} #25: {23, 24, 25, 26,
-27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60,
-62} #26: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46,
-48, 50, 52, 54, 56, 58, 60, 62} #27: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37,
-38, 39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62} #28: {28} #29: {29}
-  #30: {30}
-  #31: {31}
-  #32: {32}
-  #33: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46, 48,
-50, 52, 54, 56, 58, 60, 62} #34: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38,
-39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62} #35: {23, 24, 25, 26,
-27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60,
-62} #36: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46,
-48, 50, 52, 54, 56, 58, 60, 62} #37: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37,
-38, 39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62} #38: {23, 24, 25,
-26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58,
-60, 62} #39: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44,
-46, 48, 50, 52, 54, 56, 58, 60, 62} #40: {23, 24, 25, 26, 27, 33, 34, 35, 36,
-37, 38, 39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62} #41: {23, 24,
-25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56,
-58, 60, 62} #42: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
-44, 46, 48, 50, 52, 54, 56, 58, 60, 62} #43: {43} #44: {23, 24, 25, 26, 27, 33,
-34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62} #45:
-{45} #46: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46,
-48, 50, 52, 54, 56, 58, 60, 62} #47: {47} #48: {23, 24, 25, 26, 27, 33, 34, 35,
-36, 37, 38, 39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62} #49: {49}
-  #50: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46, 48,
-50, 52, 54, 56, 58, 60, 62} #51: {51} #52: {23, 24, 25, 26, 27, 33, 34, 35, 36,
-37, 38, 39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62} #53: {53} #54:
-{23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46, 48, 50, 52,
-54, 56, 58, 60, 62} #55: {55} #56: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38,
-39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62} #57: {57} #58: {23, 24,
-25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56,
-58, 60, 62} #59: {59} #60: {23, 24, 25, 26, 27, 33, 34, 35, 36, 37, 38, 39, 40,
-41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62} #61: {61} #62: {23, 24, 25, 26,
-27, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60,
-62}
+LLVMUnionFindAliasSet(global, ind-sens) {
+  #0: {0, 5, 17}
+  #1: {1, 2, 3, 4, 6, 7, 8, 9, 18}
+  #2: {1, 2, 3, 4, 6, 7, 8, 9, 18}
+  #3: {1, 2, 3, 4, 6, 7, 8, 9, 18}
+  #4: {1, 2, 3, 4, 6, 7, 8, 9, 18}
+  #5: {0, 5, 17}
+  #6: {1, 2, 3, 4, 6, 7, 8, 9, 18}
+  #7: {1, 2, 3, 4, 6, 7, 8, 9, 18}
+  #8: {1, 2, 3, 4, 6, 7, 8, 9, 18}
+  #9: {1, 2, 3, 4, 6, 7, 8, 9, 18}
+  #10: {10}
+  #11: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
+  #12: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
+  #13: {13}
+  #14: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
+  #15: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
+  #16: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
+  #17: {0, 5, 17}
+  #18: {1, 2, 3, 4, 6, 7, 8, 9, 18}
+  #19: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
+  #20: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
+  #21: {21}
+  #22: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
+  #23: {23}
+  #24: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
+  #25: {25}
+  #26: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
+  #27: {27}
+  #28: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
 }
   */
-  GTMap GT{{LineColFunOp{.Line = 28,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {
-                LineColFunOp{.Line = 28,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 29,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 30,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 31,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 32,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 34,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 35,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 36,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 37,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 38,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-            }},
-           {LineColFunOp{.Line = 34,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 34,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca}}},
-           {LineColFunOp{.Line = 35,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 35,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca}}},
-           {LineColFunOp{.Line = 36,
+  GTMap GT{{LineColFunOp{.Line = 20,
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 36,
+            {LineColFunOp{.Line = 20,
                           .Col = 0,
                           .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca}}},
-           {LineColFunOp{.Line = 37,
-                         .Col = 0,
-                         .InFunction = "main",
-                         .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 37,
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 21,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca}}},
-           {LineColFunOp{.Line = 38,
+           {LineColFunOp{.Line = 23,
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 38,
+            {LineColFunOp{.Line = 23,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca}}}};
 
-  doAnalysisAndCompareResults("indirection_11_cpp_dbg.ll", GT, IndAABuilder);
+  doAnalysisAndCompareResults("indirection_10_cpp_dbg.ll", GT, IndAABuilder);
 }
 
 } // namespace

From 25c0bed14b8cfc0c22957d87003ed857e0ed2605 Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Wed, 18 Feb 2026 19:58:13 +0100
Subject: [PATCH 48/75] fixed some unittests

---
 .../Pointer/LLVMUnionFindAATest.cpp           | 355 ++++++------------
 1 file changed, 114 insertions(+), 241 deletions(-)

diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index 6a843da60c..c1dbf774c5 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -91,6 +91,19 @@ void doAnalysisAndCompareResults(
   UnionFindAAResult auto Results =
       computeUnionFindAARaw(IRDB, AABuilder(IRDB, BaseCG), &VC);
 
+  for (const auto &[PtrVar, ExpectedAliasVars] : ExpectedResults) {
+    const auto PtrId = asId(VC, IRDB, PtrVar);
+    const auto ExpectedAliasIds = asIdBased(VC, IRDB, ExpectedAliasVars);
+    const RawAliasSet<ValueId> &ComputedAliasIds =
+        Results.getRawAliasSet(PtrId);
+
+    ComputedAliasIds.foreach ([&](ValueId VId) {
+      llvm::outs() << "PtrVar: " << PtrVar
+                   << " - stringifyVal(VC, VId): " << stringifyVal(VC, VId)
+                   << "\n";
+    });
+  }
+
   for (const auto &[PtrVar, ExpectedAliasVars] : ExpectedResults) {
     const auto PtrId = asId(VC, IRDB, PtrVar);
     const auto ExpectedAliasIds = asIdBased(VC, IRDB, ExpectedAliasVars);
@@ -1947,9 +1960,32 @@ TEST(CtxSensUnionFindAATest, Indirection10) {
 
 TEST(BotUnionFindAATest, Basic01) {
   /*
-
+ValueCompressor: {
+  #0:
+    %i = alloca i32, align 4, !psr.id !16 | ID: 0
+  #1:
+    %p = alloca ptr, align 8, !psr.id !17 | ID: 1
+  #2:
+    %0 = load ptr, ptr %p, align 8, !dbg !26, !psr.id !27 | ID: 5
+}
+UnionFindAAResult {
+  #0: <0, 2>
+  #1: <1>
+}
   */
-  GTMap GT = {{LineColFunOp{.Line = 4,
+  GTMap GT = {{LineColFunOp{.Line = 3,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 3,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 5,
+                             .Col = 4,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 4,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
@@ -1963,13 +1999,49 @@ TEST(BotUnionFindAATest, Basic01) {
 
 TEST(BotUnionFindAATest, Basic02) {
   /*
-
+ValueCompressor: {
+  #0:
+    %i = alloca i32, align 4, !psr.id !16 | ID: 0
+  #1:
+    %p = alloca ptr, align 8, !psr.id !17 | ID: 1
+  #2:
+    %q = alloca ptr, align 8, !psr.id !18 | ID: 2
+  #3:
+    %0 = load ptr, ptr %q, align 8, !dbg !32, !psr.id !33 | ID: 8
+  #4:
+    %1 = load ptr, ptr %0, align 8, !dbg !34, !psr.id !35 | ID: 9
+}
+UnionFindAAResult {
+  #0: <0, 1, 3, 4>
+  #1: <2>
+}
+  TODO: ask fabian why #1: <1> and #2: <2> are not here
   */
-  GTMap GT = {{LineColFunOp{.Line = 4,
+  GTMap GT = {{LineColFunOp{.Line = 3,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 4,
+               {LineColFunOp{.Line = 3,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 4,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 6,
+                             .Col = 5,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 4,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 3,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 4,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca}}}};
@@ -1995,21 +2067,45 @@ TEST(BotUnionFindAATest, Basic03) {
 
 TEST(BotUnionFindAATest, Basic04) {
   /*
+
+ValueCompressor: {
+  #0:
+    %retval = alloca i32, align 4, !psr.id !19 | ID: 1
+  #1:
+    %FuncPtr = alloca ptr, align 8, !psr.id !20 | ID: 2
+  #2:
+    %FuncPtr2 = alloca ptr, align 8, !psr.id !21 | ID: 3
+  #3:
+    fun @Func
+  #4:
+    %0 = load ptr, ptr %FuncPtr2, align 8, !dbg !37, !psr.id !38 | ID: 9
+  #5:
+    %1 = load ptr, ptr %0, align 8, !dbg !39, !psr.id !40 | ID: 10
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <1, 3, 4, 5>
+  #2: <2>
+}
+
+TODO: ask fabian how to get { fun @Func }
    */
   GTMap GT = {{LineColFunOp{.Line = 5,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {
-                   LineColFunOp{.Line = 5,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Alloca},
-                   LineColFunOp{.Line = 6,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Alloca},
-               }}};
+               {LineColFunOp{.Line = 5,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 6,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 6,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("basic_04_c_dbg.ll", GT, ContextAABuilder);
 }
@@ -7700,12 +7796,6 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
   #12: {1, 3, 6, 11, 12, 13, 14}
   #13: {1, 3, 6, 11, 12, 13, 14}
   #14: {1, 3, 6, 11, 12, 13, 14}
-}
-
-  TODO: ask Fabian if the output of the analysis is correct here/what the GT
-should look like. Unittest fails, but I think GT should be correct.
-Also, is it necessary to include the Bar alloca (+ the others) as a stand-alone
-with the same aliases as Foo?
 }
   */
   GTMap GT{{LineColFunOp{.Line = 8,
@@ -7721,10 +7811,6 @@ with the same aliases as Foo?
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 14,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
                 LineColFunOp{.Line = 15,
                              .Col = 0,
                              .InFunction = "main",
@@ -7850,18 +7936,6 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 15,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 18,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 19,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
                 LineColFunOp{.Line = 21,
                              .Col = 0,
                              .InFunction = "main",
@@ -8010,38 +8084,10 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 20,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 22,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 25,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 26,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 27,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
                 LineColFunOp{.Line = 29,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Load},
-                LineColFunOp{.Line = 30,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load},
-                LineColFunOp{.Line = 31,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load},
                 LineColFunOp{.Line = 32,
                              .Col = 0,
                              .InFunction = "main",
@@ -8050,10 +8096,6 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Load},
-                LineColFunOp{.Line = 34,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load},
             }},
            {LineColFunOp{.Line = 29,
                          .Col = 0,
@@ -8225,34 +8267,6 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 25,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 27,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 29,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 32,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 33,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 34,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 35,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
                 LineColFunOp{.Line = 37,
                              .Col = 0,
                              .InFunction = "main",
@@ -8261,30 +8275,10 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Load},
-                LineColFunOp{.Line = 39,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load},
-                LineColFunOp{.Line = 40,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load},
                 LineColFunOp{.Line = 41,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Load},
-                LineColFunOp{.Line = 42,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load},
-                LineColFunOp{.Line = 43,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load},
-                LineColFunOp{.Line = 44,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load},
             }},
            {LineColFunOp{.Line = 37,
                          .Col = 0,
@@ -8499,42 +8493,6 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 30,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 32,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 34,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 36,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 39,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 40,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 41,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 42,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 43,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
                 LineColFunOp{.Line = 45,
                              .Col = 0,
                              .InFunction = "main",
@@ -8543,18 +8501,6 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Load},
-                LineColFunOp{.Line = 47,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load},
-                LineColFunOp{.Line = 48,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load},
-                LineColFunOp{.Line = 49,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load},
                 LineColFunOp{.Line = 50,
                              .Col = 0,
                              .InFunction = "main",
@@ -8563,18 +8509,6 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Load},
-                LineColFunOp{.Line = 52,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load},
-                LineColFunOp{.Line = 53,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load},
-                LineColFunOp{.Line = 54,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load},
             }},
            {LineColFunOp{.Line = 45,
                          .Col = 0,
@@ -8820,6 +8754,9 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
   #41: {7, 35, 41}
   #42: {9, 36, 42}
 }
+
+  TODO: ask Fabian about the Bar alloca here. Is this correct?
+
   */
   GTMap GT{{LineColFunOp{.Line = 33,
                          .Col = 0,
@@ -8834,46 +8771,6 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 37,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 39,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 41,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 43,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 46,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 47,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 48,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 49,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 50,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 51,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
                 LineColFunOp{.Line = 53,
                              .Col = 0,
                              .InFunction = "main",
@@ -8886,18 +8783,6 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Load},
-                LineColFunOp{.Line = 56,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load},
-                LineColFunOp{.Line = 57,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load},
-                LineColFunOp{.Line = 58,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load},
                 LineColFunOp{.Line = 59,
                              .Col = 0,
                              .InFunction = "main",
@@ -8910,18 +8795,6 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Load},
-                LineColFunOp{.Line = 62,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load},
-                LineColFunOp{.Line = 63,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load},
-                LineColFunOp{.Line = 64,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load},
             }},
            {LineColFunOp{.Line = 53,
                          .Col = 0,

From 3d8ccfc504e911b0ff2087e05ded72607dc42de4 Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Fri, 20 Feb 2026 11:35:07 +0100
Subject: [PATCH 49/75] fixed half of ctx-sens Context tests

---
 .../Pointer/LLVMUnionFindAATest.cpp           | 1612 ++++++++++++++---
 1 file changed, 1316 insertions(+), 296 deletions(-)

diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index c1dbf774c5..8acec649e8 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -289,23 +289,24 @@ TEST(CtxSensUnionFindAATest, Basic03) {
 
 TEST(CtxSensUnionFindAATest, Basic04) {
   /*
-  ValueCompressor:
+ValueCompressor: {
+  #0:
+    %retval = alloca i32, align 4, !psr.id !19 | ID: 1
   #1:
-    @"_ZTIZ4mainE3$_0" = internal constant { ptr, ptr } { ptr getelementptr
-  inbounds (ptr, ptr @_ZTVN10__cxxabiv117__class_type_infoE, i64 2), ptr
-  @"_ZTSZ4mainE3$_0" }, align 8, !psr.id !2 | ID: 2
-  #11:
-    %0 = load ptr, ptr %FuncPtr, align 8, !dbg !415, !psr.id !416 | ID: 13
-  #46:
-    %3 = extractvalue { ptr, i32 } %2, 0, !dbg !538, !psr.id !550 | ID: 76
-
-LLVMUnionFindAliasSet(global, botctx-ind-sens) {
-  #0: {0}
-  #1: {1, 3, 4, 5}
-  #2: {2}
-  #3: {1, 3, 4, 5}
-  #4: {1, 3, 4, 5}
-  #5: {1, 3, 4, 5}
+    %FuncPtr = alloca ptr, align 8, !psr.id !20 | ID: 2
+  #2:
+    %FuncPtr2 = alloca ptr, align 8, !psr.id !21 | ID: 3
+  #3:
+    fun @Func
+  #4:
+    %0 = load ptr, ptr %FuncPtr2, align 8, !dbg !37, !psr.id !38 | ID: 9
+  #5:
+    %1 = load ptr, ptr %0, align 8, !dbg !39, !psr.id !40 | ID: 10
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <1, 3, 4, 5>
+  #2: <2>
 }
   */
   GTMap GT = {{LineColFunOp{.Line = 5,
@@ -327,177 +328,648 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
 }
 
 TEST(CtxSensUnionFindAATest, Context01) {
-  GTMap GT = {
-      {LineColFunOp{.Line = 5,
-                    .Col = 0,
-                    .InFunction = "main",
-                    .OpCode = llvm::Instruction::Alloca},
-       {
-           LineColFunOp{.Line = 5,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 8,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 11,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Load},
-           ArgInFun{.Idx = 0, .InFunction = "id"},
-       }},
-      {LineColFunOp{.Line = 6,
-                    .Col = 0,
-                    .InFunction = "main",
-                    .OpCode = llvm::Instruction::Alloca},
-       {
-           LineColFunOp{.Line = 6,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 9,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           ArgInFun{.Idx = 0, .InFunction = "id"},
-       }},
-      {ArgInFun{.Idx = 0, .InFunction = "id"},
-       {
-           LineColFunOp{.Line = 5,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 6,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 8,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 9,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 11,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Load},
-           ArgInFun{.Idx = 0, .InFunction = "id"},
-       }},
-  };
+  /*
+ValueCompressor: {
+  #0:
+    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    ptr %p | ID: id.0
+  #2:
+    %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
+  #3:
+    fun @id.<ret>
+  #4:
+    %retval = alloca i32, align 4, !psr.id !29 | ID: 5
+  #5:
+    %x = alloca i32, align 4, !psr.id !30 | ID: 6
+  #6:
+    %y = alloca i32, align 4, !psr.id !31 | ID: 7
+  #7:
+    %xx = alloca ptr, align 8, !psr.id !32 | ID: 8
+  #8:
+    %yy = alloca ptr, align 8, !psr.id !33 | ID: 9
+  #9:
+    %call = call ptr @id(ptr noundef %x), !dbg !46, !psr.id !47 | ID: 16
+  #10:
+    %call1 = call ptr @id(ptr noundef %y), !dbg !52, !psr.id !53 | ID: 19
+  #11:
+    %0 = load ptr, ptr %xx, align 8, !dbg !55, !psr.id !56 | ID: 21
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <0>
+  #2: <1, 2, 3, 5, 9, 11>
+  #3: <1, 2, 3, 6, 10>
+  #4: <4>
+  #5: <7>
+  #6: <8>
+}
+  */
+  GTMap GT = {{LineColFunOp{.Line = 5,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {ArgInFun{.Idx = 0, .InFunction = "id"},
+                LineColFunOp{.Line = 2,
+                             .Col = 26,
+                             .InFunction = "id",
+                             .OpCode = llvm::Instruction::Load},
+                RetVal{.InFunction = "id"},
+                LineColFunOp{.Line = 5,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 6,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "id"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 26,
+                                .InFunction = "id",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id"},
+                   LineColFunOp{.Line = 6,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   ArgInFun{.Idx = 0, .InFunction = "id"},
+               }},
+              {LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
   doAnalysisAndCompareResults("context_01_c_dbg.ll", GT, ContextAABuilder);
 }
 
 TEST(CtxSensUnionFindAATest, Context02) {
-  GTMap GT = {
-      {LineColFunOp{.Line = 6,
-                    .Col = 0,
-                    .InFunction = "main",
-                    .OpCode = llvm::Instruction::Alloca},
-       {
-           LineColFunOp{.Line = 6,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 9,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 10,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 14,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Load},
-       }},
-      {LineColFunOp{.Line = 7,
-                    .Col = 0,
-                    .InFunction = "main",
-                    .OpCode = llvm::Instruction::Alloca},
-       {
-           LineColFunOp{.Line = 7,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 11,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 12,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-       }},
-  };
-
-  doAnalysisAndCompareResults("context_02_c_dbg.ll", GT, ContextAABuilder);
+  /*
+ValueCompressor: {
+  #0:
+    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    ptr %p | ID: id1.0
+  #2:
+    %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
+  #3:
+    fun @id1.<ret>
+  #4:
+    %q.addr = alloca ptr, align 8, !psr.id !27 | ID: 5
+  #5:
+    ptr %q | ID: id2.0
+  #6:
+    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 8
+  #7:
+    fun @id2.<ret>
+  #8:
+    %retval = alloca i32, align 4, !psr.id !39 | ID: 10
+  #9:
+    %x = alloca i32, align 4, !psr.id !40 | ID: 11
+  #10:
+    %y = alloca i32, align 4, !psr.id !41 | ID: 12
+  #11:
+    %xx1 = alloca ptr, align 8, !psr.id !42 | ID: 13
+  #12:
+    %xx2 = alloca ptr, align 8, !psr.id !43 | ID: 14
+  #13:
+    %yy1 = alloca ptr, align 8, !psr.id !44 | ID: 15
+  #14:
+    %yy2 = alloca ptr, align 8, !psr.id !45 | ID: 16
+  #15:
+    %call = call ptr @id1(ptr noundef %x), !dbg !58, !psr.id !59 | ID: 23
+  #16:
+    %call1 = call ptr @id1(ptr noundef %x), !dbg !64, !psr.id !65 | ID: 26
+  #17:
+    %call2 = call ptr @id2(ptr noundef %y), !dbg !70, !psr.id !71 | ID: 29
+  #18:
+    %call3 = call ptr @id2(ptr noundef %y), !dbg !76, !psr.id !77 | ID: 32
+  #19:
+    %0 = load ptr, ptr %xx1, align 8, !dbg !79, !psr.id !80 | ID: 34
 }
-
-TEST(CtxSensUnionFindAATest, Context03) {
+UnionFindAAResult {
+  #0: <0>
+  #1: <0>
+  #2: <1, 2, 3, 9, 15, 16, 19>
+  #3: <4>
+  #4: <4>
+  #5: <5, 6, 7, 10, 17, 18>
+  #6: <8>
+  #7: <11>
+  #8: <12>
+  #9: <13>
+  #10: <14>
+}
+  */
   GTMap GT = {{LineColFunOp{.Line = 6,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
                {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 27,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
                    LineColFunOp{.Line = 6,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 14,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 7,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 27,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id2"},
+                   LineColFunOp{.Line = 7,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+               }},
+              {LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 10,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 10,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 11,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_02_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context03) {
+  /*
+ValueCompressor: {
+  #0:
+    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    ptr %p | ID: id1.0
+  #2:
+    %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
+  #3:
+    fun @id1.<ret>
+  #4:
+    %q.addr = alloca ptr, align 8, !psr.id !27 | ID: 5
+  #5:
+    ptr %q | ID: id2.0
+  #6:
+    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 8
+  #7:
+    %call = call ptr @id1(ptr noundef %0), !dbg !34, !psr.id !35 | ID: 9
+  #8:
+    fun @id2.<ret>
+  #9:
+    %retval = alloca i32, align 4, !psr.id !41 | ID: 11
+  #10:
+    %x = alloca i32, align 4, !psr.id !42 | ID: 12
+  #11:
+    %xx1 = alloca ptr, align 8, !psr.id !43 | ID: 13
+  #12:
+    %xx2 = alloca ptr, align 8, !psr.id !44 | ID: 14
+  #13:
+    %call = call ptr @id2(ptr noundef %x), !dbg !53, !psr.id !54 | ID: 19
+  #14:
+    %call1 = call ptr @id2(ptr noundef %x), !dbg !59, !psr.id !60 | ID: 22
+  #15:
+    %0 = load ptr, ptr %xx1, align 8, !dbg !62, !psr.id !63 | ID: 24
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <1, 2, 3, 5, 6, 7, 8, 10, 13, 14, 15>
+  #2: <4>
+  #3: <4>
+  #4: <9>
+  #5: <11>
+  #6: <12>
+}
+  */
+  GTMap GT = {{LineColFunOp{.Line = 6,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 0,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 0,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 3,
+                                .Col = 31,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id2"},
+                   LineColFunOp{.Line = 6,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 11,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 8,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_03_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context04_0) {
+  GTMap GT = {{LineColFunOp{.Line = 7,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 0,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 0,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 3,
+                                .Col = 31,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id2"},
+                   ArgInFun{.Idx = 0, .InFunction = "id3"},
+                   LineColFunOp{.Line = 4,
+                                .Col = 0,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 4,
+                                .Col = 31,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id3"},
+                   LineColFunOp{.Line = 7,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 9,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 10,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
+               }},
+              {LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 10,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 10,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_04_0_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context04_1) {
+  /*
+  ValueCompressor: {
+  #0:
+    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    ptr %p | ID: id1.0
+  #2:
+    %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
+  #3:
+    fun @id1.<ret>
+  #4:
+    %q.addr = alloca ptr, align 8, !psr.id !27 | ID: 5
+  #5:
+    ptr %q | ID: id2.0
+  #6:
+    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 8
+  #7:
+    %call = call ptr @id1(ptr noundef %0), !dbg !34, !psr.id !35 | ID: 9
+  #8:
+    fun @id2.<ret>
+  #9:
+    %r.addr = alloca ptr, align 8, !psr.id !39 | ID: 11
+  #10:
+    ptr %r | ID: id3.0
+  #11:
+    %0 = load ptr, ptr %r.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
+  #12:
+    %call = call ptr @id2(ptr noundef %0), !dbg !46, !psr.id !47 | ID: 15
+  #13:
+    fun @id3.<ret>
+  #14:
+    %retval = alloca i32, align 4, !psr.id !53 | ID: 17
+  #15:
+    %x = alloca i32, align 4, !psr.id !54 | ID: 18
+  #16:
+    %y = alloca i32, align 4, !psr.id !55 | ID: 19
+  #17:
+    %xx1 = alloca ptr, align 8, !psr.id !56 | ID: 20
+  #18:
+    %xx2 = alloca ptr, align 8, !psr.id !57 | ID: 21
+  #19:
+    %yy1 = alloca ptr, align 8, !psr.id !58 | ID: 22
+  #20:
+    %yy2 = alloca ptr, align 8, !psr.id !59 | ID: 23
+  #21:
+    %call = call ptr @id3(ptr noundef %x), !dbg !72, !psr.id !73 | ID: 30
+  #22:
+    %call1 = call ptr @id3(ptr noundef %x), !dbg !78, !psr.id !79 | ID: 33
+  #23:
+    %call2 = call ptr @id3(ptr noundef %y), !dbg !84, !psr.id !85 | ID: 36
+  #24:
+    %call3 = call ptr @id3(ptr noundef %y), !dbg !90, !psr.id !91 | ID: 39
+  #25:
+    %0 = load ptr, ptr %xx1, align 8, !dbg !93, !psr.id !94 | ID: 41
+}
+LLVMUnionFindAliasSet(global, ctx-sens) {
+  #0: {0}
+  #1: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
+  #2: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
+  #3: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
+  #4: {4}
+  #5: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
+  #6: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
+  #7: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
+  #8: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
+  #9: {9}
+  #10: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
+  #11: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
+  #12: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
+  #13: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
+  #14: {14}
+  #15: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
+  #16: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
+  #17: {17}
+  #18: {18}
+  #19: {19}
+  #20: {20}
+  #21: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
+  #22: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
+  #23: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
+  #24: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
+  #25: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
+}
+  */
+  GTMap GT = {{LineColFunOp{.Line = 7,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 0,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 0,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 3,
+                                .Col = 31,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id2"},
+                   ArgInFun{.Idx = 0, .InFunction = "id3"},
+                   LineColFunOp{.Line = 4,
+                                .Col = 0,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 4,
+                                .Col = 31,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id3"},
+                   LineColFunOp{.Line = 7,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
                    LineColFunOp{.Line = 8,
                                 .Col = 0,
                                 .InFunction = "main",
-                                .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 9,
+                                .OpCode = llvm::Instruction::Alloca},
+                   LineColFunOp{.Line = 10,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Call},
                    LineColFunOp{.Line = 11,
                                 .Col = 0,
                                 .InFunction = "main",
-                                .OpCode = llvm::Instruction::Load},
-               }}};
-
-  doAnalysisAndCompareResults("context_03_c_dbg.ll", GT, ContextAABuilder);
-}
-
-TEST(CtxSensUnionFindAATest, Context04_0) {
-  GTMap GT = {{LineColFunOp{.Line = 7,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {
-                   LineColFunOp{.Line = 7,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Alloca},
-                   LineColFunOp{.Line = 9,
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 10,
+                   LineColFunOp{.Line = 13,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 12,
+                   LineColFunOp{.Line = 15,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Load},
-               }}};
+               }},
+              {LineColFunOp{.Line = 10,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 10,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 11,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
 
-  doAnalysisAndCompareResults("context_04_0_c_dbg.ll", GT, ContextAABuilder);
+  doAnalysisAndCompareResults("context_04_1_c_dbg.ll", GT, ContextAABuilder);
 }
 
-TEST(CtxSensUnionFindAATest, Context04_1) {
-  GTMap GT = {{LineColFunOp{.Line = 7,
+TEST(CtxSensUnionFindAATest, Context05_0) {
+  GTMap GT = {{LineColFunOp{.Line = 8,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
                {
-                   LineColFunOp{.Line = 7,
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 0,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 0,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 3,
+                                .Col = 31,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id2"},
+                   ArgInFun{.Idx = 0, .InFunction = "id3"},
+                   LineColFunOp{.Line = 4,
+                                .Col = 0,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 4,
+                                .Col = 31,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id3"},
+                   ArgInFun{.Idx = 0, .InFunction = "id4"},
+                   LineColFunOp{.Line = 5,
+                                .Col = 0,
+                                .InFunction = "id4",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 5,
+                                .Col = 31,
+                                .InFunction = "id4",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id4"},
+                   LineColFunOp{.Line = 8,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Alloca},
@@ -509,65 +981,191 @@ TEST(CtxSensUnionFindAATest, Context04_1) {
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 15,
+                   LineColFunOp{.Line = 13,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Load},
                }},
-              {LineColFunOp{.Line = 8,
+              {LineColFunOp{.Line = 10,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 8,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 12,
+               {LineColFunOp{.Line = 10,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 13,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 11,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 11,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call}}}};
+                             .OpCode = llvm::Instruction::Alloca}}}};
 
-  doAnalysisAndCompareResults("context_04_1_c_dbg.ll", GT, ContextAABuilder);
+  doAnalysisAndCompareResults("context_05_0_c_dbg.ll", GT, ContextAABuilder);
 }
 
-TEST(CtxSensUnionFindAATest, Context05_0) {
+TEST(CtxSensUnionFindAATest, Context05_1) {
   GTMap GT = {{LineColFunOp{.Line = 8,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
                {
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 0,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 0,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 3,
+                                .Col = 31,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id2"},
+                   ArgInFun{.Idx = 0, .InFunction = "id3"},
+                   LineColFunOp{.Line = 4,
+                                .Col = 0,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 4,
+                                .Col = 31,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id3"},
+                   ArgInFun{.Idx = 0, .InFunction = "id4"},
+                   LineColFunOp{.Line = 5,
+                                .Col = 0,
+                                .InFunction = "id4",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 5,
+                                .Col = 31,
+                                .InFunction = "id4",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id4"},
                    LineColFunOp{.Line = 8,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Alloca},
-                   LineColFunOp{.Line = 10,
+                   LineColFunOp{.Line = 9,
                                 .Col = 0,
                                 .InFunction = "main",
-                                .OpCode = llvm::Instruction::Call},
+                                .OpCode = llvm::Instruction::Alloca},
                    LineColFunOp{.Line = 11,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 12,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
                    LineColFunOp{.Line = 13,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 14,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 16,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Load},
-               }}};
+               }},
+              {LineColFunOp{.Line = 11,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 14,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
 
-  doAnalysisAndCompareResults("context_05_0_c_dbg.ll", GT, ContextAABuilder);
+  doAnalysisAndCompareResults("context_05_1_c_dbg.ll", GT, ContextAABuilder);
 }
 
-TEST(CtxSensUnionFindAATest, Context05_1) {
-  GTMap GT = {{LineColFunOp{.Line = 8,
+TEST(CtxSensUnionFindAATest, Context06_0) {
+  GTMap GT = {{LineColFunOp{.Line = 9,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
                {
-                   LineColFunOp{.Line = 8,
+                   ArgInFun{.Idx = 0, .InFunction = "id1"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 0,
+                                .InFunction = "id1",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id1"},
+                   ArgInFun{.Idx = 0, .InFunction = "id2"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 0,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 3,
+                                .Col = 31,
+                                .InFunction = "id2",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id2"},
+                   ArgInFun{.Idx = 0, .InFunction = "id3"},
+                   LineColFunOp{.Line = 4,
+                                .Col = 0,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 4,
+                                .Col = 31,
+                                .InFunction = "id3",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id3"},
+                   ArgInFun{.Idx = 0, .InFunction = "id4"},
+                   LineColFunOp{.Line = 5,
+                                .Col = 0,
+                                .InFunction = "id4",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 5,
+                                .Col = 31,
+                                .InFunction = "id4",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id4"},
+                   ArgInFun{.Idx = 0, .InFunction = "id5"},
+                   LineColFunOp{.Line = 6,
+                                .Col = 0,
+                                .InFunction = "id5",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 6,
+                                .Col = 31,
+                                .InFunction = "id5",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "id5"},
+                   LineColFunOp{.Line = 9,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Alloca},
@@ -579,19 +1177,94 @@ TEST(CtxSensUnionFindAATest, Context05_1) {
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 16,
+                   LineColFunOp{.Line = 14,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Load},
                }},
-              {LineColFunOp{.Line = 9,
+              {LineColFunOp{.Line = 11,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 9,
+               {LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_06_0_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context06_1) {
+  GTMap GT = {{LineColFunOp{.Line = 9,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {ArgInFun{.Idx = 0, .InFunction = "id1"},
+                LineColFunOp{.Line = 2,
+                             .Col = 0,
+                             .InFunction = "id1",
+                             .OpCode = llvm::Instruction::Load},
+                RetVal{.InFunction = "id1"},
+                ArgInFun{.Idx = 0, .InFunction = "id2"},
+                LineColFunOp{.Line = 3,
+                             .Col = 0,
+                             .InFunction = "id2",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 3,
+                             .Col = 31,
+                             .InFunction = "id2",
+                             .OpCode = llvm::Instruction::Load},
+                RetVal{.InFunction = "id2"},
+                ArgInFun{.Idx = 0, .InFunction = "id3"},
+                LineColFunOp{.Line = 4,
+                             .Col = 0,
+                             .InFunction = "id3",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 4,
+                             .Col = 31,
+                             .InFunction = "id3",
+                             .OpCode = llvm::Instruction::Load},
+                RetVal{.InFunction = "id3"},
+                ArgInFun{.Idx = 0, .InFunction = "id4"},
+                LineColFunOp{.Line = 5,
+                             .Col = 0,
+                             .InFunction = "id4",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 5,
+                             .Col = 31,
+                             .InFunction = "id4",
+                             .OpCode = llvm::Instruction::Load},
+                RetVal{.InFunction = "id4"},
+                ArgInFun{.Idx = 0, .InFunction = "id5"},
+                LineColFunOp{.Line = 6,
+                             .Col = 0,
+                             .InFunction = "id5",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 6,
+                             .Col = 31,
+                             .InFunction = "id5",
+                             .OpCode = llvm::Instruction::Load},
+                RetVal{.InFunction = "id5"},
+                LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 10,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
                 LineColFunOp{.Line = 13,
                              .Col = 0,
                              .InFunction = "main",
@@ -599,17 +1272,97 @@ TEST(CtxSensUnionFindAATest, Context05_1) {
                 LineColFunOp{.Line = 14,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call}}}};
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Call},
+                LineColFunOp{.Line = 17,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 12,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 14,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 15,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
 
-  doAnalysisAndCompareResults("context_05_1_c_dbg.ll", GT, ContextAABuilder);
+  doAnalysisAndCompareResults("context_06_1_c_dbg.ll", GT, ContextAABuilder);
 }
 
-TEST(CtxSensUnionFindAATest, Context06_0) {
-  GTMap GT = {{LineColFunOp{.Line = 9,
+TEST(CtxSensUnionFindAATest, Context07) {
+  GTMap GT = {{LineColFunOp{.Line = 8,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
                {
+                   ArgInFun{.Idx = 0, .InFunction = "buzz"},
+                   LineColFunOp{.Line = 2,
+                                .Col = 0,
+                                .InFunction = "buzz",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "buzz"},
+                   ArgInFun{.Idx = 0, .InFunction = "baz"},
+                   LineColFunOp{.Line = 3,
+                                .Col = 0,
+                                .InFunction = "baz",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 3,
+                                .Col = 32,
+                                .InFunction = "baz",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "baz"},
+                   ArgInFun{.Idx = 0, .InFunction = "bar"},
+                   LineColFunOp{.Line = 4,
+                                .Col = 0,
+                                .InFunction = "bar",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 4,
+                                .Col = 31,
+                                .InFunction = "bar",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "bar"},
+                   ArgInFun{.Idx = 0, .InFunction = "foo"},
+                   LineColFunOp{.Line = 5,
+                                .Col = 0,
+                                .InFunction = "foo",
+                                .OpCode = llvm::Instruction::Call},
+                   LineColFunOp{.Line = 5,
+                                .Col = 31,
+                                .InFunction = "foo",
+                                .OpCode = llvm::Instruction::Load},
+                   RetVal{.InFunction = "foo"},
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Alloca},
                    LineColFunOp{.Line = 9,
                                 .Col = 0,
                                 .InFunction = "main",
@@ -626,99 +1379,121 @@ TEST(CtxSensUnionFindAATest, Context06_0) {
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Load},
-               }}};
-
-  doAnalysisAndCompareResults("context_06_0_c_dbg.ll", GT, ContextAABuilder);
-}
-
-TEST(CtxSensUnionFindAATest, Context06_1) {
-  GTMap GT = {{LineColFunOp{.Line = 9,
+               }},
+              {LineColFunOp{.Line = 11,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 9,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 12,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 13,
+               {LineColFunOp{.Line = 11,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call}}},
-              {LineColFunOp{.Line = 10,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 12,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {
-                   LineColFunOp{.Line = 10,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Alloca},
-                   LineColFunOp{.Line = 14,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 15,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Call},
-                   LineColFunOp{.Line = 17,
-                                .Col = 0,
-                                .InFunction = "main",
-                                .OpCode = llvm::Instruction::Load},
-               }}};
+               {LineColFunOp{.Line = 12,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
 
-  doAnalysisAndCompareResults("context_06_1_c_dbg.ll", GT, ContextAABuilder);
+  doAnalysisAndCompareResults("context_07_c_dbg.ll", GT, ContextAABuilder);
 }
 
-TEST(CtxSensUnionFindAATest, Context07) {
-  GTMap GT = {
-      {LineColFunOp{.Line = 8,
-                    .Col = 0,
-                    .InFunction = "main",
-                    .OpCode = llvm::Instruction::Alloca},
-       {
-           LineColFunOp{.Line = 8,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 11,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-           LineColFunOp{.Line = 14,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Load},
-       }},
-      {LineColFunOp{.Line = 9,
-                    .Col = 0,
-                    .InFunction = "main",
-                    .OpCode = llvm::Instruction::Alloca},
-       {
-           LineColFunOp{.Line = 9,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Alloca},
-           LineColFunOp{.Line = 12,
-                        .Col = 0,
-                        .InFunction = "main",
-                        .OpCode = llvm::Instruction::Call},
-       }},
-  };
-
-  doAnalysisAndCompareResults("context_07_c_dbg.ll", GT, ContextAABuilder);
+TEST(CtxSensUnionFindAATest, Context08) {
+  /*
+  ValueCompressor: {
+  #0:
+    %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
+  #2:
+    ptr %Ptr | ID: selfRecursion.0
+  #3:
+    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
+    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
+    %3 = load ptr, ptr %Ptr.addr, align 8, !dbg !38, !psr.id !39 | ID: 11
+    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
+    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !48, !psr.id !49 | ID: 16
+  #4:
+    %call = call ptr @selfRecursion(ptr noundef %6), !dbg !50, !psr.id !51 | ID:
+17
+  #5: fun @selfRecursion.<ret>
+  #6: %7 = load ptr, ptr %retval, align 8, !dbg
+!55, !psr.id !56 | ID: 20
+  #7: %retval = alloca i32, align 4, !psr.id !61 | ID:
+22
+  #8: %k = alloca i32, align 4, !psr.id !62 | ID: 23
+  #9: %kptr = alloca ptr,
+align 8, !psr.id !63 | ID: 24
+  #10: %x = alloca ptr, align 8, !psr.id !64 | ID:
+25
+  #11: %y = alloca ptr, align 8, !psr.id !65 | ID: 26
+  #12: %0 = load ptr, ptr
+%kptr, align 8, !dbg !78, !psr.id !79 | ID: 33 %1 = load ptr, ptr %kptr, align
+8, !dbg !88, !psr.id !89 | ID: 38
+  #13: %call = call ptr @selfRecursion(ptr
+noundef %0), !dbg !80, !psr.id !81 | ID: 34
+  #14: %call1 = call ptr
+@selfRecursion(ptr noundef %1), !dbg !90, !psr.id !91 | ID: 39
+  #15: %2 = load
+ptr, ptr %x, align 8, !dbg !93, !psr.id !94 | ID: 41
 }
-
-TEST(CtxSensUnionFindAATest, Context08) {
+UnionFindAAResult {
+  #0: <0>
+  #1: <0>
+  #2: <0>
+  #3: <1>
+  #4: <1>
+  #5: <1>
+  #6: <2, 3, 4, 5, 6, 8, 12, 13, 14, 15>
+  #7: <7>
+  #8: <9>
+  #9: <10>
+  #10: <11>
+}
+LLVMUnionFindAliasSet(global, ctx-sens) {
+  #0: {0}
+  #1: {1}
+  #2: {2, 3, 4, 5, 6, 8, 12, 13, 14, 15}
+  #3: {2, 3, 4, 5, 6, 8, 12, 13, 14, 15}
+  #4: {2, 3, 4, 5, 6, 8, 12, 13, 14, 15}
+  #5: {2, 3, 4, 5, 6, 8, 12, 13, 14, 15}
+  #6: {2, 3, 4, 5, 6, 8, 12, 13, 14, 15}
+  #7: {7}
+  #8: {2, 3, 4, 5, 6, 8, 12, 13, 14, 15}
+  #9: {9}
+  #10: {10}
+  #11: {11}
+  #12: {2, 3, 4, 5, 6, 8, 12, 13, 14, 15}
+  #13: {2, 3, 4, 5, 6, 8, 12, 13, 14, 15}
+  #14: {2, 3, 4, 5, 6, 8, 12, 13, 14, 15}
+  #15: {2, 3, 4, 5, 6, 8, 12, 13, 14, 15}
+}
+  */
   GTMap GT = {{LineColFunOp{.Line = 12,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
                {
+                   ArgInFun{.Idx = 0, .InFunction = "selfRecursion"},
+                   LineColFunOp{.Line = 4,
+                                .Col = 0,
+                                .InFunction = "selfRecursion",
+                                .OpCode = llvm::Instruction::Load},
+                   LineColFunOp{.Line = 7,
+                                .Col = 0,
+                                .InFunction = "selfRecursion",
+                                .OpCode = llvm::Instruction::Load},
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "selfRecursion",
+                                .OpCode = llvm::Instruction::Load},
+                   LineColFunOp{.Line = 8,
+                                .Col = 0,
+                                .InFunction = "selfRecursion",
+                                .OpCode = llvm::Instruction::Call},
+                   RetVal{.InFunction = "selfRecursion"},
                    LineColFunOp{.Line = 12,
                                 .Col = 0,
                                 .InFunction = "main",
@@ -735,81 +1510,322 @@ TEST(CtxSensUnionFindAATest, Context08) {
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Load},
-               }}};
-
-  doAnalysisAndCompareResults("context_08_c_dbg.ll", GT, ContextAABuilder);
-}
-
-TEST(CtxSensUnionFindAATest, Context09_0) {
-  GTMap GT = {{LineColFunOp{.Line = 12,
+               }},
+              {LineColFunOp{.Line = 13,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 12,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 15,
+               {LineColFunOp{.Line = 13,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call}}},
-              {LineColFunOp{.Line = 13,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 15,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 13,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 16,
+               {LineColFunOp{.Line = 15,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 18,
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 19,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 19,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load}}}};
+                             .OpCode = llvm::Instruction::Alloca}}}};
 
-  doAnalysisAndCompareResults("context_09_0_c_dbg.ll", GT, ContextAABuilder);
+  doAnalysisAndCompareResults("context_08_c_dbg.ll", GT, ContextAABuilder);
 }
 
-TEST(CtxSensUnionFindAATest, Context09_1) {
+TEST(CtxSensUnionFindAATest, Context09_0) {
+  /*
+  ValueCompressor: {
+  #0:
+    %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
+  #2:
+    ptr %Ptr | ID: selfRecursion.0
+  #3:
+    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
+    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
+    %3 = load ptr, ptr %Ptr.addr, align 8, !dbg !38, !psr.id !39 | ID: 11
+    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
+    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !48, !psr.id !49 | ID: 16
+  #4:
+    %call = call ptr @selfRecursion(ptr noundef %6), !dbg !50, !psr.id !51 | ID:
+17
+  #5: fun @selfRecursion.<ret>
+  #6: %7 = load ptr, ptr %retval, align 8, !dbg
+!55, !psr.id !56 | ID: 20
+  #7: %retval = alloca i32, align 4, !psr.id !61 | ID:
+22
+  #8: %k = alloca i32, align 4, !psr.id !62 | ID: 23
+  #9: %l = alloca i32, align
+4, !psr.id !63 | ID: 24
+  #10: %x = alloca ptr, align 8, !psr.id !64 | ID: 25
+  #11:
+    %y = alloca ptr, align 8, !psr.id !65 | ID: 26
+  #12:
+    %call = call ptr @selfRecursion(ptr noundef %k), !dbg !78, !psr.id !79 | ID:
+33
+  #13: %call1 = call ptr @selfRecursion(ptr noundef %l), !dbg !84, !psr.id !85
+| ID: 36
+  #14: %0 = load ptr, ptr %y, align 8, !dbg !87, !psr.id !88 | ID: 38
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <0>
+  #2: <0>
+  #3: <1>
+  #4: <1>
+  #5: <1>
+  #6: <2, 3, 4, 5, 6, 8, 9, 12, 13, 14>
+  #7: <7>
+  #8: <10>
+  #9: <11>
+}
+  LLVMUnionFindAliasSet(global, ctx-sens) {
+  #0: {0}
+  #1: {1}
+  #2: {2, 3, 4, 5, 6, 8, 9, 12, 13, 14}
+  #3: {2, 3, 4, 5, 6, 8, 9, 12, 13, 14}
+  #4: {2, 3, 4, 5, 6, 8, 9, 12, 13, 14}
+  #5: {2, 3, 4, 5, 6, 8, 9, 12, 13, 14}
+  #6: {2, 3, 4, 5, 6, 8, 9, 12, 13, 14}
+  #7: {7}
+  #8: {2, 3, 4, 5, 6, 8, 9, 12, 13, 14}
+  #9: {2, 3, 4, 5, 6, 8, 9, 12, 13, 14}
+  #10: {10}
+  #11: {11}
+  #12: {2, 3, 4, 5, 6, 8, 9, 12, 13, 14}
+  #13: {2, 3, 4, 5, 6, 8, 9, 12, 13, 14}
+  #14: {2, 3, 4, 5, 6, 8, 9, 12, 13, 14}
+}
+  */
   GTMap GT = {{LineColFunOp{.Line = 12,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 12,
+               {ArgInFun{.Idx = 0, .InFunction = "selfRecursion"},
+                LineColFunOp{.Line = 4,
                              .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 15,
+                             .InFunction = "selfRecursion",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 7,
                              .Col = 0,
-                             .InFunction = "main",
+                             .InFunction = "selfRecursion",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "selfRecursion",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 8,
+                             .Col = 0,
+                             .InFunction = "selfRecursion",
                              .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 17,
+                RetVal{.InFunction = "selfRecursion"},
+                LineColFunOp{.Line = 12,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call}}},
-              {LineColFunOp{.Line = 13,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 13,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 13,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 18,
+                LineColFunOp{.Line = 15,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 20,
+                LineColFunOp{.Line = 16,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 22,
+                LineColFunOp{.Line = 18,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load}}}};
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 15,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 15,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 16,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 16,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+
+  doAnalysisAndCompareResults("context_09_0_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context09_1) {
+  /*
+  ValueCompressor: {
+  #0:
+    %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
+  #2:
+    ptr %Ptr | ID: selfRecursion.0
+  #3:
+    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
+    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
+    %3 = load ptr, ptr %Ptr.addr, align 8, !dbg !38, !psr.id !39 | ID: 11
+    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
+    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !48, !psr.id !49 | ID: 16
+  #4:
+    %call = call ptr @selfRecursion(ptr noundef %6), !dbg !50, !psr.id !51 | ID:
+17 #5: fun @selfRecursion.<ret> #6: %7 = load ptr, ptr %retval, align 8, !dbg
+!55, !psr.id !56 | ID: 20 #7: %retval = alloca i32, align 4, !psr.id !61 | ID:
+22 #8: %k = alloca i32, align 4, !psr.id !62 | ID: 23 #9: %l = alloca i32, align
+4, !psr.id !63 | ID: 24 #10: %xx1 = alloca ptr, align 8, !psr.id !64 | ID: 25
+  #11:
+    %xx2 = alloca ptr, align 8, !psr.id !65 | ID: 26
+  #12:
+    %yy1 = alloca ptr, align 8, !psr.id !66 | ID: 27
+  #13:
+    %yy2 = alloca ptr, align 8, !psr.id !67 | ID: 28
+  #14:
+    %call = call ptr @selfRecursion(ptr noundef %k), !dbg !80, !psr.id !81 | ID:
+35 #15: %call1 = call ptr @selfRecursion(ptr noundef %k), !dbg !88, !psr.id !89
+| ID: 39 #16: %call2 = call ptr @selfRecursion(ptr noundef %l), !dbg !94,
+!psr.id !95 | ID: 42 #17: %call3 = call ptr @selfRecursion(ptr noundef %l), !dbg
+!102, !psr.id !103 | ID: 46 #18: %0 = load ptr, ptr %yy2, align 8, !dbg !105,
+!psr.id !106 | ID: 48
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <0>
+  #2: <0>
+  #3: <0>
+  #4: <0>
+  #5: <1>
+  #6: <1>
+  #7: <1>
+  #8: <1>
+  #9: <1>
+  #10: <2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18>
+  #11: <7>
+  #12: <10>
+  #13: <11>
+  #14: <12>
+  #15: <13>
+}
+  LLVMUnionFindAliasSet(global, ctx-sens) {
+  #0: {0}
+  #1: {1}
+  #2: {2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18}
+  #3: {2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18}
+  #4: {2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18}
+  #5: {2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18}
+  #6: {2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18}
+  #7: {7}
+  #8: {2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18}
+  #9: {2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18}
+  #10: {10}
+  #11: {11}
+  #12: {12}
+  #13: {13}
+  #14: {2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18}
+  #15: {2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18}
+  #16: {2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18}
+  #17: {2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18}
+  #18: {2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18}
+}
+  */
+  GTMap GT = {
+      {LineColFunOp{.Line = 12,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {ArgInFun{.Idx = 0, .InFunction = "selfRecursion"},
+        LineColFunOp{.Line = 4,
+                     .Col = 0,
+                     .InFunction = "selfRecursion",
+                     .OpCode = llvm::Instruction::Load},
+        LineColFunOp{.Line = 7,
+                     .Col = 0,
+                     .InFunction = "selfRecursion",
+                     .OpCode = llvm::Instruction::Load},
+        LineColFunOp{.Line = 8,
+                     .Col = 0,
+                     .InFunction = "selfRecursion",
+                     .OpCode = llvm::Instruction::Load},
+        LineColFunOp{.Line = 8,
+                     .Col = 0,
+                     .InFunction = "selfRecursion",
+                     .OpCode = llvm::Instruction::Call},
+        RetVal{.InFunction = "selfRecursion"},
+        LineColFunOp{.Line = 12,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca},
+        LineColFunOp{.Line = 13,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca},
+        LineColFunOp{.Line = 15,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 17,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 18,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 20,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 22,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Load}}},
+      {LineColFunOp{.Line = 15,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {LineColFunOp{.Line = 15,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca}}},
+      {LineColFunOp{.Line = 17,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {LineColFunOp{.Line = 17,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca}}},
+      {LineColFunOp{.Line = 18,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {LineColFunOp{.Line = 18,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca}}},
+      {LineColFunOp{.Line = 20,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {LineColFunOp{.Line = 20,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca}}},
+  };
 
   doAnalysisAndCompareResults("context_09_1_c_dbg.ll", GT, ContextAABuilder);
 }
@@ -7777,10 +8793,7 @@ i32 0, i32 0, !dbg !47, !psr.id !48 | ID: 19 %Next3 = getelementptr inbounds
   #14:
     %3 = load ptr, ptr %Next9, align 8, !dbg !97, !psr.id !99 | ID: 46
 }
-PhASAR v2510
-A LLVM-based static analysis framework
-LLVMUnionFindAliasSet(global, botctx-ind-sens) {
-LLVMUnionFindAliasSet(global, botctx-ind-sens) {
+LLVMUnionFindAliasSet(global, ind-sens) {
   #0: {0}
   #1: {1, 3, 6, 11, 12, 13, 14}
   #2: {2}
@@ -7865,7 +8878,8 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca}}}};
 
-  doAnalysisAndCompareResults("indirection_02_c_dbg.ll", GT, IndAABuilder);
+  doAnalysisAndCompareResults("indirection_02_c_dbg.ll", GT,
+                              TracingBuilder(IndAABuilder));
 }
 
 TEST(IndirectionSensUnionFindAATest, Indirection03) {
@@ -8983,7 +9997,13 @@ LLVMUnionFindAliasSet(global, ind-sens) {
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 13,
+            {ArgInFun{.Idx = 0, .InFunction = "_ZN3FooC2Ev"},
+             // Bar constructor calls Foo constructor and we are not context
+             // sensitive
+             ArgInFun{.Idx = 0, .InFunction = "_ZN3BarC2Ev"},
+             ArgInFun{.Idx = 0, .InFunction = "_ZN3Bar4FuncEv"},
+             ArgInFun{.Idx = 0, .InFunction = "_ZN3Foo4FuncEv"},
+             LineColFunOp{.Line = 13,
                           .Col = 7,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca},

From dda83b7c763577f131ba99b17b73b44239364d0b Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Fri, 20 Feb 2026 14:40:55 +0100
Subject: [PATCH 50/75] Nearly all ctx-sens context tests done

---
 .../Pointer/LLVMUnionFindAATest.cpp           | 1069 +++++++++++++++--
 1 file changed, 985 insertions(+), 84 deletions(-)

diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index 8acec649e8..9c7db2d774 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -1831,77 +1831,519 @@ UnionFindAAResult {
 }
 
 TEST(CtxSensUnionFindAATest, Context10_0) {
-  GTMap GT = {{LineColFunOp{.Line = 24,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 24,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 26,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 30,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 32,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load}}}};
+  /*
+  ValueCompressor: {
+  #0:
+    %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
+  #2:
+    ptr %Ptr | ID: Forth.0
+  #3:
+    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
+    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
+    %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !39, !psr.id !40 | ID: 11
+    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !43, !psr.id !44 | ID: 13
+    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !50, !psr.id !51 | ID: 17
+  #4:
+    %call = call ptr @Back(ptr noundef %5), !dbg !45, !psr.id !46 | ID: 14
+  #5:
+    fun @Back.<ret>
+  #6:
+    ptr %Ptr | ID: Back.0
+  #7:
+    %7 = load ptr, ptr %retval, align 8, !dbg !55, !psr.id !56 | ID: 20
+  #8:
+    fun @Forth.<ret>
+  #9:
+    %retval = alloca ptr, align 8, !psr.id !59 | ID: 22
+  #10:
+    %Ptr.addr = alloca ptr, align 8, !psr.id !60 | ID: 23
+  #11:
+    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !65, !psr.id !67 | ID: 26
+    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !74, !psr.id !76 | ID: 30
+    %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !81, !psr.id !82 | ID: 33
+    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !85, !psr.id !86 | ID: 35
+    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !92, !psr.id !93 | ID: 39
+  #12:
+    %call = call ptr @Forth(ptr noundef %5), !dbg !87, !psr.id !88 | ID: 36
+  #13:
+    %7 = load ptr, ptr %retval, align 8, !dbg !97, !psr.id !98 | ID: 42
+  #14:
+    %retval = alloca i32, align 4, !psr.id !103 | ID: 44
+  #15:
+    %k = alloca i32, align 4, !psr.id !104 | ID: 45
+  #16:
+    %x = alloca ptr, align 8, !psr.id !105 | ID: 46
+  #17:
+    %y = alloca ptr, align 8, !psr.id !106 | ID: 47
+  #18:
+    %call = call ptr @Back(ptr noundef %k), !dbg !115, !psr.id !116 | ID: 52
+  #19:
+    %call1 = call ptr @Back(ptr noundef %k), !dbg !123, !psr.id !124 | ID: 56
+  #20:
+    %0 = load ptr, ptr %x, align 8, !dbg !126, !psr.id !127 | ID: 58
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <1>
+  #2: <2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20>
+  #3: <9>
+  #4: <9>
+  #5: <9>
+  #6: <10>
+  #7: <10>
+  #8: <10>
+  #9: <14>
+  #10: <16>
+  #11: <17>
+}
+LLVMUnionFindAliasSet(global, ctx-sens) {
+  #0: {0}
+  #1: {1}
+  #2: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
+  #3: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
+  #4: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
+  #5: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
+  #6: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
+  #7: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
+  #8: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
+  #9: {9}
+  #10: {10}
+  #11: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
+  #12: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
+  #13: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
+  #14: {14}
+  #15: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
+  #16: {16}
+  #17: {17}
+  #18: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
+  #19: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
+  #20: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
+}
+  */
+  GTMap GT = {
+      {LineColFunOp{.Line = 24,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {ArgInFun{.Idx = 0, .InFunction = "Forth"},
+        LineColFunOp{.Line = 6,
+                     .Col = 0,
+                     .InFunction = "Forth",
+                     .OpCode = llvm::Instruction::Load},
+        LineColFunOp{.Line = 7,
+                     .Col = 0,
+                     .InFunction = "Forth",
+                     .OpCode = llvm::Instruction::Load},
+        LineColFunOp{.Line = 7,
+                     .Col = 0,
+                     .InFunction = "Forth",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 10,
+                     .Col = 0,
+                     .InFunction = "Forth",
+                     .OpCode = llvm::Instruction::Load},
+        RetVal{.InFunction = "Forth"}, ArgInFun{.Idx = 0, .InFunction = "Back"},
+        LineColFunOp{.Line = 15,
+                     .Col = 0,
+                     .InFunction = "Back",
+                     .OpCode = llvm::Instruction::Load},
+        LineColFunOp{.Line = 16,
+                     .Col = 0,
+                     .InFunction = "Back",
+                     .OpCode = llvm::Instruction::Load},
+        LineColFunOp{.Line = 16,
+                     .Col = 0,
+                     .InFunction = "Back",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 19,
+                     .Col = 0,
+                     .InFunction = "Back",
+                     .OpCode = llvm::Instruction::Load},
+        RetVal{.InFunction = "Back"},
+        LineColFunOp{.Line = 24,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca},
+        LineColFunOp{.Line = 26,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 30,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 32,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Load}}},
+      {LineColFunOp{.Line = 26,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {LineColFunOp{.Line = 26,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca}}},
+      {LineColFunOp{.Line = 30,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {LineColFunOp{.Line = 30,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("context_10_0_c_dbg.ll", GT, ContextAABuilder);
 }
 
 TEST(CtxSensUnionFindAATest, Context10_1) {
-  GTMap GT = {{LineColFunOp{.Line = 24,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 24,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 27,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 29,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call},
-                LineColFunOp{.Line = 35,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load}}},
-              {LineColFunOp{.Line = 25,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 25,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 31,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 33,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Call}}}};
+  /*
+  ValueCompressor: {
+  #0:
+    %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
+  #2:
+    ptr %Ptr | ID: Forth.0
+  #3:
+    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
+    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
+    %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !39, !psr.id !40 | ID: 11
+    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !43, !psr.id !44 | ID: 13
+    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !50, !psr.id !51 | ID: 17
+  #4:
+    %call = call ptr @Back(ptr noundef %5), !dbg !45, !psr.id !46 | ID: 14
+  #5:
+    fun @Back.<ret>
+  #6:
+    ptr %Ptr | ID: Back.0
+  #7:
+    %7 = load ptr, ptr %retval, align 8, !dbg !55, !psr.id !56 | ID: 20
+  #8:
+    fun @Forth.<ret>
+  #9:
+    %retval = alloca ptr, align 8, !psr.id !59 | ID: 22
+  #10:
+    %Ptr.addr = alloca ptr, align 8, !psr.id !60 | ID: 23
+  #11:
+    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !65, !psr.id !67 | ID: 26
+    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !74, !psr.id !76 | ID: 30
+    %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !81, !psr.id !82 | ID: 33
+    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !85, !psr.id !86 | ID: 35
+    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !92, !psr.id !93 | ID: 39
+  #12:
+    %call = call ptr @Forth(ptr noundef %5), !dbg !87, !psr.id !88 | ID: 36
+  #13:
+    %7 = load ptr, ptr %retval, align 8, !dbg !97, !psr.id !98 | ID: 42
+  #14:
+    %retval = alloca i32, align 4, !psr.id !103 | ID: 44
+  #15:
+    %k = alloca i32, align 4, !psr.id !104 | ID: 45
+  #16:
+    %l = alloca i32, align 4, !psr.id !105 | ID: 46
+  #17:
+    %xx1 = alloca ptr, align 8, !psr.id !106 | ID: 47
+  #18:
+    %xx2 = alloca ptr, align 8, !psr.id !107 | ID: 48
+  #19:
+    %yy1 = alloca ptr, align 8, !psr.id !108 | ID: 49
+  #20:
+    %yy2 = alloca ptr, align 8, !psr.id !109 | ID: 50
+  #21:
+    %call = call ptr @Back(ptr noundef %k), !dbg !122, !psr.id !123 | ID: 57
+  #22:
+    %call1 = call ptr @Back(ptr noundef %k), !dbg !130, !psr.id !131 | ID: 61
+  #23:
+    %call2 = call ptr @Back(ptr noundef %l), !dbg !136, !psr.id !137 | ID: 64
+  #24:
+    %call3 = call ptr @Back(ptr noundef %l), !dbg !144, !psr.id !145 | ID: 68
+  #25:
+    %0 = load ptr, ptr %xx1, align 8, !dbg !147, !psr.id !148 | ID: 70
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <1>
+  #2: <2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25>
+  #3: <9>
+  #4: <9>
+  #5: <9>
+  #6: <9>
+  #7: <9>
+  #8: <10>
+  #9: <10>
+  #10: <10>
+  #11: <10>
+  #12: <10>
+  #13: <14>
+  #14: <17>
+  #15: <18>
+  #16: <19>
+  #17: <20>
+}
+  */
+  GTMap GT = {
+      {LineColFunOp{.Line = 24,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {ArgInFun{.Idx = 0, .InFunction = "Forth"},
+        LineColFunOp{.Line = 6,
+                     .Col = 0,
+                     .InFunction = "Forth",
+                     .OpCode = llvm::Instruction::Load},
+        LineColFunOp{.Line = 7,
+                     .Col = 0,
+                     .InFunction = "Forth",
+                     .OpCode = llvm::Instruction::Load},
+        LineColFunOp{.Line = 7,
+                     .Col = 0,
+                     .InFunction = "Forth",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 10,
+                     .Col = 0,
+                     .InFunction = "Forth",
+                     .OpCode = llvm::Instruction::Load},
+        RetVal{.InFunction = "Forth"}, ArgInFun{.Idx = 0, .InFunction = "Back"},
+        LineColFunOp{.Line = 15,
+                     .Col = 0,
+                     .InFunction = "Back",
+                     .OpCode = llvm::Instruction::Load},
+        LineColFunOp{.Line = 16,
+                     .Col = 0,
+                     .InFunction = "Back",
+                     .OpCode = llvm::Instruction::Load},
+        LineColFunOp{.Line = 16,
+                     .Col = 0,
+                     .InFunction = "Back",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 19,
+                     .Col = 0,
+                     .InFunction = "Back",
+                     .OpCode = llvm::Instruction::Load},
+        RetVal{.InFunction = "Back"},
+        LineColFunOp{.Line = 24,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca},
+        LineColFunOp{.Line = 25,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca},
+        LineColFunOp{.Line = 27,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 29,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 31,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 33,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Call},
+        LineColFunOp{.Line = 35,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Load}}},
+      {LineColFunOp{.Line = 27,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {LineColFunOp{.Line = 27,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca}}},
+      {LineColFunOp{.Line = 29,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {LineColFunOp{.Line = 29,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca}}},
+      {LineColFunOp{.Line = 31,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {LineColFunOp{.Line = 31,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca}}},
+      {LineColFunOp{.Line = 33,
+                    .Col = 0,
+                    .InFunction = "main",
+                    .OpCode = llvm::Instruction::Alloca},
+       {LineColFunOp{.Line = 33,
+                     .Col = 0,
+                     .InFunction = "main",
+                     .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("context_10_1_c_dbg.ll", GT, ContextAABuilder);
 }
 
 TEST(CtxSensUnionFindAATest, Context11_0) {
+  /*
+  ValueCompressor: {
+  #0:
+    %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
+  #2:
+    ptr %Ptr | ID: Forth.0
+  #3:
+    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
+    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
+    %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !39, !psr.id !40 | ID: 11
+    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !43, !psr.id !44 | ID: 13
+    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !50, !psr.id !51 | ID: 17
+  #4:
+    %call = call ptr @Stop(ptr noundef %5), !dbg !45, !psr.id !46 | ID: 14
+  #5:
+    fun @Stop.<ret>
+  #6:
+    ptr %Ptr | ID: Stop.0
+  #7:
+    %7 = load ptr, ptr %retval, align 8, !dbg !55, !psr.id !56 | ID: 20
+  #8:
+    fun @Forth.<ret>
+  #9:
+    %retval = alloca ptr, align 8, !psr.id !59 | ID: 22
+  #10:
+    %Ptr.addr = alloca ptr, align 8, !psr.id !60 | ID: 23
+  #11:
+    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !65, !psr.id !67 | ID: 26
+    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !76, !psr.id !78 | ID: 31
+    %3 = load ptr, ptr %Ptr.addr, align 8, !dbg !84, !psr.id !85 | ID: 35
+  #12:
+    %call = call ptr @Forth(ptr noundef %2), !dbg !79, !psr.id !80 | ID: 32
+  #13:
+    %call1 = call ptr @Back(ptr noundef %3), !dbg !86, !psr.id !87 | ID: 36
+  #14:
+    fun @Back.<ret>
+  #15:
+    ptr %Ptr | ID: Back.0
+  #16:
+    %4 = load ptr, ptr %retval, align 8, !dbg !91, !psr.id !92 | ID: 39
+  #17:
+    %retval = alloca ptr, align 8, !psr.id !95 | ID: 41
+  #18:
+    %Ptr.addr = alloca ptr, align 8, !psr.id !96 | ID: 42
+  #19:
+    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !101, !psr.id !103 | ID: 45
+    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !110, !psr.id !112 | ID: 49
+    %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !117, !psr.id !118 | ID: 52
+    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !121, !psr.id !122 | ID: 54
+    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !128, !psr.id !129 | ID: 58
+  #20:
+    %call = call ptr @Stop(ptr noundef %5), !dbg !123, !psr.id !124 | ID: 55
+  #21:
+    %7 = load ptr, ptr %retval, align 8, !dbg !133, !psr.id !134 | ID: 61
+  #22:
+    %retval = alloca i32, align 4, !psr.id !139 | ID: 63
+  #23:
+    %k = alloca i32, align 4, !psr.id !140 | ID: 64
+  #24:
+    %l = alloca i32, align 4, !psr.id !141 | ID: 65
+  #25:
+    %x = alloca ptr, align 8, !psr.id !142 | ID: 66
+  #26:
+    %y = alloca ptr, align 8, !psr.id !143 | ID: 67
+  #27:
+    %call = call ptr @Back(ptr noundef %k), !dbg !156, !psr.id !157 | ID: 74
+  #28:
+    %call1 = call ptr @Forth(ptr noundef %l), !dbg !162, !psr.id !163 | ID: 77
+  #29:
+    %0 = load ptr, ptr %x, align 8, !dbg !165, !psr.id !166 | ID: 79
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <0>
+  #2: <1>
+  #3: <1>
+  #4: <2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 14, 15, 16, 19, 20, 21, 23, 24, 27, 28,
+29>
+  #5: <9>
+  #6: <9>
+  #7: <10>
+  #8: <10>
+  #9: <17>
+  #10: <17>
+  #11: <18>
+  #12: <18>
+  #13: <22>
+  #14: <25>
+  #15: <26>
+}
+  */
   GTMap GT{{LineColFunOp{.Line = 33,
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 33,
+            {ArgInFun{.Idx = 0, .InFunction = "Forth"},
+             LineColFunOp{.Line = 7,
+                          .Col = 0,
+                          .InFunction = "Forth",
+                          .OpCode = llvm::Instruction::Load},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "Forth",
+                          .OpCode = llvm::Instruction::Load},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "Forth",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "Forth",
+                          .OpCode = llvm::Instruction::Load},
+             RetVal{.InFunction = "Forth"},
+             ArgInFun{.Idx = 0, .InFunction = "Back"},
+             LineColFunOp{.Line = 16,
+                          .Col = 0,
+                          .InFunction = "Back",
+                          .OpCode = llvm::Instruction::Load},
+             LineColFunOp{.Line = 17,
+                          .Col = 0,
+                          .InFunction = "Back",
+                          .OpCode = llvm::Instruction::Load},
+             LineColFunOp{.Line = 17,
+                          .Col = 0,
+                          .InFunction = "Back",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 20,
+                          .Col = 0,
+                          .InFunction = "Back",
+                          .OpCode = llvm::Instruction::Load},
+             RetVal{.InFunction = "Back"},
+             ArgInFun{.Idx = 0, .InFunction = "Stop"},
+             LineColFunOp{.Line = 25,
+                          .Col = 0,
+                          .InFunction = "Stop",
+                          .OpCode = llvm::Instruction::Load},
+             LineColFunOp{.Line = 25,
+                          .Col = 0,
+                          .InFunction = "Stop",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 28,
+                          .Col = 0,
+                          .InFunction = "Stop",
+                          .OpCode = llvm::Instruction::Load},
+             LineColFunOp{.Line = 28,
+                          .Col = 0,
+                          .InFunction = "Stop",
+                          .OpCode = llvm::Instruction::Call},
+             RetVal{.InFunction = "Stop"},
+             LineColFunOp{.Line = 33,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 34,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca},
@@ -1909,36 +2351,198 @@ TEST(CtxSensUnionFindAATest, Context11_0) {
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 37,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
              LineColFunOp{.Line = 39,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Load}}},
-           {LineColFunOp{.Line = 34,
+           {LineColFunOp{.Line = 36,
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 34,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 37,
+            {LineColFunOp{.Line = 36,
                           .Col = 0,
                           .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 39,
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 37,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 37,
                           .Col = 0,
                           .InFunction = "main",
-                          .OpCode = llvm::Instruction::Load}}}};
+                          .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("context_11_0_c_dbg.ll", GT, ContextAABuilder);
 }
 
 TEST(CtxSensUnionFindAATest, Context11_1) {
+  /*
+  ValueCompressor: {
+  #0:
+    %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
+  #2:
+    ptr %Ptr | ID: Forth.0
+  #3:
+    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
+    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
+    %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !39, !psr.id !40 | ID: 11
+    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !43, !psr.id !44 | ID: 13
+    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !50, !psr.id !51 | ID: 17
+  #4:
+    %call = call ptr @Stop(ptr noundef %5), !dbg !45, !psr.id !46 | ID: 14
+  #5:
+    fun @Stop.<ret>
+  #6:
+    ptr %Ptr | ID: Stop.0
+  #7:
+    %7 = load ptr, ptr %retval, align 8, !dbg !55, !psr.id !56 | ID: 20
+  #8:
+    fun @Forth.<ret>
+  #9:
+    %retval = alloca ptr, align 8, !psr.id !59 | ID: 22
+  #10:
+    %Ptr.addr = alloca ptr, align 8, !psr.id !60 | ID: 23
+  #11:
+    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !65, !psr.id !67 | ID: 26
+    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !76, !psr.id !78 | ID: 31
+    %3 = load ptr, ptr %Ptr.addr, align 8, !dbg !84, !psr.id !85 | ID: 35
+  #12:
+    %call = call ptr @Forth(ptr noundef %2), !dbg !79, !psr.id !80 | ID: 32
+  #13:
+    %call1 = call ptr @Back(ptr noundef %3), !dbg !86, !psr.id !87 | ID: 36
+  #14:
+    fun @Back.<ret>
+  #15:
+    ptr %Ptr | ID: Back.0
+  #16:
+    %4 = load ptr, ptr %retval, align 8, !dbg !91, !psr.id !92 | ID: 39
+  #17:
+    %retval = alloca ptr, align 8, !psr.id !95 | ID: 41
+  #18:
+    %Ptr.addr = alloca ptr, align 8, !psr.id !96 | ID: 42
+  #19:
+    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !101, !psr.id !103 | ID: 45
+    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !110, !psr.id !112 | ID: 49
+    %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !117, !psr.id !118 | ID: 52
+    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !121, !psr.id !122 | ID: 54
+    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !128, !psr.id !129 | ID: 58
+  #20:
+    %call = call ptr @Stop(ptr noundef %5), !dbg !123, !psr.id !124 | ID: 55
+  #21:
+    %7 = load ptr, ptr %retval, align 8, !dbg !133, !psr.id !134 | ID: 61
+  #22:
+    %retval = alloca i32, align 4, !psr.id !139 | ID: 63
+  #23:
+    %k = alloca i32, align 4, !psr.id !140 | ID: 64
+  #24:
+    %l = alloca i32, align 4, !psr.id !141 | ID: 65
+  #25:
+    %xx1 = alloca ptr, align 8, !psr.id !142 | ID: 66
+  #26:
+    %xx2 = alloca ptr, align 8, !psr.id !143 | ID: 67
+  #27:
+    %yy1 = alloca ptr, align 8, !psr.id !144 | ID: 68
+  #28:
+    %yy2 = alloca ptr, align 8, !psr.id !145 | ID: 69
+  #29:
+    %call = call ptr @Back(ptr noundef %k), !dbg !158, !psr.id !159 | ID: 76
+  #30:
+    %call1 = call ptr @Back(ptr noundef %k), !dbg !164, !psr.id !165 | ID: 79
+  #31:
+    %call2 = call ptr @Forth(ptr noundef %l), !dbg !170, !psr.id !171 | ID: 82
+  #32:
+    %call3 = call ptr @Forth(ptr noundef %l), !dbg !176, !psr.id !177 | ID: 85
+  #33:
+    %0 = load ptr, ptr %xx2, align 8, !dbg !179, !psr.id !180 | ID: 87
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <0>
+  #2: <0>
+  #3: <1>
+  #4: <1>
+  #5: <1>
+  #6: <2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 14, 15, 16, 19, 20, 21, 23, 24, 29, 30,
+31, 32, 33> #7: <9> #8: <9> #9: <10> #10: <10> #11: <17> #12: <17> #13: <17>
+  #14: <18>
+  #15: <18>
+  #16: <18>
+  #17: <22>
+  #18: <25>
+  #19: <26>
+  #20: <27>
+  #21: <28>
+}
+  */
   GTMap GT{{LineColFunOp{.Line = 33,
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 33,
+            {ArgInFun{.Idx = 0, .InFunction = "Forth"},
+             LineColFunOp{.Line = 7,
+                          .Col = 0,
+                          .InFunction = "Forth",
+                          .OpCode = llvm::Instruction::Load},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "Forth",
+                          .OpCode = llvm::Instruction::Load},
+             LineColFunOp{.Line = 8,
+                          .Col = 0,
+                          .InFunction = "Forth",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "Forth",
+                          .OpCode = llvm::Instruction::Load},
+             RetVal{.InFunction = "Forth"},
+             ArgInFun{.Idx = 0, .InFunction = "Back"},
+             LineColFunOp{.Line = 16,
+                          .Col = 0,
+                          .InFunction = "Back",
+                          .OpCode = llvm::Instruction::Load},
+             LineColFunOp{.Line = 17,
+                          .Col = 0,
+                          .InFunction = "Back",
+                          .OpCode = llvm::Instruction::Load},
+             LineColFunOp{.Line = 17,
+                          .Col = 0,
+                          .InFunction = "Back",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 20,
+                          .Col = 0,
+                          .InFunction = "Back",
+                          .OpCode = llvm::Instruction::Load},
+             RetVal{.InFunction = "Back"},
+             ArgInFun{.Idx = 0, .InFunction = "Stop"},
+             LineColFunOp{.Line = 25,
+                          .Col = 0,
+                          .InFunction = "Stop",
+                          .OpCode = llvm::Instruction::Load},
+             LineColFunOp{.Line = 25,
+                          .Col = 0,
+                          .InFunction = "Stop",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 28,
+                          .Col = 0,
+                          .InFunction = "Stop",
+                          .OpCode = llvm::Instruction::Load},
+             LineColFunOp{.Line = 28,
+                          .Col = 0,
+                          .InFunction = "Stop",
+                          .OpCode = llvm::Instruction::Call},
+             RetVal{.InFunction = "Stop"},
+             LineColFunOp{.Line = 33,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 34,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca},
@@ -1946,7 +2550,15 @@ TEST(CtxSensUnionFindAATest, Context11_1) {
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 37,
+             LineColFunOp{.Line = 37,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 38,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Call},
+             LineColFunOp{.Line = 39,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Call},
@@ -1954,32 +2566,109 @@ TEST(CtxSensUnionFindAATest, Context11_1) {
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Load}}},
-           {LineColFunOp{.Line = 34,
+           {LineColFunOp{.Line = 36,
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 34,
+            {LineColFunOp{.Line = 36,
                           .Col = 0,
                           .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 38,
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 37,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 37,
                           .Col = 0,
                           .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call},
-             LineColFunOp{.Line = 39,
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 38,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 38,
                           .Col = 0,
                           .InFunction = "main",
-                          .OpCode = llvm::Instruction::Call}}}};
+                          .OpCode = llvm::Instruction::Alloca}}},
+           {LineColFunOp{.Line = 39,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {LineColFunOp{.Line = 39,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("context_11_1_c_dbg.ll", GT, ContextAABuilder);
 }
 
 TEST(CtxSensUnionFindAATest, Context12_0) {
+  /*
+  ValueCompressor: {
+  #0:
+    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
+  #1:
+    %q.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
+  #2:
+    ptr %p | ID: argretq.0
+  #3:
+    ptr %q | ID: argretq.1
+  #4:
+    %0 = load ptr, ptr %q.addr, align 8, !dbg !27, !psr.id !28 | ID: 6
+  #5:
+    fun @argretq.<ret>
+  #6:
+    %retval = alloca i32, align 4, !psr.id !34 | ID: 8
+  #7:
+    %x = alloca i32, align 4, !psr.id !35 | ID: 9
+  #8:
+    %y = alloca i32, align 4, !psr.id !36 | ID: 10
+  #9:
+    %xx1 = alloca ptr, align 8, !psr.id !37 | ID: 11
+  #10:
+    %xx2 = alloca ptr, align 8, !psr.id !38 | ID: 12
+  #11:
+    %yy1 = alloca ptr, align 8, !psr.id !39 | ID: 13
+  #12:
+    %yy2 = alloca ptr, align 8, !psr.id !40 | ID: 14
+  #13:
+    %call = call ptr @argretq(ptr noundef %y, ptr noundef %x), !dbg !53, !psr.id
+!54 | ID: 21 #14: %call1 = call ptr @argretq(ptr noundef %y, ptr noundef %x),
+!dbg !59, !psr.id !60 | ID: 24 #15: %call2 = call ptr @argretq(ptr noundef %x,
+ptr noundef %y), !dbg !65, !psr.id !66 | ID: 27 #16: %call3 = call ptr
+@argretq(ptr noundef %x, ptr noundef %y), !dbg !71, !psr.id !72 | ID: 30 #17: %0
+= load ptr, ptr %xx1, align 8, !dbg !74, !psr.id !75 | ID: 32
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <0>
+  #2: <0>
+  #3: <0>
+  #4: <1>
+  #5: <1>
+  #6: <1>
+  #7: <1>
+  #8: <2, 3, 4, 5, 8, 15, 16>
+  #9: <2, 3, 4, 5, 7, 13, 14, 17>
+  #10: <6>
+  #11: <9>
+  #12: <10>
+  #13: <11>
+  #14: <12>
+}
+  */
   GTMap GT{{LineColFunOp{.Line = 5,
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 5,
+            {ArgInFun{.Idx = 0, .InFunction = "argretq"},
+             ArgInFun{.Idx = 1, .InFunction = "argretq"},
+             LineColFunOp{.Line = 2,
+                          .Col = 0,
+                          .InFunction = "argretq",
+                          .OpCode = llvm::Instruction::Load},
+             RetVal{.InFunction = "argretq"},
+             LineColFunOp{.Line = 5,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca},
@@ -1995,12 +2684,18 @@ TEST(CtxSensUnionFindAATest, Context12_0) {
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Load}}},
-
            {LineColFunOp{.Line = 6,
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 6,
+            {ArgInFun{.Idx = 0, .InFunction = "argretq"},
+             ArgInFun{.Idx = 1, .InFunction = "argretq"},
+             LineColFunOp{.Line = 2,
+                          .Col = 0,
+                          .InFunction = "argretq",
+                          .OpCode = llvm::Instruction::Load},
+             RetVal{.InFunction = "argretq"},
+             LineColFunOp{.Line = 6,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca},
@@ -2021,7 +2716,14 @@ TEST(CtxSensUnionFindAATest, Context12_1) {
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 5,
+            {ArgInFun{.Idx = 0, .InFunction = "argretq"},
+             ArgInFun{.Idx = 1, .InFunction = "argretq"},
+             LineColFunOp{.Line = 2,
+                          .Col = 0,
+                          .InFunction = "argretq",
+                          .OpCode = llvm::Instruction::Load},
+             RetVal{.InFunction = "argretq"},
+             LineColFunOp{.Line = 5,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca},
@@ -2037,7 +2739,14 @@ TEST(CtxSensUnionFindAATest, Context12_1) {
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 6,
+            {ArgInFun{.Idx = 0, .InFunction = "argretq"},
+             ArgInFun{.Idx = 1, .InFunction = "argretq"},
+             LineColFunOp{.Line = 2,
+                          .Col = 0,
+                          .InFunction = "argretq",
+                          .OpCode = llvm::Instruction::Load},
+             RetVal{.InFunction = "argretq"},
+             LineColFunOp{.Line = 6,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca},
@@ -2054,7 +2763,15 @@ TEST(CtxSensUnionFindAATest, Context13_0) {
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 5,
+            {ArgInFun{.Idx = 0, .InFunction = "argretq"},
+             ArgInFun{.Idx = 1, .InFunction = "argretq"},
+             ArgInFun{.Idx = 2, .InFunction = "argretq"},
+             LineColFunOp{.Line = 2,
+                          .Col = 0,
+                          .InFunction = "argretq",
+                          .OpCode = llvm::Instruction::Load},
+             RetVal{.InFunction = "argretq"},
+             LineColFunOp{.Line = 5,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca},
@@ -2082,7 +2799,15 @@ TEST(CtxSensUnionFindAATest, Context13_0) {
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 6,
+            {ArgInFun{.Idx = 0, .InFunction = "argretq"},
+             ArgInFun{.Idx = 1, .InFunction = "argretq"},
+             ArgInFun{.Idx = 2, .InFunction = "argretq"},
+             LineColFunOp{.Line = 2,
+                          .Col = 0,
+                          .InFunction = "argretq",
+                          .OpCode = llvm::Instruction::Load},
+             RetVal{.InFunction = "argretq"},
+             LineColFunOp{.Line = 6,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca},
@@ -2111,7 +2836,15 @@ TEST(CtxSensUnionFindAATest, Context13_1) {
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 5,
+            {ArgInFun{.Idx = 0, .InFunction = "argretq"},
+             ArgInFun{.Idx = 1, .InFunction = "argretq"},
+             ArgInFun{.Idx = 2, .InFunction = "argretq"},
+             LineColFunOp{.Line = 2,
+                          .Col = 0,
+                          .InFunction = "argretq",
+                          .OpCode = llvm::Instruction::Load},
+             RetVal{.InFunction = "argretq"},
+             LineColFunOp{.Line = 5,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca},
@@ -2123,7 +2856,15 @@ TEST(CtxSensUnionFindAATest, Context13_1) {
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 6,
+            {ArgInFun{.Idx = 0, .InFunction = "argretq"},
+             ArgInFun{.Idx = 1, .InFunction = "argretq"},
+             ArgInFun{.Idx = 2, .InFunction = "argretq"},
+             LineColFunOp{.Line = 2,
+                          .Col = 0,
+                          .InFunction = "argretq",
+                          .OpCode = llvm::Instruction::Load},
+             RetVal{.InFunction = "argretq"},
+             LineColFunOp{.Line = 6,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca},
@@ -2139,6 +2880,166 @@ TEST(CtxSensUnionFindAATest, Context13_1) {
   doAnalysisAndCompareResults("context_13_1_c_dbg.ll", GT, ContextAABuilder);
 }
 
+TEST(CtxSensUnionFindAATest, Context14_0) {
+  /*
+  ValueCompressor: {
+  #0:
+    %Func.addr = alloca ptr, align 8, !psr.id !24 | ID: 1
+  #1:
+    ptr %Func | ID: callback.0
+  #2:
+    %0 = load ptr, ptr %Func.addr, align 8, !dbg !29, !psr.id !30 | ID: 4
+  #3:
+    %retval = alloca i32, align 4, !psr.id !35 | ID: 7
+  #4:
+    %FuncPtr = alloca ptr, align 8, !psr.id !36 | ID: 8
+  #5:
+    %Zero = alloca i32, align 4, !psr.id !37 | ID: 9
+  #6:
+    fun @ret0
+  #7:
+    %0 = load ptr, ptr %FuncPtr, align 8, !dbg !46, !psr.id !47 | ID: 14
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <1, 2, 6, 7>
+  #2: <3>
+  #3: <4>
+  #4: <5>
+}
+  */
+  GTMap GT{{LineColFunOp{.Line = 7,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+                // ArgInFun{.Idx = 0, .InFunction = "callback"},
+                // LineColFunOp{.Line = 4,
+                //              .Col = 0,
+                //              .InFunction = "callback",
+                //              .OpCode = llvm::Instruction::Load},
+                // RetVal{.InFunction = "callback"},
+                LineColFunOp{.Line = 7,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                // LineColFunOp{.Line = 9,
+                //              .Col = 0,
+                //              .InFunction = "main",
+                //              .OpCode = llvm::Instruction::Load},
+                // LineColFunOp{.Line = 9,
+                //              .Col = 0,
+                //              .InFunction = "main",
+                //              .OpCode = llvm::Instruction::Call}
+            }}};
+
+  doAnalysisAndCompareResults("context_14_0_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context14_1) {
+  /*
+ValueCompressor: {
+  #0:
+    %Func.addr = alloca ptr, align 8, !psr.id !27 | ID: 2
+  #1:
+    ptr %Func | ID: callback.0
+  #2:
+    %0 = load ptr, ptr %Func.addr, align 8, !dbg !32, !psr.id !33 | ID: 5
+  #3:
+    fun @callback.<ret>
+  #4:
+    %retval = alloca i32, align 4, !psr.id !37 | ID: 7
+  #5:
+    %FuncPtrZero = alloca ptr, align 8, !psr.id !38 | ID: 8
+  #6:
+    %FuncPtrOne = alloca ptr, align 8, !psr.id !39 | ID: 9
+  #7:
+    fun @ret0
+  #8:
+    fun @ret1
+  #9:
+    %call = call ptr @callback(ptr noundef @ret1), !dbg !49, !psr.id !50 | ID:
+15 #10: %call1 = call ptr @callback(ptr noundef @ret0), !dbg !53, !psr.id !54 |
+ID: 17
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <0>
+  #2: <1, 2, 3, 8, 9>
+  #3: <1, 2, 3, 7, 10>
+  #4: <4>
+  #5: <5>
+  #6: <6>
+}
+  */
+  GTMap GT{{LineColFunOp{.Line = 9,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {}}};
+
+  doAnalysisAndCompareResults("context_14_1_c_dbg.ll", GT, ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Context14_2) {
+  /*
+ValueCompressor: {
+  #0:
+    %Func.addr = alloca ptr, align 8, !psr.id !30 | ID: 3
+  #1:
+    ptr %Func | ID: callback.0
+  #2:
+    %0 = load ptr, ptr %Func.addr, align 8, !dbg !35, !psr.id !36 | ID: 6
+  #3:
+    fun @callback.<ret>
+  #4:
+    %retval = alloca i32, align 4, !psr.id !40 | ID: 8
+  #5:
+    %FuncPtrZero = alloca ptr, align 8, !psr.id !41 | ID: 9
+  #6:
+    %FuncPtrOne = alloca ptr, align 8, !psr.id !42 | ID: 10
+  #7:
+    %FuncPtrTwo = alloca ptr, align 8, !psr.id !43 | ID: 11
+  #8:
+    fun @ret0
+  #9:
+    fun @ret1
+  #10:
+    fun @ret2
+  #11:
+    %call = call ptr @callback(ptr noundef @ret2), !dbg !57, !psr.id !58 | ID:
+19 #12: %call1 = call ptr @callback(ptr noundef @ret0), !dbg !61, !psr.id !62 |
+ID: 21 #13: %call2 = call ptr @callback(ptr noundef @ret1), !dbg !65, !psr.id
+!66 | ID: 23
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <0>
+  #2: <0>
+  #3: <1, 2, 3, 10, 11>
+  #4: <1, 2, 3, 8, 12>
+  #5: <1, 2, 3, 9, 13>
+  #6: <4>
+  #7: <5>
+  #8: <6>
+  #9: <7>
+}
+  */
+  GTMap GT{{LineColFunOp{.Line = 11,
+                         .Col = 0,
+                         .InFunction = "main",
+                         .OpCode = llvm::Instruction::Alloca},
+            {
+
+            }}};
+
+  doAnalysisAndCompareResults("context_14_2_c_dbg.ll", GT, ContextAABuilder);
+}
+
 TEST(CtxSensUnionFindAATest, Indirection01) {
   GTMap GT = {{LineColFunOp{.Line = 8,
                             .Col = 0,

From dcaf7b96bab10ac694718ad4bfe465ab55041f82 Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Mon, 23 Feb 2026 23:20:23 +0100
Subject: [PATCH 51/75] FuncByName TestingSrcLocation

---
 .../Pointer/LLVMUnionFindAATest.cpp           | 1263 +++++++++++++----
 unittests/TestUtils/SrcCodeLocationEntry.h    |   33 +-
 2 files changed, 987 insertions(+), 309 deletions(-)

diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index 9c7db2d774..d4b056824b 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -314,14 +314,19 @@ UnionFindAAResult {
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
                {
+                   FuncByName{.NameOfFunction = "Func"},
                    LineColFunOp{.Line = 5,
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Alloca},
-                   LineColFunOp{.Line = 6,
-                                .Col = 0,
+                   LineColFunOp{.Line = 11,
+                                .Col = 11,
                                 .InFunction = "main",
-                                .OpCode = llvm::Instruction::Alloca},
+                                .OpCode = llvm::Instruction::Load},
+                   LineColFunOp{.Line = 11,
+                                .Col = 12,
+                                .InFunction = "main",
+                                .OpCode = llvm::Instruction::Load},
                }}};
 
   doAnalysisAndCompareResults("basic_04_c_dbg.ll", GT, ContextAABuilder);
@@ -2881,166 +2886,76 @@ TEST(CtxSensUnionFindAATest, Context13_1) {
 }
 
 TEST(CtxSensUnionFindAATest, Context14_0) {
-  /*
-  ValueCompressor: {
-  #0:
-    %Func.addr = alloca ptr, align 8, !psr.id !24 | ID: 1
-  #1:
-    ptr %Func | ID: callback.0
-  #2:
-    %0 = load ptr, ptr %Func.addr, align 8, !dbg !29, !psr.id !30 | ID: 4
-  #3:
-    %retval = alloca i32, align 4, !psr.id !35 | ID: 7
-  #4:
-    %FuncPtr = alloca ptr, align 8, !psr.id !36 | ID: 8
-  #5:
-    %Zero = alloca i32, align 4, !psr.id !37 | ID: 9
-  #6:
-    fun @ret0
-  #7:
-    %0 = load ptr, ptr %FuncPtr, align 8, !dbg !46, !psr.id !47 | ID: 14
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <1, 2, 6, 7>
-  #2: <3>
-  #3: <4>
-  #4: <5>
-}
-  */
   GTMap GT{{LineColFunOp{.Line = 7,
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {
-                // ArgInFun{.Idx = 0, .InFunction = "callback"},
-                // LineColFunOp{.Line = 4,
-                //              .Col = 0,
-                //              .InFunction = "callback",
-                //              .OpCode = llvm::Instruction::Load},
-                // RetVal{.InFunction = "callback"},
-                LineColFunOp{.Line = 7,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 9,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                // LineColFunOp{.Line = 9,
-                //              .Col = 0,
-                //              .InFunction = "main",
-                //              .OpCode = llvm::Instruction::Load},
-                // LineColFunOp{.Line = 9,
-                //              .Col = 0,
-                //              .InFunction = "main",
-                //              .OpCode = llvm::Instruction::Call}
-            }}};
+            {LineColFunOp{.Line = 7,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("context_14_0_c_dbg.ll", GT, ContextAABuilder);
 }
 
 TEST(CtxSensUnionFindAATest, Context14_1) {
-  /*
-ValueCompressor: {
-  #0:
-    %Func.addr = alloca ptr, align 8, !psr.id !27 | ID: 2
-  #1:
-    ptr %Func | ID: callback.0
-  #2:
-    %0 = load ptr, ptr %Func.addr, align 8, !dbg !32, !psr.id !33 | ID: 5
-  #3:
-    fun @callback.<ret>
-  #4:
-    %retval = alloca i32, align 4, !psr.id !37 | ID: 7
-  #5:
-    %FuncPtrZero = alloca ptr, align 8, !psr.id !38 | ID: 8
-  #6:
-    %FuncPtrOne = alloca ptr, align 8, !psr.id !39 | ID: 9
-  #7:
-    fun @ret0
-  #8:
-    fun @ret1
-  #9:
-    %call = call ptr @callback(ptr noundef @ret1), !dbg !49, !psr.id !50 | ID:
-15 #10: %call1 = call ptr @callback(ptr noundef @ret0), !dbg !53, !psr.id !54 |
-ID: 17
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <0>
-  #2: <1, 2, 3, 8, 9>
-  #3: <1, 2, 3, 7, 10>
-  #4: <4>
-  #5: <5>
-  #6: <6>
-}
-  */
   GTMap GT{{LineColFunOp{.Line = 9,
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {}}};
+            {LineColFunOp{.Line = 9,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("context_14_1_c_dbg.ll", GT, ContextAABuilder);
 }
 
 TEST(CtxSensUnionFindAATest, Context14_2) {
-  /*
-ValueCompressor: {
-  #0:
-    %Func.addr = alloca ptr, align 8, !psr.id !30 | ID: 3
-  #1:
-    ptr %Func | ID: callback.0
-  #2:
-    %0 = load ptr, ptr %Func.addr, align 8, !dbg !35, !psr.id !36 | ID: 6
-  #3:
-    fun @callback.<ret>
-  #4:
-    %retval = alloca i32, align 4, !psr.id !40 | ID: 8
-  #5:
-    %FuncPtrZero = alloca ptr, align 8, !psr.id !41 | ID: 9
-  #6:
-    %FuncPtrOne = alloca ptr, align 8, !psr.id !42 | ID: 10
-  #7:
-    %FuncPtrTwo = alloca ptr, align 8, !psr.id !43 | ID: 11
-  #8:
-    fun @ret0
-  #9:
-    fun @ret1
-  #10:
-    fun @ret2
-  #11:
-    %call = call ptr @callback(ptr noundef @ret2), !dbg !57, !psr.id !58 | ID:
-19 #12: %call1 = call ptr @callback(ptr noundef @ret0), !dbg !61, !psr.id !62 |
-ID: 21 #13: %call2 = call ptr @callback(ptr noundef @ret1), !dbg !65, !psr.id
-!66 | ID: 23
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <0>
-  #2: <0>
-  #3: <1, 2, 3, 10, 11>
-  #4: <1, 2, 3, 8, 12>
-  #5: <1, 2, 3, 9, 13>
-  #6: <4>
-  #7: <5>
-  #8: <6>
-  #9: <7>
-}
-  */
   GTMap GT{{LineColFunOp{.Line = 11,
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
             {
-
+                LineColFunOp{.Line = 11,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
             }}};
 
   doAnalysisAndCompareResults("context_14_2_c_dbg.ll", GT, ContextAABuilder);
 }
 
 TEST(CtxSensUnionFindAATest, Indirection01) {
+  /*
+  ValueCompressor: {
+  #0:
+    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
+  #1:
+    %Foo = alloca %struct._LinkedList, align 8, !psr.id !17 | ID: 1
+    %Next1 = getelementptr inbounds %struct._LinkedList, ptr %Foo, i32 0, i32 1,
+!dbg !41, !psr.id !42 | ID: 12 #2:
+    %.compoundliteral = alloca %struct._LinkedList, align 8, !psr.id !18 | ID: 2
+    %Val = getelementptr inbounds %struct._LinkedList, ptr %.compoundliteral,
+i32 0, i32 0, !dbg !30, !psr.id !31 | ID: 6 %Next = getelementptr inbounds
+%struct._LinkedList, ptr %.compoundliteral, i32 0, i32 1, !dbg !30, !psr.id !33
+| ID: 8 #3: %Alias = alloca ptr, align 8, !psr.id !19 | ID: 3 #4: %0 = load ptr,
+ptr %Next1, align 8, !dbg !41, !psr.id !43 | ID: 13
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <1, 2, 4>
+  #2: <3>
+}
+    TODO: ask Fabian about below
+    Failed
+Computed unexpected alias of LineColFunOp { Line: 8; Col: 0; InFunction: main;
+OpCode: alloca }: { %.compoundliteral = alloca %struct._LinkedList, align 8,
+!psr.id !18 | ID: 2, %Val = getelementptr inbounds %struct._LinkedList, ptr
+%.compoundliteral, i32 0, i32 0, !dbg !30, !psr.id !31 | ID: 6, %Next =
+getelementptr inbounds %struct._LinkedList, ptr %.compoundliteral, i32 0, i32 1,
+!dbg !30, !psr.id !33 | ID: 8 }
+  */
   GTMap GT = {{LineColFunOp{.Line = 8,
                             .Col = 0,
                             .InFunction = "main",
@@ -3065,6 +2980,58 @@ TEST(CtxSensUnionFindAATest, Indirection01) {
 }
 
 TEST(CtxSensUnionFindAATest, Indirection02) {
+  /*
+  ValueCompressor: {
+  #0:
+    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
+  #1:
+    %Foo = alloca %struct._LinkedList, align 8, !psr.id !17 | ID: 1
+    %Next6 = getelementptr inbounds %struct._LinkedList, ptr %Foo, i32 0, i32 1,
+!dbg !76, !psr.id !77 | ID: 33 #2:
+    %.compoundliteral = alloca %struct._LinkedList, align 8, !psr.id !18 | ID: 2
+    %Val = getelementptr inbounds %struct._LinkedList, ptr %.compoundliteral,
+i32 0, i32 0, !dbg !37, !psr.id !38 | ID: 13 %Next = getelementptr inbounds
+%struct._LinkedList, ptr %.compoundliteral, i32 0, i32 1, !dbg !37, !psr.id !40
+| ID: 15 #3: %Bar = alloca %struct._LinkedList, align 8, !psr.id !19 | ID: 3
+    %Next7 = getelementptr inbounds %struct._LinkedList, ptr %Bar, i32 0, i32 1,
+!dbg !83, !psr.id !84 | ID: 37 #4:
+    %.compoundliteral1 = alloca %struct._LinkedList, align 8, !psr.id !20 | ID:
+4 %Val2 = getelementptr inbounds %struct._LinkedList, ptr %.compoundliteral1,
+i32 0, i32 0, !dbg !47, !psr.id !48 | ID: 19 %Next3 = getelementptr inbounds
+%struct._LinkedList, ptr %.compoundliteral1, i32 0, i32 1, !dbg !47, !psr.id !50
+| ID: 21 #5: %Baz = alloca %struct._LinkedList, align 8, !psr.id !21 | ID: 5
+    %Next5 = getelementptr inbounds %struct._LinkedList, ptr %Baz, i32 0, i32 1,
+!dbg !68, !psr.id !69 | ID: 30 %Next8 = getelementptr inbounds
+%struct._LinkedList, ptr %Baz, i32 0, i32 1, !dbg !90, !psr.id !91 | ID: 41 #6:
+    %Boar = alloca %struct._LinkedList, align 8, !psr.id !22 | ID: 6
+    %Next4 = getelementptr inbounds %struct._LinkedList, ptr %Boar, i32 0, i32
+1, !dbg !64, !psr.id !65 | ID: 28 %Next9 = getelementptr inbounds
+%struct._LinkedList, ptr %Boar, i32 0, i32 1, !dbg !97, !psr.id !98 | ID: 45 #7:
+    %AliasOne = alloca ptr, align 8, !psr.id !23 | ID: 7
+  #8:
+    %AliasTwo = alloca ptr, align 8, !psr.id !24 | ID: 8
+  #9:
+    %AliasThree = alloca ptr, align 8, !psr.id !25 | ID: 9
+  #10:
+    %AliasFour = alloca ptr, align 8, !psr.id !26 | ID: 10
+  #11:
+    %0 = load ptr, ptr %Next6, align 8, !dbg !76, !psr.id !78 | ID: 34
+  #12:
+    %1 = load ptr, ptr %Next7, align 8, !dbg !83, !psr.id !85 | ID: 38
+  #13:
+    %2 = load ptr, ptr %Next8, align 8, !dbg !90, !psr.id !92 | ID: 42
+  #14:
+    %3 = load ptr, ptr %Next9, align 8, !dbg !97, !psr.id !99 | ID: 46
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <1, 2, 3, 4, 5, 6, 11, 12, 13, 14>
+  #2: <7>
+  #3: <8>
+  #4: <9>
+  #5: <10>
+}
+  */
   GTMap GT = {{LineColFunOp{.Line = 8,
                             .Col = 0,
                             .InFunction = "main",
@@ -3137,6 +3104,55 @@ TEST(CtxSensUnionFindAATest, Indirection02) {
 }
 
 TEST(CtxSensUnionFindAATest, Indirection03) {
+  /*
+  ValueCompressor: {
+  #0:
+    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
+  #1:
+    %Foo = alloca %struct._LinkedListOne, align 8, !psr.id !17 | ID: 1
+    %Next4 = getelementptr inbounds %struct._LinkedListOne, ptr %Foo, i32 0, i32
+1, !dbg !73, !psr.id !74 | ID: 29 #2:
+    %.compoundliteral = alloca %struct._LinkedListOne, align 8, !psr.id !18 |
+ID: 2 %Val = getelementptr inbounds %struct._LinkedListOne, ptr
+%.compoundliteral, i32 0, i32 0, !dbg !37, !psr.id !38 | ID: 13 %Next =
+getelementptr inbounds %struct._LinkedListOne, ptr %.compoundliteral, i32 0, i32
+1, !dbg !37, !psr.id !40 | ID: 15 #3: %Bar = alloca %struct._LinkedListTwo,
+align 8, !psr.id !19 | ID: 3 %Next5 = getelementptr inbounds
+%struct._LinkedListTwo, ptr %Bar, i32 0, i32 1, !dbg !80, !psr.id !81 | ID: 33
+  #4:
+    %.compoundliteral1 = alloca %struct._LinkedListTwo, align 8, !psr.id !20 |
+ID: 4 %Val2 = getelementptr inbounds %struct._LinkedListTwo, ptr
+%.compoundliteral1, i32 0, i32 0, !dbg !52, !psr.id !53 | ID: 19 %Next3 =
+getelementptr inbounds %struct._LinkedListTwo, ptr %.compoundliteral1, i32 0,
+i32 1, !dbg !52, !psr.id !55 | ID: 21 #5: %Baz = alloca %struct._LinkedListOne,
+align 8, !psr.id !21 | ID: 5 %Next6 = getelementptr inbounds
+%struct._LinkedListOne, ptr %Baz, i32 0, i32 1, !dbg !87, !psr.id !88 | ID: 37
+  #6:
+    %Boar = alloca %struct._LinkedListTwo, align 8, !psr.id !22 | ID: 6
+    %Next7 = getelementptr inbounds %struct._LinkedListTwo, ptr %Boar, i32 0,
+i32 1, !dbg !94, !psr.id !95 | ID: 41 #7: %AliasOne = alloca ptr, align 8,
+!psr.id !23 | ID: 7 #8: %AliasTwo = alloca ptr, align 8, !psr.id !24 | ID: 8 #9:
+    %AliasThree = alloca ptr, align 8, !psr.id !25 | ID: 9
+  #10:
+    %AliasFour = alloca ptr, align 8, !psr.id !26 | ID: 10
+  #11:
+    %0 = load ptr, ptr %Next4, align 8, !dbg !73, !psr.id !75 | ID: 30
+  #12:
+    %1 = load ptr, ptr %Next5, align 8, !dbg !80, !psr.id !82 | ID: 34
+  #13:
+    %2 = load ptr, ptr %Next6, align 8, !dbg !87, !psr.id !89 | ID: 38
+  #14:
+    %3 = load ptr, ptr %Next7, align 8, !dbg !94, !psr.id !96 | ID: 42
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <1, 2, 3, 4, 5, 6, 11, 12, 13, 14>
+  #2: <7>
+  #3: <8>
+  #4: <9>
+  #5: <10>
+}
+  */
   GTMap GT = {{LineColFunOp{.Line = 13,
                             .Col = 0,
                             .InFunction = "main",
@@ -3205,35 +3221,106 @@ TEST(CtxSensUnionFindAATest, Indirection03) {
 }
 
 TEST(CtxSensUnionFindAATest, Indirection04) {
-  GTMap GT = {{LineColFunOp{.Line = 18,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 18,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 20,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 20,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 22,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 22,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 25,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 25,
+  /*
+  ValueCompressor: {
+  #0:
+    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
+  #1:
+    %Foo = alloca %struct._LinkedListOne, align 8, !psr.id !17 | ID: 1
+    %Next10 = getelementptr inbounds %struct._LinkedListOne, ptr %Foo, i32 0,
+i32 1, !dbg !121, !psr.id !122 | ID: 54 #2:
+    %.compoundliteral = alloca %struct._LinkedListOne, align 8, !psr.id !18 |
+ID: 2 %Val = getelementptr inbounds %struct._LinkedListOne, ptr
+%.compoundliteral, i32 0, i32 0, !dbg !42, !psr.id !43 | ID: 18 %Next =
+getelementptr inbounds %struct._LinkedListOne, ptr %.compoundliteral, i32 0, i32
+1, !dbg !42, !psr.id !45 | ID: 20 #3: %Bar = alloca %struct._LinkedListTwo,
+align 8, !psr.id !19 | ID: 3 %Next11 = getelementptr inbounds
+%struct._LinkedListTwo, ptr %Bar, i32 0, i32 1, !dbg !128, !psr.id !129 | ID: 58
+  #4:
+    %.compoundliteral1 = alloca %struct._LinkedListTwo, align 8, !psr.id !20 |
+ID: 4 %Val2 = getelementptr inbounds %struct._LinkedListTwo, ptr
+%.compoundliteral1, i32 0, i32 0, !dbg !57, !psr.id !58 | ID: 24 %Next3 =
+getelementptr inbounds %struct._LinkedListTwo, ptr %.compoundliteral1, i32 0,
+i32 1, !dbg !57, !psr.id !60 | ID: 26 #5: %Baz = alloca
+%struct._LinkedListThree, align 8, !psr.id !21 | ID: 5 %Next12 = getelementptr
+inbounds %struct._LinkedListThree, ptr %Baz, i32 0, i32 1, !dbg !135, !psr.id
+!136 | ID: 62 #6:
+    %.compoundliteral4 = alloca %struct._LinkedListThree, align 8, !psr.id !22 |
+ID: 6 %Val5 = getelementptr inbounds %struct._LinkedListThree, ptr
+%.compoundliteral4, i32 0, i32 0, !dbg !73, !psr.id !74 | ID: 30 %Next6 =
+getelementptr inbounds %struct._LinkedListThree, ptr %.compoundliteral4, i32 0,
+i32 1, !dbg !73, !psr.id !76 | ID: 32 #7: %One = alloca %struct._LinkedListOne,
+align 8, !psr.id !23 | ID: 7 %Next7 = getelementptr inbounds
+%struct._LinkedListOne, ptr %One, i32 0, i32 1, !dbg !99, !psr.id !100 | ID: 42
+  #8:
+    %Two = alloca %struct._LinkedListTwo, align 8, !psr.id !24 | ID: 8
+    %Next8 = getelementptr inbounds %struct._LinkedListTwo, ptr %Two, i32 0, i32
+1, !dbg !106, !psr.id !107 | ID: 46 #9: %Three = alloca
+%struct._LinkedListThree, align 8, !psr.id !25 | ID: 9 %Next9 = getelementptr
+inbounds %struct._LinkedListThree, ptr %Three, i32 0, i32 1, !dbg !114, !psr.id
+!115 | ID: 50 #10: %AliasOne = alloca ptr, align 8, !psr.id !26 | ID: 10 #11:
+    %AliasTwo = alloca ptr, align 8, !psr.id !27 | ID: 11
+  #12:
+    %AliasThree = alloca ptr, align 8, !psr.id !28 | ID: 12
+  #13:
+    %AliasFour = alloca ptr, align 8, !psr.id !29 | ID: 13
+  #14:
+    %AliasFive = alloca ptr, align 8, !psr.id !30 | ID: 14
+  #15:
+    %AliasSix = alloca ptr, align 8, !psr.id !31 | ID: 15
+  #16:
+    %0 = load ptr, ptr %Next7, align 8, !dbg !99, !psr.id !101 | ID: 43
+  #17:
+    %1 = load ptr, ptr %Next8, align 8, !dbg !106, !psr.id !108 | ID: 47
+  #18:
+    %2 = load ptr, ptr %Next9, align 8, !dbg !114, !psr.id !116 | ID: 51
+  #19:
+    %3 = load ptr, ptr %Next10, align 8, !dbg !121, !psr.id !123 | ID: 55
+  #20:
+    %4 = load ptr, ptr %Next11, align 8, !dbg !128, !psr.id !130 | ID: 59
+  #21:
+    %5 = load ptr, ptr %Next12, align 8, !dbg !135, !psr.id !137 | ID: 63
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21>
+  #2: <10>
+  #3: <11>
+  #4: <12>
+  #5: <13>
+  #6: <14>
+  #7: <15>
+}
+  */
+  GTMap GT = {{LineColFunOp{.Line = 18,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 20,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 22,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 25,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 25,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca}}},
@@ -3305,6 +3392,95 @@ TEST(CtxSensUnionFindAATest, Indirection04) {
 }
 
 TEST(CtxSensUnionFindAATest, Indirection05) {
+  /*
+  ValueCompressor: {
+  #0:
+    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
+  #1:
+    %Foo = alloca %struct._LinkedListOne, align 8, !psr.id !17 | ID: 1
+    %Next14 = getelementptr inbounds %struct._LinkedListOne, ptr %Foo, i32 0,
+i32 1, !dbg !155, !psr.id !156 | ID: 71 #2:
+    %.compoundliteral = alloca %struct._LinkedListOne, align 8, !psr.id !18 |
+ID: 2 %Val = getelementptr inbounds %struct._LinkedListOne, ptr
+%.compoundliteral, i32 0, i32 0, !dbg !47, !psr.id !48 | ID: 23 %Next =
+getelementptr inbounds %struct._LinkedListOne, ptr %.compoundliteral, i32 0, i32
+1, !dbg !47, !psr.id !50 | ID: 25 #3: %Bar = alloca %struct._LinkedListTwo,
+align 8, !psr.id !19 | ID: 3 %Next15 = getelementptr inbounds
+%struct._LinkedListTwo, ptr %Bar, i32 0, i32 1, !dbg !162, !psr.id !163 | ID: 75
+  #4:
+    %.compoundliteral1 = alloca %struct._LinkedListTwo, align 8, !psr.id !20 |
+ID: 4 %Val2 = getelementptr inbounds %struct._LinkedListTwo, ptr
+%.compoundliteral1, i32 0, i32 0, !dbg !62, !psr.id !63 | ID: 29 %Next3 =
+getelementptr inbounds %struct._LinkedListTwo, ptr %.compoundliteral1, i32 0,
+i32 1, !dbg !62, !psr.id !65 | ID: 31 #5: %Baz = alloca
+%struct._LinkedListThree, align 8, !psr.id !21 | ID: 5 %Next16 = getelementptr
+inbounds %struct._LinkedListThree, ptr %Baz, i32 0, i32 1, !dbg !169, !psr.id
+!170 | ID: 79 #6:
+    %.compoundliteral4 = alloca %struct._LinkedListThree, align 8, !psr.id !22 |
+ID: 6 %Val5 = getelementptr inbounds %struct._LinkedListThree, ptr
+%.compoundliteral4, i32 0, i32 0, !dbg !78, !psr.id !79 | ID: 35 %Next6 =
+getelementptr inbounds %struct._LinkedListThree, ptr %.compoundliteral4, i32 0,
+i32 1, !dbg !78, !psr.id !81 | ID: 37 #7: %Boar = alloca
+%struct._LinkedListFour, align 8, !psr.id !23 | ID: 7 %Next17 = getelementptr
+inbounds %struct._LinkedListFour, ptr %Boar, i32 0, i32 1, !dbg !176, !psr.id
+!177 | ID: 83 #8:
+    %.compoundliteral7 = alloca %struct._LinkedListFour, align 8, !psr.id !24 |
+ID: 8 %Val8 = getelementptr inbounds %struct._LinkedListFour, ptr
+%.compoundliteral7, i32 0, i32 0, !dbg !94, !psr.id !95 | ID: 41 %Next9 =
+getelementptr inbounds %struct._LinkedListFour, ptr %.compoundliteral7, i32 0,
+i32 1, !dbg !94, !psr.id !97 | ID: 43 #9: %One = alloca %struct._LinkedListOne,
+align 8, !psr.id !25 | ID: 9 %Next10 = getelementptr inbounds
+%struct._LinkedListOne, ptr %One, i32 0, i32 1, !dbg !125, !psr.id !126 | ID: 55
+  #10:
+    %Two = alloca %struct._LinkedListTwo, align 8, !psr.id !26 | ID: 10
+    %Next11 = getelementptr inbounds %struct._LinkedListTwo, ptr %Two, i32 0,
+i32 1, !dbg !132, !psr.id !133 | ID: 59 #11: %Three = alloca
+%struct._LinkedListThree, align 8, !psr.id !27 | ID: 11 %Next12 = getelementptr
+inbounds %struct._LinkedListThree, ptr %Three, i32 0, i32 1, !dbg !140, !psr.id
+!141 | ID: 63 #12: %Four = alloca %struct._LinkedListFour, align 8, !psr.id !28
+| ID: 12 %Next13 = getelementptr inbounds %struct._LinkedListFour, ptr %Four,
+i32 0, i32 1, !dbg !148, !psr.id !149 | ID: 67 #13: %AliasOne = alloca ptr,
+align 8, !psr.id !29 | ID: 13 #14: %AliasTwo = alloca ptr, align 8, !psr.id !30
+| ID: 14 #15: %AliasThree = alloca ptr, align 8, !psr.id !31 | ID: 15 #16:
+    %AliasFour = alloca ptr, align 8, !psr.id !32 | ID: 16
+  #17:
+    %AliasFive = alloca ptr, align 8, !psr.id !33 | ID: 17
+  #18:
+    %AliasSix = alloca ptr, align 8, !psr.id !34 | ID: 18
+  #19:
+    %AliasSeven = alloca ptr, align 8, !psr.id !35 | ID: 19
+  #20:
+    %AliasEight = alloca ptr, align 8, !psr.id !36 | ID: 20
+  #21:
+    %0 = load ptr, ptr %Next10, align 8, !dbg !125, !psr.id !127 | ID: 56
+  #22:
+    %1 = load ptr, ptr %Next11, align 8, !dbg !132, !psr.id !134 | ID: 60
+  #23:
+    %2 = load ptr, ptr %Next12, align 8, !dbg !140, !psr.id !142 | ID: 64
+  #24:
+    %3 = load ptr, ptr %Next13, align 8, !dbg !148, !psr.id !150 | ID: 68
+  #25:
+    %4 = load ptr, ptr %Next14, align 8, !dbg !155, !psr.id !157 | ID: 72
+  #26:
+    %5 = load ptr, ptr %Next15, align 8, !dbg !162, !psr.id !164 | ID: 76
+  #27:
+    %6 = load ptr, ptr %Next16, align 8, !dbg !169, !psr.id !171 | ID: 80
+  #28:
+    %7 = load ptr, ptr %Next17, align 8, !dbg !176, !psr.id !178 | ID: 84
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 21, 22, 23, 24, 25, 26, 27, 28>
+  #2: <13>
+  #3: <14>
+  #4: <15>
+  #5: <16>
+  #6: <17>
+  #7: <18>
+  #8: <19>
+  #9: <20>
+}
+  */
   GTMap GT = {{LineColFunOp{.Line = 23,
                             .Col = 0,
                             .InFunction = "main",
@@ -3437,6 +3613,109 @@ TEST(CtxSensUnionFindAATest, Indirection05) {
 }
 
 TEST(CtxSensUnionFindAATest, Indirection06) {
+  /*
+  ValueCompressor: {
+  #0:
+    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
+  #1:
+    %Foo = alloca %struct._LinkedListOne, align 8, !psr.id !17 | ID: 1
+    %Next18 = getelementptr inbounds %struct._LinkedListOne, ptr %Foo, i32 0,
+i32 1, !dbg !189, !psr.id !190 | ID: 88 #2:
+    %.compoundliteral = alloca %struct._LinkedListOne, align 8, !psr.id !18 |
+ID: 2 %Val = getelementptr inbounds %struct._LinkedListOne, ptr
+%.compoundliteral, i32 0, i32 0, !dbg !52, !psr.id !53 | ID: 28 %Next =
+getelementptr inbounds %struct._LinkedListOne, ptr %.compoundliteral, i32 0, i32
+1, !dbg !52, !psr.id !55 | ID: 30 #3: %Bar = alloca %struct._LinkedListTwo,
+align 8, !psr.id !19 | ID: 3 %Next19 = getelementptr inbounds
+%struct._LinkedListTwo, ptr %Bar, i32 0, i32 1, !dbg !196, !psr.id !197 | ID: 92
+  #4:
+    %.compoundliteral1 = alloca %struct._LinkedListTwo, align 8, !psr.id !20 |
+ID: 4 %Val2 = getelementptr inbounds %struct._LinkedListTwo, ptr
+%.compoundliteral1, i32 0, i32 0, !dbg !67, !psr.id !68 | ID: 34 %Next3 =
+getelementptr inbounds %struct._LinkedListTwo, ptr %.compoundliteral1, i32 0,
+i32 1, !dbg !67, !psr.id !70 | ID: 36 #5: %Baz = alloca
+%struct._LinkedListThree, align 8, !psr.id !21 | ID: 5 %Next20 = getelementptr
+inbounds %struct._LinkedListThree, ptr %Baz, i32 0, i32 1, !dbg !203, !psr.id
+!204 | ID: 96 #6:
+    %.compoundliteral4 = alloca %struct._LinkedListThree, align 8, !psr.id !22 |
+ID: 6 %Val5 = getelementptr inbounds %struct._LinkedListThree, ptr
+%.compoundliteral4, i32 0, i32 0, !dbg !83, !psr.id !84 | ID: 40 %Next6 =
+getelementptr inbounds %struct._LinkedListThree, ptr %.compoundliteral4, i32 0,
+i32 1, !dbg !83, !psr.id !86 | ID: 42 #7: %Boar = alloca
+%struct._LinkedListFour, align 8, !psr.id !23 | ID: 7 %Next21 = getelementptr
+inbounds %struct._LinkedListFour, ptr %Boar, i32 0, i32 1, !dbg !210, !psr.id
+!211 | ID: 100 #8:
+    %.compoundliteral7 = alloca %struct._LinkedListFour, align 8, !psr.id !24 |
+ID: 8 %Val8 = getelementptr inbounds %struct._LinkedListFour, ptr
+%.compoundliteral7, i32 0, i32 0, !dbg !99, !psr.id !100 | ID: 46 %Next9 =
+getelementptr inbounds %struct._LinkedListFour, ptr %.compoundliteral7, i32 0,
+i32 1, !dbg !99, !psr.id !102 | ID: 48 #9: %Far = alloca
+%struct._LinkedListFive, align 8, !psr.id !25 | ID: 9 %Next22 = getelementptr
+inbounds %struct._LinkedListFive, ptr %Far, i32 0, i32 1, !dbg !217, !psr.id
+!218 | ID: 104 #10:
+    %.compoundliteral10 = alloca %struct._LinkedListFive, align 8, !psr.id !26 |
+ID: 10 %Val11 = getelementptr inbounds %struct._LinkedListFive, ptr
+%.compoundliteral10, i32 0, i32 0, !dbg !115, !psr.id !116 | ID: 52 %Next12 =
+getelementptr inbounds %struct._LinkedListFive, ptr %.compoundliteral10, i32 0,
+i32 1, !dbg !115, !psr.id !118 | ID: 54 #11: %One = alloca
+%struct._LinkedListOne, align 8, !psr.id !27 | ID: 11 %Next13 = getelementptr
+inbounds %struct._LinkedListOne, ptr %One, i32 0, i32 1, !dbg !151, !psr.id !152
+| ID: 68 #12: %Two = alloca %struct._LinkedListTwo, align 8, !psr.id !28 | ID:
+12 %Next14 = getelementptr inbounds %struct._LinkedListTwo, ptr %Two, i32 0, i32
+1, !dbg !158, !psr.id !159 | ID: 72 #13: %Three = alloca
+%struct._LinkedListThree, align 8, !psr.id !29 | ID: 13 %Next15 = getelementptr
+inbounds %struct._LinkedListThree, ptr %Three, i32 0, i32 1, !dbg !166, !psr.id
+!167 | ID: 76 #14: %Four = alloca %struct._LinkedListFour, align 8, !psr.id !30
+| ID: 14 %Next16 = getelementptr inbounds %struct._LinkedListFour, ptr %Four,
+i32 0, i32 1, !dbg !174, !psr.id !175 | ID: 80 #15: %Five = alloca
+%struct._LinkedListFive, align 8, !psr.id !31 | ID: 15 %Next17 = getelementptr
+inbounds %struct._LinkedListFive, ptr %Five, i32 0, i32 1, !dbg !182, !psr.id
+!183 | ID: 84 #16: %AliasOne = alloca ptr, align 8, !psr.id !32 | ID: 16 #17:
+    %AliasTwo = alloca ptr, align 8, !psr.id !33 | ID: 17
+  #18:
+    %AliasThree = alloca ptr, align 8, !psr.id !34 | ID: 18
+  #19:
+    %AliasFour = alloca ptr, align 8, !psr.id !35 | ID: 19
+  #20:
+    %AliasFive = alloca ptr, align 8, !psr.id !36 | ID: 20
+  #21:
+    %AliasSix = alloca ptr, align 8, !psr.id !37 | ID: 21
+  #22:
+    %AliasSeven = alloca ptr, align 8, !psr.id !38 | ID: 22
+  #23:
+    %AliasEight = alloca ptr, align 8, !psr.id !39 | ID: 23
+  #24:
+    %AliasNine = alloca ptr, align 8, !psr.id !40 | ID: 24
+  #25:
+    %AliasTen = alloca ptr, align 8, !psr.id !41 | ID: 25
+  #26:
+    %0 = load ptr, ptr %Next13, align 8, !dbg !151, !psr.id !153 | ID: 69
+  #27:
+    %1 = load ptr, ptr %Next14, align 8, !dbg !158, !psr.id !160 | ID: 73
+  #28:
+    %2 = load ptr, ptr %Next15, align 8, !dbg !166, !psr.id !168 | ID: 77
+  #29:
+    %3 = load ptr, ptr %Next16, align 8, !dbg !174, !psr.id !176 | ID: 81
+  #30:
+    %4 = load ptr, ptr %Next17, align 8, !dbg !182, !psr.id !184 | ID: 85
+  #31:
+    %5 = load ptr, ptr %Next18, align 8, !dbg !189, !psr.id !191 | ID: 89
+  #32:
+    %6 = load ptr, ptr %Next19, align 8, !dbg !196, !psr.id !198 | ID: 93
+  #33:
+    %7 = load ptr, ptr %Next20, align 8, !dbg !203, !psr.id !205 | ID: 97
+  #34:
+    %8 = load ptr, ptr %Next21, align 8, !dbg !210, !psr.id !212 | ID: 101
+  #35:
+    %9 = load ptr, ptr %Next22, align 8, !dbg !217, !psr.id !219 | ID: 105
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 26, 27, 28, 29, 30,
+31, 32, 33, 34, 35> #2: <16> #3: <17> #4: <18> #5: <19> #6: <20> #7: <21> #8:
+<22> #9: <23> #10: <24> #11: <25>
+}
+  */
   GTMap GT = {{LineColFunOp{.Line = 28,
                             .Col = 0,
                             .InFunction = "main",
@@ -3601,6 +3880,127 @@ TEST(CtxSensUnionFindAATest, Indirection06) {
 }
 
 TEST(CtxSensUnionFindAATest, Indirection07) {
+  /*
+  ValueCompressor: {
+  #0:
+    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
+  #1:
+    %Foo = alloca %struct._LinkedListOne, align 8, !psr.id !17 | ID: 1
+    %Next22 = getelementptr inbounds %struct._LinkedListOne, ptr %Foo, i32 0,
+i32 1, !dbg !223, !psr.id !224 | ID: 105 #2:
+    %.compoundliteral = alloca %struct._LinkedListOne, align 8, !psr.id !18 |
+ID: 2 %Val = getelementptr inbounds %struct._LinkedListOne, ptr
+%.compoundliteral, i32 0, i32 0, !dbg !57, !psr.id !58 | ID: 33 %Next =
+getelementptr inbounds %struct._LinkedListOne, ptr %.compoundliteral, i32 0, i32
+1, !dbg !57, !psr.id !60 | ID: 35 #3: %Bar = alloca %struct._LinkedListTwo,
+align 8, !psr.id !19 | ID: 3 %Next23 = getelementptr inbounds
+%struct._LinkedListTwo, ptr %Bar, i32 0, i32 1, !dbg !230, !psr.id !231 | ID:
+109 #4:
+    %.compoundliteral1 = alloca %struct._LinkedListTwo, align 8, !psr.id !20 |
+ID: 4 %Val2 = getelementptr inbounds %struct._LinkedListTwo, ptr
+%.compoundliteral1, i32 0, i32 0, !dbg !72, !psr.id !73 | ID: 39 %Next3 =
+getelementptr inbounds %struct._LinkedListTwo, ptr %.compoundliteral1, i32 0,
+i32 1, !dbg !72, !psr.id !75 | ID: 41 #5: %Baz = alloca
+%struct._LinkedListThree, align 8, !psr.id !21 | ID: 5 %Next24 = getelementptr
+inbounds %struct._LinkedListThree, ptr %Baz, i32 0, i32 1, !dbg !237, !psr.id
+!238 | ID: 113 #6:
+    %.compoundliteral4 = alloca %struct._LinkedListThree, align 8, !psr.id !22 |
+ID: 6 %Val5 = getelementptr inbounds %struct._LinkedListThree, ptr
+%.compoundliteral4, i32 0, i32 0, !dbg !88, !psr.id !89 | ID: 45 %Next6 =
+getelementptr inbounds %struct._LinkedListThree, ptr %.compoundliteral4, i32 0,
+i32 1, !dbg !88, !psr.id !91 | ID: 47 #7: %Boar = alloca
+%struct._LinkedListFour, align 8, !psr.id !23 | ID: 7 %Next25 = getelementptr
+inbounds %struct._LinkedListFour, ptr %Boar, i32 0, i32 1, !dbg !244, !psr.id
+!245 | ID: 117 #8:
+    %.compoundliteral7 = alloca %struct._LinkedListFour, align 8, !psr.id !24 |
+ID: 8 %Val8 = getelementptr inbounds %struct._LinkedListFour, ptr
+%.compoundliteral7, i32 0, i32 0, !dbg !104, !psr.id !105 | ID: 51 %Next9 =
+getelementptr inbounds %struct._LinkedListFour, ptr %.compoundliteral7, i32 0,
+i32 1, !dbg !104, !psr.id !107 | ID: 53 #9: %Far = alloca
+%struct._LinkedListFive, align 8, !psr.id !25 | ID: 9 %Next26 = getelementptr
+inbounds %struct._LinkedListFive, ptr %Far, i32 0, i32 1, !dbg !251, !psr.id
+!252 | ID: 121 #10:
+    %.compoundliteral10 = alloca %struct._LinkedListFive, align 8, !psr.id !26 |
+ID: 10 %Val11 = getelementptr inbounds %struct._LinkedListFive, ptr
+%.compoundliteral10, i32 0, i32 0, !dbg !120, !psr.id !121 | ID: 57 %Next12 =
+getelementptr inbounds %struct._LinkedListFive, ptr %.compoundliteral10, i32 0,
+i32 1, !dbg !120, !psr.id !123 | ID: 59 #11: %Faz = alloca
+%struct._LinkedListSix, align 8, !psr.id !27 | ID: 11 %Next27 = getelementptr
+inbounds %struct._LinkedListSix, ptr %Faz, i32 0, i32 1, !dbg !258, !psr.id !259
+| ID: 125 #12:
+    %.compoundliteral13 = alloca %struct._LinkedListSix, align 8, !psr.id !28 |
+ID: 12 %Val14 = getelementptr inbounds %struct._LinkedListSix, ptr
+%.compoundliteral13, i32 0, i32 0, !dbg !136, !psr.id !137 | ID: 63 %Next15 =
+getelementptr inbounds %struct._LinkedListSix, ptr %.compoundliteral13, i32 0,
+i32 1, !dbg !136, !psr.id !139 | ID: 65 #13: %One = alloca
+%struct._LinkedListOne, align 8, !psr.id !29 | ID: 13 %Next16 = getelementptr
+inbounds %struct._LinkedListOne, ptr %One, i32 0, i32 1, !dbg !177, !psr.id !178
+| ID: 81 #14: %Two = alloca %struct._LinkedListTwo, align 8, !psr.id !30 | ID:
+14 %Next17 = getelementptr inbounds %struct._LinkedListTwo, ptr %Two, i32 0, i32
+1, !dbg !184, !psr.id !185 | ID: 85 #15: %Three = alloca
+%struct._LinkedListThree, align 8, !psr.id !31 | ID: 15 %Next18 = getelementptr
+inbounds %struct._LinkedListThree, ptr %Three, i32 0, i32 1, !dbg !192, !psr.id
+!193 | ID: 89 #16: %Four = alloca %struct._LinkedListFour, align 8, !psr.id !32
+| ID: 16 %Next19 = getelementptr inbounds %struct._LinkedListFour, ptr %Four,
+i32 0, i32 1, !dbg !200, !psr.id !201 | ID: 93 #17: %Five = alloca
+%struct._LinkedListFive, align 8, !psr.id !33 | ID: 17 %Next20 = getelementptr
+inbounds %struct._LinkedListFive, ptr %Five, i32 0, i32 1, !dbg !208, !psr.id
+!209 | ID: 97 #18: %Six = alloca %struct._LinkedListSix, align 8, !psr.id !34 |
+ID: 18 %Next21 = getelementptr inbounds %struct._LinkedListSix, ptr %Six, i32 0,
+i32 1, !dbg !216, !psr.id !217 | ID: 101 #19: %AliasOne = alloca ptr, align 8,
+!psr.id !35 | ID: 19 #20: %AliasTwo = alloca ptr, align 8, !psr.id !36 | ID: 20
+  #21:
+    %AliasThree = alloca ptr, align 8, !psr.id !37 | ID: 21
+  #22:
+    %AliasFour = alloca ptr, align 8, !psr.id !38 | ID: 22
+  #23:
+    %AliasFive = alloca ptr, align 8, !psr.id !39 | ID: 23
+  #24:
+    %AliasSix = alloca ptr, align 8, !psr.id !40 | ID: 24
+  #25:
+    %AliasSeven = alloca ptr, align 8, !psr.id !41 | ID: 25
+  #26:
+    %AliasEight = alloca ptr, align 8, !psr.id !42 | ID: 26
+  #27:
+    %AliasNine = alloca ptr, align 8, !psr.id !43 | ID: 27
+  #28:
+    %AliasTen = alloca ptr, align 8, !psr.id !44 | ID: 28
+  #29:
+    %AliasEleven = alloca ptr, align 8, !psr.id !45 | ID: 29
+  #30:
+    %AliasTwelve = alloca ptr, align 8, !psr.id !46 | ID: 30
+  #31:
+    %0 = load ptr, ptr %Next16, align 8, !dbg !177, !psr.id !179 | ID: 82
+  #32:
+    %1 = load ptr, ptr %Next17, align 8, !dbg !184, !psr.id !186 | ID: 86
+  #33:
+    %2 = load ptr, ptr %Next18, align 8, !dbg !192, !psr.id !194 | ID: 90
+  #34:
+    %3 = load ptr, ptr %Next19, align 8, !dbg !200, !psr.id !202 | ID: 94
+  #35:
+    %4 = load ptr, ptr %Next20, align 8, !dbg !208, !psr.id !210 | ID: 98
+  #36:
+    %5 = load ptr, ptr %Next21, align 8, !dbg !216, !psr.id !218 | ID: 102
+  #37:
+    %6 = load ptr, ptr %Next22, align 8, !dbg !223, !psr.id !225 | ID: 106
+  #38:
+    %7 = load ptr, ptr %Next23, align 8, !dbg !230, !psr.id !232 | ID: 110
+  #39:
+    %8 = load ptr, ptr %Next24, align 8, !dbg !237, !psr.id !239 | ID: 114
+  #40:
+    %9 = load ptr, ptr %Next25, align 8, !dbg !244, !psr.id !246 | ID: 118
+  #41:
+    %10 = load ptr, ptr %Next26, align 8, !dbg !251, !psr.id !253 | ID: 122
+  #42:
+    %11 = load ptr, ptr %Next27, align 8, !dbg !258, !psr.id !260 | ID: 126
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 31, 32,
+33, 34, 35, 36, 37, 38, 39, 40, 41, 42> #2: <19> #3: <20> #4: <21> #5: <22> #6:
+<23> #7: <24> #8: <25> #9: <26> #10: <27> #11: <28> #12: <29> #13: <30>
+}
+  */
   GTMap GT = {{LineColFunOp{.Line = 33,
                             .Col = 0,
                             .InFunction = "main",
@@ -3795,33 +4195,158 @@ TEST(CtxSensUnionFindAATest, Indirection07) {
                              .OpCode = llvm::Instruction::Alloca}}}};
   doAnalysisAndCompareResults("indirection_07_c_dbg.ll", GT, ContextAABuilder);
 }
-
-TEST(CtxSensUnionFindAATest, Indirection08) {
-  GTMap GT = {{LineColFunOp{.Line = 13,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 13,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 14,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 16,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 16,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}}};
-  doAnalysisAndCompareResults("indirection_08_cpp_dbg.ll", GT,
-                              ContextAABuilder);
+
+TEST(CtxSensUnionFindAATest, Indirection08) {
+  /*
+  ValueCompressor: {
+  #0:
+    @_ZTV3Foo = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
+x ptr] [ptr null, ptr @_ZTI3Foo, ptr @_ZN3Foo4FuncEv] }, comdat, align 8,
+!psr.id !0 | ID: 0 #1:
+    @_ZTI3Foo = linkonce_odr dso_local constant { ptr, ptr } { ptr getelementptr
+inbounds (ptr, ptr @_ZTVN10__cxxabiv117__class_type_infoE, i64 2), ptr @_ZTS3Foo
+}, comdat, align 8, !psr.id !3 | ID: 3 #2: fun @_ZN3Foo4FuncEv #3:
+    @_ZTS3Foo = linkonce_odr dso_local constant [5 x i8] c"3Foo\00", comdat,
+align 1, !psr.id !2 | ID: 2 #4:
+    @_ZTVN10__cxxabiv117__class_type_infoE = external global ptr, !psr.id !1 |
+ID: 1 #5:
+    @_ZTV3Bar = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
+x ptr] [ptr null, ptr @_ZTI3Bar, ptr @_ZN3Bar4FuncEv] }, comdat, align 8,
+!psr.id !4 | ID: 4 #6:
+    @_ZTI3Bar = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
+getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
+2), ptr @_ZTS3Bar, ptr @_ZTI3Foo }, comdat, align 8, !psr.id !7 | ID: 7 #7: fun
+@_ZN3Bar4FuncEv #8:
+    @_ZTS3Bar = linkonce_odr dso_local constant [5 x i8] c"3Bar\00", comdat,
+align 1, !psr.id !6 | ID: 6 #9:
+    @_ZTVN10__cxxabiv120__si_class_type_infoE = external global ptr, !psr.id !5
+| ID: 5 #10: %retval = alloca i32, align 4, !psr.id !24 | ID: 8 #11: %First =
+alloca %class.Foo, align 8, !psr.id !25 | ID: 9 #12: %Second = alloca
+%class.Bar, align 8, !psr.id !26 | ID: 10 #13: %SecondAlias = alloca ptr, align
+8, !psr.id !27 | ID: 11 #14: ptr %this | ID: _ZN3FooC2Ev.0 #15: ptr %this | ID:
+_ZN3BarC2Ev.0 #16: %0 = load ptr, ptr %SecondAlias, align 8, !dbg !60, !psr.id
+!61 | ID: 21 #17: %vtable = load ptr, ptr %0, align 8, !dbg !62, !psr.id !63 |
+ID: 22 %vfn = getelementptr inbounds ptr, ptr %vtable, i64 0, !dbg !62, !psr.id
+!64 | ID: 23 #18: %1 = load ptr, ptr %vfn, align 8, !dbg !62, !psr.id !65 | ID:
+24 #19: ptr %this | ID: _ZN3Foo4FuncEv.0 #20: ptr %this | ID: _ZN3Bar4FuncEv.0
+  #21:
+    %this.addr = alloca ptr, align 8, !psr.id !73 | ID: 27
+  #22:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !79 | ID: 30
+  #23:
+    %this.addr = alloca ptr, align 8, !psr.id !87 | ID: 33
+  #24:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !93 | ID: 36
+  #25:
+    %this.addr = alloca ptr, align 8, !psr.id !99 | ID: 40
+  #26:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !104 | ID: 43
+  #27:
+    %this.addr = alloca ptr, align 8, !psr.id !108 | ID: 45
+  #28:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !113 | ID: 48
+}
+UnionFindAAResult {
+  #0: <0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 14, 15, 16, 17, 18, 19, 20, 22, 24,
+26, 28> #1: <10> #2: <13> #3: <21> #4: <21> #5: <23> #6: <25> #7: <27>
+}
+  */
+  GTMap GT = {{LineColFunOp{.Line = 13,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 13,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 14,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}},
+              {LineColFunOp{.Line = 16,
+                            .Col = 0,
+                            .InFunction = "main",
+                            .OpCode = llvm::Instruction::Alloca},
+               {LineColFunOp{.Line = 16,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca}}}};
+  doAnalysisAndCompareResults("indirection_08_cpp_dbg.ll", GT,
+                              ContextAABuilder);
+}
+
+TEST(CtxSensUnionFindAATest, Indirection09) {
+  /*
+  ValueCompressor: {
+  #0:
+    @_ZTV3Foo = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
+x ptr] [ptr null, ptr @_ZTI3Foo, ptr @_ZN3Foo4FuncEv] }, comdat, align 8,
+!psr.id !8 | ID: 1 #1:
+    @_ZTI3Foo = linkonce_odr dso_local constant { ptr, ptr } { ptr getelementptr
+inbounds (ptr, ptr @_ZTVN10__cxxabiv117__class_type_infoE, i64 2), ptr @_ZTS3Foo
+}, comdat, align 8, !psr.id !11 | ID: 4 #2: fun @_ZN3Foo4FuncEv #3:
+    @_ZTS3Foo = linkonce_odr dso_local constant [5 x i8] c"3Foo\00", comdat,
+align 1, !psr.id !10 | ID: 3 #4:
+    @_ZTVN10__cxxabiv117__class_type_infoE = external global ptr, !psr.id !9 |
+ID: 2 #5:
+    @_ZTV3Bar = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
+x ptr] [ptr null, ptr @_ZTI3Bar, ptr @_ZN3Bar4FuncEv] }, comdat, align 8,
+!psr.id !12 | ID: 5 #6:
+    @_ZTI3Bar = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
+getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
+2), ptr @_ZTS3Bar, ptr @_ZTI3Foo }, comdat, align 8, !psr.id !15 | ID: 8 #7: fun
+@_ZN3Bar4FuncEv #8:
+    @_ZTS3Bar = linkonce_odr dso_local constant [5 x i8] c"3Bar\00", comdat,
+align 1, !psr.id !14 | ID: 7 #9:
+    @_ZTVN10__cxxabiv120__si_class_type_infoE = external global ptr, !psr.id !13
+| ID: 6 #10:
+    @_ZTV3Baz = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
+x ptr] [ptr null, ptr @_ZTI3Baz, ptr @_ZN3Baz4FuncEv] }, comdat, align 8,
+!psr.id !16 | ID: 9 #11:
+    @_ZTI3Baz = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
+getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
+2), ptr @_ZTS3Baz, ptr @_ZTI3Bar }, comdat, align 8, !psr.id !18 | ID: 11 #12:
+    fun @_ZN3Baz4FuncEv
+  #13:
+    @_ZTS3Baz = linkonce_odr dso_local constant [5 x i8] c"3Baz\00", comdat,
+align 1, !psr.id !17 | ID: 10 #14: %retval = alloca i32, align 4, !psr.id !32 |
+ID: 12 #15: %First = alloca %class.Foo, align 8, !psr.id !33 | ID: 13 #16:
+    %Second = alloca %class.Bar, align 8, !psr.id !34 | ID: 14
+  #17:
+    %Third = alloca %class.Baz, align 8, !psr.id !35 | ID: 15
+  #18:
+    %FooRef = alloca ptr, align 8, !psr.id !36 | ID: 16
+  #19:
+    ptr %this | ID: _ZN3FooC2Ev.0
+  #20:
+    ptr %this | ID: _ZN3BarC2Ev.0
+  #21:
+    ptr %this | ID: _ZN3BazC2Ev.0
+  #22:
+    %cond-lvalue = phi ptr [ %Second, %cond.true ], [ %Third, %cond.false ],
+!dbg !80, !psr.id !86 | ID: 33 #23: %1 = load ptr, ptr %FooRef, align 8, !dbg
+!88, !psr.id !89 | ID: 35 #24: %vtable = load ptr, ptr %1, align 8, !dbg !90,
+!psr.id !91 | ID: 36 %vfn = getelementptr inbounds ptr, ptr %vtable, i64 0, !dbg
+!90, !psr.id !92 | ID: 37 #25: %2 = load ptr, ptr %vfn, align 8, !dbg !90,
+!psr.id !93 | ID: 38 #26: ptr %this | ID: _ZN3Bar4FuncEv.0 #27: ptr %this | ID:
+_ZN3Baz4FuncEv.0 #28: ptr %this | ID: _ZN3Foo4FuncEv.0 #29: %this.addr = alloca
+ptr, align 8, !psr.id !101 | ID: 41 #30: %this1 = load ptr, ptr %this.addr,
+align 8, !psr.id !107 | ID: 44 #31: %this.addr = alloca ptr, align 8, !psr.id
+!115 | ID: 47 #32: %this1 = load ptr, ptr %this.addr, align 8, !psr.id !121 |
+ID: 50 #33: %this.addr = alloca ptr, align 8, !psr.id !130 | ID: 54 #34: %this1
+= load ptr, ptr %this.addr, align 8, !psr.id !136 | ID: 57 #35: %this.addr =
+alloca ptr, align 8, !psr.id !142 | ID: 61 #36: %this1 = load ptr, ptr
+%this.addr, align 8, !psr.id !147 | ID: 64 #37: %this.addr = alloca ptr, align
+8, !psr.id !151 | ID: 66 #38: %this1 = load ptr, ptr %this.addr, align 8,
+!psr.id !156 | ID: 69 #39: %this.addr = alloca ptr, align 8, !psr.id !160 | ID:
+71 #40: %this1 = load ptr, ptr %this.addr, align 8, !psr.id !165 | ID: 74
+}
+UnionFindAAResult {
+  #0: <0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 16, 17, 19, 20, 21, 22,
+23, 24, 25, 26, 27, 28, 30, 32, 34, 36, 38, 40> #1: <14> #2: <18> #3: <29> #4:
+<29> #5: <31> #6: <31> #7: <33> #8: <35> #9: <37> #10: <39>
 }
-
-TEST(CtxSensUnionFindAATest, Indirection09) {
+  */
   GTMap GT = {{LineColFunOp{.Line = 19,
                             .Col = 0,
                             .InFunction = "main",
@@ -3851,6 +4376,87 @@ TEST(CtxSensUnionFindAATest, Indirection09) {
 }
 
 TEST(CtxSensUnionFindAATest, Indirection10) {
+  /*
+  ValueCompressor: {
+  #0:
+    @_ZTV3Foo = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
+x ptr] [ptr null, ptr @_ZTI3Foo, ptr @_ZN3Foo4FuncEv] }, comdat, align 8,
+!psr.id !0 | ID: 0
+  #1:
+    @_ZTI3Foo = linkonce_odr dso_local constant { ptr, ptr } { ptr getelementptr
+inbounds (ptr, ptr @_ZTVN10__cxxabiv117__class_type_infoE, i64 2), ptr @_ZTS3Foo
+}, comdat, align 8, !psr.id !3 | ID: 3
+  #2: fun @_ZN3Foo4FuncEv
+  #3:
+    @_ZTS3Foo = linkonce_odr dso_local constant [5 x i8] c"3Foo\00", comdat,
+align 1, !psr.id !2 | ID: 2
+  #4:
+    @_ZTVN10__cxxabiv117__class_type_infoE = external global ptr, !psr.id !1 |
+ID: 1
+  #5:
+    @_ZTV3Bar = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
+x ptr] [ptr null, ptr @_ZTI3Bar, ptr @_ZN3Bar4FuncEv] }, comdat, align 8,
+!psr.id !4 | ID: 4
+  #6:
+    @_ZTI3Bar = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
+getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
+2), ptr @_ZTS3Bar, ptr @_ZTI3Foo }, comdat, align 8, !psr.id !7 | ID: 7
+  #7: fun
+@_ZN3Bar4FuncEv
+  #8:
+    @_ZTS3Bar = linkonce_odr dso_local constant [5 x i8] c"3Bar\00", comdat,
+align 1, !psr.id !6 | ID: 6
+  #9:
+    @_ZTVN10__cxxabiv120__si_class_type_infoE = external global ptr, !psr.id !5
+| ID: 5
+  #10: %retval = alloca i32, align 4, !psr.id !24 | ID: 8
+  #11: %First =
+alloca %class.Foo, align 8, !psr.id !25 | ID: 9
+  #12: %Second = alloca
+%class.Bar, align 8, !psr.id !26 | ID: 10
+  #13: %SecondAlias = alloca ptr, align
+8, !psr.id !27 | ID: 11
+  #14: ptr %this | ID: _ZN3FooC2Ev.0
+  #15: ptr %this | ID:
+_ZN3BarC2Ev.0
+  #16: %0 = load ptr, ptr %SecondAlias, align 8, !dbg !62, !psr.id
+!63 | ID: 21
+  #17: %vtable = load ptr, ptr %0, align 8, !dbg !64, !psr.id !65 |
+ID: 22 %vfn = getelementptr inbounds ptr, ptr %vtable, i64 0, !dbg !64, !psr.id
+!66 | ID: 23
+  #18: %1 = load ptr, ptr %vfn, align 8, !dbg !64, !psr.id !67 | ID:
+24
+  #19: ptr %this | ID: _ZN3Foo4FuncEv.0
+  #20: ptr %this | ID: _ZN3Bar4FuncEv.0
+  #21:
+    %this.addr = alloca ptr, align 8, !psr.id !75 | ID: 27
+  #22:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !80 | ID: 30
+  #23:
+    %this.addr = alloca ptr, align 8, !psr.id !88 | ID: 33
+  #24:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !94 | ID: 36
+  #25:
+    %this.addr = alloca ptr, align 8, !psr.id !100 | ID: 40
+  #26:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !105 | ID: 43
+  #27:
+    %this.addr = alloca ptr, align 8, !psr.id !109 | ID: 45
+  #28:
+    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !114 | ID: 48
+}
+UnionFindAAResult {
+  #0: <0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 14, 15, 16, 17, 18, 19, 20, 22, 24,
+26, 28>
+  #1: <10>
+  #2: <13>
+  #3: <21>
+  #4: <21>
+  #5: <23>
+  #6: <25>
+  #7: <27>
+}
+  */
   GTMap GT = {{LineColFunOp{.Line = 20,
                             .Col = 0,
                             .InFunction = "main",
@@ -4011,7 +4617,8 @@ TODO: ask fabian how to get { fun @Func }
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 5,
+               {FuncByName{.NameOfFunction = "Func"},
+                LineColFunOp{.Line = 5,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca}}},
@@ -4810,6 +5417,32 @@ TEST(BotUnionFindAATest, Context13_1) {
 }
 
 TEST(BotUnionFindAATest, Indirection01) {
+  /*
+  ValueCompressor: {
+  #0:
+    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
+  #1:
+    %Foo = alloca %struct._LinkedList, align 8, !psr.id !17 | ID: 1
+    %Next1 = getelementptr inbounds %struct._LinkedList, ptr %Foo, i32 0, i32 1,
+!dbg !41, !psr.id !42 | ID: 12
+  #2:
+    %.compoundliteral = alloca %struct._LinkedList, align 8, !psr.id !18 | ID: 2
+    %Val = getelementptr inbounds %struct._LinkedList, ptr %.compoundliteral,
+i32 0, i32 0, !dbg !30, !psr.id !31 | ID: 6 %Next = getelementptr inbounds
+%struct._LinkedList, ptr %.compoundliteral, i32 0, i32 1, !dbg !30, !psr.id !33
+| ID: 8
+  #3: %Alias = alloca ptr, align 8, !psr.id !19 | ID: 3
+  #4: %0 = load ptr,
+ptr %Next1, align 8, !dbg !41, !psr.id !43 | ID: 13
+}
+UnionFindAAResult {
+  #0: <0>
+  #1: <1, 2, 4>
+  #2: <3>
+}
+  // TODO: get %.compoundliteral = alloca %struct._LinkedList
+           Same line as Foo alloca, but more obfuscated
+  */
   GTMap GT = {{LineColFunOp{.Line = 8,
                             .Col = 0,
                             .InFunction = "main",
@@ -5732,10 +6365,10 @@ TEST(IndirectionSensUnionFindAATest, Basic04) {
                                 .Col = 0,
                                 .InFunction = "main",
                                 .OpCode = llvm::Instruction::Alloca},
-                   LineColFunOp{.Line = 6,
+                   LineColFunOp{.Line = 11,
                                 .Col = 0,
                                 .InFunction = "main",
-                                .OpCode = llvm::Instruction::Alloca},
+                                .OpCode = llvm::Instruction::Load},
                }}};
 
   doAnalysisAndCompareResults("basic_04_c_dbg.ll", GT, IndAABuilder);
@@ -9427,10 +10060,6 @@ UnionFindAAResult {
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
             {LineColFunOp{.Line = 7,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca},
-             LineColFunOp{.Line = 6,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca}}}};
@@ -9574,13 +10203,10 @@ UnionFindAAResult {
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {
-                RetVal{.InFunction = "callback"},
-                LineColFunOp{.Line = 11,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-            }}};
+            {LineColFunOp{.Line = 11,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("context_14_2_c_dbg.ll", GT, IndAABuilder);
 }
@@ -10977,8 +11603,8 @@ ID: 12 #15: %First = alloca %class.Foo, align 8, !psr.id !33 | ID: 13 #16:
 !88, !psr.id !89 | ID: 35 #24: %vtable = load ptr, ptr %1, align 8, !dbg !90,
 !psr.id !91 | ID: 36 %vfn = getelementptr inbounds ptr, ptr %vtable, i64 0, !dbg
 !90, !psr.id !92 | ID: 37 #25: %2 = load ptr, ptr %vfn, align 8, !dbg !90,
-!psr.id !93 | ID: 38 #26: ptr %this | ID: _ZN3Foo4FuncEv.0 #27: ptr %this | ID:
-_ZN3Bar4FuncEv.0 #28: ptr %this | ID: _ZN3Baz4FuncEv.0 #29: %this.addr = alloca
+!psr.id !93 | ID: 38 #26: ptr %this | ID: _ZN3Baz4FuncEv.0 #27: ptr %this | ID:
+_ZN3Bar4FuncEv.0 #28: ptr %this | ID: _ZN3Foo4FuncEv.0 #29: %this.addr = alloca
 ptr, align 8, !psr.id !101 | ID: 41 #30: %this1 = load ptr, ptr %this.addr,
 align 8, !psr.id !107 | ID: 44 #31: %this.addr = alloca ptr, align 8, !psr.id
 !115 | ID: 47 #32: %this1 = load ptr, ptr %this.addr, align 8, !psr.id !121 |
@@ -10990,56 +11616,68 @@ alloca ptr, align 8, !psr.id !142 | ID: 61 #36: %this1 = load ptr, ptr
 !psr.id !156 | ID: 69 #39: %this.addr = alloca ptr, align 8, !psr.id !160 | ID:
 71 #40: %this1 = load ptr, ptr %this.addr, align 8, !psr.id !165 | ID: 74
 }
-
-LLVMUnionFindAliasSet(global, ind-sens) {
-  #0: {0, 5, 10, 24}
-  #1: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25}
-  #2: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25}
-  #3: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25}
-  #4: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25}
-  #5: {0, 5, 10, 24}
-  #6: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25}
-  #7: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25}
-  #8: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25}
-  #9: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25}
-  #10: {0, 5, 10, 24}
-  #11: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25}
-  #12: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25}
-  #13: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25}
-  #14: {14}
-  #15: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
-  #16: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
-  #17: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
-  #18: {18}
-  #19: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
-  #20: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
-  #21: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
-  #22: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
-  #23: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
-  #24: {0, 5, 10, 24}
-  #25: {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25}
-  #26: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
-  #27: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
-  #28: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
-  #29: {29}
-  #30: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
-  #31: {31}
-  #32: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
-  #33: {33}
-  #34: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
-  #35: {35}
-  #36: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
-  #37: {37}
-  #38: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
-  #39: {39}
-  #40: {15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40}
+UnionFindAAResult {
+  #0: <0, 5, 10, 24>
+  #1: <1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25>
+  #2: <14>
+  #3: <>
+  #4: <>
+  #5: <>
+  #6: <>
+  #7: <15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40>
+  #8: <18>
+  #9: <>
+  #10: <>
+  #11: <>
+  #12: <>
+  #13: <29>
+  #14: <>
+  #15: <>
+  #16: <>
+  #17: <>
+  #18: <31>
+  #19: <>
+  #20: <>
+  #21: <>
+  #22: <>
+  #23: <33>
+  #24: <>
+  #25: <>
+  #26: <>
+  #27: <>
+  #28: <35>
+  #29: <>
+  #30: <>
+  #31: <>
+  #32: <>
+  #33: <37>
+  #34: <>
+  #35: <>
+  #36: <>
+  #37: <>
+  #38: <39>
+  #39: <>
+  #40: <>
+  #41: <>
+  #42: <>
 }
+
+  TODO: ask Fabian about below. My impl doesn't work (commented out):
+  Computed unexpected alias of LineColFunOp { Line: 19; Col: 0; InFunction:
+main; OpCode: alloca }: { %cond-lvalue = phi ptr [ %Second, %cond.true ], [
+%Third, %cond.false ], !dbg !80, !psr.id !86 | ID: 33 }
   */
   GTMap GT{{LineColFunOp{.Line = 19,
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 19,
+            {ArgInFun{.Idx = 0, .InFunction = "_ZN3FooC2Ev"},
+             ArgInFun{.Idx = 0, .InFunction = "_ZN3BarC2Ev"},
+             ArgInFun{.Idx = 0, .InFunction = "_ZN3BazC2Ev"},
+             ArgInFun{.Idx = 0, .InFunction = "_ZN3Foo4FuncEv"},
+             ArgInFun{.Idx = 0, .InFunction = "_ZN3Bar4FuncEv"},
+             ArgInFun{.Idx = 0, .InFunction = "_ZN3Baz4FuncEv"},
+             LineColFunOp{.Line = 19,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca},
@@ -11055,51 +11693,54 @@ LLVMUnionFindAliasSet(global, ind-sens) {
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 23,
-                          .Col = 0,
-                          .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca}}}};
+            {
+                LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                // LineColFun{.Line = 23, .Col = 17, .InFunction = "main"}
+            }}};
 
   doAnalysisAndCompareResults("indirection_09_cpp_dbg.ll", GT, IndAABuilder);
 }
 
 TEST(IndirectionSensUnionFindAATest, Indirection10) {
   /*
-  ValueCompressor: {
+ValueCompressor: {
   #0:
-    @_ZTV3Foo = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
-x ptr] [ptr null, ptr @_ZTI3Foo, ptr @_ZN3Foo4FuncEv] }, comdat, align 8,
+    @_ZTV3Foo = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } {
+[3 x ptr] [ptr null, ptr @_ZTI3Foo, ptr @_ZN3Foo4FuncEv] }, comdat, align 8,
 !psr.id !0 | ID: 0 #1:
-    @_ZTI3Foo = linkonce_odr dso_local constant { ptr, ptr } { ptr getelementptr
-inbounds (ptr, ptr @_ZTVN10__cxxabiv117__class_type_infoE, i64 2), ptr @_ZTS3Foo
+    @_ZTI3Foo = linkonce_odr dso_local constant { ptr, ptr } { ptr
+getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv117__class_type_infoE, i64
+2), ptr @_ZTS3Foo
 }, comdat, align 8, !psr.id !3 | ID: 3 #2: fun @_ZN3Foo4FuncEv #3:
     @_ZTS3Foo = linkonce_odr dso_local constant [5 x i8] c"3Foo\00", comdat,
 align 1, !psr.id !2 | ID: 2 #4:
     @_ZTVN10__cxxabiv117__class_type_infoE = external global ptr, !psr.id !1 |
 ID: 1 #5:
-    @_ZTV3Bar = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
-x ptr] [ptr null, ptr @_ZTI3Bar, ptr @_ZN3Bar4FuncEv] }, comdat, align 8,
+    @_ZTV3Bar = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } {
+[3 x ptr] [ptr null, ptr @_ZTI3Bar, ptr @_ZN3Bar4FuncEv] }, comdat, align 8,
 !psr.id !4 | ID: 4 #6:
     @_ZTI3Bar = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
-getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
-2), ptr @_ZTS3Bar, ptr @_ZTI3Foo }, comdat, align 8, !psr.id !7 | ID: 7 #7: fun
+getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE,
+i64 2), ptr @_ZTS3Bar, ptr @_ZTI3Foo }, comdat, align 8, !psr.id !7 | ID: 7
+#7: fun
 @_ZN3Bar4FuncEv #8:
     @_ZTS3Bar = linkonce_odr dso_local constant [5 x i8] c"3Bar\00", comdat,
 align 1, !psr.id !6 | ID: 6 #9:
-    @_ZTVN10__cxxabiv120__si_class_type_infoE = external global ptr, !psr.id !5
-| ID: 5 #10: %retval = alloca i32, align 4, !psr.id !24 | ID: 8 #11: %First =
-alloca %class.Foo, align 8, !psr.id !25 | ID: 9 #12: %Second = alloca
-%class.Bar, align 8, !psr.id !26 | ID: 10 #13: %SecondAlias = alloca ptr, align
-8, !psr.id !27 | ID: 11 #14: ptr %this | ID: _ZN3FooC2Ev.0 #15: ptr %this | ID:
-_ZN3BarC2Ev.0 #16: %0 = load ptr, ptr %SecondAlias, align 8, !dbg !62, !psr.id
-!63 | ID: 21 #17: %vtable = load ptr, ptr %0, align 8, !dbg !64, !psr.id !65 |
-ID: 22 %vfn = getelementptr inbounds ptr, ptr %vtable, i64 0, !dbg !64, !psr.id
-!66 | ID: 23 #18: %1 = load ptr, ptr %vfn, align 8, !dbg !64, !psr.id !67 | ID:
-24 #19: ptr %this | ID: _ZN3Bar4FuncEv.0 #20: ptr %this | ID: _ZN3Foo4FuncEv.0
-  #21:
-    %this.addr = alloca ptr, align 8, !psr.id !75 | ID: 27
-  #22:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !80 | ID: 30
+    @_ZTVN10__cxxabiv120__si_class_type_infoE = external global ptr, !psr.id
+!5 | ID: 5 #10: %retval = alloca i32, align 4, !psr.id !24 | ID: 8 #11: %First
+= alloca %class.Foo, align 8, !psr.id !25 | ID: 9 #12: %Second = alloca
+%class.Bar, align 8, !psr.id !26 | ID: 10 #13: %SecondAlias = alloca ptr,
+align 8, !psr.id !27 | ID: 11 #14: ptr %this | ID: _ZN3FooC2Ev.0 #15: ptr
+%this | ID: _ZN3BarC2Ev.0 #16: %0 = load ptr, ptr %SecondAlias, align 8, !dbg
+!62, !psr.id !63 | ID: 21 #17: %vtable = load ptr, ptr %0, align 8, !dbg !64,
+!psr.id !65 | ID: 22 %vfn = getelementptr inbounds ptr, ptr %vtable, i64 0,
+!dbg !64, !psr.id !66 | ID: 23 #18: %1 = load ptr, ptr %vfn, align 8, !dbg
+!64, !psr.id !67 | ID: 24 #19: ptr %this | ID: _ZN3Foo4FuncEv.0 #20: ptr %this
+| ID: _ZN3Bar4FuncEv.0 #21: %this.addr = alloca ptr, align 8, !psr.id !75 |
+ID: 27 #22: %this1 = load ptr, ptr %this.addr, align 8, !psr.id !80 | ID: 30
   #23:
     %this.addr = alloca ptr, align 8, !psr.id !88 | ID: 33
   #24:
@@ -11113,43 +11754,51 @@ ID: 22 %vfn = getelementptr inbounds ptr, ptr %vtable, i64 0, !dbg !64, !psr.id
   #28:
     %this1 = load ptr, ptr %this.addr, align 8, !psr.id !114 | ID: 48
 }
-LLVMUnionFindAliasSet(global, ind-sens) {
-  #0: {0, 5, 17}
-  #1: {1, 2, 3, 4, 6, 7, 8, 9, 18}
-  #2: {1, 2, 3, 4, 6, 7, 8, 9, 18}
-  #3: {1, 2, 3, 4, 6, 7, 8, 9, 18}
-  #4: {1, 2, 3, 4, 6, 7, 8, 9, 18}
-  #5: {0, 5, 17}
-  #6: {1, 2, 3, 4, 6, 7, 8, 9, 18}
-  #7: {1, 2, 3, 4, 6, 7, 8, 9, 18}
-  #8: {1, 2, 3, 4, 6, 7, 8, 9, 18}
-  #9: {1, 2, 3, 4, 6, 7, 8, 9, 18}
-  #10: {10}
-  #11: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
-  #12: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
-  #13: {13}
-  #14: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
-  #15: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
-  #16: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
-  #17: {0, 5, 17}
-  #18: {1, 2, 3, 4, 6, 7, 8, 9, 18}
-  #19: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
-  #20: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
-  #21: {21}
-  #22: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
-  #23: {23}
-  #24: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
-  #25: {25}
-  #26: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
-  #27: {27}
-  #28: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
+UnionFindAAResult {
+  #0: <0, 5, 17>
+  #1: <1, 2, 3, 4, 6, 7, 8, 9, 18>
+  #2: <10>
+  #3: <>
+  #4: <>
+  #5: <>
+  #6: <>
+  #7: <11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28>
+  #8: <13>
+  #9: <>
+  #10: <>
+  #11: <>
+  #12: <>
+  #13: <21>
+  #14: <>
+  #15: <>
+  #16: <>
+  #17: <>
+  #18: <23>
+  #19: <>
+  #20: <>
+  #21: <>
+  #22: <>
+  #23: <25>
+  #24: <>
+  #25: <>
+  #26: <>
+  #27: <>
+  #28: <27>
+  #29: <>
+  #30: <>
+  #31: <>
+  #32: <>
 }
   */
   GTMap GT{{LineColFunOp{.Line = 20,
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {LineColFunOp{.Line = 20,
+            {ArgInFun{.Idx = 0, .InFunction = "_ZN3FooC2Ev"},
+             ArgInFun{.Idx = 0, .InFunction = "_ZN3BarC2Ev"},
+             ArgInFun{.Idx = 0, .InFunction = "_ZN3Foo4FuncEv"},
+             ArgInFun{.Idx = 0, .InFunction = "_ZN3Bar4FuncEv"},
+             LineColFunOp{.Line = 20,
                           .Col = 0,
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca},
diff --git a/unittests/TestUtils/SrcCodeLocationEntry.h b/unittests/TestUtils/SrcCodeLocationEntry.h
index 9cfafd1cb8..6909acce55 100644
--- a/unittests/TestUtils/SrcCodeLocationEntry.h
+++ b/unittests/TestUtils/SrcCodeLocationEntry.h
@@ -148,6 +148,7 @@ struct RetVal {
     return std::string("RetVal { InFunction: ") + InFunction.str() + " }";
   }
 };
+
 struct RetStmt {
   llvm::StringRef InFunction;
 
@@ -179,11 +180,26 @@ struct OperandOf {
   }
 };
 
+struct FuncByName {
+  llvm::StringRef NameOfFunction;
+
+  friend bool operator<(FuncByName R1, FuncByName R2) noexcept {
+    return R1.NameOfFunction < R2.NameOfFunction;
+  }
+  friend bool operator==(FuncByName R1, FuncByName R2) noexcept {
+    return R1.NameOfFunction == R2.NameOfFunction;
+  }
+  [[nodiscard]] std::string str() const {
+    return std::string("FuncByName { InFunction: ") + NameOfFunction.str() +
+           " }";
+  }
+};
+
 struct TestingSrcLocation
     : public std::variant<LineCol, LineColFun, LineColFunOp, GlobalVar, ArgNo,
-                          ArgInFun, RetVal, RetStmt, OperandOf> {
+                          ArgInFun, RetVal, RetStmt, OperandOf, FuncByName> {
   using VarT = std::variant<LineCol, LineColFun, LineColFunOp, GlobalVar, ArgNo,
-                            ArgInFun, RetVal, RetStmt, OperandOf>;
+                            ArgInFun, RetVal, RetStmt, OperandOf, FuncByName>;
   using VarT::variant;
 
   template <typename T> [[nodiscard]] constexpr bool isa() const noexcept {
@@ -267,6 +283,12 @@ template <> struct hash<psr::unittest::OperandOf> {
   }
 };
 
+template <> struct hash<psr::unittest::FuncByName> {
+  size_t operator()(psr::unittest::FuncByName FBN) const noexcept {
+    return llvm::hash_value(FBN.NameOfFunction);
+  }
+};
+
 template <> struct hash<psr::unittest::TestingSrcLocation> {
   size_t
   operator()(const psr::unittest::TestingSrcLocation &Loc) const noexcept {
@@ -399,6 +421,13 @@ testingLocInIR(TestingSrcLocation Loc,
 
             return Inst->getOperand(Op.OperandIndex);
           },
+          [&](FuncByName FBN) -> llvm::Value const * {
+            if (const auto *Func = GetFunction(FBN.NameOfFunction)) {
+              return Func;
+            }
+            llvm::report_fatal_error("No function with name " +
+                                     FBN.NameOfFunction);
+          },
       },
       Loc);
   if (!Ret) {

From b6b63d3c55f0b4a9b51493726a68a8666c0c712e Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Tue, 24 Feb 2026 10:38:00 +0100
Subject: [PATCH 52/75] Update breaking changes

---
 BreakingChanges.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/BreakingChanges.md b/BreakingChanges.md
index 0ae1744340..6a2f8cf399 100644
--- a/BreakingChanges.md
+++ b/BreakingChanges.md
@@ -2,6 +2,7 @@
 
 ## development HEAD
 
+- The function `HelperAnalyses::getAliasInfo()` no longer returns a `LLVMAliasSet &`, but a `LLVMAliasInfoRef`.
 - The location of the library summary `FunctionDataFlowFacts` and `LLVMFunctionDataFlowFacts` has moved to `phasar/Utils/` and `phasar/PhasarLLVM/Utils`, respectively.
 - Requiring C++20 instead of C++17
   - Type-traits and other templates that are specialized now use `requires` instead of `enable_if`, wherever possible. This may reduce the number of (defaulted) template parameters in some cases.

From 8d041ea042eb082bf4f0ace21e93ce7c27d8684d Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Tue, 24 Feb 2026 11:24:08 +0100
Subject: [PATCH 53/75] Fix CtxSensUnionFindAATest.Indirection01

---
 .../Pointer/LLVMUnionFindAATest.cpp           | 31 +++++++++++++++++--
 1 file changed, 29 insertions(+), 2 deletions(-)

diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index d4b056824b..57d1b42998 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -72,6 +72,28 @@ asIdBased(const ValueCompressor<PAGVariable> &VC, const LLVMProjectIRDB &IRDB,
   return Ret;
 }
 
+[[nodiscard]] std::string
+stringifyRawAliasSet(const RawAliasSet<ValueId> &Aliases) {
+  std::string Ret;
+  llvm::raw_string_ostream ROS(Ret);
+
+  ROS << '<';
+
+  bool First = true;
+  Aliases.foreach ([&](ValueId VId) {
+    if (First) {
+      First = false;
+    } else {
+      ROS << ", ";
+    }
+
+    ROS << uint32_t(VId);
+  });
+
+  ROS << '>';
+  return Ret;
+}
+
 using GTMap = std::map<unittest::TestingSrcLocation,
                        std::vector<unittest::TestingSrcLocation>>;
 
@@ -140,7 +162,8 @@ void doAnalysisAndCompareResults(
       }
       ADD_FAILURE_AT(Loc.file_name(), Loc.line())
           << "Computed unexpected alias of " << PtrVar << ": "
-          << stringifyVal(VC, VId);
+          << stringifyVal(VC, VId) << "; VId: " << uint32_t(VId)
+          << ", ExpectedIds: " << stringifyRawAliasSet(ExpectedAliasIds);
     });
   }
 
@@ -2967,7 +2990,11 @@ getelementptr inbounds %struct._LinkedList, ptr %.compoundliteral, i32 0, i32 1,
                 LineColFunOp{.Line = 11,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load}}},
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 9,
+                             .Col = 21,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr}}},
               {LineColFunOp{.Line = 11,
                             .Col = 0,
                             .InFunction = "main",

From 86860e3a8ee6f4028d656ec5c23d51318d3c673d Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Tue, 24 Feb 2026 14:34:42 +0100
Subject: [PATCH 54/75] commit for merge

---
 .../Pointer/LLVMUnionFindAATest.cpp           | 46 ++++++++-----------
 1 file changed, 19 insertions(+), 27 deletions(-)

diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index d4b056824b..a6994cc2a1 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -4538,7 +4538,6 @@ UnionFindAAResult {
   #0: <0, 1, 3, 4>
   #1: <2>
 }
-  TODO: ask fabian why #1: <1> and #2: <2> are not here
   */
   GTMap GT = {{LineColFunOp{.Line = 3,
                             .Col = 0,
@@ -4610,8 +4609,6 @@ UnionFindAAResult {
   #1: <1, 3, 4, 5>
   #2: <2>
 }
-
-TODO: ask fabian how to get { fun @Func }
    */
   GTMap GT = {{LineColFunOp{.Line = 5,
                             .Col = 0,
@@ -5440,8 +5437,6 @@ UnionFindAAResult {
   #1: <1, 2, 4>
   #2: <3>
 }
-  // TODO: get %.compoundliteral = alloca %struct._LinkedList
-           Same line as Foo alloca, but more obfuscated
   */
   GTMap GT = {{LineColFunOp{.Line = 8,
                             .Col = 0,
@@ -8251,8 +8246,6 @@ UnionFindAAResult {
 }
   */
 
-  // TODO: missing other entries. like x and y
-
   GTMap GT{{LineColFunOp{.Line = 12,
                          .Col = 0,
                          .InFunction = "main",
@@ -11143,15 +11136,18 @@ ValueCompressor: {
   #1:
     %Foo = alloca %struct._LinkedListOne, align 8, !psr.id !17 | ID: 1
     %Next22 = getelementptr inbounds %struct._LinkedListOne, ptr %Foo, i32 0,
-i32 1, !dbg !223, !psr.id !224 | ID: 105 #2:
+i32 1, !dbg !223, !psr.id !224 | ID: 105
+  #2:
     %.compoundliteral = alloca %struct._LinkedListOne, align 8, !psr.id !18 |
 ID: 2 %Val = getelementptr inbounds %struct._LinkedListOne, ptr
 %.compoundliteral, i32 0, i32 0, !dbg !57, !psr.id !58 | ID: 33 %Next =
 getelementptr inbounds %struct._LinkedListOne, ptr %.compoundliteral, i32 0, i32
-1, !dbg !57, !psr.id !60 | ID: 35 #3: %Bar = alloca %struct._LinkedListTwo,
+1, !dbg !57, !psr.id !60 | ID: 35
+  #3: %Bar = alloca %struct._LinkedListTwo,
 align 8, !psr.id !19 | ID: 3 %Next23 = getelementptr inbounds
 %struct._LinkedListTwo, ptr %Bar, i32 0, i32 1, !dbg !230, !psr.id !231 | ID:
-109 #4:
+109
+  #4:
     %.compoundliteral1 = alloca %struct._LinkedListTwo, align 8, !psr.id !20 |
 ID: 4 %Val2 = getelementptr inbounds %struct._LinkedListTwo, ptr
 %.compoundliteral1, i32 0, i32 0, !dbg !72, !psr.id !73 | ID: 39 %Next3 =
@@ -11295,9 +11291,6 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
   #41: {7, 35, 41}
   #42: {9, 36, 42}
 }
-
-  TODO: ask Fabian about the Bar alloca here. Is this correct?
-
   */
   GTMap GT{{LineColFunOp{.Line = 33,
                          .Col = 0,
@@ -11308,6 +11301,8 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
+                // TODO: double check. Probably an overapproximation due to a
+                // loop from 1 and 2 in PointerAssignmentGraph
                 LineColFunOp{.Line = 35,
                              .Col = 0,
                              .InFunction = "main",
@@ -11434,7 +11429,8 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca}}}};
 
-  doAnalysisAndCompareResults("indirection_07_c_dbg.ll", GT, IndAABuilder);
+  doAnalysisAndCompareResults("indirection_07_c_dbg.ll", GT,
+                              TracingBuilder(IndAABuilder));
 }
 
 TEST(IndirectionSensUnionFindAATest, Indirection08) {
@@ -11661,11 +11657,6 @@ UnionFindAAResult {
   #41: <>
   #42: <>
 }
-
-  TODO: ask Fabian about below. My impl doesn't work (commented out):
-  Computed unexpected alias of LineColFunOp { Line: 19; Col: 0; InFunction:
-main; OpCode: alloca }: { %cond-lvalue = phi ptr [ %Second, %cond.true ], [
-%Third, %cond.false ], !dbg !80, !psr.id !86 | ID: 33 }
   */
   GTMap GT{{LineColFunOp{.Line = 19,
                          .Col = 0,
@@ -11688,18 +11679,19 @@ main; OpCode: alloca }: { %cond-lvalue = phi ptr [ %Second, %cond.true ], [
              LineColFunOp{.Line = 21,
                           .Col = 0,
                           .InFunction = "main",
-                          .OpCode = llvm::Instruction::Alloca}}},
+                          .OpCode = llvm::Instruction::Alloca},
+             LineColFunOp{.Line = 23,
+                          .Col = 17,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::PHI}}},
            {LineColFunOp{.Line = 23,
                          .Col = 0,
                          .InFunction = "main",
                          .OpCode = llvm::Instruction::Alloca},
-            {
-                LineColFunOp{.Line = 23,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                // LineColFun{.Line = 23, .Col = 17, .InFunction = "main"}
-            }}};
+            {LineColFunOp{.Line = 23,
+                          .Col = 0,
+                          .InFunction = "main",
+                          .OpCode = llvm::Instruction::Alloca}}}};
 
   doAnalysisAndCompareResults("indirection_09_cpp_dbg.ll", GT, IndAABuilder);
 }

From 3be3c1ebba1a48b7520e4579d7631a51d3b7a2be Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Tue, 24 Feb 2026 15:34:55 +0100
Subject: [PATCH 55/75] Half of Indir Tests fixed

---
 .../Pointer/LLVMUnionFindAATest.cpp           | 808 +++++++-----------
 1 file changed, 296 insertions(+), 512 deletions(-)

diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index 9d443b53ca..8479747067 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -72,28 +72,6 @@ asIdBased(const ValueCompressor<PAGVariable> &VC, const LLVMProjectIRDB &IRDB,
   return Ret;
 }
 
-[[nodiscard]] std::string
-stringifyRawAliasSet(const RawAliasSet<ValueId> &Aliases) {
-  std::string Ret;
-  llvm::raw_string_ostream ROS(Ret);
-
-  ROS << '<';
-
-  bool First = true;
-  Aliases.foreach ([&](ValueId VId) {
-    if (First) {
-      First = false;
-    } else {
-      ROS << ", ";
-    }
-
-    ROS << uint32_t(VId);
-  });
-
-  ROS << '>';
-  return Ret;
-}
-
 using GTMap = std::map<unittest::TestingSrcLocation,
                        std::vector<unittest::TestingSrcLocation>>;
 
@@ -162,8 +140,7 @@ void doAnalysisAndCompareResults(
       }
       ADD_FAILURE_AT(Loc.file_name(), Loc.line())
           << "Computed unexpected alias of " << PtrVar << ": "
-          << stringifyVal(VC, VId) << "; VId: " << uint32_t(VId)
-          << ", ExpectedIds: " << stringifyRawAliasSet(ExpectedAliasIds);
+          << stringifyVal(VC, VId);
     });
   }
 
@@ -2950,35 +2927,6 @@ TEST(CtxSensUnionFindAATest, Context14_2) {
 }
 
 TEST(CtxSensUnionFindAATest, Indirection01) {
-  /*
-  ValueCompressor: {
-  #0:
-    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
-  #1:
-    %Foo = alloca %struct._LinkedList, align 8, !psr.id !17 | ID: 1
-    %Next1 = getelementptr inbounds %struct._LinkedList, ptr %Foo, i32 0, i32 1,
-!dbg !41, !psr.id !42 | ID: 12 #2:
-    %.compoundliteral = alloca %struct._LinkedList, align 8, !psr.id !18 | ID: 2
-    %Val = getelementptr inbounds %struct._LinkedList, ptr %.compoundliteral,
-i32 0, i32 0, !dbg !30, !psr.id !31 | ID: 6 %Next = getelementptr inbounds
-%struct._LinkedList, ptr %.compoundliteral, i32 0, i32 1, !dbg !30, !psr.id !33
-| ID: 8 #3: %Alias = alloca ptr, align 8, !psr.id !19 | ID: 3 #4: %0 = load ptr,
-ptr %Next1, align 8, !dbg !41, !psr.id !43 | ID: 13
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <1, 2, 4>
-  #2: <3>
-}
-    TODO: ask Fabian about below
-    Failed
-Computed unexpected alias of LineColFunOp { Line: 8; Col: 0; InFunction: main;
-OpCode: alloca }: { %.compoundliteral = alloca %struct._LinkedList, align 8,
-!psr.id !18 | ID: 2, %Val = getelementptr inbounds %struct._LinkedList, ptr
-%.compoundliteral, i32 0, i32 0, !dbg !30, !psr.id !31 | ID: 6, %Next =
-getelementptr inbounds %struct._LinkedList, ptr %.compoundliteral, i32 0, i32 1,
-!dbg !30, !psr.id !33 | ID: 8 }
-  */
   GTMap GT = {{LineColFunOp{.Line = 8,
                             .Col = 0,
                             .InFunction = "main",
@@ -2987,14 +2935,14 @@ getelementptr inbounds %struct._LinkedList, ptr %.compoundliteral, i32 0, i32 1,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 11,
+                LineColFunOp{.Line = 9,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Load},
-                LineColFunOp{.Line = 9,
-                             .Col = 21,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 11,
+                             .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::GetElementPtr}}},
+                             .OpCode = llvm::Instruction::Load}}},
               {LineColFunOp{.Line = 11,
                             .Col = 0,
                             .InFunction = "main",
@@ -3007,58 +2955,6 @@ getelementptr inbounds %struct._LinkedList, ptr %.compoundliteral, i32 0, i32 1,
 }
 
 TEST(CtxSensUnionFindAATest, Indirection02) {
-  /*
-  ValueCompressor: {
-  #0:
-    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
-  #1:
-    %Foo = alloca %struct._LinkedList, align 8, !psr.id !17 | ID: 1
-    %Next6 = getelementptr inbounds %struct._LinkedList, ptr %Foo, i32 0, i32 1,
-!dbg !76, !psr.id !77 | ID: 33 #2:
-    %.compoundliteral = alloca %struct._LinkedList, align 8, !psr.id !18 | ID: 2
-    %Val = getelementptr inbounds %struct._LinkedList, ptr %.compoundliteral,
-i32 0, i32 0, !dbg !37, !psr.id !38 | ID: 13 %Next = getelementptr inbounds
-%struct._LinkedList, ptr %.compoundliteral, i32 0, i32 1, !dbg !37, !psr.id !40
-| ID: 15 #3: %Bar = alloca %struct._LinkedList, align 8, !psr.id !19 | ID: 3
-    %Next7 = getelementptr inbounds %struct._LinkedList, ptr %Bar, i32 0, i32 1,
-!dbg !83, !psr.id !84 | ID: 37 #4:
-    %.compoundliteral1 = alloca %struct._LinkedList, align 8, !psr.id !20 | ID:
-4 %Val2 = getelementptr inbounds %struct._LinkedList, ptr %.compoundliteral1,
-i32 0, i32 0, !dbg !47, !psr.id !48 | ID: 19 %Next3 = getelementptr inbounds
-%struct._LinkedList, ptr %.compoundliteral1, i32 0, i32 1, !dbg !47, !psr.id !50
-| ID: 21 #5: %Baz = alloca %struct._LinkedList, align 8, !psr.id !21 | ID: 5
-    %Next5 = getelementptr inbounds %struct._LinkedList, ptr %Baz, i32 0, i32 1,
-!dbg !68, !psr.id !69 | ID: 30 %Next8 = getelementptr inbounds
-%struct._LinkedList, ptr %Baz, i32 0, i32 1, !dbg !90, !psr.id !91 | ID: 41 #6:
-    %Boar = alloca %struct._LinkedList, align 8, !psr.id !22 | ID: 6
-    %Next4 = getelementptr inbounds %struct._LinkedList, ptr %Boar, i32 0, i32
-1, !dbg !64, !psr.id !65 | ID: 28 %Next9 = getelementptr inbounds
-%struct._LinkedList, ptr %Boar, i32 0, i32 1, !dbg !97, !psr.id !98 | ID: 45 #7:
-    %AliasOne = alloca ptr, align 8, !psr.id !23 | ID: 7
-  #8:
-    %AliasTwo = alloca ptr, align 8, !psr.id !24 | ID: 8
-  #9:
-    %AliasThree = alloca ptr, align 8, !psr.id !25 | ID: 9
-  #10:
-    %AliasFour = alloca ptr, align 8, !psr.id !26 | ID: 10
-  #11:
-    %0 = load ptr, ptr %Next6, align 8, !dbg !76, !psr.id !78 | ID: 34
-  #12:
-    %1 = load ptr, ptr %Next7, align 8, !dbg !83, !psr.id !85 | ID: 38
-  #13:
-    %2 = load ptr, ptr %Next8, align 8, !dbg !90, !psr.id !92 | ID: 42
-  #14:
-    %3 = load ptr, ptr %Next9, align 8, !dbg !97, !psr.id !99 | ID: 46
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <1, 2, 3, 4, 5, 6, 11, 12, 13, 14>
-  #2: <7>
-  #3: <8>
-  #4: <9>
-  #5: <10>
-}
-  */
   GTMap GT = {{LineColFunOp{.Line = 8,
                             .Col = 0,
                             .InFunction = "main",
@@ -3067,34 +2963,42 @@ UnionFindAAResult {
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 9,
+                             .Col = 21,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
                 LineColFunOp{.Line = 11,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 11,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 11,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 12,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 14,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 14,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 14,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 15,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 15,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 15,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
               {LineColFunOp{.Line = 20,
                             .Col = 0,
                             .InFunction = "main",
@@ -3131,55 +3035,6 @@ UnionFindAAResult {
 }
 
 TEST(CtxSensUnionFindAATest, Indirection03) {
-  /*
-  ValueCompressor: {
-  #0:
-    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
-  #1:
-    %Foo = alloca %struct._LinkedListOne, align 8, !psr.id !17 | ID: 1
-    %Next4 = getelementptr inbounds %struct._LinkedListOne, ptr %Foo, i32 0, i32
-1, !dbg !73, !psr.id !74 | ID: 29 #2:
-    %.compoundliteral = alloca %struct._LinkedListOne, align 8, !psr.id !18 |
-ID: 2 %Val = getelementptr inbounds %struct._LinkedListOne, ptr
-%.compoundliteral, i32 0, i32 0, !dbg !37, !psr.id !38 | ID: 13 %Next =
-getelementptr inbounds %struct._LinkedListOne, ptr %.compoundliteral, i32 0, i32
-1, !dbg !37, !psr.id !40 | ID: 15 #3: %Bar = alloca %struct._LinkedListTwo,
-align 8, !psr.id !19 | ID: 3 %Next5 = getelementptr inbounds
-%struct._LinkedListTwo, ptr %Bar, i32 0, i32 1, !dbg !80, !psr.id !81 | ID: 33
-  #4:
-    %.compoundliteral1 = alloca %struct._LinkedListTwo, align 8, !psr.id !20 |
-ID: 4 %Val2 = getelementptr inbounds %struct._LinkedListTwo, ptr
-%.compoundliteral1, i32 0, i32 0, !dbg !52, !psr.id !53 | ID: 19 %Next3 =
-getelementptr inbounds %struct._LinkedListTwo, ptr %.compoundliteral1, i32 0,
-i32 1, !dbg !52, !psr.id !55 | ID: 21 #5: %Baz = alloca %struct._LinkedListOne,
-align 8, !psr.id !21 | ID: 5 %Next6 = getelementptr inbounds
-%struct._LinkedListOne, ptr %Baz, i32 0, i32 1, !dbg !87, !psr.id !88 | ID: 37
-  #6:
-    %Boar = alloca %struct._LinkedListTwo, align 8, !psr.id !22 | ID: 6
-    %Next7 = getelementptr inbounds %struct._LinkedListTwo, ptr %Boar, i32 0,
-i32 1, !dbg !94, !psr.id !95 | ID: 41 #7: %AliasOne = alloca ptr, align 8,
-!psr.id !23 | ID: 7 #8: %AliasTwo = alloca ptr, align 8, !psr.id !24 | ID: 8 #9:
-    %AliasThree = alloca ptr, align 8, !psr.id !25 | ID: 9
-  #10:
-    %AliasFour = alloca ptr, align 8, !psr.id !26 | ID: 10
-  #11:
-    %0 = load ptr, ptr %Next4, align 8, !dbg !73, !psr.id !75 | ID: 30
-  #12:
-    %1 = load ptr, ptr %Next5, align 8, !dbg !80, !psr.id !82 | ID: 34
-  #13:
-    %2 = load ptr, ptr %Next6, align 8, !dbg !87, !psr.id !89 | ID: 38
-  #14:
-    %3 = load ptr, ptr %Next7, align 8, !dbg !94, !psr.id !96 | ID: 42
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <1, 2, 3, 4, 5, 6, 11, 12, 13, 14>
-  #2: <7>
-  #3: <8>
-  #4: <9>
-  #5: <10>
-}
-  */
   GTMap GT = {{LineColFunOp{.Line = 13,
                             .Col = 0,
                             .InFunction = "main",
@@ -3187,31 +3042,43 @@ UnionFindAAResult {
                {LineColFunOp{.Line = 13,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 15,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 15,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 14,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 18,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 18,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 15,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 19,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 19,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 16,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 19,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 24,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
               {LineColFunOp{.Line = 21,
                             .Col = 0,
                             .InFunction = "main",
@@ -3248,77 +3115,6 @@ UnionFindAAResult {
 }
 
 TEST(CtxSensUnionFindAATest, Indirection04) {
-  /*
-  ValueCompressor: {
-  #0:
-    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
-  #1:
-    %Foo = alloca %struct._LinkedListOne, align 8, !psr.id !17 | ID: 1
-    %Next10 = getelementptr inbounds %struct._LinkedListOne, ptr %Foo, i32 0,
-i32 1, !dbg !121, !psr.id !122 | ID: 54 #2:
-    %.compoundliteral = alloca %struct._LinkedListOne, align 8, !psr.id !18 |
-ID: 2 %Val = getelementptr inbounds %struct._LinkedListOne, ptr
-%.compoundliteral, i32 0, i32 0, !dbg !42, !psr.id !43 | ID: 18 %Next =
-getelementptr inbounds %struct._LinkedListOne, ptr %.compoundliteral, i32 0, i32
-1, !dbg !42, !psr.id !45 | ID: 20 #3: %Bar = alloca %struct._LinkedListTwo,
-align 8, !psr.id !19 | ID: 3 %Next11 = getelementptr inbounds
-%struct._LinkedListTwo, ptr %Bar, i32 0, i32 1, !dbg !128, !psr.id !129 | ID: 58
-  #4:
-    %.compoundliteral1 = alloca %struct._LinkedListTwo, align 8, !psr.id !20 |
-ID: 4 %Val2 = getelementptr inbounds %struct._LinkedListTwo, ptr
-%.compoundliteral1, i32 0, i32 0, !dbg !57, !psr.id !58 | ID: 24 %Next3 =
-getelementptr inbounds %struct._LinkedListTwo, ptr %.compoundliteral1, i32 0,
-i32 1, !dbg !57, !psr.id !60 | ID: 26 #5: %Baz = alloca
-%struct._LinkedListThree, align 8, !psr.id !21 | ID: 5 %Next12 = getelementptr
-inbounds %struct._LinkedListThree, ptr %Baz, i32 0, i32 1, !dbg !135, !psr.id
-!136 | ID: 62 #6:
-    %.compoundliteral4 = alloca %struct._LinkedListThree, align 8, !psr.id !22 |
-ID: 6 %Val5 = getelementptr inbounds %struct._LinkedListThree, ptr
-%.compoundliteral4, i32 0, i32 0, !dbg !73, !psr.id !74 | ID: 30 %Next6 =
-getelementptr inbounds %struct._LinkedListThree, ptr %.compoundliteral4, i32 0,
-i32 1, !dbg !73, !psr.id !76 | ID: 32 #7: %One = alloca %struct._LinkedListOne,
-align 8, !psr.id !23 | ID: 7 %Next7 = getelementptr inbounds
-%struct._LinkedListOne, ptr %One, i32 0, i32 1, !dbg !99, !psr.id !100 | ID: 42
-  #8:
-    %Two = alloca %struct._LinkedListTwo, align 8, !psr.id !24 | ID: 8
-    %Next8 = getelementptr inbounds %struct._LinkedListTwo, ptr %Two, i32 0, i32
-1, !dbg !106, !psr.id !107 | ID: 46 #9: %Three = alloca
-%struct._LinkedListThree, align 8, !psr.id !25 | ID: 9 %Next9 = getelementptr
-inbounds %struct._LinkedListThree, ptr %Three, i32 0, i32 1, !dbg !114, !psr.id
-!115 | ID: 50 #10: %AliasOne = alloca ptr, align 8, !psr.id !26 | ID: 10 #11:
-    %AliasTwo = alloca ptr, align 8, !psr.id !27 | ID: 11
-  #12:
-    %AliasThree = alloca ptr, align 8, !psr.id !28 | ID: 12
-  #13:
-    %AliasFour = alloca ptr, align 8, !psr.id !29 | ID: 13
-  #14:
-    %AliasFive = alloca ptr, align 8, !psr.id !30 | ID: 14
-  #15:
-    %AliasSix = alloca ptr, align 8, !psr.id !31 | ID: 15
-  #16:
-    %0 = load ptr, ptr %Next7, align 8, !dbg !99, !psr.id !101 | ID: 43
-  #17:
-    %1 = load ptr, ptr %Next8, align 8, !dbg !106, !psr.id !108 | ID: 47
-  #18:
-    %2 = load ptr, ptr %Next9, align 8, !dbg !114, !psr.id !116 | ID: 51
-  #19:
-    %3 = load ptr, ptr %Next10, align 8, !dbg !121, !psr.id !123 | ID: 55
-  #20:
-    %4 = load ptr, ptr %Next11, align 8, !dbg !128, !psr.id !130 | ID: 59
-  #21:
-    %5 = load ptr, ptr %Next12, align 8, !dbg !135, !psr.id !137 | ID: 63
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21>
-  #2: <10>
-  #3: <11>
-  #4: <12>
-  #5: <13>
-  #6: <14>
-  #7: <15>
-}
-  */
   GTMap GT = {{LineColFunOp{.Line = 18,
                             .Col = 0,
                             .InFunction = "main",
@@ -3326,47 +3122,63 @@ UnionFindAAResult {
                {LineColFunOp{.Line = 18,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 20,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 20,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 19,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 22,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 22,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 20,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 25,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 25,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 21,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 26,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 26,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 22,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 27,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 27,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 23,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 25,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 26,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 27,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 29,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 31,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
               {LineColFunOp{.Line = 29,
                             .Col = 0,
                             .InFunction = "main",
@@ -3419,95 +3231,6 @@ UnionFindAAResult {
 }
 
 TEST(CtxSensUnionFindAATest, Indirection05) {
-  /*
-  ValueCompressor: {
-  #0:
-    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
-  #1:
-    %Foo = alloca %struct._LinkedListOne, align 8, !psr.id !17 | ID: 1
-    %Next14 = getelementptr inbounds %struct._LinkedListOne, ptr %Foo, i32 0,
-i32 1, !dbg !155, !psr.id !156 | ID: 71 #2:
-    %.compoundliteral = alloca %struct._LinkedListOne, align 8, !psr.id !18 |
-ID: 2 %Val = getelementptr inbounds %struct._LinkedListOne, ptr
-%.compoundliteral, i32 0, i32 0, !dbg !47, !psr.id !48 | ID: 23 %Next =
-getelementptr inbounds %struct._LinkedListOne, ptr %.compoundliteral, i32 0, i32
-1, !dbg !47, !psr.id !50 | ID: 25 #3: %Bar = alloca %struct._LinkedListTwo,
-align 8, !psr.id !19 | ID: 3 %Next15 = getelementptr inbounds
-%struct._LinkedListTwo, ptr %Bar, i32 0, i32 1, !dbg !162, !psr.id !163 | ID: 75
-  #4:
-    %.compoundliteral1 = alloca %struct._LinkedListTwo, align 8, !psr.id !20 |
-ID: 4 %Val2 = getelementptr inbounds %struct._LinkedListTwo, ptr
-%.compoundliteral1, i32 0, i32 0, !dbg !62, !psr.id !63 | ID: 29 %Next3 =
-getelementptr inbounds %struct._LinkedListTwo, ptr %.compoundliteral1, i32 0,
-i32 1, !dbg !62, !psr.id !65 | ID: 31 #5: %Baz = alloca
-%struct._LinkedListThree, align 8, !psr.id !21 | ID: 5 %Next16 = getelementptr
-inbounds %struct._LinkedListThree, ptr %Baz, i32 0, i32 1, !dbg !169, !psr.id
-!170 | ID: 79 #6:
-    %.compoundliteral4 = alloca %struct._LinkedListThree, align 8, !psr.id !22 |
-ID: 6 %Val5 = getelementptr inbounds %struct._LinkedListThree, ptr
-%.compoundliteral4, i32 0, i32 0, !dbg !78, !psr.id !79 | ID: 35 %Next6 =
-getelementptr inbounds %struct._LinkedListThree, ptr %.compoundliteral4, i32 0,
-i32 1, !dbg !78, !psr.id !81 | ID: 37 #7: %Boar = alloca
-%struct._LinkedListFour, align 8, !psr.id !23 | ID: 7 %Next17 = getelementptr
-inbounds %struct._LinkedListFour, ptr %Boar, i32 0, i32 1, !dbg !176, !psr.id
-!177 | ID: 83 #8:
-    %.compoundliteral7 = alloca %struct._LinkedListFour, align 8, !psr.id !24 |
-ID: 8 %Val8 = getelementptr inbounds %struct._LinkedListFour, ptr
-%.compoundliteral7, i32 0, i32 0, !dbg !94, !psr.id !95 | ID: 41 %Next9 =
-getelementptr inbounds %struct._LinkedListFour, ptr %.compoundliteral7, i32 0,
-i32 1, !dbg !94, !psr.id !97 | ID: 43 #9: %One = alloca %struct._LinkedListOne,
-align 8, !psr.id !25 | ID: 9 %Next10 = getelementptr inbounds
-%struct._LinkedListOne, ptr %One, i32 0, i32 1, !dbg !125, !psr.id !126 | ID: 55
-  #10:
-    %Two = alloca %struct._LinkedListTwo, align 8, !psr.id !26 | ID: 10
-    %Next11 = getelementptr inbounds %struct._LinkedListTwo, ptr %Two, i32 0,
-i32 1, !dbg !132, !psr.id !133 | ID: 59 #11: %Three = alloca
-%struct._LinkedListThree, align 8, !psr.id !27 | ID: 11 %Next12 = getelementptr
-inbounds %struct._LinkedListThree, ptr %Three, i32 0, i32 1, !dbg !140, !psr.id
-!141 | ID: 63 #12: %Four = alloca %struct._LinkedListFour, align 8, !psr.id !28
-| ID: 12 %Next13 = getelementptr inbounds %struct._LinkedListFour, ptr %Four,
-i32 0, i32 1, !dbg !148, !psr.id !149 | ID: 67 #13: %AliasOne = alloca ptr,
-align 8, !psr.id !29 | ID: 13 #14: %AliasTwo = alloca ptr, align 8, !psr.id !30
-| ID: 14 #15: %AliasThree = alloca ptr, align 8, !psr.id !31 | ID: 15 #16:
-    %AliasFour = alloca ptr, align 8, !psr.id !32 | ID: 16
-  #17:
-    %AliasFive = alloca ptr, align 8, !psr.id !33 | ID: 17
-  #18:
-    %AliasSix = alloca ptr, align 8, !psr.id !34 | ID: 18
-  #19:
-    %AliasSeven = alloca ptr, align 8, !psr.id !35 | ID: 19
-  #20:
-    %AliasEight = alloca ptr, align 8, !psr.id !36 | ID: 20
-  #21:
-    %0 = load ptr, ptr %Next10, align 8, !dbg !125, !psr.id !127 | ID: 56
-  #22:
-    %1 = load ptr, ptr %Next11, align 8, !dbg !132, !psr.id !134 | ID: 60
-  #23:
-    %2 = load ptr, ptr %Next12, align 8, !dbg !140, !psr.id !142 | ID: 64
-  #24:
-    %3 = load ptr, ptr %Next13, align 8, !dbg !148, !psr.id !150 | ID: 68
-  #25:
-    %4 = load ptr, ptr %Next14, align 8, !dbg !155, !psr.id !157 | ID: 72
-  #26:
-    %5 = load ptr, ptr %Next15, align 8, !dbg !162, !psr.id !164 | ID: 76
-  #27:
-    %6 = load ptr, ptr %Next16, align 8, !dbg !169, !psr.id !171 | ID: 80
-  #28:
-    %7 = load ptr, ptr %Next17, align 8, !dbg !176, !psr.id !178 | ID: 84
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 21, 22, 23, 24, 25, 26, 27, 28>
-  #2: <13>
-  #3: <14>
-  #4: <15>
-  #5: <16>
-  #6: <17>
-  #7: <18>
-  #8: <19>
-  #9: <20>
-}
-  */
   GTMap GT = {{LineColFunOp{.Line = 23,
                             .Col = 0,
                             .InFunction = "main",
@@ -3515,63 +3238,108 @@ UnionFindAAResult {
                {LineColFunOp{.Line = 23,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 25,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 25,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 24,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 27,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 27,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 25,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 29,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 29,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 26,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 32,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 32,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 27,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 33,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 28,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 29,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 35,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 37,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 38,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 40,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 41,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 42,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 43,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 44,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
+              {LineColFunOp{.Line = 25,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 33,
+               {LineColFunOp{.Line = 25,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 34,
+              {LineColFunOp{.Line = 27,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 34,
+               {LineColFunOp{.Line = 27,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 35,
+              {LineColFunOp{.Line = 29,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 35,
+               {LineColFunOp{.Line = 29,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca}}},
+
               {LineColFunOp{.Line = 37,
                             .Col = 0,
                             .InFunction = "main",
@@ -5441,30 +5209,6 @@ TEST(BotUnionFindAATest, Context13_1) {
 }
 
 TEST(BotUnionFindAATest, Indirection01) {
-  /*
-  ValueCompressor: {
-  #0:
-    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
-  #1:
-    %Foo = alloca %struct._LinkedList, align 8, !psr.id !17 | ID: 1
-    %Next1 = getelementptr inbounds %struct._LinkedList, ptr %Foo, i32 0, i32 1,
-!dbg !41, !psr.id !42 | ID: 12
-  #2:
-    %.compoundliteral = alloca %struct._LinkedList, align 8, !psr.id !18 | ID: 2
-    %Val = getelementptr inbounds %struct._LinkedList, ptr %.compoundliteral,
-i32 0, i32 0, !dbg !30, !psr.id !31 | ID: 6 %Next = getelementptr inbounds
-%struct._LinkedList, ptr %.compoundliteral, i32 0, i32 1, !dbg !30, !psr.id !33
-| ID: 8
-  #3: %Alias = alloca ptr, align 8, !psr.id !19 | ID: 3
-  #4: %0 = load ptr,
-ptr %Next1, align 8, !dbg !41, !psr.id !43 | ID: 13
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <1, 2, 4>
-  #2: <3>
-}
-  */
   GTMap GT = {{LineColFunOp{.Line = 8,
                             .Col = 0,
                             .InFunction = "main",
@@ -5473,6 +5217,10 @@ UnionFindAAResult {
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
                 LineColFunOp{.Line = 11,
                              .Col = 0,
                              .InFunction = "main",
@@ -5497,34 +5245,42 @@ TEST(BotUnionFindAATest, Indirection02) {
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 9,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::GetElementPtr},
                 LineColFunOp{.Line = 11,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 11,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 11,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 12,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 14,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 14,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 14,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 15,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 15,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 15,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 20,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
               {LineColFunOp{.Line = 20,
                             .Col = 0,
                             .InFunction = "main",
@@ -5568,31 +5324,43 @@ TEST(BotUnionFindAATest, Indirection03) {
                {LineColFunOp{.Line = 13,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 15,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 15,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 14,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 18,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 18,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 15,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 19,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 19,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 16,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 18,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 19,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 21,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 22,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 23,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 24,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
               {LineColFunOp{.Line = 21,
                             .Col = 0,
                             .InFunction = "main",
@@ -5636,47 +5404,63 @@ TEST(BotUnionFindAATest, Indirection04) {
                {LineColFunOp{.Line = 18,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 20,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 20,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 19,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 22,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 22,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 20,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 25,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 25,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 21,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 26,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 26,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 22,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 27,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 27,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 23,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 25,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 26,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 27,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 29,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 30,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 31,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
               {LineColFunOp{.Line = 29,
                             .Col = 0,
                             .InFunction = "main",

From 1baa7d1325e33cbf2234bd59e7f227d42eccb3e4 Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Tue, 24 Feb 2026 21:02:14 +0100
Subject: [PATCH 56/75] all unittests working now

---
 .../Pointer/LLVMUnionFindAATest.cpp           | 5232 ++---------------
 1 file changed, 465 insertions(+), 4767 deletions(-)

diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index 8479747067..971bda2647 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -96,12 +96,6 @@ void doAnalysisAndCompareResults(
     const auto ExpectedAliasIds = asIdBased(VC, IRDB, ExpectedAliasVars);
     const RawAliasSet<ValueId> &ComputedAliasIds =
         Results.getRawAliasSet(PtrId);
-
-    ComputedAliasIds.foreach ([&](ValueId VId) {
-      llvm::outs() << "PtrVar: " << PtrVar
-                   << " - stringifyVal(VC, VId): " << stringifyVal(VC, VId)
-                   << "\n";
-    });
   }
 
   for (const auto &[PtrVar, ExpectedAliasVars] : ExpectedResults) {
@@ -198,13 +192,6 @@ constexpr auto TracingBuilder = [](auto &&Builder) {
 };
 
 TEST(CtxSensUnionFindAATest, Basic01) {
-  /*
-LLVMUnionFindAliasSet(global, botctx-ind-sens) {
-  #0: {0, 2}
-  #1: {1}
-  #2: {0, 2}
-}
-  */
   GTMap GT = {{LineColFunOp{.Line = 3,
                             .Col = 0,
                             .InFunction = "main",
@@ -223,15 +210,6 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
 }
 
 TEST(CtxSensUnionFindAATest, Basic02) {
-  /*
-LLVMUnionFindAliasSet(global, botctx-ind-sens) {
-  #0: {0, 1, 3, 4}
-  #1: {0, 1, 3, 4}
-  #2: {2}
-  #3: {0, 1, 3, 4}
-  #4: {0, 1, 3, 4}
-}
-  */
   GTMap GT = {{LineColFunOp{.Line = 3,
                             .Col = 0,
                             .InFunction = "main",
@@ -267,14 +245,6 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
 }
 
 TEST(CtxSensUnionFindAATest, Basic03) {
-  /*
-  LLVMUnionFindAliasSet(global, botctx-ind-sens) {
-  #0: {0}
-  #1: {1}
-  #2: {2, 3}
-  #3: {2, 3}
-}
-  */
   GTMap GT = {{LineColFunOp{.Line = 5,
                             .Col = 0,
                             .InFunction = "main",
@@ -288,27 +258,6 @@ TEST(CtxSensUnionFindAATest, Basic03) {
 }
 
 TEST(CtxSensUnionFindAATest, Basic04) {
-  /*
-ValueCompressor: {
-  #0:
-    %retval = alloca i32, align 4, !psr.id !19 | ID: 1
-  #1:
-    %FuncPtr = alloca ptr, align 8, !psr.id !20 | ID: 2
-  #2:
-    %FuncPtr2 = alloca ptr, align 8, !psr.id !21 | ID: 3
-  #3:
-    fun @Func
-  #4:
-    %0 = load ptr, ptr %FuncPtr2, align 8, !dbg !37, !psr.id !38 | ID: 9
-  #5:
-    %1 = load ptr, ptr %0, align 8, !dbg !39, !psr.id !40 | ID: 10
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <1, 3, 4, 5>
-  #2: <2>
-}
-  */
   GTMap GT = {{LineColFunOp{.Line = 5,
                             .Col = 0,
                             .InFunction = "main",
@@ -333,43 +282,6 @@ UnionFindAAResult {
 }
 
 TEST(CtxSensUnionFindAATest, Context01) {
-  /*
-ValueCompressor: {
-  #0:
-    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    ptr %p | ID: id.0
-  #2:
-    %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
-  #3:
-    fun @id.<ret>
-  #4:
-    %retval = alloca i32, align 4, !psr.id !29 | ID: 5
-  #5:
-    %x = alloca i32, align 4, !psr.id !30 | ID: 6
-  #6:
-    %y = alloca i32, align 4, !psr.id !31 | ID: 7
-  #7:
-    %xx = alloca ptr, align 8, !psr.id !32 | ID: 8
-  #8:
-    %yy = alloca ptr, align 8, !psr.id !33 | ID: 9
-  #9:
-    %call = call ptr @id(ptr noundef %x), !dbg !46, !psr.id !47 | ID: 16
-  #10:
-    %call1 = call ptr @id(ptr noundef %y), !dbg !52, !psr.id !53 | ID: 19
-  #11:
-    %0 = load ptr, ptr %xx, align 8, !dbg !55, !psr.id !56 | ID: 21
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <0>
-  #2: <1, 2, 3, 5, 9, 11>
-  #3: <1, 2, 3, 6, 10>
-  #4: <4>
-  #5: <7>
-  #6: <8>
-}
-  */
   GTMap GT = {{LineColFunOp{.Line = 5,
                             .Col = 0,
                             .InFunction = "main",
@@ -433,63 +345,6 @@ UnionFindAAResult {
 }
 
 TEST(CtxSensUnionFindAATest, Context02) {
-  /*
-ValueCompressor: {
-  #0:
-    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    ptr %p | ID: id1.0
-  #2:
-    %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
-  #3:
-    fun @id1.<ret>
-  #4:
-    %q.addr = alloca ptr, align 8, !psr.id !27 | ID: 5
-  #5:
-    ptr %q | ID: id2.0
-  #6:
-    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 8
-  #7:
-    fun @id2.<ret>
-  #8:
-    %retval = alloca i32, align 4, !psr.id !39 | ID: 10
-  #9:
-    %x = alloca i32, align 4, !psr.id !40 | ID: 11
-  #10:
-    %y = alloca i32, align 4, !psr.id !41 | ID: 12
-  #11:
-    %xx1 = alloca ptr, align 8, !psr.id !42 | ID: 13
-  #12:
-    %xx2 = alloca ptr, align 8, !psr.id !43 | ID: 14
-  #13:
-    %yy1 = alloca ptr, align 8, !psr.id !44 | ID: 15
-  #14:
-    %yy2 = alloca ptr, align 8, !psr.id !45 | ID: 16
-  #15:
-    %call = call ptr @id1(ptr noundef %x), !dbg !58, !psr.id !59 | ID: 23
-  #16:
-    %call1 = call ptr @id1(ptr noundef %x), !dbg !64, !psr.id !65 | ID: 26
-  #17:
-    %call2 = call ptr @id2(ptr noundef %y), !dbg !70, !psr.id !71 | ID: 29
-  #18:
-    %call3 = call ptr @id2(ptr noundef %y), !dbg !76, !psr.id !77 | ID: 32
-  #19:
-    %0 = load ptr, ptr %xx1, align 8, !dbg !79, !psr.id !80 | ID: 34
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <0>
-  #2: <1, 2, 3, 9, 15, 16, 19>
-  #3: <4>
-  #4: <4>
-  #5: <5, 6, 7, 10, 17, 18>
-  #6: <8>
-  #7: <11>
-  #8: <12>
-  #9: <13>
-  #10: <14>
-}
-  */
   GTMap GT = {{LineColFunOp{.Line = 6,
                             .Col = 0,
                             .InFunction = "main",
@@ -579,51 +434,6 @@ UnionFindAAResult {
 }
 
 TEST(CtxSensUnionFindAATest, Context03) {
-  /*
-ValueCompressor: {
-  #0:
-    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    ptr %p | ID: id1.0
-  #2:
-    %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
-  #3:
-    fun @id1.<ret>
-  #4:
-    %q.addr = alloca ptr, align 8, !psr.id !27 | ID: 5
-  #5:
-    ptr %q | ID: id2.0
-  #6:
-    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 8
-  #7:
-    %call = call ptr @id1(ptr noundef %0), !dbg !34, !psr.id !35 | ID: 9
-  #8:
-    fun @id2.<ret>
-  #9:
-    %retval = alloca i32, align 4, !psr.id !41 | ID: 11
-  #10:
-    %x = alloca i32, align 4, !psr.id !42 | ID: 12
-  #11:
-    %xx1 = alloca ptr, align 8, !psr.id !43 | ID: 13
-  #12:
-    %xx2 = alloca ptr, align 8, !psr.id !44 | ID: 14
-  #13:
-    %call = call ptr @id2(ptr noundef %x), !dbg !53, !psr.id !54 | ID: 19
-  #14:
-    %call1 = call ptr @id2(ptr noundef %x), !dbg !59, !psr.id !60 | ID: 22
-  #15:
-    %0 = load ptr, ptr %xx1, align 8, !dbg !62, !psr.id !63 | ID: 24
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <1, 2, 3, 5, 6, 7, 8, 10, 13, 14, 15>
-  #2: <4>
-  #3: <4>
-  #4: <9>
-  #5: <11>
-  #6: <12>
-}
-  */
   GTMap GT = {{LineColFunOp{.Line = 6,
                             .Col = 0,
                             .InFunction = "main",
@@ -752,90 +562,6 @@ TEST(CtxSensUnionFindAATest, Context04_0) {
 }
 
 TEST(CtxSensUnionFindAATest, Context04_1) {
-  /*
-  ValueCompressor: {
-  #0:
-    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    ptr %p | ID: id1.0
-  #2:
-    %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
-  #3:
-    fun @id1.<ret>
-  #4:
-    %q.addr = alloca ptr, align 8, !psr.id !27 | ID: 5
-  #5:
-    ptr %q | ID: id2.0
-  #6:
-    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 8
-  #7:
-    %call = call ptr @id1(ptr noundef %0), !dbg !34, !psr.id !35 | ID: 9
-  #8:
-    fun @id2.<ret>
-  #9:
-    %r.addr = alloca ptr, align 8, !psr.id !39 | ID: 11
-  #10:
-    ptr %r | ID: id3.0
-  #11:
-    %0 = load ptr, ptr %r.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
-  #12:
-    %call = call ptr @id2(ptr noundef %0), !dbg !46, !psr.id !47 | ID: 15
-  #13:
-    fun @id3.<ret>
-  #14:
-    %retval = alloca i32, align 4, !psr.id !53 | ID: 17
-  #15:
-    %x = alloca i32, align 4, !psr.id !54 | ID: 18
-  #16:
-    %y = alloca i32, align 4, !psr.id !55 | ID: 19
-  #17:
-    %xx1 = alloca ptr, align 8, !psr.id !56 | ID: 20
-  #18:
-    %xx2 = alloca ptr, align 8, !psr.id !57 | ID: 21
-  #19:
-    %yy1 = alloca ptr, align 8, !psr.id !58 | ID: 22
-  #20:
-    %yy2 = alloca ptr, align 8, !psr.id !59 | ID: 23
-  #21:
-    %call = call ptr @id3(ptr noundef %x), !dbg !72, !psr.id !73 | ID: 30
-  #22:
-    %call1 = call ptr @id3(ptr noundef %x), !dbg !78, !psr.id !79 | ID: 33
-  #23:
-    %call2 = call ptr @id3(ptr noundef %y), !dbg !84, !psr.id !85 | ID: 36
-  #24:
-    %call3 = call ptr @id3(ptr noundef %y), !dbg !90, !psr.id !91 | ID: 39
-  #25:
-    %0 = load ptr, ptr %xx1, align 8, !dbg !93, !psr.id !94 | ID: 41
-}
-LLVMUnionFindAliasSet(global, ctx-sens) {
-  #0: {0}
-  #1: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
-  #2: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
-  #3: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
-  #4: {4}
-  #5: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
-  #6: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
-  #7: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
-  #8: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
-  #9: {9}
-  #10: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
-  #11: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
-  #12: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
-  #13: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
-  #14: {14}
-  #15: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
-  #16: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
-  #17: {17}
-  #18: {18}
-  #19: {19}
-  #20: {20}
-  #21: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
-  #22: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
-  #23: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
-  #24: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
-  #25: {1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25}
-}
-  */
   GTMap GT = {{LineColFunOp{.Line = 7,
                             .Col = 0,
                             .InFunction = "main",
@@ -1406,76 +1132,6 @@ TEST(CtxSensUnionFindAATest, Context07) {
 }
 
 TEST(CtxSensUnionFindAATest, Context08) {
-  /*
-  ValueCompressor: {
-  #0:
-    %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
-  #2:
-    ptr %Ptr | ID: selfRecursion.0
-  #3:
-    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
-    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
-    %3 = load ptr, ptr %Ptr.addr, align 8, !dbg !38, !psr.id !39 | ID: 11
-    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
-    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !48, !psr.id !49 | ID: 16
-  #4:
-    %call = call ptr @selfRecursion(ptr noundef %6), !dbg !50, !psr.id !51 | ID:
-17
-  #5: fun @selfRecursion.<ret>
-  #6: %7 = load ptr, ptr %retval, align 8, !dbg
-!55, !psr.id !56 | ID: 20
-  #7: %retval = alloca i32, align 4, !psr.id !61 | ID:
-22
-  #8: %k = alloca i32, align 4, !psr.id !62 | ID: 23
-  #9: %kptr = alloca ptr,
-align 8, !psr.id !63 | ID: 24
-  #10: %x = alloca ptr, align 8, !psr.id !64 | ID:
-25
-  #11: %y = alloca ptr, align 8, !psr.id !65 | ID: 26
-  #12: %0 = load ptr, ptr
-%kptr, align 8, !dbg !78, !psr.id !79 | ID: 33 %1 = load ptr, ptr %kptr, align
-8, !dbg !88, !psr.id !89 | ID: 38
-  #13: %call = call ptr @selfRecursion(ptr
-noundef %0), !dbg !80, !psr.id !81 | ID: 34
-  #14: %call1 = call ptr
-@selfRecursion(ptr noundef %1), !dbg !90, !psr.id !91 | ID: 39
-  #15: %2 = load
-ptr, ptr %x, align 8, !dbg !93, !psr.id !94 | ID: 41
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <0>
-  #2: <0>
-  #3: <1>
-  #4: <1>
-  #5: <1>
-  #6: <2, 3, 4, 5, 6, 8, 12, 13, 14, 15>
-  #7: <7>
-  #8: <9>
-  #9: <10>
-  #10: <11>
-}
-LLVMUnionFindAliasSet(global, ctx-sens) {
-  #0: {0}
-  #1: {1}
-  #2: {2, 3, 4, 5, 6, 8, 12, 13, 14, 15}
-  #3: {2, 3, 4, 5, 6, 8, 12, 13, 14, 15}
-  #4: {2, 3, 4, 5, 6, 8, 12, 13, 14, 15}
-  #5: {2, 3, 4, 5, 6, 8, 12, 13, 14, 15}
-  #6: {2, 3, 4, 5, 6, 8, 12, 13, 14, 15}
-  #7: {7}
-  #8: {2, 3, 4, 5, 6, 8, 12, 13, 14, 15}
-  #9: {9}
-  #10: {10}
-  #11: {11}
-  #12: {2, 3, 4, 5, 6, 8, 12, 13, 14, 15}
-  #13: {2, 3, 4, 5, 6, 8, 12, 13, 14, 15}
-  #14: {2, 3, 4, 5, 6, 8, 12, 13, 14, 15}
-  #15: {2, 3, 4, 5, 6, 8, 12, 13, 14, 15}
-}
-  */
   GTMap GT = {{LineColFunOp{.Line = 12,
                             .Col = 0,
                             .InFunction = "main",
@@ -1545,71 +1201,6 @@ LLVMUnionFindAliasSet(global, ctx-sens) {
 }
 
 TEST(CtxSensUnionFindAATest, Context09_0) {
-  /*
-  ValueCompressor: {
-  #0:
-    %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
-  #2:
-    ptr %Ptr | ID: selfRecursion.0
-  #3:
-    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
-    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
-    %3 = load ptr, ptr %Ptr.addr, align 8, !dbg !38, !psr.id !39 | ID: 11
-    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
-    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !48, !psr.id !49 | ID: 16
-  #4:
-    %call = call ptr @selfRecursion(ptr noundef %6), !dbg !50, !psr.id !51 | ID:
-17
-  #5: fun @selfRecursion.<ret>
-  #6: %7 = load ptr, ptr %retval, align 8, !dbg
-!55, !psr.id !56 | ID: 20
-  #7: %retval = alloca i32, align 4, !psr.id !61 | ID:
-22
-  #8: %k = alloca i32, align 4, !psr.id !62 | ID: 23
-  #9: %l = alloca i32, align
-4, !psr.id !63 | ID: 24
-  #10: %x = alloca ptr, align 8, !psr.id !64 | ID: 25
-  #11:
-    %y = alloca ptr, align 8, !psr.id !65 | ID: 26
-  #12:
-    %call = call ptr @selfRecursion(ptr noundef %k), !dbg !78, !psr.id !79 | ID:
-33
-  #13: %call1 = call ptr @selfRecursion(ptr noundef %l), !dbg !84, !psr.id !85
-| ID: 36
-  #14: %0 = load ptr, ptr %y, align 8, !dbg !87, !psr.id !88 | ID: 38
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <0>
-  #2: <0>
-  #3: <1>
-  #4: <1>
-  #5: <1>
-  #6: <2, 3, 4, 5, 6, 8, 9, 12, 13, 14>
-  #7: <7>
-  #8: <10>
-  #9: <11>
-}
-  LLVMUnionFindAliasSet(global, ctx-sens) {
-  #0: {0}
-  #1: {1}
-  #2: {2, 3, 4, 5, 6, 8, 9, 12, 13, 14}
-  #3: {2, 3, 4, 5, 6, 8, 9, 12, 13, 14}
-  #4: {2, 3, 4, 5, 6, 8, 9, 12, 13, 14}
-  #5: {2, 3, 4, 5, 6, 8, 9, 12, 13, 14}
-  #6: {2, 3, 4, 5, 6, 8, 9, 12, 13, 14}
-  #7: {7}
-  #8: {2, 3, 4, 5, 6, 8, 9, 12, 13, 14}
-  #9: {2, 3, 4, 5, 6, 8, 9, 12, 13, 14}
-  #10: {10}
-  #11: {11}
-  #12: {2, 3, 4, 5, 6, 8, 9, 12, 13, 14}
-  #13: {2, 3, 4, 5, 6, 8, 9, 12, 13, 14}
-  #14: {2, 3, 4, 5, 6, 8, 9, 12, 13, 14}
-}
-  */
   GTMap GT = {{LineColFunOp{.Line = 12,
                             .Col = 0,
                             .InFunction = "main",
@@ -1673,80 +1264,6 @@ UnionFindAAResult {
 }
 
 TEST(CtxSensUnionFindAATest, Context09_1) {
-  /*
-  ValueCompressor: {
-  #0:
-    %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
-  #2:
-    ptr %Ptr | ID: selfRecursion.0
-  #3:
-    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
-    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
-    %3 = load ptr, ptr %Ptr.addr, align 8, !dbg !38, !psr.id !39 | ID: 11
-    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
-    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !48, !psr.id !49 | ID: 16
-  #4:
-    %call = call ptr @selfRecursion(ptr noundef %6), !dbg !50, !psr.id !51 | ID:
-17 #5: fun @selfRecursion.<ret> #6: %7 = load ptr, ptr %retval, align 8, !dbg
-!55, !psr.id !56 | ID: 20 #7: %retval = alloca i32, align 4, !psr.id !61 | ID:
-22 #8: %k = alloca i32, align 4, !psr.id !62 | ID: 23 #9: %l = alloca i32, align
-4, !psr.id !63 | ID: 24 #10: %xx1 = alloca ptr, align 8, !psr.id !64 | ID: 25
-  #11:
-    %xx2 = alloca ptr, align 8, !psr.id !65 | ID: 26
-  #12:
-    %yy1 = alloca ptr, align 8, !psr.id !66 | ID: 27
-  #13:
-    %yy2 = alloca ptr, align 8, !psr.id !67 | ID: 28
-  #14:
-    %call = call ptr @selfRecursion(ptr noundef %k), !dbg !80, !psr.id !81 | ID:
-35 #15: %call1 = call ptr @selfRecursion(ptr noundef %k), !dbg !88, !psr.id !89
-| ID: 39 #16: %call2 = call ptr @selfRecursion(ptr noundef %l), !dbg !94,
-!psr.id !95 | ID: 42 #17: %call3 = call ptr @selfRecursion(ptr noundef %l), !dbg
-!102, !psr.id !103 | ID: 46 #18: %0 = load ptr, ptr %yy2, align 8, !dbg !105,
-!psr.id !106 | ID: 48
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <0>
-  #2: <0>
-  #3: <0>
-  #4: <0>
-  #5: <1>
-  #6: <1>
-  #7: <1>
-  #8: <1>
-  #9: <1>
-  #10: <2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18>
-  #11: <7>
-  #12: <10>
-  #13: <11>
-  #14: <12>
-  #15: <13>
-}
-  LLVMUnionFindAliasSet(global, ctx-sens) {
-  #0: {0}
-  #1: {1}
-  #2: {2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18}
-  #3: {2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18}
-  #4: {2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18}
-  #5: {2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18}
-  #6: {2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18}
-  #7: {7}
-  #8: {2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18}
-  #9: {2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18}
-  #10: {10}
-  #11: {11}
-  #12: {12}
-  #13: {13}
-  #14: {2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18}
-  #15: {2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18}
-  #16: {2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18}
-  #17: {2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18}
-  #18: {2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18}
-}
-  */
   GTMap GT = {
       {LineColFunOp{.Line = 12,
                     .Col = 0,
@@ -1836,97 +1353,6 @@ UnionFindAAResult {
 }
 
 TEST(CtxSensUnionFindAATest, Context10_0) {
-  /*
-  ValueCompressor: {
-  #0:
-    %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
-  #2:
-    ptr %Ptr | ID: Forth.0
-  #3:
-    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
-    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
-    %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !39, !psr.id !40 | ID: 11
-    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !43, !psr.id !44 | ID: 13
-    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !50, !psr.id !51 | ID: 17
-  #4:
-    %call = call ptr @Back(ptr noundef %5), !dbg !45, !psr.id !46 | ID: 14
-  #5:
-    fun @Back.<ret>
-  #6:
-    ptr %Ptr | ID: Back.0
-  #7:
-    %7 = load ptr, ptr %retval, align 8, !dbg !55, !psr.id !56 | ID: 20
-  #8:
-    fun @Forth.<ret>
-  #9:
-    %retval = alloca ptr, align 8, !psr.id !59 | ID: 22
-  #10:
-    %Ptr.addr = alloca ptr, align 8, !psr.id !60 | ID: 23
-  #11:
-    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !65, !psr.id !67 | ID: 26
-    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !74, !psr.id !76 | ID: 30
-    %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !81, !psr.id !82 | ID: 33
-    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !85, !psr.id !86 | ID: 35
-    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !92, !psr.id !93 | ID: 39
-  #12:
-    %call = call ptr @Forth(ptr noundef %5), !dbg !87, !psr.id !88 | ID: 36
-  #13:
-    %7 = load ptr, ptr %retval, align 8, !dbg !97, !psr.id !98 | ID: 42
-  #14:
-    %retval = alloca i32, align 4, !psr.id !103 | ID: 44
-  #15:
-    %k = alloca i32, align 4, !psr.id !104 | ID: 45
-  #16:
-    %x = alloca ptr, align 8, !psr.id !105 | ID: 46
-  #17:
-    %y = alloca ptr, align 8, !psr.id !106 | ID: 47
-  #18:
-    %call = call ptr @Back(ptr noundef %k), !dbg !115, !psr.id !116 | ID: 52
-  #19:
-    %call1 = call ptr @Back(ptr noundef %k), !dbg !123, !psr.id !124 | ID: 56
-  #20:
-    %0 = load ptr, ptr %x, align 8, !dbg !126, !psr.id !127 | ID: 58
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <1>
-  #2: <2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20>
-  #3: <9>
-  #4: <9>
-  #5: <9>
-  #6: <10>
-  #7: <10>
-  #8: <10>
-  #9: <14>
-  #10: <16>
-  #11: <17>
-}
-LLVMUnionFindAliasSet(global, ctx-sens) {
-  #0: {0}
-  #1: {1}
-  #2: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
-  #3: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
-  #4: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
-  #5: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
-  #6: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
-  #7: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
-  #8: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
-  #9: {9}
-  #10: {10}
-  #11: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
-  #12: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
-  #13: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
-  #14: {14}
-  #15: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
-  #16: {16}
-  #17: {17}
-  #18: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
-  #19: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
-  #20: {2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20}
-}
-  */
   GTMap GT = {
       {LineColFunOp{.Line = 24,
                     .Col = 0,
@@ -2004,90 +1430,6 @@ LLVMUnionFindAliasSet(global, ctx-sens) {
 }
 
 TEST(CtxSensUnionFindAATest, Context10_1) {
-  /*
-  ValueCompressor: {
-  #0:
-    %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
-  #2:
-    ptr %Ptr | ID: Forth.0
-  #3:
-    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
-    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
-    %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !39, !psr.id !40 | ID: 11
-    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !43, !psr.id !44 | ID: 13
-    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !50, !psr.id !51 | ID: 17
-  #4:
-    %call = call ptr @Back(ptr noundef %5), !dbg !45, !psr.id !46 | ID: 14
-  #5:
-    fun @Back.<ret>
-  #6:
-    ptr %Ptr | ID: Back.0
-  #7:
-    %7 = load ptr, ptr %retval, align 8, !dbg !55, !psr.id !56 | ID: 20
-  #8:
-    fun @Forth.<ret>
-  #9:
-    %retval = alloca ptr, align 8, !psr.id !59 | ID: 22
-  #10:
-    %Ptr.addr = alloca ptr, align 8, !psr.id !60 | ID: 23
-  #11:
-    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !65, !psr.id !67 | ID: 26
-    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !74, !psr.id !76 | ID: 30
-    %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !81, !psr.id !82 | ID: 33
-    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !85, !psr.id !86 | ID: 35
-    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !92, !psr.id !93 | ID: 39
-  #12:
-    %call = call ptr @Forth(ptr noundef %5), !dbg !87, !psr.id !88 | ID: 36
-  #13:
-    %7 = load ptr, ptr %retval, align 8, !dbg !97, !psr.id !98 | ID: 42
-  #14:
-    %retval = alloca i32, align 4, !psr.id !103 | ID: 44
-  #15:
-    %k = alloca i32, align 4, !psr.id !104 | ID: 45
-  #16:
-    %l = alloca i32, align 4, !psr.id !105 | ID: 46
-  #17:
-    %xx1 = alloca ptr, align 8, !psr.id !106 | ID: 47
-  #18:
-    %xx2 = alloca ptr, align 8, !psr.id !107 | ID: 48
-  #19:
-    %yy1 = alloca ptr, align 8, !psr.id !108 | ID: 49
-  #20:
-    %yy2 = alloca ptr, align 8, !psr.id !109 | ID: 50
-  #21:
-    %call = call ptr @Back(ptr noundef %k), !dbg !122, !psr.id !123 | ID: 57
-  #22:
-    %call1 = call ptr @Back(ptr noundef %k), !dbg !130, !psr.id !131 | ID: 61
-  #23:
-    %call2 = call ptr @Back(ptr noundef %l), !dbg !136, !psr.id !137 | ID: 64
-  #24:
-    %call3 = call ptr @Back(ptr noundef %l), !dbg !144, !psr.id !145 | ID: 68
-  #25:
-    %0 = load ptr, ptr %xx1, align 8, !dbg !147, !psr.id !148 | ID: 70
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <1>
-  #2: <2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25>
-  #3: <9>
-  #4: <9>
-  #5: <9>
-  #6: <9>
-  #7: <9>
-  #8: <10>
-  #9: <10>
-  #10: <10>
-  #11: <10>
-  #12: <10>
-  #13: <14>
-  #14: <17>
-  #15: <18>
-  #16: <19>
-  #17: <20>
-}
-  */
   GTMap GT = {
       {LineColFunOp{.Line = 24,
                     .Col = 0,
@@ -2193,99 +1535,6 @@ UnionFindAAResult {
 }
 
 TEST(CtxSensUnionFindAATest, Context11_0) {
-  /*
-  ValueCompressor: {
-  #0:
-    %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
-  #2:
-    ptr %Ptr | ID: Forth.0
-  #3:
-    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
-    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
-    %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !39, !psr.id !40 | ID: 11
-    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !43, !psr.id !44 | ID: 13
-    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !50, !psr.id !51 | ID: 17
-  #4:
-    %call = call ptr @Stop(ptr noundef %5), !dbg !45, !psr.id !46 | ID: 14
-  #5:
-    fun @Stop.<ret>
-  #6:
-    ptr %Ptr | ID: Stop.0
-  #7:
-    %7 = load ptr, ptr %retval, align 8, !dbg !55, !psr.id !56 | ID: 20
-  #8:
-    fun @Forth.<ret>
-  #9:
-    %retval = alloca ptr, align 8, !psr.id !59 | ID: 22
-  #10:
-    %Ptr.addr = alloca ptr, align 8, !psr.id !60 | ID: 23
-  #11:
-    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !65, !psr.id !67 | ID: 26
-    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !76, !psr.id !78 | ID: 31
-    %3 = load ptr, ptr %Ptr.addr, align 8, !dbg !84, !psr.id !85 | ID: 35
-  #12:
-    %call = call ptr @Forth(ptr noundef %2), !dbg !79, !psr.id !80 | ID: 32
-  #13:
-    %call1 = call ptr @Back(ptr noundef %3), !dbg !86, !psr.id !87 | ID: 36
-  #14:
-    fun @Back.<ret>
-  #15:
-    ptr %Ptr | ID: Back.0
-  #16:
-    %4 = load ptr, ptr %retval, align 8, !dbg !91, !psr.id !92 | ID: 39
-  #17:
-    %retval = alloca ptr, align 8, !psr.id !95 | ID: 41
-  #18:
-    %Ptr.addr = alloca ptr, align 8, !psr.id !96 | ID: 42
-  #19:
-    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !101, !psr.id !103 | ID: 45
-    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !110, !psr.id !112 | ID: 49
-    %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !117, !psr.id !118 | ID: 52
-    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !121, !psr.id !122 | ID: 54
-    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !128, !psr.id !129 | ID: 58
-  #20:
-    %call = call ptr @Stop(ptr noundef %5), !dbg !123, !psr.id !124 | ID: 55
-  #21:
-    %7 = load ptr, ptr %retval, align 8, !dbg !133, !psr.id !134 | ID: 61
-  #22:
-    %retval = alloca i32, align 4, !psr.id !139 | ID: 63
-  #23:
-    %k = alloca i32, align 4, !psr.id !140 | ID: 64
-  #24:
-    %l = alloca i32, align 4, !psr.id !141 | ID: 65
-  #25:
-    %x = alloca ptr, align 8, !psr.id !142 | ID: 66
-  #26:
-    %y = alloca ptr, align 8, !psr.id !143 | ID: 67
-  #27:
-    %call = call ptr @Back(ptr noundef %k), !dbg !156, !psr.id !157 | ID: 74
-  #28:
-    %call1 = call ptr @Forth(ptr noundef %l), !dbg !162, !psr.id !163 | ID: 77
-  #29:
-    %0 = load ptr, ptr %x, align 8, !dbg !165, !psr.id !166 | ID: 79
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <0>
-  #2: <1>
-  #3: <1>
-  #4: <2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 14, 15, 16, 19, 20, 21, 23, 24, 27, 28,
-29>
-  #5: <9>
-  #6: <9>
-  #7: <10>
-  #8: <10>
-  #9: <17>
-  #10: <17>
-  #11: <18>
-  #12: <18>
-  #13: <22>
-  #14: <25>
-  #15: <26>
-}
-  */
   GTMap GT{{LineColFunOp{.Line = 33,
                          .Col = 0,
                          .InFunction = "main",
@@ -2385,106 +1634,6 @@ UnionFindAAResult {
 }
 
 TEST(CtxSensUnionFindAATest, Context11_1) {
-  /*
-  ValueCompressor: {
-  #0:
-    %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
-  #2:
-    ptr %Ptr | ID: Forth.0
-  #3:
-    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
-    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
-    %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !39, !psr.id !40 | ID: 11
-    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !43, !psr.id !44 | ID: 13
-    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !50, !psr.id !51 | ID: 17
-  #4:
-    %call = call ptr @Stop(ptr noundef %5), !dbg !45, !psr.id !46 | ID: 14
-  #5:
-    fun @Stop.<ret>
-  #6:
-    ptr %Ptr | ID: Stop.0
-  #7:
-    %7 = load ptr, ptr %retval, align 8, !dbg !55, !psr.id !56 | ID: 20
-  #8:
-    fun @Forth.<ret>
-  #9:
-    %retval = alloca ptr, align 8, !psr.id !59 | ID: 22
-  #10:
-    %Ptr.addr = alloca ptr, align 8, !psr.id !60 | ID: 23
-  #11:
-    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !65, !psr.id !67 | ID: 26
-    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !76, !psr.id !78 | ID: 31
-    %3 = load ptr, ptr %Ptr.addr, align 8, !dbg !84, !psr.id !85 | ID: 35
-  #12:
-    %call = call ptr @Forth(ptr noundef %2), !dbg !79, !psr.id !80 | ID: 32
-  #13:
-    %call1 = call ptr @Back(ptr noundef %3), !dbg !86, !psr.id !87 | ID: 36
-  #14:
-    fun @Back.<ret>
-  #15:
-    ptr %Ptr | ID: Back.0
-  #16:
-    %4 = load ptr, ptr %retval, align 8, !dbg !91, !psr.id !92 | ID: 39
-  #17:
-    %retval = alloca ptr, align 8, !psr.id !95 | ID: 41
-  #18:
-    %Ptr.addr = alloca ptr, align 8, !psr.id !96 | ID: 42
-  #19:
-    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !101, !psr.id !103 | ID: 45
-    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !110, !psr.id !112 | ID: 49
-    %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !117, !psr.id !118 | ID: 52
-    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !121, !psr.id !122 | ID: 54
-    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !128, !psr.id !129 | ID: 58
-  #20:
-    %call = call ptr @Stop(ptr noundef %5), !dbg !123, !psr.id !124 | ID: 55
-  #21:
-    %7 = load ptr, ptr %retval, align 8, !dbg !133, !psr.id !134 | ID: 61
-  #22:
-    %retval = alloca i32, align 4, !psr.id !139 | ID: 63
-  #23:
-    %k = alloca i32, align 4, !psr.id !140 | ID: 64
-  #24:
-    %l = alloca i32, align 4, !psr.id !141 | ID: 65
-  #25:
-    %xx1 = alloca ptr, align 8, !psr.id !142 | ID: 66
-  #26:
-    %xx2 = alloca ptr, align 8, !psr.id !143 | ID: 67
-  #27:
-    %yy1 = alloca ptr, align 8, !psr.id !144 | ID: 68
-  #28:
-    %yy2 = alloca ptr, align 8, !psr.id !145 | ID: 69
-  #29:
-    %call = call ptr @Back(ptr noundef %k), !dbg !158, !psr.id !159 | ID: 76
-  #30:
-    %call1 = call ptr @Back(ptr noundef %k), !dbg !164, !psr.id !165 | ID: 79
-  #31:
-    %call2 = call ptr @Forth(ptr noundef %l), !dbg !170, !psr.id !171 | ID: 82
-  #32:
-    %call3 = call ptr @Forth(ptr noundef %l), !dbg !176, !psr.id !177 | ID: 85
-  #33:
-    %0 = load ptr, ptr %xx2, align 8, !dbg !179, !psr.id !180 | ID: 87
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <0>
-  #2: <0>
-  #3: <1>
-  #4: <1>
-  #5: <1>
-  #6: <2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 14, 15, 16, 19, 20, 21, 23, 24, 29, 30,
-31, 32, 33> #7: <9> #8: <9> #9: <10> #10: <10> #11: <17> #12: <17> #13: <17>
-  #14: <18>
-  #15: <18>
-  #16: <18>
-  #17: <22>
-  #18: <25>
-  #19: <26>
-  #20: <27>
-  #21: <28>
-}
-  */
   GTMap GT{{LineColFunOp{.Line = 33,
                          .Col = 0,
                          .InFunction = "main",
@@ -2608,60 +1757,6 @@ UnionFindAAResult {
 }
 
 TEST(CtxSensUnionFindAATest, Context12_0) {
-  /*
-  ValueCompressor: {
-  #0:
-    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    %q.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
-  #2:
-    ptr %p | ID: argretq.0
-  #3:
-    ptr %q | ID: argretq.1
-  #4:
-    %0 = load ptr, ptr %q.addr, align 8, !dbg !27, !psr.id !28 | ID: 6
-  #5:
-    fun @argretq.<ret>
-  #6:
-    %retval = alloca i32, align 4, !psr.id !34 | ID: 8
-  #7:
-    %x = alloca i32, align 4, !psr.id !35 | ID: 9
-  #8:
-    %y = alloca i32, align 4, !psr.id !36 | ID: 10
-  #9:
-    %xx1 = alloca ptr, align 8, !psr.id !37 | ID: 11
-  #10:
-    %xx2 = alloca ptr, align 8, !psr.id !38 | ID: 12
-  #11:
-    %yy1 = alloca ptr, align 8, !psr.id !39 | ID: 13
-  #12:
-    %yy2 = alloca ptr, align 8, !psr.id !40 | ID: 14
-  #13:
-    %call = call ptr @argretq(ptr noundef %y, ptr noundef %x), !dbg !53, !psr.id
-!54 | ID: 21 #14: %call1 = call ptr @argretq(ptr noundef %y, ptr noundef %x),
-!dbg !59, !psr.id !60 | ID: 24 #15: %call2 = call ptr @argretq(ptr noundef %x,
-ptr noundef %y), !dbg !65, !psr.id !66 | ID: 27 #16: %call3 = call ptr
-@argretq(ptr noundef %x, ptr noundef %y), !dbg !71, !psr.id !72 | ID: 30 #17: %0
-= load ptr, ptr %xx1, align 8, !dbg !74, !psr.id !75 | ID: 32
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <0>
-  #2: <0>
-  #3: <0>
-  #4: <1>
-  #5: <1>
-  #6: <1>
-  #7: <1>
-  #8: <2, 3, 4, 5, 8, 15, 16>
-  #9: <2, 3, 4, 5, 7, 13, 14, 17>
-  #10: <6>
-  #11: <9>
-  #12: <10>
-  #13: <11>
-  #14: <12>
-}
-  */
   GTMap GT{{LineColFunOp{.Line = 5,
                          .Col = 0,
                          .InFunction = "main",
@@ -3315,31 +2410,6 @@ TEST(CtxSensUnionFindAATest, Indirection05) {
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Load}}},
-              {LineColFunOp{.Line = 25,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 25,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 27,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 27,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 29,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 29,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-
               {LineColFunOp{.Line = 37,
                             .Col = 0,
                             .InFunction = "main",
@@ -3408,109 +2478,6 @@ TEST(CtxSensUnionFindAATest, Indirection05) {
 }
 
 TEST(CtxSensUnionFindAATest, Indirection06) {
-  /*
-  ValueCompressor: {
-  #0:
-    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
-  #1:
-    %Foo = alloca %struct._LinkedListOne, align 8, !psr.id !17 | ID: 1
-    %Next18 = getelementptr inbounds %struct._LinkedListOne, ptr %Foo, i32 0,
-i32 1, !dbg !189, !psr.id !190 | ID: 88 #2:
-    %.compoundliteral = alloca %struct._LinkedListOne, align 8, !psr.id !18 |
-ID: 2 %Val = getelementptr inbounds %struct._LinkedListOne, ptr
-%.compoundliteral, i32 0, i32 0, !dbg !52, !psr.id !53 | ID: 28 %Next =
-getelementptr inbounds %struct._LinkedListOne, ptr %.compoundliteral, i32 0, i32
-1, !dbg !52, !psr.id !55 | ID: 30 #3: %Bar = alloca %struct._LinkedListTwo,
-align 8, !psr.id !19 | ID: 3 %Next19 = getelementptr inbounds
-%struct._LinkedListTwo, ptr %Bar, i32 0, i32 1, !dbg !196, !psr.id !197 | ID: 92
-  #4:
-    %.compoundliteral1 = alloca %struct._LinkedListTwo, align 8, !psr.id !20 |
-ID: 4 %Val2 = getelementptr inbounds %struct._LinkedListTwo, ptr
-%.compoundliteral1, i32 0, i32 0, !dbg !67, !psr.id !68 | ID: 34 %Next3 =
-getelementptr inbounds %struct._LinkedListTwo, ptr %.compoundliteral1, i32 0,
-i32 1, !dbg !67, !psr.id !70 | ID: 36 #5: %Baz = alloca
-%struct._LinkedListThree, align 8, !psr.id !21 | ID: 5 %Next20 = getelementptr
-inbounds %struct._LinkedListThree, ptr %Baz, i32 0, i32 1, !dbg !203, !psr.id
-!204 | ID: 96 #6:
-    %.compoundliteral4 = alloca %struct._LinkedListThree, align 8, !psr.id !22 |
-ID: 6 %Val5 = getelementptr inbounds %struct._LinkedListThree, ptr
-%.compoundliteral4, i32 0, i32 0, !dbg !83, !psr.id !84 | ID: 40 %Next6 =
-getelementptr inbounds %struct._LinkedListThree, ptr %.compoundliteral4, i32 0,
-i32 1, !dbg !83, !psr.id !86 | ID: 42 #7: %Boar = alloca
-%struct._LinkedListFour, align 8, !psr.id !23 | ID: 7 %Next21 = getelementptr
-inbounds %struct._LinkedListFour, ptr %Boar, i32 0, i32 1, !dbg !210, !psr.id
-!211 | ID: 100 #8:
-    %.compoundliteral7 = alloca %struct._LinkedListFour, align 8, !psr.id !24 |
-ID: 8 %Val8 = getelementptr inbounds %struct._LinkedListFour, ptr
-%.compoundliteral7, i32 0, i32 0, !dbg !99, !psr.id !100 | ID: 46 %Next9 =
-getelementptr inbounds %struct._LinkedListFour, ptr %.compoundliteral7, i32 0,
-i32 1, !dbg !99, !psr.id !102 | ID: 48 #9: %Far = alloca
-%struct._LinkedListFive, align 8, !psr.id !25 | ID: 9 %Next22 = getelementptr
-inbounds %struct._LinkedListFive, ptr %Far, i32 0, i32 1, !dbg !217, !psr.id
-!218 | ID: 104 #10:
-    %.compoundliteral10 = alloca %struct._LinkedListFive, align 8, !psr.id !26 |
-ID: 10 %Val11 = getelementptr inbounds %struct._LinkedListFive, ptr
-%.compoundliteral10, i32 0, i32 0, !dbg !115, !psr.id !116 | ID: 52 %Next12 =
-getelementptr inbounds %struct._LinkedListFive, ptr %.compoundliteral10, i32 0,
-i32 1, !dbg !115, !psr.id !118 | ID: 54 #11: %One = alloca
-%struct._LinkedListOne, align 8, !psr.id !27 | ID: 11 %Next13 = getelementptr
-inbounds %struct._LinkedListOne, ptr %One, i32 0, i32 1, !dbg !151, !psr.id !152
-| ID: 68 #12: %Two = alloca %struct._LinkedListTwo, align 8, !psr.id !28 | ID:
-12 %Next14 = getelementptr inbounds %struct._LinkedListTwo, ptr %Two, i32 0, i32
-1, !dbg !158, !psr.id !159 | ID: 72 #13: %Three = alloca
-%struct._LinkedListThree, align 8, !psr.id !29 | ID: 13 %Next15 = getelementptr
-inbounds %struct._LinkedListThree, ptr %Three, i32 0, i32 1, !dbg !166, !psr.id
-!167 | ID: 76 #14: %Four = alloca %struct._LinkedListFour, align 8, !psr.id !30
-| ID: 14 %Next16 = getelementptr inbounds %struct._LinkedListFour, ptr %Four,
-i32 0, i32 1, !dbg !174, !psr.id !175 | ID: 80 #15: %Five = alloca
-%struct._LinkedListFive, align 8, !psr.id !31 | ID: 15 %Next17 = getelementptr
-inbounds %struct._LinkedListFive, ptr %Five, i32 0, i32 1, !dbg !182, !psr.id
-!183 | ID: 84 #16: %AliasOne = alloca ptr, align 8, !psr.id !32 | ID: 16 #17:
-    %AliasTwo = alloca ptr, align 8, !psr.id !33 | ID: 17
-  #18:
-    %AliasThree = alloca ptr, align 8, !psr.id !34 | ID: 18
-  #19:
-    %AliasFour = alloca ptr, align 8, !psr.id !35 | ID: 19
-  #20:
-    %AliasFive = alloca ptr, align 8, !psr.id !36 | ID: 20
-  #21:
-    %AliasSix = alloca ptr, align 8, !psr.id !37 | ID: 21
-  #22:
-    %AliasSeven = alloca ptr, align 8, !psr.id !38 | ID: 22
-  #23:
-    %AliasEight = alloca ptr, align 8, !psr.id !39 | ID: 23
-  #24:
-    %AliasNine = alloca ptr, align 8, !psr.id !40 | ID: 24
-  #25:
-    %AliasTen = alloca ptr, align 8, !psr.id !41 | ID: 25
-  #26:
-    %0 = load ptr, ptr %Next13, align 8, !dbg !151, !psr.id !153 | ID: 69
-  #27:
-    %1 = load ptr, ptr %Next14, align 8, !dbg !158, !psr.id !160 | ID: 73
-  #28:
-    %2 = load ptr, ptr %Next15, align 8, !dbg !166, !psr.id !168 | ID: 77
-  #29:
-    %3 = load ptr, ptr %Next16, align 8, !dbg !174, !psr.id !176 | ID: 81
-  #30:
-    %4 = load ptr, ptr %Next17, align 8, !dbg !182, !psr.id !184 | ID: 85
-  #31:
-    %5 = load ptr, ptr %Next18, align 8, !dbg !189, !psr.id !191 | ID: 89
-  #32:
-    %6 = load ptr, ptr %Next19, align 8, !dbg !196, !psr.id !198 | ID: 93
-  #33:
-    %7 = load ptr, ptr %Next20, align 8, !dbg !203, !psr.id !205 | ID: 97
-  #34:
-    %8 = load ptr, ptr %Next21, align 8, !dbg !210, !psr.id !212 | ID: 101
-  #35:
-    %9 = load ptr, ptr %Next22, align 8, !dbg !217, !psr.id !219 | ID: 105
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 26, 27, 28, 29, 30,
-31, 32, 33, 34, 35> #2: <16> #3: <17> #4: <18> #5: <19> #6: <20> #7: <21> #8:
-<22> #9: <23> #10: <24> #11: <25>
-}
-  */
   GTMap GT = {{LineColFunOp{.Line = 28,
                             .Col = 0,
                             .InFunction = "main",
@@ -3518,79 +2485,103 @@ UnionFindAAResult {
                {LineColFunOp{.Line = 28,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 30,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 30,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 29,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 32,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 32,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 30,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 34,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 34,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 31,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 36,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 36,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 32,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 39,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 39,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 33,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 40,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 40,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 34,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 41,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 41,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 35,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 42,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 42,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 36,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 43,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 43,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 37,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 40,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 41,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 42,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 43,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 45,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 46,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 47,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 48,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 49,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 50,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 51,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 52,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 53,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 54,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
               {LineColFunOp{.Line = 45,
                             .Col = 0,
                             .InFunction = "main",
@@ -3675,127 +2666,6 @@ UnionFindAAResult {
 }
 
 TEST(CtxSensUnionFindAATest, Indirection07) {
-  /*
-  ValueCompressor: {
-  #0:
-    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
-  #1:
-    %Foo = alloca %struct._LinkedListOne, align 8, !psr.id !17 | ID: 1
-    %Next22 = getelementptr inbounds %struct._LinkedListOne, ptr %Foo, i32 0,
-i32 1, !dbg !223, !psr.id !224 | ID: 105 #2:
-    %.compoundliteral = alloca %struct._LinkedListOne, align 8, !psr.id !18 |
-ID: 2 %Val = getelementptr inbounds %struct._LinkedListOne, ptr
-%.compoundliteral, i32 0, i32 0, !dbg !57, !psr.id !58 | ID: 33 %Next =
-getelementptr inbounds %struct._LinkedListOne, ptr %.compoundliteral, i32 0, i32
-1, !dbg !57, !psr.id !60 | ID: 35 #3: %Bar = alloca %struct._LinkedListTwo,
-align 8, !psr.id !19 | ID: 3 %Next23 = getelementptr inbounds
-%struct._LinkedListTwo, ptr %Bar, i32 0, i32 1, !dbg !230, !psr.id !231 | ID:
-109 #4:
-    %.compoundliteral1 = alloca %struct._LinkedListTwo, align 8, !psr.id !20 |
-ID: 4 %Val2 = getelementptr inbounds %struct._LinkedListTwo, ptr
-%.compoundliteral1, i32 0, i32 0, !dbg !72, !psr.id !73 | ID: 39 %Next3 =
-getelementptr inbounds %struct._LinkedListTwo, ptr %.compoundliteral1, i32 0,
-i32 1, !dbg !72, !psr.id !75 | ID: 41 #5: %Baz = alloca
-%struct._LinkedListThree, align 8, !psr.id !21 | ID: 5 %Next24 = getelementptr
-inbounds %struct._LinkedListThree, ptr %Baz, i32 0, i32 1, !dbg !237, !psr.id
-!238 | ID: 113 #6:
-    %.compoundliteral4 = alloca %struct._LinkedListThree, align 8, !psr.id !22 |
-ID: 6 %Val5 = getelementptr inbounds %struct._LinkedListThree, ptr
-%.compoundliteral4, i32 0, i32 0, !dbg !88, !psr.id !89 | ID: 45 %Next6 =
-getelementptr inbounds %struct._LinkedListThree, ptr %.compoundliteral4, i32 0,
-i32 1, !dbg !88, !psr.id !91 | ID: 47 #7: %Boar = alloca
-%struct._LinkedListFour, align 8, !psr.id !23 | ID: 7 %Next25 = getelementptr
-inbounds %struct._LinkedListFour, ptr %Boar, i32 0, i32 1, !dbg !244, !psr.id
-!245 | ID: 117 #8:
-    %.compoundliteral7 = alloca %struct._LinkedListFour, align 8, !psr.id !24 |
-ID: 8 %Val8 = getelementptr inbounds %struct._LinkedListFour, ptr
-%.compoundliteral7, i32 0, i32 0, !dbg !104, !psr.id !105 | ID: 51 %Next9 =
-getelementptr inbounds %struct._LinkedListFour, ptr %.compoundliteral7, i32 0,
-i32 1, !dbg !104, !psr.id !107 | ID: 53 #9: %Far = alloca
-%struct._LinkedListFive, align 8, !psr.id !25 | ID: 9 %Next26 = getelementptr
-inbounds %struct._LinkedListFive, ptr %Far, i32 0, i32 1, !dbg !251, !psr.id
-!252 | ID: 121 #10:
-    %.compoundliteral10 = alloca %struct._LinkedListFive, align 8, !psr.id !26 |
-ID: 10 %Val11 = getelementptr inbounds %struct._LinkedListFive, ptr
-%.compoundliteral10, i32 0, i32 0, !dbg !120, !psr.id !121 | ID: 57 %Next12 =
-getelementptr inbounds %struct._LinkedListFive, ptr %.compoundliteral10, i32 0,
-i32 1, !dbg !120, !psr.id !123 | ID: 59 #11: %Faz = alloca
-%struct._LinkedListSix, align 8, !psr.id !27 | ID: 11 %Next27 = getelementptr
-inbounds %struct._LinkedListSix, ptr %Faz, i32 0, i32 1, !dbg !258, !psr.id !259
-| ID: 125 #12:
-    %.compoundliteral13 = alloca %struct._LinkedListSix, align 8, !psr.id !28 |
-ID: 12 %Val14 = getelementptr inbounds %struct._LinkedListSix, ptr
-%.compoundliteral13, i32 0, i32 0, !dbg !136, !psr.id !137 | ID: 63 %Next15 =
-getelementptr inbounds %struct._LinkedListSix, ptr %.compoundliteral13, i32 0,
-i32 1, !dbg !136, !psr.id !139 | ID: 65 #13: %One = alloca
-%struct._LinkedListOne, align 8, !psr.id !29 | ID: 13 %Next16 = getelementptr
-inbounds %struct._LinkedListOne, ptr %One, i32 0, i32 1, !dbg !177, !psr.id !178
-| ID: 81 #14: %Two = alloca %struct._LinkedListTwo, align 8, !psr.id !30 | ID:
-14 %Next17 = getelementptr inbounds %struct._LinkedListTwo, ptr %Two, i32 0, i32
-1, !dbg !184, !psr.id !185 | ID: 85 #15: %Three = alloca
-%struct._LinkedListThree, align 8, !psr.id !31 | ID: 15 %Next18 = getelementptr
-inbounds %struct._LinkedListThree, ptr %Three, i32 0, i32 1, !dbg !192, !psr.id
-!193 | ID: 89 #16: %Four = alloca %struct._LinkedListFour, align 8, !psr.id !32
-| ID: 16 %Next19 = getelementptr inbounds %struct._LinkedListFour, ptr %Four,
-i32 0, i32 1, !dbg !200, !psr.id !201 | ID: 93 #17: %Five = alloca
-%struct._LinkedListFive, align 8, !psr.id !33 | ID: 17 %Next20 = getelementptr
-inbounds %struct._LinkedListFive, ptr %Five, i32 0, i32 1, !dbg !208, !psr.id
-!209 | ID: 97 #18: %Six = alloca %struct._LinkedListSix, align 8, !psr.id !34 |
-ID: 18 %Next21 = getelementptr inbounds %struct._LinkedListSix, ptr %Six, i32 0,
-i32 1, !dbg !216, !psr.id !217 | ID: 101 #19: %AliasOne = alloca ptr, align 8,
-!psr.id !35 | ID: 19 #20: %AliasTwo = alloca ptr, align 8, !psr.id !36 | ID: 20
-  #21:
-    %AliasThree = alloca ptr, align 8, !psr.id !37 | ID: 21
-  #22:
-    %AliasFour = alloca ptr, align 8, !psr.id !38 | ID: 22
-  #23:
-    %AliasFive = alloca ptr, align 8, !psr.id !39 | ID: 23
-  #24:
-    %AliasSix = alloca ptr, align 8, !psr.id !40 | ID: 24
-  #25:
-    %AliasSeven = alloca ptr, align 8, !psr.id !41 | ID: 25
-  #26:
-    %AliasEight = alloca ptr, align 8, !psr.id !42 | ID: 26
-  #27:
-    %AliasNine = alloca ptr, align 8, !psr.id !43 | ID: 27
-  #28:
-    %AliasTen = alloca ptr, align 8, !psr.id !44 | ID: 28
-  #29:
-    %AliasEleven = alloca ptr, align 8, !psr.id !45 | ID: 29
-  #30:
-    %AliasTwelve = alloca ptr, align 8, !psr.id !46 | ID: 30
-  #31:
-    %0 = load ptr, ptr %Next16, align 8, !dbg !177, !psr.id !179 | ID: 82
-  #32:
-    %1 = load ptr, ptr %Next17, align 8, !dbg !184, !psr.id !186 | ID: 86
-  #33:
-    %2 = load ptr, ptr %Next18, align 8, !dbg !192, !psr.id !194 | ID: 90
-  #34:
-    %3 = load ptr, ptr %Next19, align 8, !dbg !200, !psr.id !202 | ID: 94
-  #35:
-    %4 = load ptr, ptr %Next20, align 8, !dbg !208, !psr.id !210 | ID: 98
-  #36:
-    %5 = load ptr, ptr %Next21, align 8, !dbg !216, !psr.id !218 | ID: 102
-  #37:
-    %6 = load ptr, ptr %Next22, align 8, !dbg !223, !psr.id !225 | ID: 106
-  #38:
-    %7 = load ptr, ptr %Next23, align 8, !dbg !230, !psr.id !232 | ID: 110
-  #39:
-    %8 = load ptr, ptr %Next24, align 8, !dbg !237, !psr.id !239 | ID: 114
-  #40:
-    %9 = load ptr, ptr %Next25, align 8, !dbg !244, !psr.id !246 | ID: 118
-  #41:
-    %10 = load ptr, ptr %Next26, align 8, !dbg !251, !psr.id !253 | ID: 122
-  #42:
-    %11 = load ptr, ptr %Next27, align 8, !dbg !258, !psr.id !260 | ID: 126
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 31, 32,
-33, 34, 35, 36, 37, 38, 39, 40, 41, 42> #2: <19> #3: <20> #4: <21> #5: <22> #6:
-<23> #7: <24> #8: <25> #9: <26> #10: <27> #11: <28> #12: <29> #13: <30>
-}
-  */
   GTMap GT = {{LineColFunOp{.Line = 33,
                             .Col = 0,
                             .InFunction = "main",
@@ -3803,95 +2673,123 @@ UnionFindAAResult {
                {LineColFunOp{.Line = 33,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 35,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 35,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 34,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 37,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 37,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 35,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 39,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 39,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 36,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 41,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 41,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 37,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 43,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 43,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 38,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 46,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 46,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 39,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 47,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 47,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 40,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 48,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 48,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 41,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 49,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 49,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 42,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 50,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 50,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 43,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 51,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 51,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 44,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 46,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 47,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 48,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 49,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 50,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 51,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 53,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 54,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 55,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 56,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 57,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 58,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 59,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 60,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 61,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 62,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 63,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 64,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
               {LineColFunOp{.Line = 53,
                             .Col = 0,
                             .InFunction = "main",
@@ -3992,65 +2890,23 @@ UnionFindAAResult {
 }
 
 TEST(CtxSensUnionFindAATest, Indirection08) {
-  /*
-  ValueCompressor: {
-  #0:
-    @_ZTV3Foo = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
-x ptr] [ptr null, ptr @_ZTI3Foo, ptr @_ZN3Foo4FuncEv] }, comdat, align 8,
-!psr.id !0 | ID: 0 #1:
-    @_ZTI3Foo = linkonce_odr dso_local constant { ptr, ptr } { ptr getelementptr
-inbounds (ptr, ptr @_ZTVN10__cxxabiv117__class_type_infoE, i64 2), ptr @_ZTS3Foo
-}, comdat, align 8, !psr.id !3 | ID: 3 #2: fun @_ZN3Foo4FuncEv #3:
-    @_ZTS3Foo = linkonce_odr dso_local constant [5 x i8] c"3Foo\00", comdat,
-align 1, !psr.id !2 | ID: 2 #4:
-    @_ZTVN10__cxxabiv117__class_type_infoE = external global ptr, !psr.id !1 |
-ID: 1 #5:
-    @_ZTV3Bar = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
-x ptr] [ptr null, ptr @_ZTI3Bar, ptr @_ZN3Bar4FuncEv] }, comdat, align 8,
-!psr.id !4 | ID: 4 #6:
-    @_ZTI3Bar = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
-getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
-2), ptr @_ZTS3Bar, ptr @_ZTI3Foo }, comdat, align 8, !psr.id !7 | ID: 7 #7: fun
-@_ZN3Bar4FuncEv #8:
-    @_ZTS3Bar = linkonce_odr dso_local constant [5 x i8] c"3Bar\00", comdat,
-align 1, !psr.id !6 | ID: 6 #9:
-    @_ZTVN10__cxxabiv120__si_class_type_infoE = external global ptr, !psr.id !5
-| ID: 5 #10: %retval = alloca i32, align 4, !psr.id !24 | ID: 8 #11: %First =
-alloca %class.Foo, align 8, !psr.id !25 | ID: 9 #12: %Second = alloca
-%class.Bar, align 8, !psr.id !26 | ID: 10 #13: %SecondAlias = alloca ptr, align
-8, !psr.id !27 | ID: 11 #14: ptr %this | ID: _ZN3FooC2Ev.0 #15: ptr %this | ID:
-_ZN3BarC2Ev.0 #16: %0 = load ptr, ptr %SecondAlias, align 8, !dbg !60, !psr.id
-!61 | ID: 21 #17: %vtable = load ptr, ptr %0, align 8, !dbg !62, !psr.id !63 |
-ID: 22 %vfn = getelementptr inbounds ptr, ptr %vtable, i64 0, !dbg !62, !psr.id
-!64 | ID: 23 #18: %1 = load ptr, ptr %vfn, align 8, !dbg !62, !psr.id !65 | ID:
-24 #19: ptr %this | ID: _ZN3Foo4FuncEv.0 #20: ptr %this | ID: _ZN3Bar4FuncEv.0
-  #21:
-    %this.addr = alloca ptr, align 8, !psr.id !73 | ID: 27
-  #22:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !79 | ID: 30
-  #23:
-    %this.addr = alloca ptr, align 8, !psr.id !87 | ID: 33
-  #24:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !93 | ID: 36
-  #25:
-    %this.addr = alloca ptr, align 8, !psr.id !99 | ID: 40
-  #26:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !104 | ID: 43
-  #27:
-    %this.addr = alloca ptr, align 8, !psr.id !108 | ID: 45
-  #28:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !113 | ID: 48
-}
-UnionFindAAResult {
-  #0: <0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 14, 15, 16, 17, 18, 19, 20, 22, 24,
-26, 28> #1: <10> #2: <13> #3: <21> #4: <21> #5: <23> #6: <25> #7: <27>
-}
-  */
   GTMap GT = {{LineColFunOp{.Line = 13,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 13,
+               {ArgInFun{.Idx = 0, .InFunction = "_ZN3FooC2Ev"},
+                ArgInFun{.Idx = 0, .InFunction = "_ZN3BarC2Ev"},
+                ArgInFun{.Idx = 0, .InFunction = "_ZN3Foo4FuncEv"},
+                ArgInFun{.Idx = 0, .InFunction = "_ZN3Bar4FuncEv"},
+                GlobalVar{.Name = "_ZTV3Foo"},
+                GlobalVar{.Name = "_ZTVN10__cxxabiv117__class_type_infoE"},
+                GlobalVar{.Name = "_ZTS3Foo"}, GlobalVar{.Name = "_ZTI3Foo"},
+                GlobalVar{.Name = "_ZTV3Bar"},
+                GlobalVar{.Name = "_ZTVN10__cxxabiv120__si_class_type_infoE"},
+                GlobalVar{.Name = "_ZTS3Bar"}, GlobalVar{.Name = "_ZTI3Bar"},
+                FuncByName{.NameOfFunction = "_ZN3Foo4FuncEv"},
+                FuncByName{.NameOfFunction = "_ZN3Bar4FuncEv"},
+                LineColFunOp{.Line = 13,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
@@ -4071,82 +2927,31 @@ UnionFindAAResult {
 }
 
 TEST(CtxSensUnionFindAATest, Indirection09) {
-  /*
-  ValueCompressor: {
-  #0:
-    @_ZTV3Foo = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
-x ptr] [ptr null, ptr @_ZTI3Foo, ptr @_ZN3Foo4FuncEv] }, comdat, align 8,
-!psr.id !8 | ID: 1 #1:
-    @_ZTI3Foo = linkonce_odr dso_local constant { ptr, ptr } { ptr getelementptr
-inbounds (ptr, ptr @_ZTVN10__cxxabiv117__class_type_infoE, i64 2), ptr @_ZTS3Foo
-}, comdat, align 8, !psr.id !11 | ID: 4 #2: fun @_ZN3Foo4FuncEv #3:
-    @_ZTS3Foo = linkonce_odr dso_local constant [5 x i8] c"3Foo\00", comdat,
-align 1, !psr.id !10 | ID: 3 #4:
-    @_ZTVN10__cxxabiv117__class_type_infoE = external global ptr, !psr.id !9 |
-ID: 2 #5:
-    @_ZTV3Bar = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
-x ptr] [ptr null, ptr @_ZTI3Bar, ptr @_ZN3Bar4FuncEv] }, comdat, align 8,
-!psr.id !12 | ID: 5 #6:
-    @_ZTI3Bar = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
-getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
-2), ptr @_ZTS3Bar, ptr @_ZTI3Foo }, comdat, align 8, !psr.id !15 | ID: 8 #7: fun
-@_ZN3Bar4FuncEv #8:
-    @_ZTS3Bar = linkonce_odr dso_local constant [5 x i8] c"3Bar\00", comdat,
-align 1, !psr.id !14 | ID: 7 #9:
-    @_ZTVN10__cxxabiv120__si_class_type_infoE = external global ptr, !psr.id !13
-| ID: 6 #10:
-    @_ZTV3Baz = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
-x ptr] [ptr null, ptr @_ZTI3Baz, ptr @_ZN3Baz4FuncEv] }, comdat, align 8,
-!psr.id !16 | ID: 9 #11:
-    @_ZTI3Baz = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
-getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
-2), ptr @_ZTS3Baz, ptr @_ZTI3Bar }, comdat, align 8, !psr.id !18 | ID: 11 #12:
-    fun @_ZN3Baz4FuncEv
-  #13:
-    @_ZTS3Baz = linkonce_odr dso_local constant [5 x i8] c"3Baz\00", comdat,
-align 1, !psr.id !17 | ID: 10 #14: %retval = alloca i32, align 4, !psr.id !32 |
-ID: 12 #15: %First = alloca %class.Foo, align 8, !psr.id !33 | ID: 13 #16:
-    %Second = alloca %class.Bar, align 8, !psr.id !34 | ID: 14
-  #17:
-    %Third = alloca %class.Baz, align 8, !psr.id !35 | ID: 15
-  #18:
-    %FooRef = alloca ptr, align 8, !psr.id !36 | ID: 16
-  #19:
-    ptr %this | ID: _ZN3FooC2Ev.0
-  #20:
-    ptr %this | ID: _ZN3BarC2Ev.0
-  #21:
-    ptr %this | ID: _ZN3BazC2Ev.0
-  #22:
-    %cond-lvalue = phi ptr [ %Second, %cond.true ], [ %Third, %cond.false ],
-!dbg !80, !psr.id !86 | ID: 33 #23: %1 = load ptr, ptr %FooRef, align 8, !dbg
-!88, !psr.id !89 | ID: 35 #24: %vtable = load ptr, ptr %1, align 8, !dbg !90,
-!psr.id !91 | ID: 36 %vfn = getelementptr inbounds ptr, ptr %vtable, i64 0, !dbg
-!90, !psr.id !92 | ID: 37 #25: %2 = load ptr, ptr %vfn, align 8, !dbg !90,
-!psr.id !93 | ID: 38 #26: ptr %this | ID: _ZN3Bar4FuncEv.0 #27: ptr %this | ID:
-_ZN3Baz4FuncEv.0 #28: ptr %this | ID: _ZN3Foo4FuncEv.0 #29: %this.addr = alloca
-ptr, align 8, !psr.id !101 | ID: 41 #30: %this1 = load ptr, ptr %this.addr,
-align 8, !psr.id !107 | ID: 44 #31: %this.addr = alloca ptr, align 8, !psr.id
-!115 | ID: 47 #32: %this1 = load ptr, ptr %this.addr, align 8, !psr.id !121 |
-ID: 50 #33: %this.addr = alloca ptr, align 8, !psr.id !130 | ID: 54 #34: %this1
-= load ptr, ptr %this.addr, align 8, !psr.id !136 | ID: 57 #35: %this.addr =
-alloca ptr, align 8, !psr.id !142 | ID: 61 #36: %this1 = load ptr, ptr
-%this.addr, align 8, !psr.id !147 | ID: 64 #37: %this.addr = alloca ptr, align
-8, !psr.id !151 | ID: 66 #38: %this1 = load ptr, ptr %this.addr, align 8,
-!psr.id !156 | ID: 69 #39: %this.addr = alloca ptr, align 8, !psr.id !160 | ID:
-71 #40: %this1 = load ptr, ptr %this.addr, align 8, !psr.id !165 | ID: 74
-}
-UnionFindAAResult {
-  #0: <0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 16, 17, 19, 20, 21, 22,
-23, 24, 25, 26, 27, 28, 30, 32, 34, 36, 38, 40> #1: <14> #2: <18> #3: <29> #4:
-<29> #5: <31> #6: <31> #7: <33> #8: <35> #9: <37> #10: <39>
-}
-  */
   GTMap GT = {{LineColFunOp{.Line = 19,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 19,
+               {ArgInFun{.Idx = 0, .InFunction = "_ZN3FooC2Ev"},
+                ArgInFun{.Idx = 0, .InFunction = "_ZN3BarC2Ev"},
+                ArgInFun{.Idx = 0, .InFunction = "_ZN3BazC2Ev"},
+                ArgInFun{.Idx = 0, .InFunction = "_ZN3Foo4FuncEv"},
+                ArgInFun{.Idx = 0, .InFunction = "_ZN3Bar4FuncEv"},
+                ArgInFun{.Idx = 0, .InFunction = "_ZN3Baz4FuncEv"},
+                GlobalVar{.Name = "_ZTV3Foo"},
+                GlobalVar{.Name = "_ZTVN10__cxxabiv117__class_type_infoE"},
+                GlobalVar{.Name = "_ZTS3Foo"},
+                GlobalVar{.Name = "_ZTI3Foo"},
+                GlobalVar{.Name = "_ZTV3Bar"},
+                GlobalVar{.Name = "_ZTVN10__cxxabiv120__si_class_type_infoE"},
+                GlobalVar{.Name = "_ZTS3Bar"},
+                GlobalVar{.Name = "_ZTI3Bar"},
+                GlobalVar{.Name = "_ZTV3Baz"},
+                GlobalVar{.Name = "_ZTS3Baz"},
+                GlobalVar{.Name = "_ZTI3Baz"},
+                FuncByName{.NameOfFunction = "_ZN3Foo4FuncEv"},
+                FuncByName{.NameOfFunction = "_ZN3Bar4FuncEv"},
+                FuncByName{.NameOfFunction = "_ZN3Baz4FuncEv"},
+                LineColFunOp{.Line = 19,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
@@ -4157,7 +2962,11 @@ UnionFindAAResult {
                 LineColFunOp{.Line = 21,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 23,
+                             .Col = 17,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::PHI}}},
               {LineColFunOp{.Line = 23,
                             .Col = 0,
                             .InFunction = "main",
@@ -4171,92 +2980,23 @@ UnionFindAAResult {
 }
 
 TEST(CtxSensUnionFindAATest, Indirection10) {
-  /*
-  ValueCompressor: {
-  #0:
-    @_ZTV3Foo = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
-x ptr] [ptr null, ptr @_ZTI3Foo, ptr @_ZN3Foo4FuncEv] }, comdat, align 8,
-!psr.id !0 | ID: 0
-  #1:
-    @_ZTI3Foo = linkonce_odr dso_local constant { ptr, ptr } { ptr getelementptr
-inbounds (ptr, ptr @_ZTVN10__cxxabiv117__class_type_infoE, i64 2), ptr @_ZTS3Foo
-}, comdat, align 8, !psr.id !3 | ID: 3
-  #2: fun @_ZN3Foo4FuncEv
-  #3:
-    @_ZTS3Foo = linkonce_odr dso_local constant [5 x i8] c"3Foo\00", comdat,
-align 1, !psr.id !2 | ID: 2
-  #4:
-    @_ZTVN10__cxxabiv117__class_type_infoE = external global ptr, !psr.id !1 |
-ID: 1
-  #5:
-    @_ZTV3Bar = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
-x ptr] [ptr null, ptr @_ZTI3Bar, ptr @_ZN3Bar4FuncEv] }, comdat, align 8,
-!psr.id !4 | ID: 4
-  #6:
-    @_ZTI3Bar = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
-getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
-2), ptr @_ZTS3Bar, ptr @_ZTI3Foo }, comdat, align 8, !psr.id !7 | ID: 7
-  #7: fun
-@_ZN3Bar4FuncEv
-  #8:
-    @_ZTS3Bar = linkonce_odr dso_local constant [5 x i8] c"3Bar\00", comdat,
-align 1, !psr.id !6 | ID: 6
-  #9:
-    @_ZTVN10__cxxabiv120__si_class_type_infoE = external global ptr, !psr.id !5
-| ID: 5
-  #10: %retval = alloca i32, align 4, !psr.id !24 | ID: 8
-  #11: %First =
-alloca %class.Foo, align 8, !psr.id !25 | ID: 9
-  #12: %Second = alloca
-%class.Bar, align 8, !psr.id !26 | ID: 10
-  #13: %SecondAlias = alloca ptr, align
-8, !psr.id !27 | ID: 11
-  #14: ptr %this | ID: _ZN3FooC2Ev.0
-  #15: ptr %this | ID:
-_ZN3BarC2Ev.0
-  #16: %0 = load ptr, ptr %SecondAlias, align 8, !dbg !62, !psr.id
-!63 | ID: 21
-  #17: %vtable = load ptr, ptr %0, align 8, !dbg !64, !psr.id !65 |
-ID: 22 %vfn = getelementptr inbounds ptr, ptr %vtable, i64 0, !dbg !64, !psr.id
-!66 | ID: 23
-  #18: %1 = load ptr, ptr %vfn, align 8, !dbg !64, !psr.id !67 | ID:
-24
-  #19: ptr %this | ID: _ZN3Foo4FuncEv.0
-  #20: ptr %this | ID: _ZN3Bar4FuncEv.0
-  #21:
-    %this.addr = alloca ptr, align 8, !psr.id !75 | ID: 27
-  #22:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !80 | ID: 30
-  #23:
-    %this.addr = alloca ptr, align 8, !psr.id !88 | ID: 33
-  #24:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !94 | ID: 36
-  #25:
-    %this.addr = alloca ptr, align 8, !psr.id !100 | ID: 40
-  #26:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !105 | ID: 43
-  #27:
-    %this.addr = alloca ptr, align 8, !psr.id !109 | ID: 45
-  #28:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !114 | ID: 48
-}
-UnionFindAAResult {
-  #0: <0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 14, 15, 16, 17, 18, 19, 20, 22, 24,
-26, 28>
-  #1: <10>
-  #2: <13>
-  #3: <21>
-  #4: <21>
-  #5: <23>
-  #6: <25>
-  #7: <27>
-}
-  */
   GTMap GT = {{LineColFunOp{.Line = 20,
                             .Col = 0,
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 20,
+               {ArgInFun{.Idx = 0, .InFunction = "_ZN3FooC2Ev"},
+                ArgInFun{.Idx = 0, .InFunction = "_ZN3BarC2Ev"},
+                ArgInFun{.Idx = 0, .InFunction = "_ZN3Foo4FuncEv"},
+                ArgInFun{.Idx = 0, .InFunction = "_ZN3Bar4FuncEv"},
+                GlobalVar{.Name = "_ZTV3Foo"},
+                GlobalVar{.Name = "_ZTVN10__cxxabiv117__class_type_infoE"},
+                GlobalVar{.Name = "_ZTS3Foo"}, GlobalVar{.Name = "_ZTI3Foo"},
+                GlobalVar{.Name = "_ZTV3Bar"},
+                GlobalVar{.Name = "_ZTVN10__cxxabiv120__si_class_type_infoE"},
+                GlobalVar{.Name = "_ZTS3Bar"}, GlobalVar{.Name = "_ZTI3Bar"},
+                FuncByName{.NameOfFunction = "_ZN3Foo4FuncEv"},
+                FuncByName{.NameOfFunction = "_ZN3Bar4FuncEv"},
+                LineColFunOp{.Line = 20,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
@@ -4277,20 +3017,6 @@ UnionFindAAResult {
 }
 
 TEST(BotUnionFindAATest, Basic01) {
-  /*
-ValueCompressor: {
-  #0:
-    %i = alloca i32, align 4, !psr.id !16 | ID: 0
-  #1:
-    %p = alloca ptr, align 8, !psr.id !17 | ID: 1
-  #2:
-    %0 = load ptr, ptr %p, align 8, !dbg !26, !psr.id !27 | ID: 5
-}
-UnionFindAAResult {
-  #0: <0, 2>
-  #1: <1>
-}
-  */
   GTMap GT = {{LineColFunOp{.Line = 3,
                             .Col = 0,
                             .InFunction = "main",
@@ -4316,24 +3042,6 @@ UnionFindAAResult {
 }
 
 TEST(BotUnionFindAATest, Basic02) {
-  /*
-ValueCompressor: {
-  #0:
-    %i = alloca i32, align 4, !psr.id !16 | ID: 0
-  #1:
-    %p = alloca ptr, align 8, !psr.id !17 | ID: 1
-  #2:
-    %q = alloca ptr, align 8, !psr.id !18 | ID: 2
-  #3:
-    %0 = load ptr, ptr %q, align 8, !dbg !32, !psr.id !33 | ID: 8
-  #4:
-    %1 = load ptr, ptr %0, align 8, !dbg !34, !psr.id !35 | ID: 9
-}
-UnionFindAAResult {
-  #0: <0, 1, 3, 4>
-  #1: <2>
-}
-  */
   GTMap GT = {{LineColFunOp{.Line = 3,
                             .Col = 0,
                             .InFunction = "main",
@@ -4367,9 +3075,6 @@ UnionFindAAResult {
 }
 
 TEST(BotUnionFindAATest, Basic03) {
-  /*
-
-  */
   GTMap GT = {{LineColFunOp{.Line = 5,
                             .Col = 0,
                             .InFunction = "main",
@@ -4383,28 +3088,6 @@ TEST(BotUnionFindAATest, Basic03) {
 }
 
 TEST(BotUnionFindAATest, Basic04) {
-  /*
-
-ValueCompressor: {
-  #0:
-    %retval = alloca i32, align 4, !psr.id !19 | ID: 1
-  #1:
-    %FuncPtr = alloca ptr, align 8, !psr.id !20 | ID: 2
-  #2:
-    %FuncPtr2 = alloca ptr, align 8, !psr.id !21 | ID: 3
-  #3:
-    fun @Func
-  #4:
-    %0 = load ptr, ptr %FuncPtr2, align 8, !dbg !37, !psr.id !38 | ID: 9
-  #5:
-    %1 = load ptr, ptr %0, align 8, !dbg !39, !psr.id !40 | ID: 10
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <1, 3, 4, 5>
-  #2: <2>
-}
-   */
   GTMap GT = {{LineColFunOp{.Line = 5,
                             .Col = 0,
                             .InFunction = "main",
@@ -5520,63 +4203,83 @@ TEST(BotUnionFindAATest, Indirection05) {
                {LineColFunOp{.Line = 23,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 25,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 25,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 24,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 27,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 27,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 25,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 29,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 29,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 26,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 32,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 32,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 27,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 33,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 33,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 28,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 34,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 34,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 29,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 35,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 35,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 30,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 32,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 33,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 34,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 35,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 37,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 38,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 40,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 41,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 42,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 43,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 44,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
               {LineColFunOp{.Line = 37,
                             .Col = 0,
                             .InFunction = "main",
@@ -5652,79 +4355,103 @@ TEST(BotUnionFindAATest, Indirection06) {
                {LineColFunOp{.Line = 28,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 30,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 30,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 29,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 32,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 32,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 30,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 34,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 34,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 31,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 36,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 36,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 32,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 39,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 39,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 33,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 40,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 40,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 34,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 41,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 41,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 35,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 42,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 42,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 36,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 43,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 43,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 37,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 39,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 40,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 41,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 42,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 43,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 45,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 46,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 47,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 48,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 49,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 50,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 51,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 52,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 53,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 54,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
               {LineColFunOp{.Line = 45,
                             .Col = 0,
                             .InFunction = "main",
@@ -5816,95 +4543,123 @@ TEST(BotUnionFindAATest, Indirection07) {
                {LineColFunOp{.Line = 33,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 35,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 35,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 34,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 37,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 37,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 35,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 39,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 39,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 36,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 41,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 41,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 37,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 43,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 43,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 38,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 46,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 46,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 39,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 47,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 47,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 40,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 48,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 48,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 41,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 49,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 49,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 42,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 50,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 50,
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 43,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
-              {LineColFunOp{.Line = 51,
-                            .Col = 0,
-                            .InFunction = "main",
-                            .OpCode = llvm::Instruction::Alloca},
-               {LineColFunOp{.Line = 51,
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 44,
                              .Col = 0,
                              .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca}}},
+                             .OpCode = llvm::Instruction::GetElementPtr},
+                LineColFunOp{.Line = 46,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 47,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 48,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 49,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 50,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 51,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Alloca},
+                LineColFunOp{.Line = 53,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 54,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 55,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 56,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 57,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 58,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 59,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 60,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 61,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 62,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 63,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load},
+                LineColFunOp{.Line = 64,
+                             .Col = 0,
+                             .InFunction = "main",
+                             .OpCode = llvm::Instruction::Load}}},
               {LineColFunOp{.Line = 53,
                             .Col = 0,
                             .InFunction = "main",
@@ -6010,10 +4765,6 @@ TEST(BotUnionFindAATest, Indirection08) {
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
                {LineColFunOp{.Line = 13,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 14,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca}}},
@@ -6034,14 +4785,6 @@ TEST(BotUnionFindAATest, Indirection09) {
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
                {LineColFunOp{.Line = 19,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 20,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 21,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca}}},
@@ -6062,14 +4805,6 @@ TEST(BotUnionFindAATest, Indirection10) {
                             .InFunction = "main",
                             .OpCode = llvm::Instruction::Alloca},
                {LineColFunOp{.Line = 19,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 20,
-                             .Col = 0,
-                             .InFunction = "main",
-                             .OpCode = llvm::Instruction::Alloca},
-                LineColFunOp{.Line = 21,
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca}}},
@@ -6181,62 +4916,6 @@ TEST(IndirectionSensUnionFindAATest, Basic04) {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context01) {
-  /*
-  ValueCompressor: {
-    #0:
-      %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
-    #1:
-      ptr %p | ID: id.0
-    #2:
-      %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
-    #3:
-      fun @id.<ret>
-    #4:
-      %retval = alloca i32, align 4, !psr.id !29 | ID: 5
-    #5:
-      %x = alloca i32, align 4, !psr.id !30 | ID: 6
-    #6:
-      %y = alloca i32, align 4, !psr.id !31 | ID: 7
-    #7:
-      %xx = alloca ptr, align 8, !psr.id !32 | ID: 8
-    #8:
-      %yy = alloca ptr, align 8, !psr.id !33 | ID: 9
-    #9:
-      %call = call ptr @id(ptr noundef %x), !dbg !46, !psr.id !47 | ID: 16
-    #10:
-      %call1 = call ptr @id(ptr noundef %y), !dbg !52, !psr.id !53 | ID: 19
-    #11:
-      %0 = load ptr, ptr %xx, align 8, !dbg !55, !psr.id !56 | ID: 21
-  }
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1, 2, 3, 5, 6, 9, 10, 11>
-  #6: <>
-  #7: <>
-  #8: <>
-  #9: <>
-  #10: <4>
-  #11: <>
-  #12: <>
-  #13: <>
-  #14: <>
-  #15: <7>
-  #16: <>
-  #17: <>
-  #18: <>
-  #19: <>
-  #20: <8>
-  #21: <>
-  #22: <>
-  #23: <>
-  #24: <>
-}
-  */
-
   GTMap GT = {{LineColFunOp{.Line = 5,
                             .Col = 0,
                             .InFunction = "main",
@@ -6287,97 +4966,6 @@ UnionFindAAResult {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context02) {
-  /*
-  ValueCompressor: {
-  #0:
-    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    ptr %p | ID: id1.0
-  #2:
-    %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
-  #3:
-    fun @id1.<ret>
-  #4:
-    %q.addr = alloca ptr, align 8, !psr.id !27 | ID: 5
-  #5:
-    ptr %q | ID: id2.0
-  #6:
-    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 8
-  #7:
-    fun @id2.<ret>
-  #8:
-    %retval = alloca i32, align 4, !psr.id !39 | ID: 10
-  #9:
-    %x = alloca i32, align 4, !psr.id !40 | ID: 11
-  #10:
-    %y = alloca i32, align 4, !psr.id !41 | ID: 12
-  #11:
-    %xx1 = alloca ptr, align 8, !psr.id !42 | ID: 13
-  #12:
-    %xx2 = alloca ptr, align 8, !psr.id !43 | ID: 14
-  #13:
-    %yy1 = alloca ptr, align 8, !psr.id !44 | ID: 15
-  #14:
-    %yy2 = alloca ptr, align 8, !psr.id !45 | ID: 16
-  #15:
-    %call = call ptr @id1(ptr noundef %x), !dbg !58, !psr.id !59 | ID: 23
-  #16:
-    %call1 = call ptr @id1(ptr noundef %x), !dbg !64, !psr.id !65 | ID: 26
-  #17:
-    %call2 = call ptr @id2(ptr noundef %y), !dbg !70, !psr.id !71 | ID: 29
-  #18:
-    %call3 = call ptr @id2(ptr noundef %y), !dbg !76, !psr.id !77 | ID: 32
-  #19:
-    %0 = load ptr, ptr %xx1, align 8, !dbg !79, !psr.id !80 | ID: 34
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1, 2, 3, 9, 15, 16, 19>
-  #6: <>
-  #7: <>
-  #8: <>
-  #9: <>
-  #10: <4>
-  #11: <>
-  #12: <>
-  #13: <>
-  #14: <>
-  #15: <5, 6, 7, 10, 17, 18>
-  #16: <>
-  #17: <>
-  #18: <>
-  #19: <>
-  #20: <8>
-  #21: <>
-  #22: <>
-  #23: <>
-  #24: <>
-  #25: <11>
-  #26: <>
-  #27: <>
-  #28: <>
-  #29: <>
-  #30: <12>
-  #31: <>
-  #32: <>
-  #33: <>
-  #34: <>
-  #35: <13>
-  #36: <>
-  #37: <>
-  #38: <>
-  #39: <>
-  #40: <14>
-  #41: <>
-  #42: <>
-  #43: <>
-  #44: <>
-}
-  */
   GTMap GT = {{LineColFunOp{.Line = 6,
                             .Col = 0,
                             .InFunction = "main",
@@ -6467,75 +5055,6 @@ UnionFindAAResult {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context03) {
-  /*
-  ValueCompressor: {
-  #0:
-    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    ptr %p | ID: id1.0
-  #2:
-    %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
-  #3:
-    fun @id1.<ret>
-  #4:
-    %q.addr = alloca ptr, align 8, !psr.id !27 | ID: 5
-  #5:
-    ptr %q | ID: id2.0
-  #6:
-    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 8
-  #7:
-    %call = call ptr @id1(ptr noundef %0), !dbg !34, !psr.id !35 | ID: 9
-  #8:
-    fun @id2.<ret>
-  #9:
-    %retval = alloca i32, align 4, !psr.id !41 | ID: 11
-  #10:
-    %x = alloca i32, align 4, !psr.id !42 | ID: 12
-  #11:
-    %xx1 = alloca ptr, align 8, !psr.id !43 | ID: 13
-  #12:
-    %xx2 = alloca ptr, align 8, !psr.id !44 | ID: 14
-  #13:
-    %call = call ptr @id2(ptr noundef %x), !dbg !53, !psr.id !54 | ID: 19
-  #14:
-    %call1 = call ptr @id2(ptr noundef %x), !dbg !59, !psr.id !60 | ID: 22
-  #15:
-    %0 = load ptr, ptr %xx1, align 8, !dbg !62, !psr.id !63 | ID: 24
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1, 2, 3, 5, 6, 7, 8, 10, 13, 14, 15>
-  #6: <>
-  #7: <>
-  #8: <>
-  #9: <>
-  #10: <4>
-  #11: <>
-  #12: <>
-  #13: <>
-  #14: <>
-  #15: <9>
-  #16: <>
-  #17: <>
-  #18: <>
-  #19: <>
-  #20: <11>
-  #21: <>
-  #22: <>
-  #23: <>
-  #24: <>
-  #25: <12>
-  #26: <>
-  #27: <>
-  #28: <>
-  #29: <>
-}
-  */
-
   GTMap GT = {{LineColFunOp{.Line = 6,
                             .Col = 0,
                             .InFunction = "main",
@@ -6591,90 +5110,6 @@ UnionFindAAResult {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context04_0) {
-  /*
-  ValueCompressor: {
-  #0:
-    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    ptr %p | ID: id1.0
-  #2:
-    %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
-  #3:
-    fun @id1.<ret>
-  #4:
-    %q.addr = alloca ptr, align 8, !psr.id !27 | ID: 5
-  #5:
-    ptr %q | ID: id2.0
-  #6:
-    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 8
-  #7:
-    %call = call ptr @id1(ptr noundef %0), !dbg !34, !psr.id !35 | ID: 9
-  #8:
-    fun @id2.<ret>
-  #9:
-    %r.addr = alloca ptr, align 8, !psr.id !39 | ID: 11
-  #10:
-    ptr %r | ID: id3.0
-  #11:
-    %0 = load ptr, ptr %r.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
-  #12:
-    %call = call ptr @id2(ptr noundef %0), !dbg !46, !psr.id !47 | ID: 15
-  #13:
-    fun @id3.<ret>
-  #14:
-    %retval = alloca i32, align 4, !psr.id !53 | ID: 17
-  #15:
-    %x = alloca i32, align 4, !psr.id !54 | ID: 18
-  #16:
-    %xx1 = alloca ptr, align 8, !psr.id !55 | ID: 19
-  #17:
-    %xx2 = alloca ptr, align 8, !psr.id !56 | ID: 20
-  #18:
-    %call = call ptr @id3(ptr noundef %x), !dbg !65, !psr.id !66 | ID: 25
-  #19:
-    %call1 = call ptr @id3(ptr noundef %x), !dbg !71, !psr.id !72 | ID: 28
-  #20:
-    %0 = load ptr, ptr %xx1, align 8, !dbg !74, !psr.id !75 | ID: 30
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 18, 19, 20>
-  #6: <>
-  #7: <>
-  #8: <>
-  #9: <>
-  #10: <4>
-  #11: <>
-  #12: <>
-  #13: <>
-  #14: <>
-  #15: <9>
-  #16: <>
-  #17: <>
-  #18: <>
-  #19: <>
-  #20: <14>
-  #21: <>
-  #22: <>
-  #23: <>
-  #24: <>
-  #25: <16>
-  #26: <>
-  #27: <>
-  #28: <>
-  #29: <>
-  #30: <17>
-  #31: <>
-  #32: <>
-  #33: <>
-  #34: <>
-}
-
-  */
   GTMap GT = {{LineColFunOp{.Line = 7,
                             .Col = 0,
                             .InFunction = "main",
@@ -6736,110 +5171,6 @@ UnionFindAAResult {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context04_1) {
-  /*
-  ValueCompressor: {
-  #0:
-    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    ptr %p | ID: id1.0
-  #2:
-    %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
-  #3:
-    fun @id1.<ret>
-  #4:
-    %q.addr = alloca ptr, align 8, !psr.id !27 | ID: 5
-  #5:
-    ptr %q | ID: id2.0
-  #6:
-    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 8
-  #7:
-    %call = call ptr @id1(ptr noundef %0), !dbg !34, !psr.id !35 | ID: 9
-  #8:
-    fun @id2.<ret>
-  #9:
-    %r.addr = alloca ptr, align 8, !psr.id !39 | ID: 11
-  #10:
-    ptr %r | ID: id3.0
-  #11:
-    %0 = load ptr, ptr %r.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
-  #12:
-    %call = call ptr @id2(ptr noundef %0), !dbg !46, !psr.id !47 | ID: 15
-  #13:
-    fun @id3.<ret>
-  #14:
-    %retval = alloca i32, align 4, !psr.id !53 | ID: 17
-  #15:
-    %x = alloca i32, align 4, !psr.id !54 | ID: 18
-  #16:
-    %y = alloca i32, align 4, !psr.id !55 | ID: 19
-  #17:
-    %xx1 = alloca ptr, align 8, !psr.id !56 | ID: 20
-  #18:
-    %xx2 = alloca ptr, align 8, !psr.id !57 | ID: 21
-  #19:
-    %yy1 = alloca ptr, align 8, !psr.id !58 | ID: 22
-  #20:
-    %yy2 = alloca ptr, align 8, !psr.id !59 | ID: 23
-  #21:
-    %call = call ptr @id3(ptr noundef %x), !dbg !72, !psr.id !73 | ID: 30
-  #22:
-    %call1 = call ptr @id3(ptr noundef %x), !dbg !78, !psr.id !79 | ID: 33
-  #23:
-    %call2 = call ptr @id3(ptr noundef %y), !dbg !84, !psr.id !85 | ID: 36
-  #24:
-    %call3 = call ptr @id3(ptr noundef %y), !dbg !90, !psr.id !91 | ID: 39
-  #25:
-    %0 = load ptr, ptr %xx1, align 8, !dbg !93, !psr.id !94 | ID: 41
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25>
-  #6: <>
-  #7: <>
-  #8: <>
-  #9: <>
-  #10: <4>
-  #11: <>
-  #12: <>
-  #13: <>
-  #14: <>
-  #15: <9>
-  #16: <>
-  #17: <>
-  #18: <>
-  #19: <>
-  #20: <14>
-  #21: <>
-  #22: <>
-  #23: <>
-  #24: <>
-  #25: <17>
-  #26: <>
-  #27: <>
-  #28: <>
-  #29: <>
-  #30: <18>
-  #31: <>
-  #32: <>
-  #33: <>
-  #34: <>
-  #35: <19>
-  #36: <>
-  #37: <>
-  #38: <>
-  #39: <>
-  #40: <20>
-  #41: <>
-  #42: <>
-  #43: <>
-  #44: <>
-}
-
-  */
   GTMap GT = {{LineColFunOp{.Line = 7,
                             .Col = 0,
                             .InFunction = "main",
@@ -6929,105 +5260,6 @@ UnionFindAAResult {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context05_0) {
-  /*
-  ValueCompressor: {
-  #0:
-    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    ptr %p | ID: id1.0
-  #2:
-    %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
-  #3:
-    fun @id1.<ret>
-  #4:
-    %q.addr = alloca ptr, align 8, !psr.id !27 | ID: 5
-  #5:
-    ptr %q | ID: id2.0
-  #6:
-    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 8
-  #7:
-    %call = call ptr @id1(ptr noundef %0), !dbg !34, !psr.id !35 | ID: 9
-  #8:
-    fun @id2.<ret>
-  #9:
-    %r.addr = alloca ptr, align 8, !psr.id !39 | ID: 11
-  #10:
-    ptr %r | ID: id3.0
-  #11:
-    %0 = load ptr, ptr %r.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
-  #12:
-    %call = call ptr @id2(ptr noundef %0), !dbg !46, !psr.id !47 | ID: 15
-  #13:
-    fun @id3.<ret>
-  #14:
-    %s.addr = alloca ptr, align 8, !psr.id !51 | ID: 17
-  #15:
-    ptr %s | ID: id4.0
-  #16:
-    %0 = load ptr, ptr %s.addr, align 8, !dbg !56, !psr.id !57 | ID: 20
-  #17:
-    %call = call ptr @id3(ptr noundef %0), !dbg !58, !psr.id !59 | ID: 21
-  #18:
-    fun @id4.<ret>
-  #19:
-    %retval = alloca i32, align 4, !psr.id !65 | ID: 23
-  #20:
-    %x = alloca i32, align 4, !psr.id !66 | ID: 24
-  #21:
-    %xx = alloca ptr, align 8, !psr.id !67 | ID: 25
-  #22:
-    %yy = alloca ptr, align 8, !psr.id !68 | ID: 26
-  #23:
-    %call = call ptr @id4(ptr noundef %x), !dbg !77, !psr.id !78 | ID: 31
-  #24:
-    %call1 = call ptr @id4(ptr noundef %x), !dbg !83, !psr.id !84 | ID: 34
-  #25:
-    %0 = load ptr, ptr %xx, align 8, !dbg !86, !psr.id !87 | ID: 36
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 17, 18, 20, 23, 24, 25>
-  #6: <>
-  #7: <>
-  #8: <>
-  #9: <>
-  #10: <4>
-  #11: <>
-  #12: <>
-  #13: <>
-  #14: <>
-  #15: <9>
-  #16: <>
-  #17: <>
-  #18: <>
-  #19: <>
-  #20: <14>
-  #21: <>
-  #22: <>
-  #23: <>
-  #24: <>
-  #25: <19>
-  #26: <>
-  #27: <>
-  #28: <>
-  #29: <>
-  #30: <21>
-  #31: <>
-  #32: <>
-  #33: <>
-  #34: <>
-  #35: <22>
-  #36: <>
-  #37: <>
-  #38: <>
-  #39: <>
-}
-
-  */
   GTMap GT = {{LineColFunOp{.Line = 8,
                             .Col = 0,
                             .InFunction = "main",
@@ -7095,117 +5327,6 @@ UnionFindAAResult {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context05_1) {
-  /*
-  ValueCompressor: {
-  #0:
-    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    ptr %p | ID: id1.0
-  #2:
-    %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
-  #3:
-    fun @id1.<ret>
-  #4:
-    %q.addr = alloca ptr, align 8, !psr.id !27 | ID: 5
-  #5:
-    ptr %q | ID: id2.0
-  #6:
-    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 8
-  #7:
-    %call = call ptr @id1(ptr noundef %0), !dbg !34, !psr.id !35 | ID: 9
-  #8:
-    fun @id2.<ret>
-  #9:
-    %r.addr = alloca ptr, align 8, !psr.id !39 | ID: 11
-  #10:
-    ptr %r | ID: id3.0
-  #11:
-    %0 = load ptr, ptr %r.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
-  #12:
-    %call = call ptr @id2(ptr noundef %0), !dbg !46, !psr.id !47 | ID: 15
-  #13:
-    fun @id3.<ret>
-  #14:
-    %s.addr = alloca ptr, align 8, !psr.id !51 | ID: 17
-  #15:
-    ptr %s | ID: id4.0
-  #16:
-    %0 = load ptr, ptr %s.addr, align 8, !dbg !56, !psr.id !57 | ID: 20
-  #17:
-    %call = call ptr @id3(ptr noundef %0), !dbg !58, !psr.id !59 | ID: 21
-  #18:
-    fun @id4.<ret>
-  #19:
-    %retval = alloca i32, align 4, !psr.id !65 | ID: 23
-  #20:
-    %x = alloca i32, align 4, !psr.id !66 | ID: 24
-  #21:
-    %y = alloca i32, align 4, !psr.id !67 | ID: 25
-  #22:
-    %xx1 = alloca ptr, align 8, !psr.id !68 | ID: 26
-  #23:
-    %xx2 = alloca ptr, align 8, !psr.id !69 | ID: 27
-  #24:
-    %yy1 = alloca ptr, align 8, !psr.id !70 | ID: 28
-  #25:
-    %yy2 = alloca ptr, align 8, !psr.id !71 | ID: 29
-  #26:
-    %call = call ptr @id4(ptr noundef %x), !dbg !84, !psr.id !85 | ID: 36
-  #27:
-    %call1 = call ptr @id4(ptr noundef %x), !dbg !90, !psr.id !91 | ID: 39
-  #28:
-    %call2 = call ptr @id4(ptr noundef %y), !dbg !96, !psr.id !97 | ID: 42
-  #29:
-    %call3 = call ptr @id4(ptr noundef %y), !dbg !102, !psr.id !103 | ID: 45
-  #30:
-    %0 = load ptr, ptr %xx2, align 8, !dbg !105, !psr.id !106 | ID: 47
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 17, 18, 20, 21, 26, 27, 28,
-29, 30> #6: <> #7: <> #8: <> #9: <> #10: <4> #11: <> #12: <> #13: <> #14: <>
-  #15: <9>
-  #16: <>
-  #17: <>
-  #18: <>
-  #19: <>
-  #20: <14>
-  #21: <>
-  #22: <>
-  #23: <>
-  #24: <>
-  #25: <19>
-  #26: <>
-  #27: <>
-  #28: <>
-  #29: <>
-  #30: <22>
-  #31: <>
-  #32: <>
-  #33: <>
-  #34: <>
-  #35: <23>
-  #36: <>
-  #37: <>
-  #38: <>
-  #39: <>
-  #40: <24>
-  #41: <>
-  #42: <>
-  #43: <>
-  #44: <>
-  #45: <25>
-  #46: <>
-  #47: <>
-  #48: <>
-  #49: <>
-}
-
-  */
   GTMap GT = {{LineColFunOp{.Line = 8,
                             .Col = 0,
                             .InFunction = "main",
@@ -7301,111 +5422,6 @@ UnionFindAAResult {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context06_0) {
-  /*
-  ValueCompressor: {
-  #0:
-    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    ptr %p | ID: id1.0
-  #2:
-    %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
-  #3:
-    fun @id1.<ret>
-  #4:
-    %q.addr = alloca ptr, align 8, !psr.id !27 | ID: 5
-  #5:
-    ptr %q | ID: id2.0
-  #6:
-    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 8
-  #7:
-    %call = call ptr @id1(ptr noundef %0), !dbg !34, !psr.id !35 | ID: 9
-  #8:
-    fun @id2.<ret>
-  #9:
-    %r.addr = alloca ptr, align 8, !psr.id !39 | ID: 11
-  #10:
-    ptr %r | ID: id3.0
-  #11:
-    %0 = load ptr, ptr %r.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
-  #12:
-    %call = call ptr @id2(ptr noundef %0), !dbg !46, !psr.id !47 | ID: 15
-  #13:
-    fun @id3.<ret>
-  #14:
-    %s.addr = alloca ptr, align 8, !psr.id !51 | ID: 17
-  #15:
-    ptr %s | ID: id4.0
-  #16:
-    %0 = load ptr, ptr %s.addr, align 8, !dbg !56, !psr.id !57 | ID: 20
-  #17:
-    %call = call ptr @id3(ptr noundef %0), !dbg !58, !psr.id !59 | ID: 21
-  #18:
-    fun @id4.<ret>
-  #19:
-    %t.addr = alloca ptr, align 8, !psr.id !63 | ID: 23
-  #20:
-    ptr %t | ID: id5.0
-  #21:
-    %0 = load ptr, ptr %t.addr, align 8, !dbg !68, !psr.id !69 | ID: 26
-  #22:
-    %call = call ptr @id4(ptr noundef %0), !dbg !70, !psr.id !71 | ID: 27
-  #23:
-    fun @id5.<ret>
-  #24:
-    %retval = alloca i32, align 4, !psr.id !77 | ID: 29
-  #25:
-    %x = alloca i32, align 4, !psr.id !78 | ID: 30
-  #26:
-    %xx = alloca ptr, align 8, !psr.id !79 | ID: 31
-  #27:
-    %yy = alloca ptr, align 8, !psr.id !80 | ID: 32
-  #28:
-    %call = call ptr @id5(ptr noundef %x), !dbg !89, !psr.id !90 | ID: 37
-  #29:
-    %call1 = call ptr @id5(ptr noundef %x), !dbg !95, !psr.id !96 | ID: 40
-  #30:
-    %0 = load ptr, ptr %xx, align 8, !dbg !98, !psr.id !99 | ID: 42
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 17, 18, 20, 21, 22, 23, 25,
-28, 29, 30> #6: <> #7: <> #8: <> #9: <> #10: <4> #11: <> #12: <> #13: <> #14: <>
-  #15: <9>
-  #16: <>
-  #17: <>
-  #18: <>
-  #19: <>
-  #20: <14>
-  #21: <>
-  #22: <>
-  #23: <>
-  #24: <>
-  #25: <19>
-  #26: <>
-  #27: <>
-  #28: <>
-  #29: <>
-  #30: <24>
-  #31: <>
-  #32: <>
-  #33: <>
-  #34: <>
-  #35: <26>
-  #36: <>
-  #37: <>
-  #38: <>
-  #39: <>
-  #40: <27>
-  #41: <>
-  #42: <>
-  #43: <>
-  #44: <>
-}
-  */
   GTMap GT = {{LineColFunOp{.Line = 9,
                             .Col = 0,
                             .InFunction = "main",
@@ -7479,134 +5495,6 @@ UnionFindAAResult {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context06_1) {
-  /*
-  ValueCompressor: {
-  #0:
-    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    ptr %p | ID: id1.0
-  #2:
-    %0 = load ptr, ptr %p.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
-  #3:
-    fun @id1.<ret>
-  #4:
-    %q.addr = alloca ptr, align 8, !psr.id !27 | ID: 5
-  #5:
-    ptr %q | ID: id2.0
-  #6:
-    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 8
-  #7:
-    %call = call ptr @id1(ptr noundef %0), !dbg !34, !psr.id !35 | ID: 9
-  #8:
-    fun @id2.<ret>
-  #9:
-    %r.addr = alloca ptr, align 8, !psr.id !39 | ID: 11
-  #10:
-    ptr %r | ID: id3.0
-  #11:
-    %0 = load ptr, ptr %r.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
-  #12:
-    %call = call ptr @id2(ptr noundef %0), !dbg !46, !psr.id !47 | ID: 15
-  #13:
-    fun @id3.<ret>
-  #14:
-    %s.addr = alloca ptr, align 8, !psr.id !51 | ID: 17
-  #15:
-    ptr %s | ID: id4.0
-  #16:
-    %0 = load ptr, ptr %s.addr, align 8, !dbg !56, !psr.id !57 | ID: 20
-  #17:
-    %call = call ptr @id3(ptr noundef %0), !dbg !58, !psr.id !59 | ID: 21
-  #18:
-    fun @id4.<ret>
-  #19:
-    %t.addr = alloca ptr, align 8, !psr.id !63 | ID: 23
-  #20:
-    ptr %t | ID: id5.0
-  #21:
-    %0 = load ptr, ptr %t.addr, align 8, !dbg !68, !psr.id !69 | ID: 26
-  #22:
-    %call = call ptr @id4(ptr noundef %0), !dbg !70, !psr.id !71 | ID: 27
-  #23:
-    fun @id5.<ret>
-  #24:
-    %retval = alloca i32, align 4, !psr.id !77 | ID: 29
-  #25:
-    %x = alloca i32, align 4, !psr.id !78 | ID: 30
-  #26:
-    %y = alloca i32, align 4, !psr.id !79 | ID: 31
-  #27:
-    %xx1 = alloca ptr, align 8, !psr.id !80 | ID: 32
-  #28:
-    %xx2 = alloca ptr, align 8, !psr.id !81 | ID: 33
-  #29:
-    %yy1 = alloca ptr, align 8, !psr.id !82 | ID: 34
-  #30:
-    %yy2 = alloca ptr, align 8, !psr.id !83 | ID: 35
-  #31:
-    %call = call ptr @id5(ptr noundef %x), !dbg !96, !psr.id !97 | ID: 42
-  #32:
-    %call1 = call ptr @id5(ptr noundef %x), !dbg !102, !psr.id !103 | ID: 45
-  #33:
-    %call2 = call ptr @id5(ptr noundef %y), !dbg !108, !psr.id !109 | ID: 48
-  #34:
-    %call3 = call ptr @id5(ptr noundef %y), !dbg !114, !psr.id !115 | ID: 51
-  #35:
-    %0 = load ptr, ptr %yy1, align 8, !dbg !117, !psr.id !118 | ID: 53
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 17, 18, 20, 21, 22, 23, 25,
-26, 31, 32, 33, 34, 35> #6: <> #7: <> #8: <> #9: <> #10: <4> #11: <> #12: <>
-  #13: <>
-  #14: <>
-  #15: <9>
-  #16: <>
-  #17: <>
-  #18: <>
-  #19: <>
-  #20: <14>
-  #21: <>
-  #22: <>
-  #23: <>
-  #24: <>
-  #25: <19>
-  #26: <>
-  #27: <>
-  #28: <>
-  #29: <>
-  #30: <24>
-  #31: <>
-  #32: <>
-  #33: <>
-  #34: <>
-  #35: <27>
-  #36: <>
-  #37: <>
-  #38: <>
-  #39: <>
-  #40: <28>
-  #41: <>
-  #42: <>
-  #43: <>
-  #44: <>
-  #45: <29>
-  #46: <>
-  #47: <>
-  #48: <>
-  #49: <>
-  #50: <30>
-  #51: <>
-  #52: <>
-  #53: <>
-  #54: <>
-}
-
-  */
   GTMap GT = {{LineColFunOp{.Line = 9,
                             .Col = 0,
                             .InFunction = "main",
@@ -7706,107 +5594,6 @@ UnionFindAAResult {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context07) {
-  /*
-  ValueCompressor: {
-  #0:
-    %s.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    ptr %s | ID: buzz.0
-  #2:
-    %0 = load ptr, ptr %s.addr, align 8, !dbg !22, !psr.id !23 | ID: 3
-  #3:
-    fun @buzz.<ret>
-  #4:
-    %r.addr = alloca ptr, align 8, !psr.id !27 | ID: 5
-  #5:
-    ptr %r | ID: baz.0
-  #6:
-    %0 = load ptr, ptr %r.addr, align 8, !dbg !32, !psr.id !33 | ID: 8
-  #7:
-    %call = call ptr @buzz(ptr noundef %0), !dbg !34, !psr.id !35 | ID: 9
-  #8:
-    fun @baz.<ret>
-  #9:
-    %q.addr = alloca ptr, align 8, !psr.id !39 | ID: 11
-  #10:
-    ptr %q | ID: bar.0
-  #11:
-    %0 = load ptr, ptr %q.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
-  #12:
-    %call = call ptr @baz(ptr noundef %0), !dbg !46, !psr.id !47 | ID: 15
-  #13:
-    fun @bar.<ret>
-  #14:
-    %p.addr = alloca ptr, align 8, !psr.id !51 | ID: 17
-  #15:
-    ptr %p | ID: foo.0
-  #16:
-    %0 = load ptr, ptr %p.addr, align 8, !dbg !56, !psr.id !57 | ID: 20
-  #17:
-    %call = call ptr @bar(ptr noundef %0), !dbg !58, !psr.id !59 | ID: 21
-  #18:
-    fun @foo.<ret>
-  #19:
-    %retval = alloca i32, align 4, !psr.id !65 | ID: 23
-  #20:
-    %x = alloca i32, align 4, !psr.id !66 | ID: 24
-  #21:
-    %y = alloca i32, align 4, !psr.id !67 | ID: 25
-  #22:
-    %xx = alloca ptr, align 8, !psr.id !68 | ID: 26
-  #23:
-    %yy = alloca ptr, align 8, !psr.id !69 | ID: 27
-  #24:
-    %call = call ptr @foo(ptr noundef %x), !dbg !82, !psr.id !83 | ID: 34
-  #25:
-    %call1 = call ptr @foo(ptr noundef %y), !dbg !88, !psr.id !89 | ID: 37
-  #26:
-    %0 = load ptr, ptr %xx, align 8, !dbg !91, !psr.id !92 | ID: 39
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1, 2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 17, 18, 20, 21, 24, 25, 26>
-  #6: <>
-  #7: <>
-  #8: <>
-  #9: <>
-  #10: <4>
-  #11: <>
-  #12: <>
-  #13: <>
-  #14: <>
-  #15: <9>
-  #16: <>
-  #17: <>
-  #18: <>
-  #19: <>
-  #20: <14>
-  #21: <>
-  #22: <>
-  #23: <>
-  #24: <>
-  #25: <19>
-  #26: <>
-  #27: <>
-  #28: <>
-  #29: <>
-  #30: <22>
-  #31: <>
-  #32: <>
-  #33: <>
-  #34: <>
-  #35: <23>
-  #36: <>
-  #37: <>
-  #38: <>
-  #39: <>
-}
-
-  */
   GTMap GT = {
       {LineColFunOp{.Line = 8,
                     .Col = 0,
@@ -7880,74 +5667,6 @@ UnionFindAAResult {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context08) {
-  /*
-  ValueCompressor: {
-  #0:
-    %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
-  #2:
-    ptr %Ptr | ID: selfRecursion.0
-  #3:
-    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
-    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
-    %3 = load ptr, ptr %Ptr.addr, align 8, !dbg !38, !psr.id !39 | ID: 11
-    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
-    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !48, !psr.id !49 | ID: 16
-  #4:
-    %call = call ptr @selfRecursion(ptr noundef %6), !dbg !50, !psr.id !51 | ID:
-17 #5: fun @selfRecursion.<ret> #6: %7 = load ptr, ptr %retval, align 8, !dbg
-!55, !psr.id !56 | ID: 20 #7: %retval = alloca i32, align 4, !psr.id !61 | ID:
-22 #8: %k = alloca i32, align 4, !psr.id !62 | ID: 23 #9: %kptr = alloca ptr,
-align 8, !psr.id !63 | ID: 24 #10: %x = alloca ptr, align 8, !psr.id !64 | ID:
-25 #11: %y = alloca ptr, align 8, !psr.id !65 | ID: 26 #12: %0 = load ptr, ptr
-%kptr, align 8, !dbg !78, !psr.id !79 | ID: 33 %1 = load ptr, ptr %kptr, align
-8, !dbg !88, !psr.id !89 | ID: 38 #13: %call = call ptr @selfRecursion(ptr
-noundef %0), !dbg !80, !psr.id !81 | ID: 34 #14: %call1 = call ptr
-@selfRecursion(ptr noundef %1), !dbg !90, !psr.id !91 | ID: 39 #15: %2 = load
-ptr, ptr %x, align 8, !dbg !93, !psr.id !94 | ID: 41
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1>
-  #6: <>
-  #7: <>
-  #8: <>
-  #9: <>
-  #10: <2, 3, 4, 5, 6, 8, 12, 13, 14, 15>
-  #11: <>
-  #12: <>
-  #13: <>
-  #14: <>
-  #15: <7>
-  #16: <>
-  #17: <>
-  #18: <>
-  #19: <>
-  #20: <9>
-  #21: <>
-  #22: <>
-  #23: <>
-  #24: <>
-  #25: <10>
-  #26: <>
-  #27: <>
-  #28: <>
-  #29: <>
-  #30: <11>
-  #31: <>
-  #32: <>
-  #33: <>
-  #34: <>
-}
-
-#10: <2, 3, 4, 5, 6, 8, 12, 13, 14, 15>
-
-  */
   GTMap GT = {{LineColFunOp{.Line = 12,
                             .Col = 0,
                             .InFunction = "main",
@@ -7996,67 +5715,6 @@ UnionFindAAResult {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context09_0) {
-
-  /*
-ValueCompressor: {
-  #0:
-    %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
-  #2:
-    ptr %Ptr | ID: selfRecursion.0
-  #3:
-    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
-    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
-    %3 = load ptr, ptr %Ptr.addr, align 8, !dbg !38, !psr.id !39 | ID: 11
-    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
-    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !48, !psr.id !49 | ID: 16
-  #4:
-    %call = call ptr @selfRecursion(ptr noundef %6), !dbg !50, !psr.id !51 | ID:
-17 #5: fun @selfRecursion.<ret> #6: %7 = load ptr, ptr %retval, align 8, !dbg
-!55, !psr.id !56 | ID: 20 #7: %retval = alloca i32, align 4, !psr.id !61 | ID:
-22 #8: %k = alloca i32, align 4, !psr.id !62 | ID: 23 #9: %l = alloca i32, align
-4, !psr.id !63 | ID: 24 #10: %x = alloca ptr, align 8, !psr.id !64 | ID: 25 #11:
-    %y = alloca ptr, align 8, !psr.id !65 | ID: 26
-  #12:
-    %call = call ptr @selfRecursion(ptr noundef %k), !dbg !78, !psr.id !79 | ID:
-33 #13: %call1 = call ptr @selfRecursion(ptr noundef %l), !dbg !84, !psr.id !85
-| ID: 36 #14: %0 = load ptr, ptr %y, align 8, !dbg !87, !psr.id !88 | ID: 38
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1>
-  #6: <>
-  #7: <>
-  #8: <>
-  #9: <>
-  #10: <2, 3, 4, 5, 6, 8, 9, 12, 13, 14>
-  #11: <>
-  #12: <>
-  #13: <>
-  #14: <>
-  #15: <7>
-  #16: <>
-  #17: <>
-  #18: <>
-  #19: <>
-  #20: <10>
-  #21: <>
-  #22: <>
-  #23: <>
-  #24: <>
-  #25: <11>
-  #26: <>
-  #27: <>
-  #28: <>
-  #29: <>
-}
-  */
-
   GTMap GT{{LineColFunOp{.Line = 12,
                          .Col = 0,
                          .InFunction = "main",
@@ -8126,80 +5784,6 @@ UnionFindAAResult {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context09_1) {
-
-  /*
-  ValueCompressor: {
-    #0:
-      %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
-    #1:
-      %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
-    #2:
-      ptr %Ptr | ID: selfRecursion.0
-    #3:
-      %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
-      %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
-      %3 = load ptr, ptr %Ptr.addr, align 8, !dbg !38, !psr.id !39 | ID: 11
-      %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !44, !psr.id !45 | ID: 14
-      %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !48, !psr.id !49 | ID: 16
-    #4:
-      %call = call ptr @selfRecursion(ptr noundef %6), !dbg !50, !psr.id !51 |
-  ID: 17 #5: fun @selfRecursion.<ret> #6: %7 = load ptr, ptr %retval, align 8,
-  !dbg !55, !psr.id !56 | ID: 20 #7: %retval = alloca i32, align 4, !psr.id !61
-  | ID: 22 #8: %k = alloca i32, align 4, !psr.id !62 | ID: 23 #9: %l = alloca
-  i32, align 4, !psr.id !63 | ID: 24 #10: %xx1 = alloca ptr, align 8, !psr.id
-  !64 | ID: 25 #11: %xx2 = alloca ptr, align 8, !psr.id !65 | ID: 26 #12: %yy1 =
-  alloca ptr, align 8, !psr.id !66 | ID: 27 #13: %yy2 = alloca ptr, align 8,
-  !psr.id !67 | ID: 28 #14: %call = call ptr @selfRecursion(ptr noundef %k),
-  !dbg !80, !psr.id !81 | ID: 35 #15: %call1 = call ptr @selfRecursion(ptr
-  noundef %k), !dbg !88, !psr.id !89 | ID: 39 #16: %call2 = call ptr
-  @selfRecursion(ptr noundef %l), !dbg !94, !psr.id !95 | ID: 42 #17: %call3 =
-  call ptr @selfRecursion(ptr noundef %l), !dbg !102, !psr.id !103 | ID: 46 #18:
-      %0 = load ptr, ptr %yy2, align 8, !dbg !105, !psr.id !106 | ID: 48
-  }
-  UnionFindAAResult {
-    #0: <0>
-    #1: <>
-    #2: <>
-    #3: <>
-    #4: <>
-    #5: <1>
-    #6: <>
-    #7: <>
-    #8: <>
-    #9: <>
-    #10: <2, 3, 4, 5, 6, 8, 9, 14, 15, 16, 17, 18>
-    #11: <>
-    #12: <>
-    #13: <>
-    #14: <>
-    #15: <7>
-    #16: <>
-    #17: <>
-    #18: <>
-    #19: <>
-    #20: <10>
-    #21: <>
-    #22: <>
-    #23: <>
-    #24: <>
-    #25: <11>
-    #26: <>
-    #27: <>
-    #28: <>
-    #29: <>
-    #30: <12>
-    #31: <>
-    #32: <>
-    #33: <>
-    #34: <>
-    #35: <13>
-    #36: <>
-    #37: <>
-    #38: <>
-    #39: <>
-  }
-  */
-
   GTMap GT{{LineColFunOp{.Line = 12,
                          .Col = 0,
                          .InFunction = "main",
@@ -8297,102 +5881,6 @@ TEST(IndirectionSensUnionFindAATest, Context09_1) {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context10_0) {
-  /*
-  ValueCompressor: {
-  #0:
-    %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
-  #2:
-    ptr %Ptr | ID: Forth.0
-  #3:
-    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
-    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
-    %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !39, !psr.id !40 | ID: 11
-    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !43, !psr.id !44 | ID: 13
-    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !50, !psr.id !51 | ID: 17
-  #4:
-    %call = call ptr @Back(ptr noundef %5), !dbg !45, !psr.id !46 | ID: 14
-  #5:
-    fun @Back.<ret>
-  #6:
-    ptr %Ptr | ID: Back.0
-  #7:
-    %7 = load ptr, ptr %retval, align 8, !dbg !55, !psr.id !56 | ID: 20
-  #8:
-    fun @Forth.<ret>
-  #9:
-    %retval = alloca ptr, align 8, !psr.id !59 | ID: 22
-  #10:
-    %Ptr.addr = alloca ptr, align 8, !psr.id !60 | ID: 23
-  #11:
-    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !65, !psr.id !67 | ID: 26
-    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !74, !psr.id !76 | ID: 30
-    %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !81, !psr.id !82 | ID: 33
-    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !85, !psr.id !86 | ID: 35
-    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !92, !psr.id !93 | ID: 39
-  #12:
-    %call = call ptr @Forth(ptr noundef %5), !dbg !87, !psr.id !88 | ID: 36
-  #13:
-    %7 = load ptr, ptr %retval, align 8, !dbg !97, !psr.id !98 | ID: 42
-  #14:
-    %retval = alloca i32, align 4, !psr.id !103 | ID: 44
-  #15:
-    %k = alloca i32, align 4, !psr.id !104 | ID: 45
-  #16:
-    %x = alloca ptr, align 8, !psr.id !105 | ID: 46
-  #17:
-    %y = alloca ptr, align 8, !psr.id !106 | ID: 47
-  #18:
-    %call = call ptr @Back(ptr noundef %k), !dbg !115, !psr.id !116 | ID: 52
-  #19:
-    %call1 = call ptr @Back(ptr noundef %k), !dbg !123, !psr.id !124 | ID: 56
-  #20:
-    %0 = load ptr, ptr %x, align 8, !dbg !126, !psr.id !127 | ID: 58
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1>
-  #6: <>
-  #7: <>
-  #8: <>
-  #9: <>
-  #10: <2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 18, 19, 20>
-  #11: <>
-  #12: <>
-  #13: <>
-  #14: <>
-  #15: <9>
-  #16: <>
-  #17: <>
-  #18: <>
-  #19: <>
-  #20: <10>
-  #21: <>
-  #22: <>
-  #23: <>
-  #24: <>
-  #25: <14>
-  #26: <>
-  #27: <>
-  #28: <>
-  #29: <>
-  #30: <16>
-  #31: <>
-  #32: <>
-  #33: <>
-  #34: <>
-  #35: <17>
-  #36: <>
-  #37: <>
-  #38: <>
-  #39: <>
-}
-  */
   GTMap GT{{LineColFunOp{.Line = 24,
                          .Col = 0,
                          .InFunction = "main",
@@ -8468,122 +5956,6 @@ UnionFindAAResult {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context10_1) {
-  /*
-  ValueCompressor: {
-    #0:
-      %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
-    #1:
-      %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
-    #2:
-      ptr %Ptr | ID: Forth.0
-    #3:
-      %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
-      %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
-      %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !39, !psr.id !40 | ID: 11
-      %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !43, !psr.id !44 | ID: 13
-      %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !50, !psr.id !51 | ID: 17
-    #4:
-      %call = call ptr @Back(ptr noundef %5), !dbg !45, !psr.id !46 | ID: 14
-    #5:
-      fun @Back.<ret>
-    #6:
-      ptr %Ptr | ID: Back.0
-    #7:
-      %7 = load ptr, ptr %retval, align 8, !dbg !55, !psr.id !56 | ID: 20
-    #8:
-      fun @Forth.<ret>
-    #9:
-      %retval = alloca ptr, align 8, !psr.id !59 | ID: 22
-    #10:
-      %Ptr.addr = alloca ptr, align 8, !psr.id !60 | ID: 23
-    #11:
-      %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !65, !psr.id !67 | ID: 26
-      %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !74, !psr.id !76 | ID: 30
-      %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !81, !psr.id !82 | ID: 33
-      %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !85, !psr.id !86 | ID: 35
-      %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !92, !psr.id !93 | ID: 39
-    #12:
-      %call = call ptr @Forth(ptr noundef %5), !dbg !87, !psr.id !88 | ID: 36
-    #13:
-      %7 = load ptr, ptr %retval, align 8, !dbg !97, !psr.id !98 | ID: 42
-    #14:
-      %retval = alloca i32, align 4, !psr.id !103 | ID: 44
-    #15:
-      %k = alloca i32, align 4, !psr.id !104 | ID: 45
-    #16:
-      %l = alloca i32, align 4, !psr.id !105 | ID: 46
-    #17:
-      %xx1 = alloca ptr, align 8, !psr.id !106 | ID: 47
-    #18:
-      %xx2 = alloca ptr, align 8, !psr.id !107 | ID: 48
-    #19:
-      %yy1 = alloca ptr, align 8, !psr.id !108 | ID: 49
-    #20:
-      %yy2 = alloca ptr, align 8, !psr.id !109 | ID: 50
-    #21:
-      %call = call ptr @Back(ptr noundef %k), !dbg !122, !psr.id !123 | ID: 57
-    #22:
-      %call1 = call ptr @Back(ptr noundef %k), !dbg !130, !psr.id !131 | ID: 61
-    #23:
-      %call2 = call ptr @Back(ptr noundef %l), !dbg !136, !psr.id !137 | ID: 64
-    #24:
-      %call3 = call ptr @Back(ptr noundef %l), !dbg !144, !psr.id !145 | ID: 68
-    #25:
-      %0 = load ptr, ptr %xx1, align 8, !dbg !147, !psr.id !148 | ID: 70
-  }
-  UnionFindAAResult {
-    #0: <0>
-    #1: <>
-    #2: <>
-    #3: <>
-    #4: <>
-    #5: <1>
-    #6: <>
-    #7: <>
-    #8: <>
-    #9: <>
-    #10: <2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 15, 16, 21, 22, 23, 24, 25>
-    #11: <>
-    #12: <>
-    #13: <>
-    #14: <>
-    #15: <9>
-    #16: <>
-    #17: <>
-    #18: <>
-    #19: <>
-    #20: <10>
-    #21: <>
-    #22: <>
-    #23: <>
-    #24: <>
-    #25: <14>
-    #26: <>
-    #27: <>
-    #28: <>
-    #29: <>
-    #30: <17>
-    #31: <>
-    #32: <>
-    #33: <>
-    #34: <>
-    #35: <18>
-    #36: <>
-    #37: <>
-    #38: <>
-    #39: <>
-    #40: <19>
-    #41: <>
-    #42: <>
-    #43: <>
-    #44: <>
-    #45: <20>
-    #46: <>
-    #47: <>
-    #48: <>
-    #49: <>
-  }
-  */
   GTMap GT{{LineColFunOp{.Line = 24,
                          .Col = 0,
                          .InFunction = "main",
@@ -8691,116 +6063,6 @@ TEST(IndirectionSensUnionFindAATest, Context10_1) {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context11_0) {
-  /*
-  ValueCompressor: {
-    #0:
-      %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
-    #1:
-      %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
-    #2:
-      ptr %Ptr | ID: Forth.0
-    #3:
-      %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
-      %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
-      %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !39, !psr.id !40 | ID: 11
-      %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !43, !psr.id !44 | ID: 13
-      %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !50, !psr.id !51 | ID: 17
-    #4:
-      %call = call ptr @Stop(ptr noundef %5), !dbg !45, !psr.id !46 | ID: 14
-    #5:
-      fun @Stop.<ret>
-    #6:
-      ptr %Ptr | ID: Stop.0
-    #7:
-      %7 = load ptr, ptr %retval, align 8, !dbg !55, !psr.id !56 | ID: 20
-    #8:
-      fun @Forth.<ret>
-    #9:
-      %retval = alloca ptr, align 8, !psr.id !59 | ID: 22
-    #10:
-      %Ptr.addr = alloca ptr, align 8, !psr.id !60 | ID: 23
-    #11:
-      %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !65, !psr.id !67 | ID: 26
-      %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !76, !psr.id !78 | ID: 31
-      %3 = load ptr, ptr %Ptr.addr, align 8, !dbg !84, !psr.id !85 | ID: 35
-    #12:
-      %call = call ptr @Forth(ptr noundef %2), !dbg !79, !psr.id !80 | ID: 32
-    #13:
-      %call1 = call ptr @Back(ptr noundef %3), !dbg !86, !psr.id !87 | ID: 36
-    #14:
-      fun @Back.<ret>
-    #15:
-      ptr %Ptr | ID: Back.0
-    #16:
-      %4 = load ptr, ptr %retval, align 8, !dbg !91, !psr.id !92 | ID: 39
-    #17:
-      %retval = alloca ptr, align 8, !psr.id !95 | ID: 41
-    #18:
-      %Ptr.addr = alloca ptr, align 8, !psr.id !96 | ID: 42
-    #19:
-      %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !101, !psr.id !103 | ID: 45
-      %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !110, !psr.id !112 | ID: 49
-      %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !117, !psr.id !118 | ID: 52
-      %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !121, !psr.id !122 | ID: 54
-      %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !128, !psr.id !129 | ID: 58
-    #20:
-      %call = call ptr @Stop(ptr noundef %5), !dbg !123, !psr.id !124 | ID: 55
-    #21:
-      %7 = load ptr, ptr %retval, align 8, !dbg !133, !psr.id !134 | ID: 61
-    #22:
-      %retval = alloca i32, align 4, !psr.id !139 | ID: 63
-    #23:
-      %k = alloca i32, align 4, !psr.id !140 | ID: 64
-    #24:
-      %l = alloca i32, align 4, !psr.id !141 | ID: 65
-    #25:
-      %x = alloca ptr, align 8, !psr.id !142 | ID: 66
-    #26:
-      %y = alloca ptr, align 8, !psr.id !143 | ID: 67
-    #27:
-      %call = call ptr @Back(ptr noundef %k), !dbg !156, !psr.id !157 | ID: 74
-    #28:
-      %call1 = call ptr @Forth(ptr noundef %l), !dbg !162, !psr.id !163 | ID: 77
-    #29:
-      %0 = load ptr, ptr %x, align 8, !dbg !165, !psr.id !166 | ID: 79
-  }
-  UnionFindAAResult {
-    #0: <0>
-    #1: <>
-    #2: <>
-    #3: <>
-    #4: <>
-    #5: <1>
-    #6: <>
-    #7: <>
-    #8: <>
-    #9: <>
-    #10: <2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 14, 15, 16, 19, 20, 21, 23, 24, 27,
-  28, 29> #11: <> #12: <> #13: <> #14: <> #15: <9> #16: <> #17: <> #18: <> #19:
-  <> #20: <10> #21: <> #22: <> #23: <> #24: <> #25: <17> #26: <> #27: <> #28: <>
-    #29: <>
-    #30: <18>
-    #31: <>
-    #32: <>
-    #33: <>
-    #34: <>
-    #35: <22>
-    #36: <>
-    #37: <>
-    #38: <>
-    #39: <>
-    #40: <25>
-    #41: <>
-    #42: <>
-    #43: <>
-    #44: <>
-    #45: <26>
-    #46: <>
-    #47: <>
-    #48: <>
-    #49: <>
-  }
-  */
   GTMap GT{{LineColFunOp{.Line = 33,
                          .Col = 0,
                          .InFunction = "main",
@@ -8894,143 +6156,6 @@ TEST(IndirectionSensUnionFindAATest, Context11_0) {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context11_1) {
-  /*
-  ValueCompressor: {
-  #0:
-    %retval = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    %Ptr.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
-  #2:
-    ptr %Ptr | ID: Forth.0
-  #3:
-    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !23, !psr.id !25 | ID: 4
-    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !32, !psr.id !34 | ID: 8
-    %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !39, !psr.id !40 | ID: 11
-    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !43, !psr.id !44 | ID: 13
-    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !50, !psr.id !51 | ID: 17
-  #4:
-    %call = call ptr @Stop(ptr noundef %5), !dbg !45, !psr.id !46 | ID: 14
-  #5:
-    fun @Stop.<ret>
-  #6:
-    ptr %Ptr | ID: Stop.0
-  #7:
-    %7 = load ptr, ptr %retval, align 8, !dbg !55, !psr.id !56 | ID: 20
-  #8:
-    fun @Forth.<ret>
-  #9:
-    %retval = alloca ptr, align 8, !psr.id !59 | ID: 22
-  #10:
-    %Ptr.addr = alloca ptr, align 8, !psr.id !60 | ID: 23
-  #11:
-    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !65, !psr.id !67 | ID: 26
-    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !76, !psr.id !78 | ID: 31
-    %3 = load ptr, ptr %Ptr.addr, align 8, !dbg !84, !psr.id !85 | ID: 35
-  #12:
-    %call = call ptr @Forth(ptr noundef %2), !dbg !79, !psr.id !80 | ID: 32
-  #13:
-    %call1 = call ptr @Back(ptr noundef %3), !dbg !86, !psr.id !87 | ID: 36
-  #14:
-    fun @Back.<ret>
-  #15:
-    ptr %Ptr | ID: Back.0
-  #16:
-    %4 = load ptr, ptr %retval, align 8, !dbg !91, !psr.id !92 | ID: 39
-  #17:
-    %retval = alloca ptr, align 8, !psr.id !95 | ID: 41
-  #18:
-    %Ptr.addr = alloca ptr, align 8, !psr.id !96 | ID: 42
-  #19:
-    %0 = load ptr, ptr %Ptr.addr, align 8, !dbg !101, !psr.id !103 | ID: 45
-    %2 = load ptr, ptr %Ptr.addr, align 8, !dbg !110, !psr.id !112 | ID: 49
-    %4 = load ptr, ptr %Ptr.addr, align 8, !dbg !117, !psr.id !118 | ID: 52
-    %5 = load ptr, ptr %Ptr.addr, align 8, !dbg !121, !psr.id !122 | ID: 54
-    %6 = load ptr, ptr %Ptr.addr, align 8, !dbg !128, !psr.id !129 | ID: 58
-  #20:
-    %call = call ptr @Stop(ptr noundef %5), !dbg !123, !psr.id !124 | ID: 55
-  #21:
-    %7 = load ptr, ptr %retval, align 8, !dbg !133, !psr.id !134 | ID: 61
-  #22:
-    %retval = alloca i32, align 4, !psr.id !139 | ID: 63
-  #23:
-    %k = alloca i32, align 4, !psr.id !140 | ID: 64
-  #24:
-    %l = alloca i32, align 4, !psr.id !141 | ID: 65
-  #25:
-    %xx1 = alloca ptr, align 8, !psr.id !142 | ID: 66
-  #26:
-    %xx2 = alloca ptr, align 8, !psr.id !143 | ID: 67
-  #27:
-    %yy1 = alloca ptr, align 8, !psr.id !144 | ID: 68
-  #28:
-    %yy2 = alloca ptr, align 8, !psr.id !145 | ID: 69
-  #29:
-    %call = call ptr @Back(ptr noundef %k), !dbg !158, !psr.id !159 | ID: 76
-  #30:
-    %call1 = call ptr @Back(ptr noundef %k), !dbg !164, !psr.id !165 | ID: 79
-  #31:
-    %call2 = call ptr @Forth(ptr noundef %l), !dbg !170, !psr.id !171 | ID: 82
-  #32:
-    %call3 = call ptr @Forth(ptr noundef %l), !dbg !176, !psr.id !177 | ID: 85
-  #33:
-    %0 = load ptr, ptr %xx2, align 8, !dbg !179, !psr.id !180 | ID: 87
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1>
-  #6: <>
-  #7: <>
-  #8: <>
-  #9: <>
-  #10: <2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 14, 15, 16, 19, 20, 21, 23, 24, 29, 30,
-31, 32, 33> #11: <> #12: <> #13: <> #14: <> #15: <9> #16: <> #17: <> #18: <>
-  #19: <>
-  #20: <10>
-  #21: <>
-  #22: <>
-  #23: <>
-  #24: <>
-  #25: <17>
-  #26: <>
-  #27: <>
-  #28: <>
-  #29: <>
-  #30: <18>
-  #31: <>
-  #32: <>
-  #33: <>
-  #34: <>
-  #35: <22>
-  #36: <>
-  #37: <>
-  #38: <>
-  #39: <>
-  #40: <25>
-  #41: <>
-  #42: <>
-  #43: <>
-  #44: <>
-  #45: <26>
-  #46: <>
-  #47: <>
-  #48: <>
-  #49: <>
-  #50: <27>
-  #51: <>
-  #52: <>
-  #53: <>
-  #54: <>
-  #55: <28>
-  #56: <>
-  #57: <>
-  #58: <>
-  #59: <>
-}
-  */
   GTMap GT{{LineColFunOp{.Line = 33,
                          .Col = 0,
                          .InFunction = "main",
@@ -9152,85 +6277,6 @@ UnionFindAAResult {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context12_0) {
-  /*
-  ValueCompressor: {
-  #0:
-    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    %q.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
-  #2:
-    ptr %p | ID: argretq.0
-  #3:
-    ptr %q | ID: argretq.1
-  #4:
-    %0 = load ptr, ptr %q.addr, align 8, !dbg !27, !psr.id !28 | ID: 6
-  #5:
-    fun @argretq.<ret>
-  #6:
-    %retval = alloca i32, align 4, !psr.id !34 | ID: 8
-  #7:
-    %x = alloca i32, align 4, !psr.id !35 | ID: 9
-  #8:
-    %y = alloca i32, align 4, !psr.id !36 | ID: 10
-  #9:
-    %xx1 = alloca ptr, align 8, !psr.id !37 | ID: 11
-  #10:
-    %xx2 = alloca ptr, align 8, !psr.id !38 | ID: 12
-  #11:
-    %yy1 = alloca ptr, align 8, !psr.id !39 | ID: 13
-  #12:
-    %yy2 = alloca ptr, align 8, !psr.id !40 | ID: 14
-  #13:
-    %call = call ptr @argretq(ptr noundef %y, ptr noundef %x), !dbg !53, !psr.id
-!54 | ID: 21 #14: %call1 = call ptr @argretq(ptr noundef %y, ptr noundef %x),
-!dbg !59, !psr.id !60 | ID: 24 #15: %call2 = call ptr @argretq(ptr noundef %x,
-ptr noundef %y), !dbg !65, !psr.id !66 | ID: 27 #16: %call3 = call ptr
-@argretq(ptr noundef %x, ptr noundef %y), !dbg !71, !psr.id !72 | ID: 30 #17: %0
-= load ptr, ptr %xx1, align 8, !dbg !74, !psr.id !75 | ID: 32
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1>
-  #6: <>
-  #7: <>
-  #8: <>
-  #9: <>
-  #10: <2, 3, 4, 5, 7, 8, 13, 14, 15, 16, 17>
-  #11: <>
-  #12: <>
-  #13: <>
-  #14: <>
-  #15: <6>
-  #16: <>
-  #17: <>
-  #18: <>
-  #19: <>
-  #20: <9>
-  #21: <>
-  #22: <>
-  #23: <>
-  #24: <>
-  #25: <10>
-  #26: <>
-  #27: <>
-  #28: <>
-  #29: <>
-  #30: <11>
-  #31: <>
-  #32: <>
-  #33: <>
-  #34: <>
-  #35: <12>
-  #36: <>
-  #37: <>
-  #38: <>
-  #39: <>
-}
-  */
   GTMap GT{{LineColFunOp{.Line = 5,
                          .Col = 0,
                          .InFunction = "main",
@@ -9311,69 +6357,6 @@ UnionFindAAResult {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context12_1) {
-  /*
-  ValueCompressor: {
-  #0:
-    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    %q.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
-  #2:
-    ptr %p | ID: argretq.0
-  #3:
-    ptr %q | ID: argretq.1
-  #4:
-    %0 = load ptr, ptr %q.addr, align 8, !dbg !27, !psr.id !28 | ID: 6
-  #5:
-    fun @argretq.<ret>
-  #6:
-    %retval = alloca i32, align 4, !psr.id !34 | ID: 8
-  #7:
-    %x = alloca i32, align 4, !psr.id !35 | ID: 9
-  #8:
-    %y = alloca i32, align 4, !psr.id !36 | ID: 10
-  #9:
-    %xx1 = alloca ptr, align 8, !psr.id !37 | ID: 11
-  #10:
-    %yy1 = alloca ptr, align 8, !psr.id !38 | ID: 12
-  #11:
-    %call = call ptr @argretq(ptr noundef %y, ptr noundef %x), !dbg !51, !psr.id
-!52 | ID: 19 #12: %call1 = call ptr @argretq(ptr noundef %x, ptr noundef %y),
-!dbg !57, !psr.id !58 | ID: 22 #13: %0 = load ptr, ptr %xx1, align 8, !dbg !60,
-!psr.id !61 | ID: 24
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1>
-  #6: <>
-  #7: <>
-  #8: <>
-  #9: <>
-  #10: <2, 3, 4, 5, 7, 8, 11, 12, 13>
-  #11: <>
-  #12: <>
-  #13: <>
-  #14: <>
-  #15: <6>
-  #16: <>
-  #17: <>
-  #18: <>
-  #19: <>
-  #20: <9>
-  #21: <>
-  #22: <>
-  #23: <>
-  #24: <>
-  #25: <10>
-  #26: <>
-  #27: <>
-  #28: <>
-  #29: <>
-}
-  */
   GTMap GT{{LineColFunOp{.Line = 5,
                          .Col = 0,
                          .InFunction = "main",
@@ -9426,130 +6409,6 @@ UnionFindAAResult {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context13_0) {
-
-  /*
-  ValueCompressor: {
-  #0:
-    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    %q.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
-  #2:
-    %r.addr = alloca ptr, align 8, !psr.id !19 | ID: 2
-  #3:
-    ptr %p | ID: argretq.0
-  #4:
-    ptr %q | ID: argretq.1
-  #5:
-    ptr %r | ID: argretq.2
-  #6:
-    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 9
-  #7:
-    fun @argretq.<ret>
-  #8:
-    %retval = alloca i32, align 4, !psr.id !39 | ID: 11
-  #9:
-    %x = alloca i32, align 4, !psr.id !40 | ID: 12
-  #10:
-    %y = alloca i32, align 4, !psr.id !41 | ID: 13
-  #11:
-    %xx1 = alloca ptr, align 8, !psr.id !42 | ID: 14
-  #12:
-    %xx2 = alloca ptr, align 8, !psr.id !43 | ID: 15
-  #13:
-    %xx3 = alloca ptr, align 8, !psr.id !44 | ID: 16
-  #14:
-    %xx4 = alloca ptr, align 8, !psr.id !45 | ID: 17
-  #15:
-    %yy1 = alloca ptr, align 8, !psr.id !46 | ID: 18
-  #16:
-    %yy2 = alloca ptr, align 8, !psr.id !47 | ID: 19
-  #17:
-    %yy3 = alloca ptr, align 8, !psr.id !48 | ID: 20
-  #18:
-    %yy4 = alloca ptr, align 8, !psr.id !49 | ID: 21
-  #19:
-    %call = call ptr @argretq(ptr noundef %x, ptr noundef %x, ptr noundef %x),
-!dbg !62, !psr.id !63 | ID: 28 #20: %call1 = call ptr @argretq(ptr noundef %x,
-ptr noundef %x, ptr noundef %y), !dbg !68, !psr.id !69 | ID: 31 #21: %call2 =
-call ptr @argretq(ptr noundef %y, ptr noundef %x, ptr noundef %y), !dbg !74,
-!psr.id !75 | ID: 34 #22: %call3 = call ptr @argretq(ptr noundef %y, ptr noundef
-%x, ptr noundef %x), !dbg !80, !psr.id !81 | ID: 37 #23: %call4 = call ptr
-@argretq(ptr noundef %x, ptr noundef %y, ptr noundef %x), !dbg !86, !psr.id !87
-| ID: 40 #24: %call5 = call ptr @argretq(ptr noundef %x, ptr noundef %y, ptr
-noundef %y), !dbg !92, !psr.id !93 | ID: 43 #25: %call6 = call ptr @argretq(ptr
-noundef %y, ptr noundef %y, ptr noundef %y), !dbg !98, !psr.id !99 | ID: 46 #26:
-    %call7 = call ptr @argretq(ptr noundef %y, ptr noundef %y, ptr noundef %x),
-!dbg !104, !psr.id !105 | ID: 49 #27: %0 = load ptr, ptr %xx1, align 8, !dbg
-!107, !psr.id !108 | ID: 51
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1>
-  #6: <>
-  #7: <>
-  #8: <>
-  #9: <>
-  #10: <2>
-  #11: <>
-  #12: <>
-  #13: <>
-  #14: <>
-  #15: <3, 4, 5, 6, 7, 9, 10, 19, 20, 21, 22, 23, 24, 25, 26, 27>
-  #16: <>
-  #17: <>
-  #18: <>
-  #19: <>
-  #20: <8>
-  #21: <>
-  #22: <>
-  #23: <>
-  #24: <>
-  #25: <11>
-  #26: <>
-  #27: <>
-  #28: <>
-  #29: <>
-  #30: <12>
-  #31: <>
-  #32: <>
-  #33: <>
-  #34: <>
-  #35: <13>
-  #36: <>
-  #37: <>
-  #38: <>
-  #39: <>
-  #40: <14>
-  #41: <>
-  #42: <>
-  #43: <>
-  #44: <>
-  #45: <15>
-  #46: <>
-  #47: <>
-  #48: <>
-  #49: <>
-  #50: <16>
-  #51: <>
-  #52: <>
-  #53: <>
-  #54: <>
-  #55: <17>
-  #56: <>
-  #57: <>
-  #58: <>
-  #59: <>
-  #60: <18>
-  #61: <>
-  #62: <>
-  #63: <>
-  #64: <>
-}
-  */
   GTMap GT{{LineColFunOp{.Line = 5,
                          .Col = 0,
                          .InFunction = "main",
@@ -9687,78 +6546,6 @@ UnionFindAAResult {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context13_1) {
-  /*
-ValueCompressor: {
-  #0:
-    %p.addr = alloca ptr, align 8, !psr.id !17 | ID: 0
-  #1:
-    %q.addr = alloca ptr, align 8, !psr.id !18 | ID: 1
-  #2:
-    %r.addr = alloca ptr, align 8, !psr.id !19 | ID: 2
-  #3:
-    ptr %p | ID: argretq.0
-  #4:
-    ptr %q | ID: argretq.1
-  #5:
-    ptr %r | ID: argretq.2
-  #6:
-    %0 = load ptr, ptr %q.addr, align 8, !dbg !32, !psr.id !33 | ID: 9
-  #7:
-    fun @argretq.<ret>
-  #8:
-    %retval = alloca i32, align 4, !psr.id !39 | ID: 11
-  #9:
-    %x = alloca i32, align 4, !psr.id !40 | ID: 12
-  #10:
-    %y = alloca i32, align 4, !psr.id !41 | ID: 13
-  #11:
-    %xx1 = alloca ptr, align 8, !psr.id !42 | ID: 14
-  #12:
-    %yy1 = alloca ptr, align 8, !psr.id !43 | ID: 15
-  #13:
-    %call = call ptr @argretq(ptr noundef %x, ptr noundef %x, ptr noundef %x),
-!dbg !56, !psr.id !57 | ID: 22 #14: %call1 = call ptr @argretq(ptr noundef %y,
-ptr noundef %y, ptr noundef %y), !dbg !62, !psr.id !63 | ID: 25 #15: %0 = load
-ptr, ptr %yy1, align 8, !dbg !65, !psr.id !66 | ID: 27
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1>
-  #6: <>
-  #7: <>
-  #8: <>
-  #9: <>
-  #10: <2>
-  #11: <>
-  #12: <>
-  #13: <>
-  #14: <>
-  #15: <3, 4, 5, 6, 7, 9, 10, 13, 14, 15>
-  #16: <>
-  #17: <>
-  #18: <>
-  #19: <>
-  #20: <8>
-  #21: <>
-  #22: <>
-  #23: <>
-  #24: <>
-  #25: <11>
-  #26: <>
-  #27: <>
-  #28: <>
-  #29: <>
-  #30: <12>
-  #31: <>
-  #32: <>
-  #33: <>
-  #34: <>
-}
-  */
   GTMap GT{{LineColFunOp{.Line = 5,
                          .Col = 0,
                          .InFunction = "main",
@@ -9812,53 +6599,6 @@ UnionFindAAResult {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context14_0) {
-  /*
-  ValueCompressor: {
-  #0:
-    %Func.addr = alloca ptr, align 8, !psr.id !24 | ID: 1
-  #1:
-    ptr %Func | ID: callback.0
-  #2:
-    %0 = load ptr, ptr %Func.addr, align 8, !dbg !29, !psr.id !30 | ID: 4
-  #3:
-    %retval = alloca i32, align 4, !psr.id !36 | ID: 7
-  #4:
-    %FuncPtr = alloca ptr, align 8, !psr.id !37 | ID: 8
-  #5:
-    %Zero = alloca i32, align 4, !psr.id !38 | ID: 9
-  #6:
-    fun @ret0
-  #7:
-    %0 = load ptr, ptr %FuncPtr, align 8, !dbg !47, !psr.id !48 | ID: 14
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1, 2, 6, 7>
-  #6: <>
-  #7: <>
-  #8: <>
-  #9: <>
-  #10: <3>
-  #11: <>
-  #12: <>
-  #13: <>
-  #14: <>
-  #15: <4>
-  #16: <>
-  #17: <>
-  #18: <>
-  #19: <>
-  #20: <5>
-  #21: <>
-  #22: <>
-  #23: <>
-  #24: <>
-}
-  */
   GTMap GT{{LineColFunOp{.Line = 7,
                          .Col = 0,
                          .InFunction = "main",
@@ -9872,59 +6612,6 @@ UnionFindAAResult {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context14_1) {
-  /*
-ValueCompressor: {
-  #0:
-    %Func.addr = alloca ptr, align 8, !psr.id !27 | ID: 2
-  #1:
-    ptr %Func | ID: callback.0
-  #2:
-    %0 = load ptr, ptr %Func.addr, align 8, !dbg !32, !psr.id !33 | ID: 5
-  #3:
-    fun @callback.<ret>
-  #4:
-    %retval = alloca i32, align 4, !psr.id !37 | ID: 7
-  #5:
-    %FuncPtrZero = alloca ptr, align 8, !psr.id !38 | ID: 8
-  #6:
-    %FuncPtrOne = alloca ptr, align 8, !psr.id !39 | ID: 9
-  #7:
-    fun @ret0
-  #8:
-    fun @ret1
-  #9:
-    %call = call ptr @callback(ptr noundef @ret1), !dbg !49, !psr.id !50 | ID:
-15 #10: %call1 = call ptr @callback(ptr noundef @ret0), !dbg !53, !psr.id !54 |
-ID: 17
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1, 2, 3, 7, 8, 9, 10>
-  #6: <>
-  #7: <>
-  #8: <>
-  #9: <>
-  #10: <4>
-  #11: <>
-  #12: <>
-  #13: <>
-  #14: <>
-  #15: <5>
-  #16: <>
-  #17: <>
-  #18: <>
-  #19: <>
-  #20: <6>
-  #21: <>
-  #22: <>
-  #23: <>
-  #24: <>
-}
-  */
   GTMap GT{{LineColFunOp{.Line = 9,
                          .Col = 0,
                          .InFunction = "main",
@@ -9940,69 +6627,6 @@ UnionFindAAResult {
 }
 
 TEST(IndirectionSensUnionFindAATest, Context14_2) {
-  /*
-ValueCompressor: {
-  #0:
-    %Func.addr = alloca ptr, align 8, !psr.id !30 | ID: 3
-  #1:
-    ptr %Func | ID: callback.0
-  #2:
-    %0 = load ptr, ptr %Func.addr, align 8, !dbg !35, !psr.id !36 | ID: 6
-  #3:
-    fun @callback.<ret>
-  #4:
-    %retval = alloca i32, align 4, !psr.id !40 | ID: 8
-  #5:
-    %FuncPtrZero = alloca ptr, align 8, !psr.id !41 | ID: 9
-  #6:
-    %FuncPtrOne = alloca ptr, align 8, !psr.id !42 | ID: 10
-  #7:
-    %FuncPtrTwo = alloca ptr, align 8, !psr.id !43 | ID: 11
-  #8:
-    fun @ret0
-  #9:
-    fun @ret1
-  #10:
-    fun @ret2
-  #11:
-    %call = call ptr @callback(ptr noundef @ret2), !dbg !57, !psr.id !58 | ID:
-19 #12: %call1 = call ptr @callback(ptr noundef @ret0), !dbg !61, !psr.id !62 |
-ID: 21 #13: %call2 = call ptr @callback(ptr noundef @ret1), !dbg !65, !psr.id
-!66 | ID: 23
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1, 2, 3, 8, 9, 10, 11, 12, 13>
-  #6: <>
-  #7: <>
-  #8: <>
-  #9: <>
-  #10: <4>
-  #11: <>
-  #12: <>
-  #13: <>
-  #14: <>
-  #15: <5>
-  #16: <>
-  #17: <>
-  #18: <>
-  #19: <>
-  #20: <6>
-  #21: <>
-  #22: <>
-  #23: <>
-  #24: <>
-  #25: <7>
-  #26: <>
-  #27: <>
-  #28: <>
-  #29: <>
-}
-  */
   GTMap GT{{LineColFunOp{.Line = 11,
                          .Col = 0,
                          .InFunction = "main",
@@ -10016,36 +6640,6 @@ UnionFindAAResult {
 }
 
 TEST(IndirectionSensUnionFindAATest, Indirection01) {
-  /*
-ValueCompressor: {
-  #0:
-    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
-  #1:
-    %Foo = alloca %struct._LinkedList, align 8, !psr.id !17 | ID: 1
-    %Next1 = getelementptr inbounds %struct._LinkedList, ptr %Foo, i32 0, i32 1,
-!dbg !41, !psr.id !42 | ID: 12 #2:
-    %.compoundliteral = alloca %struct._LinkedList, align 8, !psr.id !18 | ID: 2
-    %Val = getelementptr inbounds %struct._LinkedList, ptr %.compoundliteral,
-i32 0, i32 0, !dbg !30, !psr.id !31 | ID: 6 %Next = getelementptr inbounds
-%struct._LinkedList, ptr %.compoundliteral, i32 0, i32 1, !dbg !30, !psr.id !33
-| ID: 8 #3: %Alias = alloca ptr, align 8, !psr.id !19 | ID: 3 #4: %0 = load ptr,
-ptr %Next1, align 8, !dbg !41, !psr.id !43 | ID: 13
-}
-UnionFindAAResult {
-  #0: <0>
-  #1: <>
-  #2: <>
-  #3: <>
-  #4: <>
-  #5: <1, 4>
-  #6: <2>
-  #7: <3>
-  #8: <>
-  #9: <>
-  #10: <>
-  #11: <>
-}
-  */
   GTMap GT{{LineColFunOp{.Line = 8,
                          .Col = 0,
                          .InFunction = "main",
@@ -10075,73 +6669,6 @@ UnionFindAAResult {
 }
 
 TEST(IndirectionSensUnionFindAATest, Indirection02) {
-  /*
-ValueCompressor: {
-  #0:
-    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
-  #1:
-    %Foo = alloca %struct._LinkedList, align 8, !psr.id !17 | ID: 1
-    %Next6 = getelementptr inbounds %struct._LinkedList, ptr %Foo, i32 0, i32 1,
-!dbg !76, !psr.id !77 | ID: 33
-  #2:
-    %.compoundliteral = alloca %struct._LinkedList, align 8, !psr.id !18 | ID: 2
-    %Val = getelementptr inbounds %struct._LinkedList, ptr %.compoundliteral,
-i32 0, i32 0, !dbg !37, !psr.id !38 | ID: 13 %Next = getelementptr inbounds
-%struct._LinkedList, ptr %.compoundliteral, i32 0, i32 1, !dbg !37, !psr.id !40
-| ID: 15
-  #3: %Bar = alloca %struct._LinkedList, align 8, !psr.id !19 | ID: 3
-    %Next7 = getelementptr inbounds %struct._LinkedList, ptr %Bar, i32 0, i32 1,
-!dbg !83, !psr.id !84 | ID: 37
-  #4:
-    %.compoundliteral1 = alloca %struct._LinkedList, align 8, !psr.id !20 | ID:
-4 %Val2 = getelementptr inbounds %struct._LinkedList, ptr %.compoundliteral1,
-i32 0, i32 0, !dbg !47, !psr.id !48 | ID: 19 %Next3 = getelementptr inbounds
-%struct._LinkedList, ptr %.compoundliteral1, i32 0, i32 1, !dbg !47, !psr.id !50
-| ID: 21
-  #5: %Baz = alloca %struct._LinkedList, align 8, !psr.id !21 | ID: 5
-    %Next5 = getelementptr inbounds %struct._LinkedList, ptr %Baz, i32 0, i32 1,
-!dbg !68, !psr.id !69 | ID: 30 %Next8 = getelementptr inbounds
-%struct._LinkedList, ptr %Baz, i32 0, i32 1, !dbg !90, !psr.id !91 | ID: 41
-  #6:
-    %Boar = alloca %struct._LinkedList, align 8, !psr.id !22 | ID: 6
-    %Next4 = getelementptr inbounds %struct._LinkedList, ptr %Boar, i32 0, i32
-1, !dbg !64, !psr.id !65 | ID: 28 %Next9 = getelementptr inbounds
-%struct._LinkedList, ptr %Boar, i32 0, i32 1, !dbg !97, !psr.id !98 | ID: 45
-  #7:
-    %AliasOne = alloca ptr, align 8, !psr.id !23 | ID: 7
-  #8:
-    %AliasTwo = alloca ptr, align 8, !psr.id !24 | ID: 8
-  #9:
-    %AliasThree = alloca ptr, align 8, !psr.id !25 | ID: 9
-  #10:
-    %AliasFour = alloca ptr, align 8, !psr.id !26 | ID: 10
-  #11:
-    %0 = load ptr, ptr %Next6, align 8, !dbg !76, !psr.id !78 | ID: 34
-  #12:
-    %1 = load ptr, ptr %Next7, align 8, !dbg !83, !psr.id !85 | ID: 38
-  #13:
-    %2 = load ptr, ptr %Next8, align 8, !dbg !90, !psr.id !92 | ID: 42
-  #14:
-    %3 = load ptr, ptr %Next9, align 8, !dbg !97, !psr.id !99 | ID: 46
-}
-LLVMUnionFindAliasSet(global, ind-sens) {
-  #0: {0}
-  #1: {1, 3, 6, 11, 12, 13, 14}
-  #2: {2}
-  #3: {1, 3, 6, 11, 12, 13, 14}
-  #4: {4}
-  #5: {5}
-  #6: {1, 3, 6, 11, 12, 13, 14}
-  #7: {7}
-  #8: {8}
-  #9: {9}
-  #10: {10}
-  #11: {1, 3, 6, 11, 12, 13, 14}
-  #12: {1, 3, 6, 11, 12, 13, 14}
-  #13: {1, 3, 6, 11, 12, 13, 14}
-  #14: {1, 3, 6, 11, 12, 13, 14}
-}
-  */
   GTMap GT{{LineColFunOp{.Line = 8,
                          .Col = 0,
                          .InFunction = "main",
@@ -10209,69 +6736,10 @@ LLVMUnionFindAliasSet(global, ind-sens) {
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca}}}};
 
-  doAnalysisAndCompareResults("indirection_02_c_dbg.ll", GT,
-                              TracingBuilder(IndAABuilder));
+  doAnalysisAndCompareResults("indirection_02_c_dbg.ll", GT, IndAABuilder);
 }
 
 TEST(IndirectionSensUnionFindAATest, Indirection03) {
-  /*
-ValueCompressor: {
-  #0:
-    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
-  #1:
-    %Foo = alloca %struct._LinkedListOne, align 8, !psr.id !17 | ID: 1
-    %Next4 = getelementptr inbounds %struct._LinkedListOne, ptr %Foo, i32 0, i32
-1, !dbg !73, !psr.id !74 | ID: 29 #2:
-    %.compoundliteral = alloca %struct._LinkedListOne, align 8, !psr.id !18 |
-ID: 2 %Val = getelementptr inbounds %struct._LinkedListOne, ptr
-%.compoundliteral, i32 0, i32 0, !dbg !37, !psr.id !38 | ID: 13 %Next =
-getelementptr inbounds %struct._LinkedListOne, ptr %.compoundliteral, i32 0, i32
-1, !dbg !37, !psr.id !40 | ID: 15 #3: %Bar = alloca %struct._LinkedListTwo,
-align 8, !psr.id !19 | ID: 3 %Next5 = getelementptr inbounds
-%struct._LinkedListTwo, ptr %Bar, i32 0, i32 1, !dbg !80, !psr.id !81 | ID: 33
-  #4:
-    %.compoundliteral1 = alloca %struct._LinkedListTwo, align 8, !psr.id !20 |
-ID: 4 %Val2 = getelementptr inbounds %struct._LinkedListTwo, ptr
-%.compoundliteral1, i32 0, i32 0, !dbg !52, !psr.id !53 | ID: 19 %Next3 =
-getelementptr inbounds %struct._LinkedListTwo, ptr %.compoundliteral1, i32 0,
-i32 1, !dbg !52, !psr.id !55 | ID: 21 #5: %Baz = alloca %struct._LinkedListOne,
-align 8, !psr.id !21 | ID: 5 %Next6 = getelementptr inbounds
-%struct._LinkedListOne, ptr %Baz, i32 0, i32 1, !dbg !87, !psr.id !88 | ID: 37
-  #6:
-    %Boar = alloca %struct._LinkedListTwo, align 8, !psr.id !22 | ID: 6
-    %Next7 = getelementptr inbounds %struct._LinkedListTwo, ptr %Boar, i32 0,
-i32 1, !dbg !94, !psr.id !95 | ID: 41 #7: %AliasOne = alloca ptr, align 8,
-!psr.id !23 | ID: 7 #8: %AliasTwo = alloca ptr, align 8, !psr.id !24 | ID: 8 #9:
-    %AliasThree = alloca ptr, align 8, !psr.id !25 | ID: 9
-  #10:
-    %AliasFour = alloca ptr, align 8, !psr.id !26 | ID: 10
-  #11:
-    %0 = load ptr, ptr %Next4, align 8, !dbg !73, !psr.id !75 | ID: 30
-  #12:
-    %1 = load ptr, ptr %Next5, align 8, !dbg !80, !psr.id !82 | ID: 34
-  #13:
-    %2 = load ptr, ptr %Next6, align 8, !dbg !87, !psr.id !89 | ID: 38
-  #14:
-    %3 = load ptr, ptr %Next7, align 8, !dbg !94, !psr.id !96 | ID: 42
-}
-LLVMUnionFindAliasSet(global, botctx-ind-sens) {
-  #0: {0}
-  #1: {1, 11, 12, 13, 14}
-  #2: {2}
-  #3: {3}
-  #4: {4}
-  #5: {5}
-  #6: {6}
-  #7: {7}
-  #8: {8}
-  #9: {9}
-  #10: {10}
-  #11: {1, 11, 12, 13, 14}
-  #12: {1, 11, 12, 13, 14}
-  #13: {1, 11, 12, 13, 14}
-  #14: {1, 11, 12, 13, 14}
-}
-  */
   GTMap GT{{LineColFunOp{.Line = 13,
                          .Col = 0,
                          .InFunction = "main",
@@ -10335,91 +6803,6 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
 }
 
 TEST(IndirectionSensUnionFindAATest, Indirection04) {
-  /*
-ValueCompressor: {
-  #0:
-    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
-  #1:
-    %Foo = alloca %struct._LinkedListOne, align 8, !psr.id !17 | ID: 1
-    %Next10 = getelementptr inbounds %struct._LinkedListOne, ptr %Foo, i32 0,
-i32 1, !dbg !121, !psr.id !122 | ID: 54 #2:
-    %.compoundliteral = alloca %struct._LinkedListOne, align 8, !psr.id !18 |
-ID: 2 %Val = getelementptr inbounds %struct._LinkedListOne, ptr
-%.compoundliteral, i32 0, i32 0, !dbg !42, !psr.id !43 | ID: 18 %Next =
-getelementptr inbounds %struct._LinkedListOne, ptr %.compoundliteral, i32 0, i32
-1, !dbg !42, !psr.id !45 | ID: 20 #3: %Bar = alloca %struct._LinkedListTwo,
-align 8, !psr.id !19 | ID: 3 %Next11 = getelementptr inbounds
-%struct._LinkedListTwo, ptr %Bar, i32 0, i32 1, !dbg !128, !psr.id !129 | ID: 58
-  #4:
-    %.compoundliteral1 = alloca %struct._LinkedListTwo, align 8, !psr.id !20 |
-ID: 4 %Val2 = getelementptr inbounds %struct._LinkedListTwo, ptr
-%.compoundliteral1, i32 0, i32 0, !dbg !57, !psr.id !58 | ID: 24 %Next3 =
-getelementptr inbounds %struct._LinkedListTwo, ptr %.compoundliteral1, i32 0,
-i32 1, !dbg !57, !psr.id !60 | ID: 26 #5: %Baz = alloca
-%struct._LinkedListThree, align 8, !psr.id !21 | ID: 5 %Next12 = getelementptr
-inbounds %struct._LinkedListThree, ptr %Baz, i32 0, i32 1, !dbg !135, !psr.id
-!136 | ID: 62 #6:
-    %.compoundliteral4 = alloca %struct._LinkedListThree, align 8, !psr.id !22 |
-ID: 6 %Val5 = getelementptr inbounds %struct._LinkedListThree, ptr
-%.compoundliteral4, i32 0, i32 0, !dbg !73, !psr.id !74 | ID: 30 %Next6 =
-getelementptr inbounds %struct._LinkedListThree, ptr %.compoundliteral4, i32 0,
-i32 1, !dbg !73, !psr.id !76 | ID: 32 #7: %One = alloca %struct._LinkedListOne,
-align 8, !psr.id !23 | ID: 7 %Next7 = getelementptr inbounds
-%struct._LinkedListOne, ptr %One, i32 0, i32 1, !dbg !99, !psr.id !100 | ID: 42
-  #8:
-    %Two = alloca %struct._LinkedListTwo, align 8, !psr.id !24 | ID: 8
-    %Next8 = getelementptr inbounds %struct._LinkedListTwo, ptr %Two, i32 0, i32
-1, !dbg !106, !psr.id !107 | ID: 46 #9: %Three = alloca
-%struct._LinkedListThree, align 8, !psr.id !25 | ID: 9 %Next9 = getelementptr
-inbounds %struct._LinkedListThree, ptr %Three, i32 0, i32 1, !dbg !114, !psr.id
-!115 | ID: 50 #10: %AliasOne = alloca ptr, align 8, !psr.id !26 | ID: 10 #11:
-    %AliasTwo = alloca ptr, align 8, !psr.id !27 | ID: 11
-  #12:
-    %AliasThree = alloca ptr, align 8, !psr.id !28 | ID: 12
-  #13:
-    %AliasFour = alloca ptr, align 8, !psr.id !29 | ID: 13
-  #14:
-    %AliasFive = alloca ptr, align 8, !psr.id !30 | ID: 14
-  #15:
-    %AliasSix = alloca ptr, align 8, !psr.id !31 | ID: 15
-  #16:
-    %0 = load ptr, ptr %Next7, align 8, !dbg !99, !psr.id !101 | ID: 43
-  #17:
-    %1 = load ptr, ptr %Next8, align 8, !dbg !106, !psr.id !108 | ID: 47
-  #18:
-    %2 = load ptr, ptr %Next9, align 8, !dbg !114, !psr.id !116 | ID: 51
-  #19:
-    %3 = load ptr, ptr %Next10, align 8, !dbg !121, !psr.id !123 | ID: 55
-  #20:
-    %4 = load ptr, ptr %Next11, align 8, !dbg !128, !psr.id !130 | ID: 59
-  #21:
-    %5 = load ptr, ptr %Next12, align 8, !dbg !135, !psr.id !137 | ID: 63
-}
-LLVMUnionFindAliasSet(global, botctx-ind-sens) {
-  #0: {0}
-  #1: {1, 16, 17, 19, 20}
-  #2: {2}
-  #3: {3, 18, 21}
-  #4: {4}
-  #5: {5}
-  #6: {6}
-  #7: {7}
-  #8: {8}
-  #9: {9}
-  #10: {10}
-  #11: {11}
-  #12: {12}
-  #13: {13}
-  #14: {14}
-  #15: {15}
-  #16: {1, 16, 17, 19, 20}
-  #17: {1, 16, 17, 19, 20}
-  #18: {3, 18, 21}
-  #19: {1, 16, 17, 19, 20}
-  #20: {1, 16, 17, 19, 20}
-  #21: {3, 18, 21}
-}
-  */
   GTMap GT{{LineColFunOp{.Line = 18,
                          .Col = 0,
                          .InFunction = "main",
@@ -10495,114 +6878,6 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
 }
 
 TEST(IndirectionSensUnionFindAATest, Indirection05) {
-  /*
-ValueCompressor: {
-  #0:
-    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
-  #1:
-    %Foo = alloca %struct._LinkedListOne, align 8, !psr.id !17 | ID: 1
-    %Next14 = getelementptr inbounds %struct._LinkedListOne, ptr %Foo, i32 0,
-i32 1, !dbg !155, !psr.id !156 | ID: 71 #2:
-    %.compoundliteral = alloca %struct._LinkedListOne, align 8, !psr.id !18 |
-ID: 2 %Val = getelementptr inbounds %struct._LinkedListOne, ptr
-%.compoundliteral, i32 0, i32 0, !dbg !47, !psr.id !48 | ID: 23 %Next =
-getelementptr inbounds %struct._LinkedListOne, ptr %.compoundliteral, i32 0, i32
-1, !dbg !47, !psr.id !50 | ID: 25 #3: %Bar = alloca %struct._LinkedListTwo,
-align 8, !psr.id !19 | ID: 3 %Next15 = getelementptr inbounds
-%struct._LinkedListTwo, ptr %Bar, i32 0, i32 1, !dbg !162, !psr.id !163 | ID: 75
-  #4:
-    %.compoundliteral1 = alloca %struct._LinkedListTwo, align 8, !psr.id !20 |
-ID: 4 %Val2 = getelementptr inbounds %struct._LinkedListTwo, ptr
-%.compoundliteral1, i32 0, i32 0, !dbg !62, !psr.id !63 | ID: 29 %Next3 =
-getelementptr inbounds %struct._LinkedListTwo, ptr %.compoundliteral1, i32 0,
-i32 1, !dbg !62, !psr.id !65 | ID: 31 #5: %Baz = alloca
-%struct._LinkedListThree, align 8, !psr.id !21 | ID: 5 %Next16 = getelementptr
-inbounds %struct._LinkedListThree, ptr %Baz, i32 0, i32 1, !dbg !169, !psr.id
-!170 | ID: 79 #6:
-    %.compoundliteral4 = alloca %struct._LinkedListThree, align 8, !psr.id !22 |
-ID: 6 %Val5 = getelementptr inbounds %struct._LinkedListThree, ptr
-%.compoundliteral4, i32 0, i32 0, !dbg !78, !psr.id !79 | ID: 35 %Next6 =
-getelementptr inbounds %struct._LinkedListThree, ptr %.compoundliteral4, i32 0,
-i32 1, !dbg !78, !psr.id !81 | ID: 37 #7: %Boar = alloca
-%struct._LinkedListFour, align 8, !psr.id !23 | ID: 7 %Next17 = getelementptr
-inbounds %struct._LinkedListFour, ptr %Boar, i32 0, i32 1, !dbg !176, !psr.id
-!177 | ID: 83 #8:
-    %.compoundliteral7 = alloca %struct._LinkedListFour, align 8, !psr.id !24 |
-ID: 8 %Val8 = getelementptr inbounds %struct._LinkedListFour, ptr
-%.compoundliteral7, i32 0, i32 0, !dbg !94, !psr.id !95 | ID: 41 %Next9 =
-getelementptr inbounds %struct._LinkedListFour, ptr %.compoundliteral7, i32 0,
-i32 1, !dbg !94, !psr.id !97 | ID: 43 #9: %One = alloca %struct._LinkedListOne,
-align 8, !psr.id !25 | ID: 9 %Next10 = getelementptr inbounds
-%struct._LinkedListOne, ptr %One, i32 0, i32 1, !dbg !125, !psr.id !126 | ID: 55
-  #10:
-    %Two = alloca %struct._LinkedListTwo, align 8, !psr.id !26 | ID: 10
-    %Next11 = getelementptr inbounds %struct._LinkedListTwo, ptr %Two, i32 0,
-i32 1, !dbg !132, !psr.id !133 | ID: 59 #11: %Three = alloca
-%struct._LinkedListThree, align 8, !psr.id !27 | ID: 11 %Next12 = getelementptr
-inbounds %struct._LinkedListThree, ptr %Three, i32 0, i32 1, !dbg !140, !psr.id
-!141 | ID: 63 #12: %Four = alloca %struct._LinkedListFour, align 8, !psr.id !28
-| ID: 12 %Next13 = getelementptr inbounds %struct._LinkedListFour, ptr %Four,
-i32 0, i32 1, !dbg !148, !psr.id !149 | ID: 67 #13: %AliasOne = alloca ptr,
-align 8, !psr.id !29 | ID: 13 #14: %AliasTwo = alloca ptr, align 8, !psr.id !30
-| ID: 14 #15: %AliasThree = alloca ptr, align 8, !psr.id !31 | ID: 15 #16:
-    %AliasFour = alloca ptr, align 8, !psr.id !32 | ID: 16
-  #17:
-    %AliasFive = alloca ptr, align 8, !psr.id !33 | ID: 17
-  #18:
-    %AliasSix = alloca ptr, align 8, !psr.id !34 | ID: 18
-  #19:
-    %AliasSeven = alloca ptr, align 8, !psr.id !35 | ID: 19
-  #20:
-    %AliasEight = alloca ptr, align 8, !psr.id !36 | ID: 20
-  #21:
-    %0 = load ptr, ptr %Next10, align 8, !dbg !125, !psr.id !127 | ID: 56
-  #22:
-    %1 = load ptr, ptr %Next11, align 8, !dbg !132, !psr.id !134 | ID: 60
-  #23:
-    %2 = load ptr, ptr %Next12, align 8, !dbg !140, !psr.id !142 | ID: 64
-  #24:
-    %3 = load ptr, ptr %Next13, align 8, !dbg !148, !psr.id !150 | ID: 68
-  #25:
-    %4 = load ptr, ptr %Next14, align 8, !dbg !155, !psr.id !157 | ID: 72
-  #26:
-    %5 = load ptr, ptr %Next15, align 8, !dbg !162, !psr.id !164 | ID: 76
-  #27:
-    %6 = load ptr, ptr %Next16, align 8, !dbg !169, !psr.id !171 | ID: 80
-  #28:
-    %7 = load ptr, ptr %Next17, align 8, !dbg !176, !psr.id !178 | ID: 84
-}
-LLVMUnionFindAliasSet(global, botctx-ind-sens) {
-  #0: {0}
-  #1: {1, 21, 22, 25, 26}
-  #2: {2}
-  #3: {3, 23, 27}
-  #4: {4}
-  #5: {5, 24, 28}
-  #6: {6}
-  #7: {7}
-  #8: {8}
-  #9: {9}
-  #10: {10}
-  #11: {11}
-  #12: {12}
-  #13: {13}
-  #14: {14}
-  #15: {15}
-  #16: {16}
-  #17: {17}
-  #18: {18}
-  #19: {19}
-  #20: {20}
-  #21: {1, 21, 22, 25, 26}
-  #22: {1, 21, 22, 25, 26}
-  #23: {3, 23, 27}
-  #24: {5, 24, 28}
-  #25: {1, 21, 22, 25, 26}
-  #26: {1, 21, 22, 25, 26}
-  #27: {3, 23, 27}
-  #28: {5, 24, 28}
-}
-  */
   GTMap GT{{LineColFunOp{.Line = 23,
                          .Col = 0,
                          .InFunction = "main",
@@ -10694,141 +6969,6 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
 }
 
 TEST(IndirectionSensUnionFindAATest, Indirection06) {
-  /*
-ValueCompressor: {
-  #0:
-    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
-  #1:
-    %Foo = alloca %struct._LinkedListOne, align 8, !psr.id !17 | ID: 1
-    %Next18 = getelementptr inbounds %struct._LinkedListOne, ptr %Foo, i32 0,
-i32 1, !dbg !189, !psr.id !190 | ID: 88 #2:
-    %.compoundliteral = alloca %struct._LinkedListOne, align 8, !psr.id !18 |
-ID: 2 %Val = getelementptr inbounds %struct._LinkedListOne, ptr
-%.compoundliteral, i32 0, i32 0, !dbg !52, !psr.id !53 | ID: 28 %Next =
-getelementptr inbounds %struct._LinkedListOne, ptr %.compoundliteral, i32 0, i32
-1, !dbg !52, !psr.id !55 | ID: 30 #3: %Bar = alloca %struct._LinkedListTwo,
-align 8, !psr.id !19 | ID: 3 %Next19 = getelementptr inbounds
-%struct._LinkedListTwo, ptr %Bar, i32 0, i32 1, !dbg !196, !psr.id !197 | ID: 92
-  #4:
-    %.compoundliteral1 = alloca %struct._LinkedListTwo, align 8, !psr.id !20 |
-ID: 4 %Val2 = getelementptr inbounds %struct._LinkedListTwo, ptr
-%.compoundliteral1, i32 0, i32 0, !dbg !67, !psr.id !68 | ID: 34 %Next3 =
-getelementptr inbounds %struct._LinkedListTwo, ptr %.compoundliteral1, i32 0,
-i32 1, !dbg !67, !psr.id !70 | ID: 36 #5: %Baz = alloca
-%struct._LinkedListThree, align 8, !psr.id !21 | ID: 5 %Next20 = getelementptr
-inbounds %struct._LinkedListThree, ptr %Baz, i32 0, i32 1, !dbg !203, !psr.id
-!204 | ID: 96 #6:
-    %.compoundliteral4 = alloca %struct._LinkedListThree, align 8, !psr.id !22 |
-ID: 6 %Val5 = getelementptr inbounds %struct._LinkedListThree, ptr
-%.compoundliteral4, i32 0, i32 0, !dbg !83, !psr.id !84 | ID: 40 %Next6 =
-getelementptr inbounds %struct._LinkedListThree, ptr %.compoundliteral4, i32 0,
-i32 1, !dbg !83, !psr.id !86 | ID: 42 #7: %Boar = alloca
-%struct._LinkedListFour, align 8, !psr.id !23 | ID: 7 %Next21 = getelementptr
-inbounds %struct._LinkedListFour, ptr %Boar, i32 0, i32 1, !dbg !210, !psr.id
-!211 | ID: 100 #8:
-    %.compoundliteral7 = alloca %struct._LinkedListFour, align 8, !psr.id !24 |
-ID: 8 %Val8 = getelementptr inbounds %struct._LinkedListFour, ptr
-%.compoundliteral7, i32 0, i32 0, !dbg !99, !psr.id !100 | ID: 46 %Next9 =
-getelementptr inbounds %struct._LinkedListFour, ptr %.compoundliteral7, i32 0,
-i32 1, !dbg !99, !psr.id !102 | ID: 48 #9: %Far = alloca
-%struct._LinkedListFive, align 8, !psr.id !25 | ID: 9 %Next22 = getelementptr
-inbounds %struct._LinkedListFive, ptr %Far, i32 0, i32 1, !dbg !217, !psr.id
-!218 | ID: 104 #10:
-    %.compoundliteral10 = alloca %struct._LinkedListFive, align 8, !psr.id !26 |
-ID: 10 %Val11 = getelementptr inbounds %struct._LinkedListFive, ptr
-%.compoundliteral10, i32 0, i32 0, !dbg !115, !psr.id !116 | ID: 52 %Next12 =
-getelementptr inbounds %struct._LinkedListFive, ptr %.compoundliteral10, i32 0,
-i32 1, !dbg !115, !psr.id !118 | ID: 54 #11: %One = alloca
-%struct._LinkedListOne, align 8, !psr.id !27 | ID: 11 %Next13 = getelementptr
-inbounds %struct._LinkedListOne, ptr %One, i32 0, i32 1, !dbg !151, !psr.id !152
-| ID: 68 #12: %Two = alloca %struct._LinkedListTwo, align 8, !psr.id !28 | ID:
-12 %Next14 = getelementptr inbounds %struct._LinkedListTwo, ptr %Two, i32 0, i32
-1, !dbg !158, !psr.id !159 | ID: 72 #13: %Three = alloca
-%struct._LinkedListThree, align 8, !psr.id !29 | ID: 13 %Next15 = getelementptr
-inbounds %struct._LinkedListThree, ptr %Three, i32 0, i32 1, !dbg !166, !psr.id
-!167 | ID: 76 #14: %Four = alloca %struct._LinkedListFour, align 8, !psr.id !30
-| ID: 14 %Next16 = getelementptr inbounds %struct._LinkedListFour, ptr %Four,
-i32 0, i32 1, !dbg !174, !psr.id !175 | ID: 80 #15: %Five = alloca
-%struct._LinkedListFive, align 8, !psr.id !31 | ID: 15 %Next17 = getelementptr
-inbounds %struct._LinkedListFive, ptr %Five, i32 0, i32 1, !dbg !182, !psr.id
-!183 | ID: 84 #16: %AliasOne = alloca ptr, align 8, !psr.id !32 | ID: 16 #17:
-    %AliasTwo = alloca ptr, align 8, !psr.id !33 | ID: 17
-  #18:
-    %AliasThree = alloca ptr, align 8, !psr.id !34 | ID: 18
-  #19:
-    %AliasFour = alloca ptr, align 8, !psr.id !35 | ID: 19
-  #20:
-    %AliasFive = alloca ptr, align 8, !psr.id !36 | ID: 20
-  #21:
-    %AliasSix = alloca ptr, align 8, !psr.id !37 | ID: 21
-  #22:
-    %AliasSeven = alloca ptr, align 8, !psr.id !38 | ID: 22
-  #23:
-    %AliasEight = alloca ptr, align 8, !psr.id !39 | ID: 23
-  #24:
-    %AliasNine = alloca ptr, align 8, !psr.id !40 | ID: 24
-  #25:
-    %AliasTen = alloca ptr, align 8, !psr.id !41 | ID: 25
-  #26:
-    %0 = load ptr, ptr %Next13, align 8, !dbg !151, !psr.id !153 | ID: 69
-  #27:
-    %1 = load ptr, ptr %Next14, align 8, !dbg !158, !psr.id !160 | ID: 73
-  #28:
-    %2 = load ptr, ptr %Next15, align 8, !dbg !166, !psr.id !168 | ID: 77
-  #29:
-    %3 = load ptr, ptr %Next16, align 8, !dbg !174, !psr.id !176 | ID: 81
-  #30:
-    %4 = load ptr, ptr %Next17, align 8, !dbg !182, !psr.id !184 | ID: 85
-  #31:
-    %5 = load ptr, ptr %Next18, align 8, !dbg !189, !psr.id !191 | ID: 89
-  #32:
-    %6 = load ptr, ptr %Next19, align 8, !dbg !196, !psr.id !198 | ID: 93
-  #33:
-    %7 = load ptr, ptr %Next20, align 8, !dbg !203, !psr.id !205 | ID: 97
-  #34:
-    %8 = load ptr, ptr %Next21, align 8, !dbg !210, !psr.id !212 | ID: 101
-  #35:
-    %9 = load ptr, ptr %Next22, align 8, !dbg !217, !psr.id !219 | ID: 105
-}
-LLVMUnionFindAliasSet(global, botctx-ind-sens) {
-  #0: {0}
-  #1: {1, 26, 27, 31, 32}
-  #2: {2}
-  #3: {3, 28, 33}
-  #4: {4}
-  #5: {5, 29, 34}
-  #6: {6}
-  #7: {7, 30, 35}
-  #8: {8}
-  #9: {9}
-  #10: {10}
-  #11: {11}
-  #12: {12}
-  #13: {13}
-  #14: {14}
-  #15: {15}
-  #16: {16}
-  #17: {17}
-  #18: {18}
-  #19: {19}
-  #20: {20}
-  #21: {21}
-  #22: {22}
-  #23: {23}
-  #24: {24}
-  #25: {25}
-  #26: {1, 26, 27, 31, 32}
-  #27: {1, 26, 27, 31, 32}
-  #28: {3, 28, 33}
-  #29: {5, 29, 34}
-  #30: {7, 30, 35}
-  #31: {1, 26, 27, 31, 32}
-  #32: {1, 26, 27, 31, 32}
-  #33: {3, 28, 33}
-  #34: {5, 29, 34}
-  #35: {7, 30, 35}
-}
-  */
   GTMap GT{{LineColFunOp{.Line = 28,
                          .Col = 0,
                          .InFunction = "main",
@@ -10940,169 +7080,6 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
 }
 
 TEST(IndirectionSensUnionFindAATest, Indirection07) {
-  /*
-ValueCompressor: {
-  #0:
-    %retval = alloca i32, align 4, !psr.id !16 | ID: 0
-  #1:
-    %Foo = alloca %struct._LinkedListOne, align 8, !psr.id !17 | ID: 1
-    %Next22 = getelementptr inbounds %struct._LinkedListOne, ptr %Foo, i32 0,
-i32 1, !dbg !223, !psr.id !224 | ID: 105
-  #2:
-    %.compoundliteral = alloca %struct._LinkedListOne, align 8, !psr.id !18 |
-ID: 2 %Val = getelementptr inbounds %struct._LinkedListOne, ptr
-%.compoundliteral, i32 0, i32 0, !dbg !57, !psr.id !58 | ID: 33 %Next =
-getelementptr inbounds %struct._LinkedListOne, ptr %.compoundliteral, i32 0, i32
-1, !dbg !57, !psr.id !60 | ID: 35
-  #3: %Bar = alloca %struct._LinkedListTwo,
-align 8, !psr.id !19 | ID: 3 %Next23 = getelementptr inbounds
-%struct._LinkedListTwo, ptr %Bar, i32 0, i32 1, !dbg !230, !psr.id !231 | ID:
-109
-  #4:
-    %.compoundliteral1 = alloca %struct._LinkedListTwo, align 8, !psr.id !20 |
-ID: 4 %Val2 = getelementptr inbounds %struct._LinkedListTwo, ptr
-%.compoundliteral1, i32 0, i32 0, !dbg !72, !psr.id !73 | ID: 39 %Next3 =
-getelementptr inbounds %struct._LinkedListTwo, ptr %.compoundliteral1, i32 0,
-i32 1, !dbg !72, !psr.id !75 | ID: 41 #5: %Baz = alloca
-%struct._LinkedListThree, align 8, !psr.id !21 | ID: 5 %Next24 = getelementptr
-inbounds %struct._LinkedListThree, ptr %Baz, i32 0, i32 1, !dbg !237, !psr.id
-!238 | ID: 113 #6:
-    %.compoundliteral4 = alloca %struct._LinkedListThree, align 8, !psr.id !22 |
-ID: 6 %Val5 = getelementptr inbounds %struct._LinkedListThree, ptr
-%.compoundliteral4, i32 0, i32 0, !dbg !88, !psr.id !89 | ID: 45 %Next6 =
-getelementptr inbounds %struct._LinkedListThree, ptr %.compoundliteral4, i32 0,
-i32 1, !dbg !88, !psr.id !91 | ID: 47 #7: %Boar = alloca
-%struct._LinkedListFour, align 8, !psr.id !23 | ID: 7 %Next25 = getelementptr
-inbounds %struct._LinkedListFour, ptr %Boar, i32 0, i32 1, !dbg !244, !psr.id
-!245 | ID: 117 #8:
-    %.compoundliteral7 = alloca %struct._LinkedListFour, align 8, !psr.id !24 |
-ID: 8 %Val8 = getelementptr inbounds %struct._LinkedListFour, ptr
-%.compoundliteral7, i32 0, i32 0, !dbg !104, !psr.id !105 | ID: 51 %Next9 =
-getelementptr inbounds %struct._LinkedListFour, ptr %.compoundliteral7, i32 0,
-i32 1, !dbg !104, !psr.id !107 | ID: 53 #9: %Far = alloca
-%struct._LinkedListFive, align 8, !psr.id !25 | ID: 9 %Next26 = getelementptr
-inbounds %struct._LinkedListFive, ptr %Far, i32 0, i32 1, !dbg !251, !psr.id
-!252 | ID: 121 #10:
-    %.compoundliteral10 = alloca %struct._LinkedListFive, align 8, !psr.id !26 |
-ID: 10 %Val11 = getelementptr inbounds %struct._LinkedListFive, ptr
-%.compoundliteral10, i32 0, i32 0, !dbg !120, !psr.id !121 | ID: 57 %Next12 =
-getelementptr inbounds %struct._LinkedListFive, ptr %.compoundliteral10, i32 0,
-i32 1, !dbg !120, !psr.id !123 | ID: 59 #11: %Faz = alloca
-%struct._LinkedListSix, align 8, !psr.id !27 | ID: 11 %Next27 = getelementptr
-inbounds %struct._LinkedListSix, ptr %Faz, i32 0, i32 1, !dbg !258, !psr.id !259
-| ID: 125 #12:
-    %.compoundliteral13 = alloca %struct._LinkedListSix, align 8, !psr.id !28 |
-ID: 12 %Val14 = getelementptr inbounds %struct._LinkedListSix, ptr
-%.compoundliteral13, i32 0, i32 0, !dbg !136, !psr.id !137 | ID: 63 %Next15 =
-getelementptr inbounds %struct._LinkedListSix, ptr %.compoundliteral13, i32 0,
-i32 1, !dbg !136, !psr.id !139 | ID: 65 #13: %One = alloca
-%struct._LinkedListOne, align 8, !psr.id !29 | ID: 13 %Next16 = getelementptr
-inbounds %struct._LinkedListOne, ptr %One, i32 0, i32 1, !dbg !177, !psr.id !178
-| ID: 81 #14: %Two = alloca %struct._LinkedListTwo, align 8, !psr.id !30 | ID:
-14 %Next17 = getelementptr inbounds %struct._LinkedListTwo, ptr %Two, i32 0, i32
-1, !dbg !184, !psr.id !185 | ID: 85 #15: %Three = alloca
-%struct._LinkedListThree, align 8, !psr.id !31 | ID: 15 %Next18 = getelementptr
-inbounds %struct._LinkedListThree, ptr %Three, i32 0, i32 1, !dbg !192, !psr.id
-!193 | ID: 89 #16: %Four = alloca %struct._LinkedListFour, align 8, !psr.id !32
-| ID: 16 %Next19 = getelementptr inbounds %struct._LinkedListFour, ptr %Four,
-i32 0, i32 1, !dbg !200, !psr.id !201 | ID: 93 #17: %Five = alloca
-%struct._LinkedListFive, align 8, !psr.id !33 | ID: 17 %Next20 = getelementptr
-inbounds %struct._LinkedListFive, ptr %Five, i32 0, i32 1, !dbg !208, !psr.id
-!209 | ID: 97 #18: %Six = alloca %struct._LinkedListSix, align 8, !psr.id !34 |
-ID: 18 %Next21 = getelementptr inbounds %struct._LinkedListSix, ptr %Six, i32 0,
-i32 1, !dbg !216, !psr.id !217 | ID: 101 #19: %AliasOne = alloca ptr, align 8,
-!psr.id !35 | ID: 19 #20: %AliasTwo = alloca ptr, align 8, !psr.id !36 | ID: 20
-  #21:
-    %AliasThree = alloca ptr, align 8, !psr.id !37 | ID: 21
-  #22:
-    %AliasFour = alloca ptr, align 8, !psr.id !38 | ID: 22
-  #23:
-    %AliasFive = alloca ptr, align 8, !psr.id !39 | ID: 23
-  #24:
-    %AliasSix = alloca ptr, align 8, !psr.id !40 | ID: 24
-  #25:
-    %AliasSeven = alloca ptr, align 8, !psr.id !41 | ID: 25
-  #26:
-    %AliasEight = alloca ptr, align 8, !psr.id !42 | ID: 26
-  #27:
-    %AliasNine = alloca ptr, align 8, !psr.id !43 | ID: 27
-  #28:
-    %AliasTen = alloca ptr, align 8, !psr.id !44 | ID: 28
-  #29:
-    %AliasEleven = alloca ptr, align 8, !psr.id !45 | ID: 29
-  #30:
-    %AliasTwelve = alloca ptr, align 8, !psr.id !46 | ID: 30
-  #31:
-    %0 = load ptr, ptr %Next16, align 8, !dbg !177, !psr.id !179 | ID: 82
-  #32:
-    %1 = load ptr, ptr %Next17, align 8, !dbg !184, !psr.id !186 | ID: 86
-  #33:
-    %2 = load ptr, ptr %Next18, align 8, !dbg !192, !psr.id !194 | ID: 90
-  #34:
-    %3 = load ptr, ptr %Next19, align 8, !dbg !200, !psr.id !202 | ID: 94
-  #35:
-    %4 = load ptr, ptr %Next20, align 8, !dbg !208, !psr.id !210 | ID: 98
-  #36:
-    %5 = load ptr, ptr %Next21, align 8, !dbg !216, !psr.id !218 | ID: 102
-  #37:
-    %6 = load ptr, ptr %Next22, align 8, !dbg !223, !psr.id !225 | ID: 106
-  #38:
-    %7 = load ptr, ptr %Next23, align 8, !dbg !230, !psr.id !232 | ID: 110
-  #39:
-    %8 = load ptr, ptr %Next24, align 8, !dbg !237, !psr.id !239 | ID: 114
-  #40:
-    %9 = load ptr, ptr %Next25, align 8, !dbg !244, !psr.id !246 | ID: 118
-  #41:
-    %10 = load ptr, ptr %Next26, align 8, !dbg !251, !psr.id !253 | ID: 122
-  #42:
-    %11 = load ptr, ptr %Next27, align 8, !dbg !258, !psr.id !260 | ID: 126
-}
-LLVMUnionFindAliasSet(global, botctx-ind-sens) {
-  #0: {0}
-  #1: {1, 3, 31, 32, 33, 37, 38, 39}
-  #2: {2}
-  #3: {1, 3, 31, 32, 33, 37, 38, 39}
-  #4: {4}
-  #5: {5, 34, 40}
-  #6: {6}
-  #7: {7, 35, 41}
-  #8: {8}
-  #9: {9, 36, 42}
-  #10: {10}
-  #11: {11}
-  #12: {12}
-  #13: {13}
-  #14: {14}
-  #15: {15}
-  #16: {16}
-  #17: {17}
-  #18: {18}
-  #19: {19}
-  #20: {20}
-  #21: {21}
-  #22: {22}
-  #23: {23}
-  #24: {24}
-  #25: {25}
-  #26: {26}
-  #27: {27}
-  #28: {28}
-  #29: {29}
-  #30: {30}
-  #31: {1, 3, 31, 32, 33, 37, 38, 39}
-  #32: {1, 3, 31, 32, 33, 37, 38, 39}
-  #33: {1, 3, 31, 32, 33, 37, 38, 39}
-  #34: {5, 34, 40}
-  #35: {7, 35, 41}
-  #36: {9, 36, 42}
-  #37: {1, 3, 31, 32, 33, 37, 38, 39}
-  #38: {1, 3, 31, 32, 33, 37, 38, 39}
-  #39: {1, 3, 31, 32, 33, 37, 38, 39}
-  #40: {5, 34, 40}
-  #41: {7, 35, 41}
-  #42: {9, 36, 42}
-}
-  */
   GTMap GT{{LineColFunOp{.Line = 33,
                          .Col = 0,
                          .InFunction = "main",
@@ -11240,93 +7217,10 @@ LLVMUnionFindAliasSet(global, botctx-ind-sens) {
                           .InFunction = "main",
                           .OpCode = llvm::Instruction::Alloca}}}};
 
-  doAnalysisAndCompareResults("indirection_07_c_dbg.ll", GT,
-                              TracingBuilder(IndAABuilder));
+  doAnalysisAndCompareResults("indirection_07_c_dbg.ll", GT, IndAABuilder);
 }
 
 TEST(IndirectionSensUnionFindAATest, Indirection08) {
-  /*
-  ValueCompressor: {
-  #0:
-    @_ZTV3Foo = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
-x ptr] [ptr null, ptr @_ZTI3Foo, ptr @_ZN3Foo4FuncEv] }, comdat, align 8,
-!psr.id !0 | ID: 0 #1:
-    @_ZTI3Foo = linkonce_odr dso_local constant { ptr, ptr } { ptr getelementptr
-inbounds (ptr, ptr @_ZTVN10__cxxabiv117__class_type_infoE, i64 2), ptr @_ZTS3Foo
-}, comdat, align 8, !psr.id !3 | ID: 3 #2: fun @_ZN3Foo4FuncEv #3:
-    @_ZTS3Foo = linkonce_odr dso_local constant [5 x i8] c"3Foo\00", comdat,
-align 1, !psr.id !2 | ID: 2 #4:
-    @_ZTVN10__cxxabiv117__class_type_infoE = external global ptr, !psr.id !1 |
-ID: 1 #5:
-    @_ZTV3Bar = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
-x ptr] [ptr null, ptr @_ZTI3Bar, ptr @_ZN3Bar4FuncEv] }, comdat, align 8,
-!psr.id !4 | ID: 4 #6:
-    @_ZTI3Bar = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
-getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
-2), ptr @_ZTS3Bar, ptr @_ZTI3Foo }, comdat, align 8, !psr.id !7 | ID: 7 #7: fun
-@_ZN3Bar4FuncEv #8:
-    @_ZTS3Bar = linkonce_odr dso_local constant [5 x i8] c"3Bar\00", comdat,
-align 1, !psr.id !6 | ID: 6 #9:
-    @_ZTVN10__cxxabiv120__si_class_type_infoE = external global ptr, !psr.id !5
-| ID: 5 #10: %retval = alloca i32, align 4, !psr.id !24 | ID: 8 #11: %First =
-alloca %class.Foo, align 8, !psr.id !25 | ID: 9 #12: %Second = alloca
-%class.Bar, align 8, !psr.id !26 | ID: 10 #13: %SecondAlias = alloca ptr, align
-8, !psr.id !27 | ID: 11 #14: ptr %this | ID: _ZN3FooC2Ev.0 #15: ptr %this | ID:
-_ZN3BarC2Ev.0 #16: %0 = load ptr, ptr %SecondAlias, align 8, !dbg !60, !psr.id
-!61 | ID: 21 #17: %vtable = load ptr, ptr %0, align 8, !dbg !62, !psr.id !63 |
-ID: 22 %vfn = getelementptr inbounds ptr, ptr %vtable, i64 0, !dbg !62, !psr.id
-!64 | ID: 23 #18: %1 = load ptr, ptr %vfn, align 8, !dbg !62, !psr.id !65 | ID:
-24 #19: ptr %this | ID: _ZN3Foo4FuncEv.0 #20: ptr %this | ID: _ZN3Bar4FuncEv.0
-  #21:
-    %this.addr = alloca ptr, align 8, !psr.id !73 | ID: 27
-  #22:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !79 | ID: 30
-  #23:
-    %this.addr = alloca ptr, align 8, !psr.id !87 | ID: 33
-  #24:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !93 | ID: 36
-  #25:
-    %this.addr = alloca ptr, align 8, !psr.id !99 | ID: 40
-  #26:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !104 | ID: 43
-  #27:
-    %this.addr = alloca ptr, align 8, !psr.id !108 | ID: 45
-  #28:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !113 | ID: 48
-}
-
-LLVMUnionFindAliasSet(global, ind-sens) {
-  #0: {0, 5, 17}
-  #1: {1, 2, 3, 4, 6, 7, 8, 9, 18}
-  #2: {1, 2, 3, 4, 6, 7, 8, 9, 18}
-  #3: {1, 2, 3, 4, 6, 7, 8, 9, 18}
-  #4: {1, 2, 3, 4, 6, 7, 8, 9, 18}
-  #5: {0, 5, 17}
-  #6: {1, 2, 3, 4, 6, 7, 8, 9, 18}
-  #7: {1, 2, 3, 4, 6, 7, 8, 9, 18}
-  #8: {1, 2, 3, 4, 6, 7, 8, 9, 18}
-  #9: {1, 2, 3, 4, 6, 7, 8, 9, 18}
-  #10: {10}
-  #11: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
-  #12: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
-  #13: {13}
-  #14: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
-  #15: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
-  #16: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
-  #17: {0, 5, 17}
-  #18: {1, 2, 3, 4, 6, 7, 8, 9, 18}
-  #19: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
-  #20: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
-  #21: {21}
-  #22: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
-  #23: {23}
-  #24: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
-  #25: {25}
-  #26: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
-  #27: {27}
-  #28: {11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28}
-}
-  */
   GTMap GT{{LineColFunOp{.Line = 13,
                          .Col = 0,
                          .InFunction = "main",
@@ -11358,117 +7252,6 @@ LLVMUnionFindAliasSet(global, ind-sens) {
 }
 
 TEST(IndirectionSensUnionFindAATest, Indirection09) {
-  /*
-ValueCompressor: {
-  #0:
-    @_ZTV3Foo = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
-x ptr] [ptr null, ptr @_ZTI3Foo, ptr @_ZN3Foo4FuncEv] }, comdat, align 8,
-!psr.id !8 | ID: 1 #1:
-    @_ZTI3Foo = linkonce_odr dso_local constant { ptr, ptr } { ptr getelementptr
-inbounds (ptr, ptr @_ZTVN10__cxxabiv117__class_type_infoE, i64 2), ptr @_ZTS3Foo
-}, comdat, align 8, !psr.id !11 | ID: 4 #2: fun @_ZN3Foo4FuncEv #3:
-    @_ZTS3Foo = linkonce_odr dso_local constant [5 x i8] c"3Foo\00", comdat,
-align 1, !psr.id !10 | ID: 3 #4:
-    @_ZTVN10__cxxabiv117__class_type_infoE = external global ptr, !psr.id !9 |
-ID: 2 #5:
-    @_ZTV3Bar = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
-x ptr] [ptr null, ptr @_ZTI3Bar, ptr @_ZN3Bar4FuncEv] }, comdat, align 8,
-!psr.id !12 | ID: 5 #6:
-    @_ZTI3Bar = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
-getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
-2), ptr @_ZTS3Bar, ptr @_ZTI3Foo }, comdat, align 8, !psr.id !15 | ID: 8 #7: fun
-@_ZN3Bar4FuncEv #8:
-    @_ZTS3Bar = linkonce_odr dso_local constant [5 x i8] c"3Bar\00", comdat,
-align 1, !psr.id !14 | ID: 7 #9:
-    @_ZTVN10__cxxabiv120__si_class_type_infoE = external global ptr, !psr.id !13
-| ID: 6 #10:
-    @_ZTV3Baz = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } { [3
-x ptr] [ptr null, ptr @_ZTI3Baz, ptr @_ZN3Baz4FuncEv] }, comdat, align 8,
-!psr.id !16 | ID: 9 #11:
-    @_ZTI3Baz = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
-getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE, i64
-2), ptr @_ZTS3Baz, ptr @_ZTI3Bar }, comdat, align 8, !psr.id !18 | ID: 11 #12:
-    fun @_ZN3Baz4FuncEv
-  #13:
-    @_ZTS3Baz = linkonce_odr dso_local constant [5 x i8] c"3Baz\00", comdat,
-align 1, !psr.id !17 | ID: 10 #14: %retval = alloca i32, align 4, !psr.id !32 |
-ID: 12 #15: %First = alloca %class.Foo, align 8, !psr.id !33 | ID: 13 #16:
-    %Second = alloca %class.Bar, align 8, !psr.id !34 | ID: 14
-  #17:
-    %Third = alloca %class.Baz, align 8, !psr.id !35 | ID: 15
-  #18:
-    %FooRef = alloca ptr, align 8, !psr.id !36 | ID: 16
-  #19:
-    ptr %this | ID: _ZN3FooC2Ev.0
-  #20:
-    ptr %this | ID: _ZN3BarC2Ev.0
-  #21:
-    ptr %this | ID: _ZN3BazC2Ev.0
-  #22:
-    %cond-lvalue = phi ptr [ %Second, %cond.true ], [ %Third, %cond.false ],
-!dbg !80, !psr.id !86 | ID: 33 #23: %1 = load ptr, ptr %FooRef, align 8, !dbg
-!88, !psr.id !89 | ID: 35 #24: %vtable = load ptr, ptr %1, align 8, !dbg !90,
-!psr.id !91 | ID: 36 %vfn = getelementptr inbounds ptr, ptr %vtable, i64 0, !dbg
-!90, !psr.id !92 | ID: 37 #25: %2 = load ptr, ptr %vfn, align 8, !dbg !90,
-!psr.id !93 | ID: 38 #26: ptr %this | ID: _ZN3Baz4FuncEv.0 #27: ptr %this | ID:
-_ZN3Bar4FuncEv.0 #28: ptr %this | ID: _ZN3Foo4FuncEv.0 #29: %this.addr = alloca
-ptr, align 8, !psr.id !101 | ID: 41 #30: %this1 = load ptr, ptr %this.addr,
-align 8, !psr.id !107 | ID: 44 #31: %this.addr = alloca ptr, align 8, !psr.id
-!115 | ID: 47 #32: %this1 = load ptr, ptr %this.addr, align 8, !psr.id !121 |
-ID: 50 #33: %this.addr = alloca ptr, align 8, !psr.id !130 | ID: 54 #34: %this1
-= load ptr, ptr %this.addr, align 8, !psr.id !136 | ID: 57 #35: %this.addr =
-alloca ptr, align 8, !psr.id !142 | ID: 61 #36: %this1 = load ptr, ptr
-%this.addr, align 8, !psr.id !147 | ID: 64 #37: %this.addr = alloca ptr, align
-8, !psr.id !151 | ID: 66 #38: %this1 = load ptr, ptr %this.addr, align 8,
-!psr.id !156 | ID: 69 #39: %this.addr = alloca ptr, align 8, !psr.id !160 | ID:
-71 #40: %this1 = load ptr, ptr %this.addr, align 8, !psr.id !165 | ID: 74
-}
-UnionFindAAResult {
-  #0: <0, 5, 10, 24>
-  #1: <1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 25>
-  #2: <14>
-  #3: <>
-  #4: <>
-  #5: <>
-  #6: <>
-  #7: <15, 16, 17, 19, 20, 21, 22, 23, 26, 27, 28, 30, 32, 34, 36, 38, 40>
-  #8: <18>
-  #9: <>
-  #10: <>
-  #11: <>
-  #12: <>
-  #13: <29>
-  #14: <>
-  #15: <>
-  #16: <>
-  #17: <>
-  #18: <31>
-  #19: <>
-  #20: <>
-  #21: <>
-  #22: <>
-  #23: <33>
-  #24: <>
-  #25: <>
-  #26: <>
-  #27: <>
-  #28: <35>
-  #29: <>
-  #30: <>
-  #31: <>
-  #32: <>
-  #33: <37>
-  #34: <>
-  #35: <>
-  #36: <>
-  #37: <>
-  #38: <39>
-  #39: <>
-  #40: <>
-  #41: <>
-  #42: <>
-}
-  */
   GTMap GT{{LineColFunOp{.Line = 19,
                          .Col = 0,
                          .InFunction = "main",
@@ -11508,91 +7291,6 @@ UnionFindAAResult {
 }
 
 TEST(IndirectionSensUnionFindAATest, Indirection10) {
-  /*
-ValueCompressor: {
-  #0:
-    @_ZTV3Foo = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } {
-[3 x ptr] [ptr null, ptr @_ZTI3Foo, ptr @_ZN3Foo4FuncEv] }, comdat, align 8,
-!psr.id !0 | ID: 0 #1:
-    @_ZTI3Foo = linkonce_odr dso_local constant { ptr, ptr } { ptr
-getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv117__class_type_infoE, i64
-2), ptr @_ZTS3Foo
-}, comdat, align 8, !psr.id !3 | ID: 3 #2: fun @_ZN3Foo4FuncEv #3:
-    @_ZTS3Foo = linkonce_odr dso_local constant [5 x i8] c"3Foo\00", comdat,
-align 1, !psr.id !2 | ID: 2 #4:
-    @_ZTVN10__cxxabiv117__class_type_infoE = external global ptr, !psr.id !1 |
-ID: 1 #5:
-    @_ZTV3Bar = linkonce_odr dso_local unnamed_addr constant { [3 x ptr] } {
-[3 x ptr] [ptr null, ptr @_ZTI3Bar, ptr @_ZN3Bar4FuncEv] }, comdat, align 8,
-!psr.id !4 | ID: 4 #6:
-    @_ZTI3Bar = linkonce_odr dso_local constant { ptr, ptr, ptr } { ptr
-getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv120__si_class_type_infoE,
-i64 2), ptr @_ZTS3Bar, ptr @_ZTI3Foo }, comdat, align 8, !psr.id !7 | ID: 7
-#7: fun
-@_ZN3Bar4FuncEv #8:
-    @_ZTS3Bar = linkonce_odr dso_local constant [5 x i8] c"3Bar\00", comdat,
-align 1, !psr.id !6 | ID: 6 #9:
-    @_ZTVN10__cxxabiv120__si_class_type_infoE = external global ptr, !psr.id
-!5 | ID: 5 #10: %retval = alloca i32, align 4, !psr.id !24 | ID: 8 #11: %First
-= alloca %class.Foo, align 8, !psr.id !25 | ID: 9 #12: %Second = alloca
-%class.Bar, align 8, !psr.id !26 | ID: 10 #13: %SecondAlias = alloca ptr,
-align 8, !psr.id !27 | ID: 11 #14: ptr %this | ID: _ZN3FooC2Ev.0 #15: ptr
-%this | ID: _ZN3BarC2Ev.0 #16: %0 = load ptr, ptr %SecondAlias, align 8, !dbg
-!62, !psr.id !63 | ID: 21 #17: %vtable = load ptr, ptr %0, align 8, !dbg !64,
-!psr.id !65 | ID: 22 %vfn = getelementptr inbounds ptr, ptr %vtable, i64 0,
-!dbg !64, !psr.id !66 | ID: 23 #18: %1 = load ptr, ptr %vfn, align 8, !dbg
-!64, !psr.id !67 | ID: 24 #19: ptr %this | ID: _ZN3Foo4FuncEv.0 #20: ptr %this
-| ID: _ZN3Bar4FuncEv.0 #21: %this.addr = alloca ptr, align 8, !psr.id !75 |
-ID: 27 #22: %this1 = load ptr, ptr %this.addr, align 8, !psr.id !80 | ID: 30
-  #23:
-    %this.addr = alloca ptr, align 8, !psr.id !88 | ID: 33
-  #24:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !94 | ID: 36
-  #25:
-    %this.addr = alloca ptr, align 8, !psr.id !100 | ID: 40
-  #26:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !105 | ID: 43
-  #27:
-    %this.addr = alloca ptr, align 8, !psr.id !109 | ID: 45
-  #28:
-    %this1 = load ptr, ptr %this.addr, align 8, !psr.id !114 | ID: 48
-}
-UnionFindAAResult {
-  #0: <0, 5, 17>
-  #1: <1, 2, 3, 4, 6, 7, 8, 9, 18>
-  #2: <10>
-  #3: <>
-  #4: <>
-  #5: <>
-  #6: <>
-  #7: <11, 12, 14, 15, 16, 19, 20, 22, 24, 26, 28>
-  #8: <13>
-  #9: <>
-  #10: <>
-  #11: <>
-  #12: <>
-  #13: <21>
-  #14: <>
-  #15: <>
-  #16: <>
-  #17: <>
-  #18: <23>
-  #19: <>
-  #20: <>
-  #21: <>
-  #22: <>
-  #23: <25>
-  #24: <>
-  #25: <>
-  #26: <>
-  #27: <>
-  #28: <27>
-  #29: <>
-  #30: <>
-  #31: <>
-  #32: <>
-}
-  */
   GTMap GT{{LineColFunOp{.Line = 20,
                          .Col = 0,
                          .InFunction = "main",

From 921ce1d29698c1c4a40330bac01a0404c09ed520 Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Tue, 17 Mar 2026 11:37:03 +0100
Subject: [PATCH 57/75] test tool

---
 include/phasar/Pointer/AliasResult.h      |   1 +
 include/phasar/Pointer/UnionFindAA.h      |  12 +
 include/phasar/Utils/AliasQueryType.h     |  22 ++
 include/phasar/Utils/AliasQueryType.inc   |  13 ++
 include/phasar/Utils/FileUtils.hpp        |  11 +
 include/phasar/Utils/PTAResult.hpp        |  18 ++
 include/phasar/Utils/PTAUtils.hpp         |  79 +++++++
 include/phasar/Utils/QueryId.hpp          |   8 +
 include/phasar/Utils/QueryLocation.hpp    |  18 ++
 include/phasar/Utils/QuerySer.hpp         |  18 ++
 include/phasar/Utils/ResultsCollector.hpp |  17 ++
 lib/Pointer/AliasResult.cpp               |  13 ++
 lib/Utils/AliasQueryType.cpp              |  84 +++++++
 lib/Utils/FileUtils.cpp                   |  25 ++
 lib/Utils/PTAUtils.cpp                    | 117 ++++++++++
 lib/Utils/QuerySerializer.cpp             |  16 ++
 lib/Utils/ResultCollector.cpp             |  12 +
 tools/svftestingtool/svftestingtool.cpp   | 267 ++++++++++++++++++++++
 18 files changed, 751 insertions(+)
 create mode 100755 include/phasar/Utils/AliasQueryType.h
 create mode 100755 include/phasar/Utils/AliasQueryType.inc
 create mode 100755 include/phasar/Utils/FileUtils.hpp
 create mode 100755 include/phasar/Utils/PTAResult.hpp
 create mode 100755 include/phasar/Utils/PTAUtils.hpp
 create mode 100755 include/phasar/Utils/QueryId.hpp
 create mode 100755 include/phasar/Utils/QueryLocation.hpp
 create mode 100755 include/phasar/Utils/QuerySer.hpp
 create mode 100755 include/phasar/Utils/ResultsCollector.hpp
 create mode 100755 lib/Utils/AliasQueryType.cpp
 create mode 100755 lib/Utils/FileUtils.cpp
 create mode 100755 lib/Utils/PTAUtils.cpp
 create mode 100755 lib/Utils/QuerySerializer.cpp
 create mode 100755 lib/Utils/ResultCollector.cpp
 create mode 100644 tools/svftestingtool/svftestingtool.cpp

diff --git a/include/phasar/Pointer/AliasResult.h b/include/phasar/Pointer/AliasResult.h
index 825d51ca0c..79646e006a 100644
--- a/include/phasar/Pointer/AliasResult.h
+++ b/include/phasar/Pointer/AliasResult.h
@@ -21,6 +21,7 @@ enum class AliasResult {
 };
 
 std::string toString(AliasResult AR);
+[[nodiscard]] llvm::StringRef to_string(AliasResult Res) noexcept;
 
 AliasResult toAliasResult(llvm::StringRef S);
 
diff --git a/include/phasar/Pointer/UnionFindAA.h b/include/phasar/Pointer/UnionFindAA.h
index d05ce439f5..861a8ee465 100644
--- a/include/phasar/Pointer/UnionFindAA.h
+++ b/include/phasar/Pointer/UnionFindAA.h
@@ -176,6 +176,13 @@ struct BasicUnionFindAAResult : UnionFindAAResultBase {
     if (Var1 == Var2) {
       return true;
     }
+
+    if (!Var2Rep.inbounds(Var1) || !Var2Rep.inbounds(Var2)) {
+      llvm::errs()
+          << "ERROR: !Var2Rep.inbounds(Var1) || !Var2Rep.inbounds(Var2)\n";
+      return false;
+    }
+
     auto Rep1 = Var2Rep[Var1];
     auto Rep2 = Var2Rep[Var2];
     return Rep1 == Rep2;
@@ -206,6 +213,11 @@ struct CallingContextSensUnionFindAAResult : UnionFindAAResultBase {
     }
 
     // Note: K is mostly small (1 or 2), so below loop should be very cheap
+    if (!Var2Rep.inbounds(Var1) || !Var2Rep.inbounds(Var2)) {
+      llvm::errs()
+          << "ERROR: !Var2Rep.inbounds(Var1) || !Var2Rep.inbounds(Var2)\n";
+      return false;
+    }
     const auto &Reps1 = Var2Rep[Var1];
     const auto &Reps2 = Var2Rep[Var2];
     for (ObjectRepId R1 : Reps1) {
diff --git a/include/phasar/Utils/AliasQueryType.h b/include/phasar/Utils/AliasQueryType.h
new file mode 100755
index 0000000000..44fd2ae700
--- /dev/null
+++ b/include/phasar/Utils/AliasQueryType.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Compiler.h"
+
+#include <optional>
+
+namespace psr {
+enum class AliasQueryType {
+#define ALIAS_QUERY_TYPE(NAME) NAME,
+#include "AliasQueryType.inc"
+};
+
+[[nodiscard]] llvm::StringRef to_string(AliasQueryType QueryType) noexcept;
+[[nodiscard]] std::optional<AliasQueryType>
+parseAliasQueryType(llvm::StringRef Str) noexcept;
+
+enum class AliasResult;
+
+[[nodiscard]] AliasResult getExpectedAliasResult(AliasQueryType QT) noexcept;
+
+} // namespace psr
diff --git a/include/phasar/Utils/AliasQueryType.inc b/include/phasar/Utils/AliasQueryType.inc
new file mode 100755
index 0000000000..755ace23c4
--- /dev/null
+++ b/include/phasar/Utils/AliasQueryType.inc
@@ -0,0 +1,13 @@
+#ifndef ALIAS_QUERY_TYPE
+#error "You have to #define ALIAS_QUERY_TYPE(NAME) before including AliasQueryType.inc"
+#endif
+
+ALIAS_QUERY_TYPE(MAYALIAS)
+ALIAS_QUERY_TYPE(MUSTALIAS)
+ALIAS_QUERY_TYPE(NOALIAS)
+ALIAS_QUERY_TYPE(PARTIALALIAS)
+ALIAS_QUERY_TYPE(EXPECTEDFAILMAYALIAS)
+ALIAS_QUERY_TYPE(EXPECTEDFAILMUSTALIAS)
+ALIAS_QUERY_TYPE(EXPECTEDFAILNOALIAS)
+
+#undef ALIAS_QUERY_TYPE
diff --git a/include/phasar/Utils/FileUtils.hpp b/include/phasar/Utils/FileUtils.hpp
new file mode 100755
index 0000000000..7fdc6b5da2
--- /dev/null
+++ b/include/phasar/Utils/FileUtils.hpp
@@ -0,0 +1,11 @@
+#pragma once
+
+#include "llvm/ADT/Twine.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include <memory>
+
+namespace psr {
+std::unique_ptr<llvm::raw_ostream>
+openFileForWrite(const llvm::Twine &FilePath);
+} // namespace psr
diff --git a/include/phasar/Utils/PTAResult.hpp b/include/phasar/Utils/PTAResult.hpp
new file mode 100755
index 0000000000..68113a0165
--- /dev/null
+++ b/include/phasar/Utils/PTAResult.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "phasar/Pointer/AliasResult.h"
+
+#include "llvm/Support/raw_ostream.h"
+
+#include "QueryId.hpp"
+
+namespace psr {
+
+struct PTAResult {
+  QueryId Query{};
+  AliasResult Result{};
+};
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, PTAResult Res);
+
+} // namespace psr
diff --git a/include/phasar/Utils/PTAUtils.hpp b/include/phasar/Utils/PTAUtils.hpp
new file mode 100755
index 0000000000..e8a765625e
--- /dev/null
+++ b/include/phasar/Utils/PTAUtils.hpp
@@ -0,0 +1,79 @@
+#pragma once
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Twine.h"
+#include "llvm/Support/FileSystem.h"
+
+#include "QueryLocation.hpp"
+
+#include <functional>
+#include <type_traits>
+
+namespace llvm {
+class Module;
+class Value;
+class Instruction;
+class raw_ostream;
+} // namespace llvm
+
+namespace psr {
+enum class AliasQueryType;
+enum class AliasResult;
+
+struct QueryResult : QueryLocation {
+  AliasResult Result{};
+};
+
+struct QuerySrcCodeLocation {
+  std::string FileName{};
+  size_t QueryIndex{};
+};
+
+[[nodiscard]] bool isSoundResult(const QueryResult &QR) noexcept;
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const QueryResult &Result);
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+                              const QueryLocation &Result);
+
+void findAllQueryLocations(
+    const llvm::Module &Mod, llvm::SmallVectorImpl<QueryLocation> &Locs,
+    llvm::SmallVectorImpl<QuerySrcCodeLocation> *SrcLocs = nullptr);
+
+[[nodiscard]] bool verifyAnalysisResult(AliasResult Res,
+                                        const QueryLocation &QueryLoc);
+
+template <typename CheckFn>
+std::enable_if_t<std::is_invocable_r_v<bool, CheckFn, llvm::StringRef>>
+checkDir(const llvm::Twine &DirName,
+         llvm::SmallVectorImpl<std::string> &Failures, CheckFn Check) {
+  std::error_code EC;
+  llvm::sys::fs::recursive_directory_iterator It(DirName, EC, false);
+  llvm::sys::fs::recursive_directory_iterator End;
+
+  size_t NumTests = 0;
+
+  static constexpr auto IsLLVMIRFile = [](llvm::StringRef Path) {
+    return Path.endswith(".ll") || Path.endswith(".bc");
+  };
+
+  for (; It != End && !EC; It.increment(EC)) {
+    auto Ty = It->type();
+    llvm::StringRef Path = It->path();
+    if (Ty == llvm::sys::fs::file_type::regular_file && IsLLVMIRFile(Path)) {
+      ++NumTests;
+
+      if (!std::invoke(Check, Path)) {
+        Failures.push_back(Path.str());
+      }
+    }
+  }
+
+  llvm::outs() << "Analyzed " << NumTests << " Benchmark files\n";
+
+  if (EC) {
+    llvm::errs() << "[ERROR]: " << EC.message() << '\n';
+  }
+}
+} // namespace psr
diff --git a/include/phasar/Utils/QueryId.hpp b/include/phasar/Utils/QueryId.hpp
new file mode 100755
index 0000000000..2452e5eda2
--- /dev/null
+++ b/include/phasar/Utils/QueryId.hpp
@@ -0,0 +1,8 @@
+#pragma once
+
+#include <cstdint>
+
+namespace psr {
+enum class [[clang::enum_extensibility(open)]] QueryId : uint64_t {};
+
+} // namespace psr
diff --git a/include/phasar/Utils/QueryLocation.hpp b/include/phasar/Utils/QueryLocation.hpp
new file mode 100755
index 0000000000..814ccf4d4a
--- /dev/null
+++ b/include/phasar/Utils/QueryLocation.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <cstdint>
+
+namespace llvm {
+class Instruction;
+} // namespace llvm
+
+namespace psr {
+enum class QueryId : uint64_t;
+enum class AliasQueryType;
+
+struct QueryLocation {
+  QueryId Id{};
+  const llvm::Instruction *Inst{};
+  AliasQueryType QueryType{};
+};
+} // namespace psr
diff --git a/include/phasar/Utils/QuerySer.hpp b/include/phasar/Utils/QuerySer.hpp
new file mode 100755
index 0000000000..7cddf49f96
--- /dev/null
+++ b/include/phasar/Utils/QuerySer.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "llvm/Support/raw_ostream.h"
+
+namespace psr {
+struct QueryLocation;
+struct QuerySrcCodeLocation;
+class QuerySerializer {
+public:
+  explicit QuerySerializer(llvm::raw_ostream *OS);
+
+  void handleQuery(const QueryLocation &QueryLoc,
+                   const QuerySrcCodeLocation &QuerySrcLoc);
+
+private:
+  llvm::raw_ostream *OS{};
+};
+} // namespace psr
diff --git a/include/phasar/Utils/ResultsCollector.hpp b/include/phasar/Utils/ResultsCollector.hpp
new file mode 100755
index 0000000000..216f5a247d
--- /dev/null
+++ b/include/phasar/Utils/ResultsCollector.hpp
@@ -0,0 +1,17 @@
+#pragma once
+
+#include "phasar/Utils/PTAResult.hpp"
+
+#include "llvm/Support/raw_ostream.h"
+
+namespace psr {
+class ResultCollector {
+public:
+  explicit ResultCollector(llvm::raw_ostream *OS, llvm::StringRef ResultName);
+
+  void handleResult(PTAResult Result);
+
+private:
+  llvm::raw_ostream *OS{};
+};
+}; // namespace psr
diff --git a/lib/Pointer/AliasResult.cpp b/lib/Pointer/AliasResult.cpp
index c0e7851314..2c589bf513 100644
--- a/lib/Pointer/AliasResult.cpp
+++ b/lib/Pointer/AliasResult.cpp
@@ -35,3 +35,16 @@ psr::AliasResult psr::toAliasResult(llvm::StringRef S) {
 llvm::raw_ostream &psr::operator<<(llvm::raw_ostream &OS, AliasResult AR) {
   return OS << toString(AR);
 }
+
+llvm::StringRef psr::to_string(AliasResult Res) noexcept {
+  switch (Res) {
+  case AliasResult::NoAlias:
+    return "NoAlias";
+  case AliasResult::MustAlias:
+    return "MustAlias";
+  case AliasResult::MayAlias:
+    return "MayAlias";
+  }
+  llvm_unreachable(
+      "All AliasResult kinds should be handled by the switch above");
+}
diff --git a/lib/Utils/AliasQueryType.cpp b/lib/Utils/AliasQueryType.cpp
new file mode 100755
index 0000000000..0c934e4f49
--- /dev/null
+++ b/lib/Utils/AliasQueryType.cpp
@@ -0,0 +1,84 @@
+#include "phasar/Utils/AliasQueryType.h"
+
+#include "phasar/Pointer/AliasResult.h"
+
+#include "llvm/Support/ErrorHandling.h"
+
+#include <array>
+
+#include <llvm/ADT/StringRef.h>
+
+llvm::StringRef psr::to_string(AliasQueryType QueryType) noexcept {
+  switch (QueryType) {
+#define ALIAS_QUERY_TYPE(NAME)                                                 \
+  case AliasQueryType::NAME:                                                   \
+    return #NAME;
+#include "phasar/Utils/AliasQueryType.inc"
+  }
+  llvm_unreachable(
+      "All AliasQueryType variants should be handled in the switch above");
+}
+
+static constexpr size_t NumQueryTypes = 0
+#define ALIAS_QUERY_TYPE(NAME) +1
+#include "phasar/Utils/AliasQueryType.inc"
+    ;
+
+struct NamedQuery {
+  llvm::StringRef Name{};
+  psr::AliasQueryType QueryType{};
+};
+
+static constexpr std::array<NamedQuery, NumQueryTypes>
+getSortedQueryTypes() noexcept {
+  using namespace psr;
+  std::array<NamedQuery, NumQueryTypes> AllQueries = {{
+#define ALIAS_QUERY_TYPE(NAME) {#NAME, AliasQueryType::NAME},
+#include "phasar/Utils/AliasQueryType.inc"
+  }};
+
+  // std::sort is not constexpr
+  for (size_t I = 0; I < AllQueries.size(); ++I) {
+    auto Max = I;
+    for (size_t J = I + 1; J < AllQueries.size(); ++J) {
+      if (AllQueries[J].Name.size() > AllQueries[Max].Name.size())
+        Max = J;
+    }
+    auto Tmp = AllQueries[I];
+    AllQueries[I] = AllQueries[Max];
+    AllQueries[Max] = Tmp;
+  }
+
+  return AllQueries;
+}
+
+auto psr::parseAliasQueryType(llvm::StringRef Str) noexcept
+    -> std::optional<AliasQueryType> {
+  static constexpr auto AllQueries = getSortedQueryTypes();
+
+  for (const auto &NQ : AllQueries) {
+    if (Str.contains(NQ.Name)) {
+      return NQ.QueryType;
+    }
+  }
+
+  return std::nullopt;
+}
+
+auto psr::getExpectedAliasResult(AliasQueryType QT) noexcept -> AliasResult {
+  switch (QT) {
+  case AliasQueryType::MAYALIAS:
+  case AliasQueryType::EXPECTEDFAILMAYALIAS:
+  case AliasQueryType::PARTIALALIAS:
+    return AliasResult::MayAlias;
+  case AliasQueryType::MUSTALIAS:
+  case AliasQueryType::EXPECTEDFAILMUSTALIAS:
+    return AliasResult::MustAlias;
+  case AliasQueryType::NOALIAS:
+  case AliasQueryType::EXPECTEDFAILNOALIAS:
+    return AliasResult::NoAlias;
+  }
+
+  llvm_unreachable(
+      "All alias query types should be handled in the switch above");
+}
diff --git a/lib/Utils/FileUtils.cpp b/lib/Utils/FileUtils.cpp
new file mode 100755
index 0000000000..ceccc5a36c
--- /dev/null
+++ b/lib/Utils/FileUtils.cpp
@@ -0,0 +1,25 @@
+#include "phasar/Utils/FileUtils.hpp"
+
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/Twine.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include <memory>
+#include <system_error>
+
+std::unique_ptr<llvm::raw_ostream>
+psr::openFileForWrite(const llvm::Twine &FilePath) {
+  llvm::SmallString<256> Buf;
+  auto FileName = FilePath.toStringRef(Buf);
+
+  std::error_code EC;
+  auto Ret = std::make_unique<llvm::raw_fd_ostream>(FileName, EC);
+  if (EC) {
+    llvm::errs() << "[ERROR]: Failed to open file '" << FileName
+                 << "' for writing:\n";
+    llvm::errs() << "  > " << EC.message() << '\n';
+    Ret.reset();
+  }
+
+  return Ret;
+}
diff --git a/lib/Utils/PTAUtils.cpp b/lib/Utils/PTAUtils.cpp
new file mode 100755
index 0000000000..40dc5e9659
--- /dev/null
+++ b/lib/Utils/PTAUtils.cpp
@@ -0,0 +1,117 @@
+#include "phasar/Utils/PTAUtils.hpp"
+
+#include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
+#include "phasar/Pointer/AliasResult.h"
+#include "phasar/Utils/AliasQueryType.h"
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/IR/InstIterator.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/SHA256.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include <cstdint>
+
+bool psr::isSoundResult(const QueryResult &QR) noexcept {
+  auto Res = QR.Result;
+  auto ExpectedRes = getExpectedAliasResult(QR.QueryType);
+
+  return Res == ExpectedRes || Res == AliasResult::MayAlias;
+}
+
+llvm::raw_ostream &psr::operator<<(llvm::raw_ostream &OS,
+                                   const QueryResult &Result) {
+  OS << "Query at " << psr::llvmIRToString(Result.Inst) << " expected "
+     << to_string(Result.QueryType) << ", but got " << to_string(Result.Result);
+  return OS;
+}
+
+llvm::raw_ostream &psr::operator<<(llvm::raw_ostream &OS,
+                                   const QueryLocation &Result) {
+  return OS << "Query at " << psr::llvmIRToString(Result.Inst);
+}
+
+static psr::QueryId getQueryId(llvm::StringRef FileName, uint32_t SeqNo) {
+  llvm::SHA256 Hasher;
+  Hasher.update(FileName);
+
+  {
+    std::array<uint8_t, 4> Buf{};
+    llvm::support::endian::write32(Buf.data(), SeqNo,
+                                   llvm::support::endianness::little);
+    Hasher.update(Buf);
+  }
+
+  auto Hash = Hasher.final();
+
+  auto QId = llvm::support::endian::read64(Hash.data(),
+                                           llvm::support::endianness::little);
+
+  return psr::QueryId(QId);
+}
+
+void psr::findAllQueryLocations(
+    const llvm::Module &Mod, llvm::SmallVectorImpl<QueryLocation> &Locs,
+    llvm::SmallVectorImpl<QuerySrcCodeLocation> *SrcLocs) {
+  const auto &FilePath = Mod.getSourceFileName();
+  auto FileName = llvm::sys::path::filename(FilePath);
+  uint32_t Ctr = 0;
+
+  for (const auto &Fun : Mod.functions()) {
+    for (const auto &Inst : llvm::instructions(Fun)) {
+      if (const auto *Call = llvm::dyn_cast<llvm::CallBase>(&Inst);
+          Call && Call->getCalledFunction()) {
+        if (auto QueryType =
+                parseAliasQueryType(Call->getCalledFunction()->getName())) {
+          auto QId = getQueryId(FileName, Ctr++);
+          Locs.push_back(QueryLocation{QId, Call, *QueryType});
+
+          if (SrcLocs) {
+            SrcLocs->push_back(QuerySrcCodeLocation{FilePath, Ctr});
+          }
+        }
+      }
+    }
+  }
+}
+
+bool psr::verifyAnalysisResult(AliasResult Res, const QueryLocation &QueryLoc) {
+  switch (QueryLoc.QueryType) {
+  case psr::AliasQueryType::EXPECTEDFAILMAYALIAS:
+    if (Res != psr::AliasResult::MayAlias)
+      llvm::outs() << "[INFO]: Failed EXPECTEDFAIL_MAYALIAS at" << QueryLoc
+                   << '\n';
+    return true;
+  case psr::AliasQueryType::PARTIALALIAS:
+    // We don't support partial alias. Use may alias instead.
+    [[fallthrough]];
+  case psr::AliasQueryType::MAYALIAS:
+    if (Res == psr::AliasResult::MayAlias)
+      return true;
+    break;
+
+  case psr::AliasQueryType::EXPECTEDFAILMUSTALIAS:
+    if (Res != psr::AliasResult::MustAlias)
+      llvm::outs() << "[INFO]: Failed EXPECTEDFAIL_MUSTALIAS at" << QueryLoc
+                   << '\n';
+    return true;
+  case psr::AliasQueryType::MUSTALIAS:
+    if (Res == psr::AliasResult::MustAlias)
+      return true;
+    break;
+
+  case psr::AliasQueryType::EXPECTEDFAILNOALIAS:
+    if (Res != psr::AliasResult::NoAlias)
+      llvm::outs() << "[INFO]: Failed EXPECTEDFAIL_NOALIAS at" << QueryLoc
+                   << '\n';
+    return true;
+  case psr::AliasQueryType::NOALIAS:
+    if (Res == psr::AliasResult::NoAlias)
+      return true;
+    break;
+  }
+
+  return false;
+}
diff --git a/lib/Utils/QuerySerializer.cpp b/lib/Utils/QuerySerializer.cpp
new file mode 100755
index 0000000000..92c9b94578
--- /dev/null
+++ b/lib/Utils/QuerySerializer.cpp
@@ -0,0 +1,16 @@
+#include "phasar/Utils/AliasQueryType.h"
+#include "phasar/Utils/PTAUtils.hpp"
+#include "phasar/Utils/QuerySer.hpp"
+
+using namespace psr;
+
+QuerySerializer::QuerySerializer(llvm::raw_ostream *OS) : OS(OS) {
+  assert(OS != nullptr);
+  *OS << "Query, QueryType, FileName, Index\n";
+}
+
+void QuerySerializer::handleQuery(const QueryLocation &QueryLoc,
+                                  const QuerySrcCodeLocation &QuerySrcLoc) {
+  *OS << uint64_t(QueryLoc.Id) << ", " << to_string(QueryLoc.QueryType) << ", "
+      << QuerySrcLoc.FileName << ", " << QuerySrcLoc.QueryIndex << '\n';
+}
diff --git a/lib/Utils/ResultCollector.cpp b/lib/Utils/ResultCollector.cpp
new file mode 100755
index 0000000000..e6cb50b69e
--- /dev/null
+++ b/lib/Utils/ResultCollector.cpp
@@ -0,0 +1,12 @@
+#include "phasar/Utils/ResultsCollector.hpp"
+
+using namespace psr;
+
+ResultCollector::ResultCollector(llvm::raw_ostream *OS,
+                                 llvm::StringRef ResultName)
+    : OS(OS) {
+  assert(OS != nullptr);
+  *OS << "Query, " << ResultName << '\n';
+}
+
+void ResultCollector::handleResult(PTAResult Result) { *OS << Result << '\n'; }
diff --git a/tools/svftestingtool/svftestingtool.cpp b/tools/svftestingtool/svftestingtool.cpp
new file mode 100644
index 0000000000..e293355fa2
--- /dev/null
+++ b/tools/svftestingtool/svftestingtool.cpp
@@ -0,0 +1,267 @@
+#include "phasar/ControlFlow/CallGraphAnalysisType.h"
+#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraph.h"
+#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraphBuilder.h"
+#include "phasar/PhasarLLVM/ControlFlow/LLVMVFTableProvider.h"
+#include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
+#include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
+#include "phasar/Pointer/AliasAnalysisType.h"
+#include "phasar/Pointer/AliasResult.h"
+#include "phasar/Pointer/BottomupUnionFindAA.h"
+#include "phasar/Pointer/RawAliasSet.h"
+#include "phasar/Pointer/UnionFindAA.h"
+#include "phasar/Utils/FileUtils.hpp"
+#include "phasar/Utils/Macros.h"
+#include "phasar/Utils/MapUtils.h"
+#include "phasar/Utils/MaybeUniquePtr.h"
+#include "phasar/Utils/NonNullPtr.h"
+#include "phasar/Utils/PTAUtils.hpp"
+#include "phasar/Utils/QuerySer.hpp"
+#include "phasar/Utils/ResultsCollector.hpp"
+#include "phasar/Utils/Utilities.h"
+#include "phasar/Utils/ValueCompressor.h"
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Analysis/AliasAnalysis.h"
+#include "llvm/Analysis/BasicAliasAnalysis.h"
+#include "llvm/Analysis/ScopedNoAliasAA.h"
+#include "llvm/Analysis/TypeBasedAliasAnalysis.h"
+#include "llvm/IR/Instruction.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include <cstdint>
+#include <iostream>
+#include <string>
+
+namespace cl = llvm::cl;
+
+static cl::opt<std::string> IRPath(cl::Positional, cl::Required,
+                                   cl::desc("ptaben-ir-directory"));
+static cl::opt<std::string>
+    QueryTablePath("queries-table",
+                   cl::desc("The Output-Path to the queries table"),
+                   cl::init("queries.csv"));
+static cl::opt<std::string>
+    AndersTablePath("anders-table",
+                    cl::desc("The Output-Path to the anders output table"),
+                    cl::init("anders-results.csv"));
+static cl::opt<std::string>
+    SteensTablePath("steens-table",
+                    cl::desc("The Output-Path to the steens output table"),
+                    cl::init("steens-results.csv"));
+static cl::opt<std::string>
+    CtxTablePath("ctx-table",
+                 cl::desc("The Output-Path to the ctx output table"),
+                 cl::init("ctx-results.csv"));
+static cl::opt<std::string>
+    BotTablePath("bot-table",
+                 cl::desc("The Output-Path to the bot output table"),
+                 cl::init("bot-results.csv"));
+static cl::opt<std::string>
+    IndTablePath("ind-table",
+                 cl::desc("The Output-Path to the ind output table"),
+                 cl::init("ind-results.csv"));
+
+constexpr auto CtxAABuilder = [](const auto &IRDB, const auto &CG) {
+  return psr::CallingContextSensUnionFindAA<psr::LLVMPAGDomain>{
+      &CG,
+      &IRDB,
+  };
+};
+
+constexpr auto IndAABuilder = [](const auto & /*IRDB*/, const auto &CG) {
+  auto Ret = psr::pag::PBMixin{
+      psr::IndirectionSensUnionFindAA<psr::LLVMPAGDomain>{},
+      psr::pag::LLVMCGProvider{&CG},
+  };
+
+  static_assert(psr::pag::PBStrategy<decltype(Ret)>);
+  return Ret;
+};
+
+constexpr auto BotAABuilder = [](const auto &IRDB, const auto &CG) {
+  auto Ret = psr::BottomupUnionFindAA<psr::LLVMPAGDomain>{
+      psr::ReverseCGGraph{
+          &CG,
+          &IRDB,
+      },
+  };
+
+  static_assert(psr::pag::PBStrategy<decltype(Ret)>);
+  return Ret;
+};
+
+static psr::AliasResult mapAliasResult(psr::AliasResult Res) {
+  switch (Res) {
+  case psr::AliasResult::NoAlias:
+    return psr::AliasResult::NoAlias;
+
+  case psr::AliasResult::PartialAlias:
+  case psr::AliasResult::MayAlias:
+  case psr::AliasResult::MustAlias:
+    return psr::AliasResult::MayAlias;
+  }
+  llvm_unreachable(
+      "All AliasResult kinds should be handled in the switch above!");
+}
+
+static psr::AliasResult
+checkLLVMQueryLoc(psr::LLVMAliasInfoRef ComputeAliasResult,
+                  const llvm::Instruction *QueryInst) {
+  const auto *Ptr1 = QueryInst->getOperand(0);
+  const auto *Ptr2 = QueryInst->getOperand(1);
+
+  return mapAliasResult(ComputeAliasResult.alias(Ptr1, Ptr2, QueryInst));
+}
+
+static void performAndersAnalysis(psr::LLVMProjectIRDB &IRDB,
+                                  llvm::ArrayRef<psr::QueryLocation> QueryLocs,
+                                  psr::ResultCollector &RC) {
+  psr::LLVMAliasSet AliasSet(&IRDB, false, psr::AliasAnalysisType::CFLAnders);
+
+  for (const auto &Loc : QueryLocs) {
+    auto Res = checkLLVMQueryLoc(&AliasSet, Loc.Inst);
+    RC.handleResult(psr::PTAResult{.Query = Loc.Id, .Result = Res});
+  }
+}
+
+static void performSteensAnalysis(psr::LLVMProjectIRDB &IRDB,
+                                  llvm::ArrayRef<psr::QueryLocation> QueryLocs,
+                                  psr::ResultCollector &RC) {
+  psr::LLVMAliasSet AliasSet(&IRDB, false, psr::AliasAnalysisType::CFLSteens);
+
+  for (const auto &Loc : QueryLocs) {
+    auto Res = checkLLVMQueryLoc(&AliasSet, Loc.Inst);
+    RC.handleResult(psr::PTAResult{.Query = Loc.Id, .Result = Res});
+  }
+}
+
+static void performCtxAnalysis(psr::LLVMProjectIRDB &IRDB,
+                               llvm::ArrayRef<psr::QueryLocation> QueryLocs,
+                               psr::ResultCollector &RC) {
+  psr::LLVMUnionFindAliasSet AliasSet(
+      &IRDB,
+      psr::LLVMUnionFindAliasSet::Config{
+          .AType = psr::UnionFindAliasAnalysisType::CtxSens,
+          .ALocality = psr::LLVMUnionFindAliasSet::AnalysisLocality::Global,
+      });
+
+  for (const auto &Loc : QueryLocs) {
+    auto Res = checkLLVMQueryLoc(&AliasSet, Loc.Inst);
+    RC.handleResult(psr::PTAResult{.Query = Loc.Id, .Result = Res});
+  }
+}
+
+static void performBotAnalysis(psr::LLVMProjectIRDB &IRDB,
+                               llvm::ArrayRef<psr::QueryLocation> QueryLocs,
+                               psr::ResultCollector &RC) {
+  psr::LLVMUnionFindAliasSet AliasSet(
+      &IRDB,
+      psr::LLVMUnionFindAliasSet::Config{
+          .AType = psr::UnionFindAliasAnalysisType::BotCtxSens,
+          .ALocality = psr::LLVMUnionFindAliasSet::AnalysisLocality::Global,
+      });
+
+  for (const auto &Loc : QueryLocs) {
+    auto Res = checkLLVMQueryLoc(&AliasSet, Loc.Inst);
+    RC.handleResult(psr::PTAResult{.Query = Loc.Id, .Result = Res});
+  }
+}
+
+static void performIndAnalysis(psr::LLVMProjectIRDB &IRDB,
+                               llvm::ArrayRef<psr::QueryLocation> QueryLocs,
+                               psr::ResultCollector &RC) {
+  psr::LLVMUnionFindAliasSet AliasSet(
+      &IRDB,
+      psr::LLVMUnionFindAliasSet::Config{
+          .AType = psr::UnionFindAliasAnalysisType::IndSens,
+          .ALocality = psr::LLVMUnionFindAliasSet::AnalysisLocality::Global,
+      });
+
+  for (const auto &Loc : QueryLocs) {
+    auto Res = checkLLVMQueryLoc(&AliasSet, Loc.Inst);
+    RC.handleResult(psr::PTAResult{.Query = Loc.Id, .Result = Res});
+  }
+}
+
+int main(int Argc, char *Argv[]) {
+  cl::ParseCommandLineOptions(Argc, Argv);
+
+  auto QFile = psr::openFileForWrite(QueryTablePath);
+  if (!QFile) {
+    return 1;
+  }
+
+  auto AndersFile = psr::openFileForWrite(AndersTablePath);
+  if (!AndersFile) {
+    return 1;
+  }
+
+  auto SteensFile = psr::openFileForWrite(SteensTablePath);
+  if (!SteensFile) {
+    return 1;
+  }
+
+  auto CtxFile = psr::openFileForWrite(CtxTablePath);
+  if (!CtxFile) {
+    return 1;
+  }
+
+  auto BotFile = psr::openFileForWrite(BotTablePath);
+  if (!BotFile) {
+    return 1;
+  }
+
+  auto IndFile = psr::openFileForWrite(IndTablePath);
+  if (!IndFile) {
+    return 1;
+  }
+
+  psr::QuerySerializer QSer(QFile.get());
+  psr::ResultCollector AndersSer(AndersFile.get(), "AndersResult");
+  psr::ResultCollector SteensSer(SteensFile.get(), "SteensResult");
+  psr::ResultCollector CtxSer(CtxFile.get(), "CtxResult");
+  psr::ResultCollector BotSer(BotFile.get(), "BotResult");
+  psr::ResultCollector IndSer(IndFile.get(), "IndResult");
+
+  llvm::SmallVector<std::string, 4> Failures;
+  psr::checkDir(IRPath, Failures, [&](llvm::StringRef FileName) {
+    llvm::errs() << "Analyzing " << FileName << '\n';
+
+    psr::LLVMProjectIRDB IRDB(FileName);
+    auto *Mod = IRDB.getModule();
+    if (!Mod) {
+      return false;
+    }
+
+    llvm::SmallVector<psr::QueryLocation, 4> QueryLocs;
+    llvm::SmallVector<psr::QuerySrcCodeLocation> QuerySrcLocs;
+    psr::findAllQueryLocations(*Mod, QueryLocs, &QuerySrcLocs);
+
+    if (QueryLocs.empty()) {
+      llvm::errs()
+          << "[NOTE]: File does not contain any alias queries. Skip it.\n";
+      return true;
+    }
+
+    for (const auto &[QLoc, QSrcLoc] : llvm::zip(QueryLocs, QuerySrcLocs)) {
+      QSer.handleQuery(QLoc, QSrcLoc);
+    }
+
+    performAndersAnalysis(IRDB, QueryLocs, AndersSer);
+    performSteensAnalysis(IRDB, QueryLocs, SteensSer);
+    performCtxAnalysis(IRDB, QueryLocs, CtxSer);
+    performBotAnalysis(IRDB, QueryLocs, BotSer);
+    performIndAnalysis(IRDB, QueryLocs, IndSer);
+
+    return true;
+  });
+}

From f9b39ce43726acbc1da90f37557d1877600da0ed Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Tue, 17 Mar 2026 15:54:47 +0100
Subject: [PATCH 58/75] Fix LLVMUnionFindAliasSet dependency to
 phasar_llvm_controlflow

---
 .../Pointer/LLVMUnionFindAliasSet.h           |  14 +-
 lib/PhasarLLVM/HelperAnalyses.cpp             |  10 +-
 .../Pointer/LLVMUnionFindAliasSet.cpp         |  11 +-
 .../Utils => tools/ptaben}/AliasQueryType.cpp |  21 +-
 .../Utils => tools/ptaben}/AliasQueryType.h   |   9 +-
 .../Utils => tools/ptaben}/AliasQueryType.inc |   0
 tools/ptaben/PTAResult.cpp                    |   6 +
 .../PTAResult.hpp => tools/ptaben/PTAResult.h |   6 +-
 {lib/Utils => tools/ptaben}/PTAUtils.cpp      |  59 ++--
 .../PTAUtils.hpp => tools/ptaben/PTAUtils.h   |  11 +-
 .../QueryId.hpp => tools/ptaben/QueryId.h     |   4 +-
 .../ptaben/QueryLocation.h                    |   9 +-
 .../QuerySer.hpp => tools/ptaben/QuerySer.h   |  10 +-
 .../ptaben}/QuerySerializer.cpp               |   8 +-
 .../ptaben}/ResultCollector.cpp               |   4 +-
 .../ptaben/ResultsCollector.h                 |   8 +-
 tools/ptaben/ptaben_benchmark_tool.cpp        | 181 ++++++++++++
 tools/svftestingtool/svftestingtool.cpp       | 267 ------------------
 18 files changed, 287 insertions(+), 351 deletions(-)
 rename {lib/Utils => tools/ptaben}/AliasQueryType.cpp (78%)
 rename {include/phasar/Utils => tools/ptaben}/AliasQueryType.h (81%)
 rename {include/phasar/Utils => tools/ptaben}/AliasQueryType.inc (100%)
 create mode 100644 tools/ptaben/PTAResult.cpp
 rename include/phasar/Utils/PTAResult.hpp => tools/ptaben/PTAResult.h (76%)
 rename {lib/Utils => tools/ptaben}/PTAUtils.cpp (68%)
 rename include/phasar/Utils/PTAUtils.hpp => tools/ptaben/PTAUtils.h (94%)
 rename include/phasar/Utils/QueryId.hpp => tools/ptaben/QueryId.h (67%)
 rename include/phasar/Utils/QueryLocation.hpp => tools/ptaben/QueryLocation.h (61%)
 rename include/phasar/Utils/QuerySer.hpp => tools/ptaben/QuerySer.h (73%)
 rename {lib/Utils => tools/ptaben}/QuerySerializer.cpp (76%)
 rename {lib/Utils => tools/ptaben}/ResultCollector.cpp (81%)
 rename include/phasar/Utils/ResultsCollector.hpp => tools/ptaben/ResultsCollector.h (76%)
 create mode 100644 tools/ptaben/ptaben_benchmark_tool.cpp
 delete mode 100644 tools/svftestingtool/svftestingtool.cpp

diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h
index e454b0aa7d..9cc84386be 100644
--- a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraph.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMPointsToUtils.h"
@@ -52,12 +53,15 @@ class LLVMUnionFindAliasSet
     AnalysisLocality ALocality = AnalysisLocality::Global;
   };
 
-  explicit LLVMUnionFindAliasSet(const LLVMProjectIRDB *IRDB, Config Cfg,
+  explicit LLVMUnionFindAliasSet(const LLVMProjectIRDB *IRDB,
+                                 const LLVMBasedCallGraph &BaseCG, Config Cfg,
                                  ValueCompressor<PAGVariable> *VC);
-  explicit LLVMUnionFindAliasSet(const LLVMProjectIRDB *IRDB, Config Cfg)
-      : LLVMUnionFindAliasSet(IRDB, Cfg, nullptr) {}
-  explicit LLVMUnionFindAliasSet(const LLVMProjectIRDB *IRDB)
-      : LLVMUnionFindAliasSet(IRDB, Config{}, nullptr) {}
+  explicit LLVMUnionFindAliasSet(const LLVMProjectIRDB *IRDB,
+                                 const LLVMBasedCallGraph &BaseCG, Config Cfg)
+      : LLVMUnionFindAliasSet(IRDB, BaseCG, Cfg, nullptr) {}
+  explicit LLVMUnionFindAliasSet(const LLVMProjectIRDB *IRDB,
+                                 const LLVMBasedCallGraph &BaseCG)
+      : LLVMUnionFindAliasSet(IRDB, BaseCG, Config{}, nullptr) {}
 
   [[nodiscard]] constexpr std::true_type isInterProcedural() const noexcept {
     return {};
diff --git a/lib/PhasarLLVM/HelperAnalyses.cpp b/lib/PhasarLLVM/HelperAnalyses.cpp
index 3946ef5a5d..6897c6980e 100644
--- a/lib/PhasarLLVM/HelperAnalyses.cpp
+++ b/lib/PhasarLLVM/HelperAnalyses.cpp
@@ -1,6 +1,9 @@
 #include "phasar/PhasarLLVM/HelperAnalyses.h"
 
+#include "phasar/PhasarLLVM/ControlFlow/EntryFunctionUtils.h"
+#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraphBuilder.h"
 #include "phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h"
+#include "phasar/PhasarLLVM/ControlFlow/Resolver/RTAResolver.h"
 #include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasSetData.h"
@@ -75,8 +78,13 @@ LLVMAliasInfoRef HelperAnalyses::getAliasInfo() {
     if (PrecomputedPTS.has_value()) {
       PT = std::make_unique<LLVMAliasSet>(&getProjectIRDB(), *PrecomputedPTS);
     } else if (PTATy == AliasAnalysisType::UnionFind) {
+      auto &IRDB = getProjectIRDB();
+      auto VTP = LLVMVFTableProvider(IRDB);
+      auto Res = RTAResolver(&IRDB, &VTP, &getTypeHierarchy());
+      const auto BaseCG = buildLLVMBasedCallGraph(
+          IRDB, Res, getEntryFunctions(IRDB, EntryPoints));
       PT = std::make_unique<LLVMUnionFindAliasSet>(
-          &getProjectIRDB(),
+          &getProjectIRDB(), BaseCG,
           LLVMUnionFindAliasSet::Config{
               .AType = UFAATy,
               .ALocality = LLVMUnionFindAliasSet::AnalysisLocality::Global,
diff --git a/lib/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.cpp b/lib/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.cpp
index 6d21c2b6a4..1b7d6064fe 100644
--- a/lib/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.cpp
+++ b/lib/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.cpp
@@ -1,9 +1,7 @@
 #include "phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h"
 
 #include "phasar/PhasarLLVM/ControlFlow/EntryFunctionUtils.h"
-#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraphBuilder.h"
-#include "phasar/PhasarLLVM/ControlFlow/LLVMVFTableProvider.h"
-#include "phasar/PhasarLLVM/ControlFlow/Resolver/RTAResolver.h"
+#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraph.h"
 #include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h"
@@ -140,6 +138,7 @@ struct [[clang::internal_linkage]] LLVMUnionFindAliasSet::UnionFindAAResultModel
 };
 
 LLVMUnionFindAliasSet::LLVMUnionFindAliasSet(const LLVMProjectIRDB *IRDB,
+                                             const LLVMBasedCallGraph &BaseCG,
                                              Config Cfg,
                                              ValueCompressor<PAGVariable> *VC)
     : Cfg(Cfg) {
@@ -148,12 +147,6 @@ LLVMUnionFindAliasSet::LLVMUnionFindAliasSet(const LLVMProjectIRDB *IRDB,
     VCOwn = std::make_unique<ValueCompressor<PAGVariable>>();
   }
 
-  auto VTP = LLVMVFTableProvider(*IRDB);
-  auto TH = DIBasedTypeHierarchy(*IRDB);
-  auto Res = RTAResolver(IRDB, &VTP, &TH);
-  const auto BaseCG = buildLLVMBasedCallGraph(
-      *IRDB, Res, getEntryFunctions(*IRDB, getDefaultEntryPoints(*IRDB)));
-
   auto MakeAAResModel =
       [&, IRDB, Cfg, VCOwn = std::move(VCOwn)](
           auto AAResCtor) mutable -> std::unique_ptr<UnionFindAAResultConcept> {
diff --git a/lib/Utils/AliasQueryType.cpp b/tools/ptaben/AliasQueryType.cpp
similarity index 78%
rename from lib/Utils/AliasQueryType.cpp
rename to tools/ptaben/AliasQueryType.cpp
index 0c934e4f49..22fec3d15a 100755
--- a/lib/Utils/AliasQueryType.cpp
+++ b/tools/ptaben/AliasQueryType.cpp
@@ -1,19 +1,20 @@
-#include "phasar/Utils/AliasQueryType.h"
+#include "AliasQueryType.h"
 
 #include "phasar/Pointer/AliasResult.h"
 
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ErrorHandling.h"
 
 #include <array>
 
-#include <llvm/ADT/StringRef.h>
+using namespace psr;
 
-llvm::StringRef psr::to_string(AliasQueryType QueryType) noexcept {
+llvm::StringRef ptaben::to_string(AliasQueryType QueryType) noexcept {
   switch (QueryType) {
 #define ALIAS_QUERY_TYPE(NAME)                                                 \
   case AliasQueryType::NAME:                                                   \
     return #NAME;
-#include "phasar/Utils/AliasQueryType.inc"
+#include "AliasQueryType.inc"
   }
   llvm_unreachable(
       "All AliasQueryType variants should be handled in the switch above");
@@ -21,20 +22,20 @@ llvm::StringRef psr::to_string(AliasQueryType QueryType) noexcept {
 
 static constexpr size_t NumQueryTypes = 0
 #define ALIAS_QUERY_TYPE(NAME) +1
-#include "phasar/Utils/AliasQueryType.inc"
+#include "AliasQueryType.inc"
     ;
 
 struct NamedQuery {
   llvm::StringRef Name{};
-  psr::AliasQueryType QueryType{};
+  ptaben::AliasQueryType QueryType{};
 };
 
 static constexpr std::array<NamedQuery, NumQueryTypes>
 getSortedQueryTypes() noexcept {
   using namespace psr;
   std::array<NamedQuery, NumQueryTypes> AllQueries = {{
-#define ALIAS_QUERY_TYPE(NAME) {#NAME, AliasQueryType::NAME},
-#include "phasar/Utils/AliasQueryType.inc"
+#define ALIAS_QUERY_TYPE(NAME) {#NAME, ptaben::AliasQueryType::NAME},
+#include "AliasQueryType.inc"
   }};
 
   // std::sort is not constexpr
@@ -52,7 +53,7 @@ getSortedQueryTypes() noexcept {
   return AllQueries;
 }
 
-auto psr::parseAliasQueryType(llvm::StringRef Str) noexcept
+auto ptaben::parseAliasQueryType(llvm::StringRef Str) noexcept
     -> std::optional<AliasQueryType> {
   static constexpr auto AllQueries = getSortedQueryTypes();
 
@@ -65,7 +66,7 @@ auto psr::parseAliasQueryType(llvm::StringRef Str) noexcept
   return std::nullopt;
 }
 
-auto psr::getExpectedAliasResult(AliasQueryType QT) noexcept -> AliasResult {
+auto ptaben::getExpectedAliasResult(AliasQueryType QT) noexcept -> AliasResult {
   switch (QT) {
   case AliasQueryType::MAYALIAS:
   case AliasQueryType::EXPECTEDFAILMAYALIAS:
diff --git a/include/phasar/Utils/AliasQueryType.h b/tools/ptaben/AliasQueryType.h
similarity index 81%
rename from include/phasar/Utils/AliasQueryType.h
rename to tools/ptaben/AliasQueryType.h
index 44fd2ae700..a83e1f923c 100755
--- a/include/phasar/Utils/AliasQueryType.h
+++ b/tools/ptaben/AliasQueryType.h
@@ -1,11 +1,12 @@
 #pragma once
 
+#include "phasar/Pointer/AliasResult.h"
+
 #include "llvm/ADT/StringRef.h"
-#include "llvm/Support/Compiler.h"
 
 #include <optional>
 
-namespace psr {
+namespace psr::ptaben {
 enum class AliasQueryType {
 #define ALIAS_QUERY_TYPE(NAME) NAME,
 #include "AliasQueryType.inc"
@@ -15,8 +16,6 @@ enum class AliasQueryType {
 [[nodiscard]] std::optional<AliasQueryType>
 parseAliasQueryType(llvm::StringRef Str) noexcept;
 
-enum class AliasResult;
-
 [[nodiscard]] AliasResult getExpectedAliasResult(AliasQueryType QT) noexcept;
 
-} // namespace psr
+} // namespace psr::ptaben
diff --git a/include/phasar/Utils/AliasQueryType.inc b/tools/ptaben/AliasQueryType.inc
similarity index 100%
rename from include/phasar/Utils/AliasQueryType.inc
rename to tools/ptaben/AliasQueryType.inc
diff --git a/tools/ptaben/PTAResult.cpp b/tools/ptaben/PTAResult.cpp
new file mode 100644
index 0000000000..445410c776
--- /dev/null
+++ b/tools/ptaben/PTAResult.cpp
@@ -0,0 +1,6 @@
+#include "PTAResult.h"
+
+llvm::raw_ostream &psr::ptaben::operator<<(llvm::raw_ostream &OS,
+                                           PTAResult Res) {
+  return OS << uint64_t(Res.Query) << ", " << to_string(Res.Result);
+}
diff --git a/include/phasar/Utils/PTAResult.hpp b/tools/ptaben/PTAResult.h
similarity index 76%
rename from include/phasar/Utils/PTAResult.hpp
rename to tools/ptaben/PTAResult.h
index 68113a0165..6a22290fd1 100755
--- a/include/phasar/Utils/PTAResult.hpp
+++ b/tools/ptaben/PTAResult.h
@@ -4,9 +4,9 @@
 
 #include "llvm/Support/raw_ostream.h"
 
-#include "QueryId.hpp"
+#include "QueryId.h"
 
-namespace psr {
+namespace psr::ptaben {
 
 struct PTAResult {
   QueryId Query{};
@@ -15,4 +15,4 @@ struct PTAResult {
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, PTAResult Res);
 
-} // namespace psr
+} // namespace psr::ptaben
diff --git a/lib/Utils/PTAUtils.cpp b/tools/ptaben/PTAUtils.cpp
similarity index 68%
rename from lib/Utils/PTAUtils.cpp
rename to tools/ptaben/PTAUtils.cpp
index 40dc5e9659..e200fc2bce 100755
--- a/lib/Utils/PTAUtils.cpp
+++ b/tools/ptaben/PTAUtils.cpp
@@ -1,8 +1,7 @@
-#include "phasar/Utils/PTAUtils.hpp"
+#include "PTAUtils.h"
 
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
 #include "phasar/Pointer/AliasResult.h"
-#include "phasar/Utils/AliasQueryType.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/IR/InstIterator.h"
@@ -12,28 +11,32 @@
 #include "llvm/Support/SHA256.h"
 #include "llvm/Support/raw_ostream.h"
 
+#include "AliasQueryType.h"
+
 #include <cstdint>
 
-bool psr::isSoundResult(const QueryResult &QR) noexcept {
+using namespace psr;
+
+bool ptaben::isSoundResult(const QueryResult &QR) noexcept {
   auto Res = QR.Result;
   auto ExpectedRes = getExpectedAliasResult(QR.QueryType);
 
   return Res == ExpectedRes || Res == AliasResult::MayAlias;
 }
 
-llvm::raw_ostream &psr::operator<<(llvm::raw_ostream &OS,
-                                   const QueryResult &Result) {
+llvm::raw_ostream &ptaben::operator<<(llvm::raw_ostream &OS,
+                                      const QueryResult &Result) {
   OS << "Query at " << psr::llvmIRToString(Result.Inst) << " expected "
      << to_string(Result.QueryType) << ", but got " << to_string(Result.Result);
   return OS;
 }
 
-llvm::raw_ostream &psr::operator<<(llvm::raw_ostream &OS,
-                                   const QueryLocation &Result) {
+llvm::raw_ostream &ptaben::operator<<(llvm::raw_ostream &OS,
+                                      const QueryLocation &Result) {
   return OS << "Query at " << psr::llvmIRToString(Result.Inst);
 }
 
-static psr::QueryId getQueryId(llvm::StringRef FileName, uint32_t SeqNo) {
+static ptaben::QueryId getQueryId(llvm::StringRef FileName, uint32_t SeqNo) {
   llvm::SHA256 Hasher;
   Hasher.update(FileName);
 
@@ -49,10 +52,10 @@ static psr::QueryId getQueryId(llvm::StringRef FileName, uint32_t SeqNo) {
   auto QId = llvm::support::endian::read64(Hash.data(),
                                            llvm::support::endianness::little);
 
-  return psr::QueryId(QId);
+  return ptaben::QueryId(QId);
 }
 
-void psr::findAllQueryLocations(
+void ptaben::findAllQueryLocations(
     const llvm::Module &Mod, llvm::SmallVectorImpl<QueryLocation> &Locs,
     llvm::SmallVectorImpl<QuerySrcCodeLocation> *SrcLocs) {
   const auto &FilePath = Mod.getSourceFileName();
@@ -77,39 +80,47 @@ void psr::findAllQueryLocations(
   }
 }
 
-bool psr::verifyAnalysisResult(AliasResult Res, const QueryLocation &QueryLoc) {
+bool ptaben::verifyAnalysisResult(AliasResult Res,
+                                  const QueryLocation &QueryLoc) {
   switch (QueryLoc.QueryType) {
-  case psr::AliasQueryType::EXPECTEDFAILMAYALIAS:
-    if (Res != psr::AliasResult::MayAlias)
+    using enum ptaben::AliasQueryType;
+  case EXPECTEDFAILMAYALIAS:
+    if (Res != psr::AliasResult::MayAlias) {
       llvm::outs() << "[INFO]: Failed EXPECTEDFAIL_MAYALIAS at" << QueryLoc
                    << '\n';
+    }
     return true;
-  case psr::AliasQueryType::PARTIALALIAS:
+  case PARTIALALIAS:
     // We don't support partial alias. Use may alias instead.
     [[fallthrough]];
-  case psr::AliasQueryType::MAYALIAS:
-    if (Res == psr::AliasResult::MayAlias)
+  case MAYALIAS:
+    if (Res == psr::AliasResult::MayAlias) {
       return true;
+    }
     break;
 
-  case psr::AliasQueryType::EXPECTEDFAILMUSTALIAS:
-    if (Res != psr::AliasResult::MustAlias)
+  case EXPECTEDFAILMUSTALIAS:
+    if (Res != psr::AliasResult::MustAlias) {
       llvm::outs() << "[INFO]: Failed EXPECTEDFAIL_MUSTALIAS at" << QueryLoc
                    << '\n';
+    }
     return true;
-  case psr::AliasQueryType::MUSTALIAS:
-    if (Res == psr::AliasResult::MustAlias)
+  case MUSTALIAS:
+    if (Res == psr::AliasResult::MustAlias) {
       return true;
+    }
     break;
 
-  case psr::AliasQueryType::EXPECTEDFAILNOALIAS:
-    if (Res != psr::AliasResult::NoAlias)
+  case EXPECTEDFAILNOALIAS:
+    if (Res != psr::AliasResult::NoAlias) {
       llvm::outs() << "[INFO]: Failed EXPECTEDFAIL_NOALIAS at" << QueryLoc
                    << '\n';
+    }
     return true;
-  case psr::AliasQueryType::NOALIAS:
-    if (Res == psr::AliasResult::NoAlias)
+  case NOALIAS:
+    if (Res == psr::AliasResult::NoAlias) {
       return true;
+    }
     break;
   }
 
diff --git a/include/phasar/Utils/PTAUtils.hpp b/tools/ptaben/PTAUtils.h
similarity index 94%
rename from include/phasar/Utils/PTAUtils.hpp
rename to tools/ptaben/PTAUtils.h
index e8a765625e..f2b3093147 100755
--- a/include/phasar/Utils/PTAUtils.hpp
+++ b/tools/ptaben/PTAUtils.h
@@ -1,11 +1,13 @@
 #pragma once
 
+#include "phasar/Pointer/AliasResult.h"
+
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/FileSystem.h"
 
-#include "QueryLocation.hpp"
+#include "QueryLocation.h"
 
 #include <functional>
 #include <type_traits>
@@ -17,10 +19,7 @@ class Instruction;
 class raw_ostream;
 } // namespace llvm
 
-namespace psr {
-enum class AliasQueryType;
-enum class AliasResult;
-
+namespace psr::ptaben {
 struct QueryResult : QueryLocation {
   AliasResult Result{};
 };
@@ -76,4 +75,4 @@ checkDir(const llvm::Twine &DirName,
     llvm::errs() << "[ERROR]: " << EC.message() << '\n';
   }
 }
-} // namespace psr
+} // namespace psr::ptaben
diff --git a/include/phasar/Utils/QueryId.hpp b/tools/ptaben/QueryId.h
similarity index 67%
rename from include/phasar/Utils/QueryId.hpp
rename to tools/ptaben/QueryId.h
index 2452e5eda2..e9dde07c3b 100755
--- a/include/phasar/Utils/QueryId.hpp
+++ b/tools/ptaben/QueryId.h
@@ -2,7 +2,7 @@
 
 #include <cstdint>
 
-namespace psr {
+namespace psr::ptaben {
 enum class [[clang::enum_extensibility(open)]] QueryId : uint64_t {};
 
-} // namespace psr
+} // namespace psr::ptaben
diff --git a/include/phasar/Utils/QueryLocation.hpp b/tools/ptaben/QueryLocation.h
similarity index 61%
rename from include/phasar/Utils/QueryLocation.hpp
rename to tools/ptaben/QueryLocation.h
index 814ccf4d4a..4ea0b3f19f 100755
--- a/include/phasar/Utils/QueryLocation.hpp
+++ b/tools/ptaben/QueryLocation.h
@@ -1,18 +1,17 @@
 #pragma once
 
-#include <cstdint>
+#include "AliasQueryType.h"
+#include "QueryId.h"
 
 namespace llvm {
 class Instruction;
 } // namespace llvm
 
-namespace psr {
-enum class QueryId : uint64_t;
-enum class AliasQueryType;
+namespace psr::ptaben {
 
 struct QueryLocation {
   QueryId Id{};
   const llvm::Instruction *Inst{};
   AliasQueryType QueryType{};
 };
-} // namespace psr
+} // namespace psr::ptaben
diff --git a/include/phasar/Utils/QuerySer.hpp b/tools/ptaben/QuerySer.h
similarity index 73%
rename from include/phasar/Utils/QuerySer.hpp
rename to tools/ptaben/QuerySer.h
index 7cddf49f96..48931eed88 100755
--- a/include/phasar/Utils/QuerySer.hpp
+++ b/tools/ptaben/QuerySer.h
@@ -2,9 +2,11 @@
 
 #include "llvm/Support/raw_ostream.h"
 
-namespace psr {
-struct QueryLocation;
-struct QuerySrcCodeLocation;
+#include "PTAUtils.h"
+#include "QueryLocation.h"
+
+namespace psr::ptaben {
+
 class QuerySerializer {
 public:
   explicit QuerySerializer(llvm::raw_ostream *OS);
@@ -15,4 +17,4 @@ class QuerySerializer {
 private:
   llvm::raw_ostream *OS{};
 };
-} // namespace psr
+} // namespace psr::ptaben
diff --git a/lib/Utils/QuerySerializer.cpp b/tools/ptaben/QuerySerializer.cpp
similarity index 76%
rename from lib/Utils/QuerySerializer.cpp
rename to tools/ptaben/QuerySerializer.cpp
index 92c9b94578..32c19565c5 100755
--- a/lib/Utils/QuerySerializer.cpp
+++ b/tools/ptaben/QuerySerializer.cpp
@@ -1,8 +1,8 @@
-#include "phasar/Utils/AliasQueryType.h"
-#include "phasar/Utils/PTAUtils.hpp"
-#include "phasar/Utils/QuerySer.hpp"
+#include "AliasQueryType.h"
+#include "PTAUtils.h"
+#include "QuerySer.h"
 
-using namespace psr;
+using namespace psr::ptaben;
 
 QuerySerializer::QuerySerializer(llvm::raw_ostream *OS) : OS(OS) {
   assert(OS != nullptr);
diff --git a/lib/Utils/ResultCollector.cpp b/tools/ptaben/ResultCollector.cpp
similarity index 81%
rename from lib/Utils/ResultCollector.cpp
rename to tools/ptaben/ResultCollector.cpp
index e6cb50b69e..173276c93c 100755
--- a/lib/Utils/ResultCollector.cpp
+++ b/tools/ptaben/ResultCollector.cpp
@@ -1,6 +1,6 @@
-#include "phasar/Utils/ResultsCollector.hpp"
+#include "ResultsCollector.h"
 
-using namespace psr;
+using namespace psr::ptaben;
 
 ResultCollector::ResultCollector(llvm::raw_ostream *OS,
                                  llvm::StringRef ResultName)
diff --git a/include/phasar/Utils/ResultsCollector.hpp b/tools/ptaben/ResultsCollector.h
similarity index 76%
rename from include/phasar/Utils/ResultsCollector.hpp
rename to tools/ptaben/ResultsCollector.h
index 216f5a247d..3cb77e4787 100755
--- a/include/phasar/Utils/ResultsCollector.hpp
+++ b/tools/ptaben/ResultsCollector.h
@@ -1,10 +1,10 @@
 #pragma once
 
-#include "phasar/Utils/PTAResult.hpp"
-
 #include "llvm/Support/raw_ostream.h"
 
-namespace psr {
+#include "PTAResult.h"
+
+namespace psr::ptaben {
 class ResultCollector {
 public:
   explicit ResultCollector(llvm::raw_ostream *OS, llvm::StringRef ResultName);
@@ -14,4 +14,4 @@ class ResultCollector {
 private:
   llvm::raw_ostream *OS{};
 };
-}; // namespace psr
+}; // namespace psr::ptaben
diff --git a/tools/ptaben/ptaben_benchmark_tool.cpp b/tools/ptaben/ptaben_benchmark_tool.cpp
new file mode 100644
index 0000000000..0f7047cc41
--- /dev/null
+++ b/tools/ptaben/ptaben_benchmark_tool.cpp
@@ -0,0 +1,181 @@
+#include "phasar/PhasarLLVM/ControlFlow/EntryFunctionUtils.h"
+#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraph.h"
+#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraphBuilder.h"
+#include "phasar/PhasarLLVM/ControlFlow/LLVMVFTableProvider.h"
+#include "phasar/PhasarLLVM/ControlFlow/Resolver/RTAResolver.h"
+#include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
+#include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
+#include "phasar/Pointer/AliasAnalysisType.h"
+#include "phasar/Pointer/AliasResult.h"
+#include "phasar/Pointer/BottomupUnionFindAA.h"
+#include "phasar/Pointer/UnionFindAA.h"
+#include "phasar/Pointer/UnionFindAliasAnalysisType.h"
+#include "phasar/Utils/FileUtils.hpp"
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/IR/Instruction.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include "PTAUtils.h"
+#include "QuerySer.h"
+#include "ResultsCollector.h"
+
+#include <string>
+
+namespace cl = llvm::cl;
+
+static cl::opt<std::string> IRPath(cl::Positional, cl::Required,
+                                   cl::desc("ptaben-ir-directory"));
+static cl::opt<std::string>
+    QueryTablePath("queries-table",
+                   cl::desc("The Output-Path to the queries table"),
+                   cl::init("queries.csv"));
+static cl::opt<std::string>
+    AndersTablePath("anders-table",
+                    cl::desc("The Output-Path to the anders output table"),
+                    cl::init("anders-results.csv"));
+static cl::opt<std::string>
+    SteensTablePath("steens-table",
+                    cl::desc("The Output-Path to the steens output table"),
+                    cl::init("steens-results.csv"));
+static cl::opt<std::string>
+    CtxTablePath("ctx-table",
+                 cl::desc("The Output-Path to the ctx output table"),
+                 cl::init("ctx-results.csv"));
+static cl::opt<std::string>
+    BotTablePath("bot-table",
+                 cl::desc("The Output-Path to the bot output table"),
+                 cl::init("bot-results.csv"));
+static cl::opt<std::string>
+    IndTablePath("ind-table",
+                 cl::desc("The Output-Path to the ind output table"),
+                 cl::init("ind-results.csv"));
+
+static psr::AliasResult
+checkLLVMQueryLoc(psr::LLVMAliasInfoRef ComputedAliasResult,
+                  const llvm::Instruction *QueryInst) {
+  const auto *Ptr1 = QueryInst->getOperand(0);
+  const auto *Ptr2 = QueryInst->getOperand(1);
+
+  return ComputedAliasResult.alias(Ptr1, Ptr2, QueryInst);
+}
+
+static void
+performAndersAnalysis(psr::LLVMProjectIRDB &IRDB,
+                      llvm::ArrayRef<psr::ptaben::QueryLocation> QueryLocs,
+                      psr::ptaben::ResultCollector &RC) {
+  psr::LLVMAliasSet AliasSet(&IRDB, false, psr::AliasAnalysisType::CFLAnders);
+
+  for (const auto &Loc : QueryLocs) {
+    auto Res = checkLLVMQueryLoc(&AliasSet, Loc.Inst);
+    RC.handleResult(psr::ptaben::PTAResult{.Query = Loc.Id, .Result = Res});
+  }
+}
+
+static void
+performSteensAnalysis(psr::LLVMProjectIRDB &IRDB,
+                      llvm::ArrayRef<psr::ptaben::QueryLocation> QueryLocs,
+                      psr::ptaben::ResultCollector &RC) {
+  psr::LLVMAliasSet AliasSet(&IRDB, false, psr::AliasAnalysisType::CFLSteens);
+
+  for (const auto &Loc : QueryLocs) {
+    auto Res = checkLLVMQueryLoc(&AliasSet, Loc.Inst);
+    RC.handleResult(psr::ptaben::PTAResult{.Query = Loc.Id, .Result = Res});
+  }
+}
+
+static void performUnionFindAliasAnalysis(
+    psr::LLVMProjectIRDB &IRDB, const psr::LLVMBasedCallGraph &BaseCG,
+    llvm::ArrayRef<psr::ptaben::QueryLocation> QueryLocs,
+    psr::ptaben::ResultCollector &RC, psr::UnionFindAliasAnalysisType AType) {
+  auto AliasSet = psr::LLVMUnionFindAliasSet(
+      &IRDB, BaseCG,
+      psr::LLVMUnionFindAliasSet::Config{
+          .AType = AType,
+          .ALocality = psr::LLVMUnionFindAliasSet::AnalysisLocality::Global,
+      });
+
+  for (const auto &Loc : QueryLocs) {
+    auto Res = checkLLVMQueryLoc(&AliasSet, Loc.Inst);
+    RC.handleResult(psr::ptaben::PTAResult{.Query = Loc.Id, .Result = Res});
+  }
+}
+
+static auto openFileOrExit(llvm::StringRef Filepath) {
+  auto File = psr::openFileForWrite(Filepath);
+  if (!File) {
+    std::exit(1);
+  }
+  return File;
+}
+
+int main(int Argc, char *Argv[]) {
+  cl::ParseCommandLineOptions(Argc, Argv);
+
+  auto QFile = openFileOrExit(QueryTablePath);
+  auto AndersFile = openFileOrExit(AndersTablePath);
+  auto SteensFile = openFileOrExit(SteensTablePath);
+  auto CtxFile = openFileOrExit(CtxTablePath);
+  auto BotFile = openFileOrExit(BotTablePath);
+  auto IndFile = openFileOrExit(IndTablePath);
+
+  psr::ptaben::QuerySerializer QSer(QFile.get());
+  psr::ptaben::ResultCollector AndersSer(AndersFile.get(), "AndersResult");
+  psr::ptaben::ResultCollector SteensSer(SteensFile.get(), "SteensResult");
+  psr::ptaben::ResultCollector CtxSer(CtxFile.get(), "CtxResult");
+  psr::ptaben::ResultCollector BotSer(BotFile.get(), "BotResult");
+  psr::ptaben::ResultCollector IndSer(IndFile.get(), "IndResult");
+
+  llvm::SmallVector<std::string, 4> Failures;
+  psr::ptaben::checkDir(IRPath, Failures, [&](llvm::StringRef FileName) {
+    llvm::errs() << "Analyzing " << FileName << '\n';
+
+    psr::LLVMProjectIRDB IRDB(FileName);
+    auto *Mod = IRDB.getModule();
+    if (!Mod) {
+      return false;
+    }
+
+    llvm::SmallVector<psr::ptaben::QueryLocation, 4> QueryLocs;
+    llvm::SmallVector<psr::ptaben::QuerySrcCodeLocation> QuerySrcLocs;
+    psr::ptaben::findAllQueryLocations(*Mod, QueryLocs, &QuerySrcLocs);
+
+    if (QueryLocs.empty()) {
+      llvm::errs()
+          << "[NOTE]: File does not contain any alias queries. Skip it.\n";
+      return true;
+    }
+
+    for (const auto &[QLoc, QSrcLoc] : llvm::zip(QueryLocs, QuerySrcLocs)) {
+      QSer.handleQuery(QLoc, QSrcLoc);
+    }
+
+    using psr::UnionFindAliasAnalysisType;
+
+    performAndersAnalysis(IRDB, QueryLocs, AndersSer);
+    performSteensAnalysis(IRDB, QueryLocs, SteensSer);
+
+    auto VTP = psr::LLVMVFTableProvider(IRDB);
+    auto TH = psr::DIBasedTypeHierarchy(IRDB);
+    auto Res = psr::RTAResolver(&IRDB, &VTP, &TH);
+    const auto BaseCG = buildLLVMBasedCallGraph(
+        IRDB, Res, getEntryFunctions(IRDB, psr::getDefaultEntryPoints(IRDB)));
+
+    performUnionFindAliasAnalysis(IRDB, BaseCG, QueryLocs, CtxSer,
+                                  UnionFindAliasAnalysisType::CtxSens);
+    performUnionFindAliasAnalysis(IRDB, BaseCG, QueryLocs, BotSer,
+                                  UnionFindAliasAnalysisType::BotCtxSens);
+    performUnionFindAliasAnalysis(IRDB, BaseCG, QueryLocs, IndSer,
+                                  UnionFindAliasAnalysisType::IndSens);
+
+    return true;
+  });
+}
diff --git a/tools/svftestingtool/svftestingtool.cpp b/tools/svftestingtool/svftestingtool.cpp
deleted file mode 100644
index e293355fa2..0000000000
--- a/tools/svftestingtool/svftestingtool.cpp
+++ /dev/null
@@ -1,267 +0,0 @@
-#include "phasar/ControlFlow/CallGraphAnalysisType.h"
-#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraph.h"
-#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraphBuilder.h"
-#include "phasar/PhasarLLVM/ControlFlow/LLVMVFTableProvider.h"
-#include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
-#include "phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h"
-#include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
-#include "phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h"
-#include "phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h"
-#include "phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h"
-#include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
-#include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
-#include "phasar/Pointer/AliasAnalysisType.h"
-#include "phasar/Pointer/AliasResult.h"
-#include "phasar/Pointer/BottomupUnionFindAA.h"
-#include "phasar/Pointer/RawAliasSet.h"
-#include "phasar/Pointer/UnionFindAA.h"
-#include "phasar/Utils/FileUtils.hpp"
-#include "phasar/Utils/Macros.h"
-#include "phasar/Utils/MapUtils.h"
-#include "phasar/Utils/MaybeUniquePtr.h"
-#include "phasar/Utils/NonNullPtr.h"
-#include "phasar/Utils/PTAUtils.hpp"
-#include "phasar/Utils/QuerySer.hpp"
-#include "phasar/Utils/ResultsCollector.hpp"
-#include "phasar/Utils/Utilities.h"
-#include "phasar/Utils/ValueCompressor.h"
-
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Analysis/AliasAnalysis.h"
-#include "llvm/Analysis/BasicAliasAnalysis.h"
-#include "llvm/Analysis/ScopedNoAliasAA.h"
-#include "llvm/Analysis/TypeBasedAliasAnalysis.h"
-#include "llvm/IR/Instruction.h"
-#include "llvm/IR/Module.h"
-#include "llvm/Support/CommandLine.h"
-#include "llvm/Support/raw_ostream.h"
-
-#include <cstdint>
-#include <iostream>
-#include <string>
-
-namespace cl = llvm::cl;
-
-static cl::opt<std::string> IRPath(cl::Positional, cl::Required,
-                                   cl::desc("ptaben-ir-directory"));
-static cl::opt<std::string>
-    QueryTablePath("queries-table",
-                   cl::desc("The Output-Path to the queries table"),
-                   cl::init("queries.csv"));
-static cl::opt<std::string>
-    AndersTablePath("anders-table",
-                    cl::desc("The Output-Path to the anders output table"),
-                    cl::init("anders-results.csv"));
-static cl::opt<std::string>
-    SteensTablePath("steens-table",
-                    cl::desc("The Output-Path to the steens output table"),
-                    cl::init("steens-results.csv"));
-static cl::opt<std::string>
-    CtxTablePath("ctx-table",
-                 cl::desc("The Output-Path to the ctx output table"),
-                 cl::init("ctx-results.csv"));
-static cl::opt<std::string>
-    BotTablePath("bot-table",
-                 cl::desc("The Output-Path to the bot output table"),
-                 cl::init("bot-results.csv"));
-static cl::opt<std::string>
-    IndTablePath("ind-table",
-                 cl::desc("The Output-Path to the ind output table"),
-                 cl::init("ind-results.csv"));
-
-constexpr auto CtxAABuilder = [](const auto &IRDB, const auto &CG) {
-  return psr::CallingContextSensUnionFindAA<psr::LLVMPAGDomain>{
-      &CG,
-      &IRDB,
-  };
-};
-
-constexpr auto IndAABuilder = [](const auto & /*IRDB*/, const auto &CG) {
-  auto Ret = psr::pag::PBMixin{
-      psr::IndirectionSensUnionFindAA<psr::LLVMPAGDomain>{},
-      psr::pag::LLVMCGProvider{&CG},
-  };
-
-  static_assert(psr::pag::PBStrategy<decltype(Ret)>);
-  return Ret;
-};
-
-constexpr auto BotAABuilder = [](const auto &IRDB, const auto &CG) {
-  auto Ret = psr::BottomupUnionFindAA<psr::LLVMPAGDomain>{
-      psr::ReverseCGGraph{
-          &CG,
-          &IRDB,
-      },
-  };
-
-  static_assert(psr::pag::PBStrategy<decltype(Ret)>);
-  return Ret;
-};
-
-static psr::AliasResult mapAliasResult(psr::AliasResult Res) {
-  switch (Res) {
-  case psr::AliasResult::NoAlias:
-    return psr::AliasResult::NoAlias;
-
-  case psr::AliasResult::PartialAlias:
-  case psr::AliasResult::MayAlias:
-  case psr::AliasResult::MustAlias:
-    return psr::AliasResult::MayAlias;
-  }
-  llvm_unreachable(
-      "All AliasResult kinds should be handled in the switch above!");
-}
-
-static psr::AliasResult
-checkLLVMQueryLoc(psr::LLVMAliasInfoRef ComputeAliasResult,
-                  const llvm::Instruction *QueryInst) {
-  const auto *Ptr1 = QueryInst->getOperand(0);
-  const auto *Ptr2 = QueryInst->getOperand(1);
-
-  return mapAliasResult(ComputeAliasResult.alias(Ptr1, Ptr2, QueryInst));
-}
-
-static void performAndersAnalysis(psr::LLVMProjectIRDB &IRDB,
-                                  llvm::ArrayRef<psr::QueryLocation> QueryLocs,
-                                  psr::ResultCollector &RC) {
-  psr::LLVMAliasSet AliasSet(&IRDB, false, psr::AliasAnalysisType::CFLAnders);
-
-  for (const auto &Loc : QueryLocs) {
-    auto Res = checkLLVMQueryLoc(&AliasSet, Loc.Inst);
-    RC.handleResult(psr::PTAResult{.Query = Loc.Id, .Result = Res});
-  }
-}
-
-static void performSteensAnalysis(psr::LLVMProjectIRDB &IRDB,
-                                  llvm::ArrayRef<psr::QueryLocation> QueryLocs,
-                                  psr::ResultCollector &RC) {
-  psr::LLVMAliasSet AliasSet(&IRDB, false, psr::AliasAnalysisType::CFLSteens);
-
-  for (const auto &Loc : QueryLocs) {
-    auto Res = checkLLVMQueryLoc(&AliasSet, Loc.Inst);
-    RC.handleResult(psr::PTAResult{.Query = Loc.Id, .Result = Res});
-  }
-}
-
-static void performCtxAnalysis(psr::LLVMProjectIRDB &IRDB,
-                               llvm::ArrayRef<psr::QueryLocation> QueryLocs,
-                               psr::ResultCollector &RC) {
-  psr::LLVMUnionFindAliasSet AliasSet(
-      &IRDB,
-      psr::LLVMUnionFindAliasSet::Config{
-          .AType = psr::UnionFindAliasAnalysisType::CtxSens,
-          .ALocality = psr::LLVMUnionFindAliasSet::AnalysisLocality::Global,
-      });
-
-  for (const auto &Loc : QueryLocs) {
-    auto Res = checkLLVMQueryLoc(&AliasSet, Loc.Inst);
-    RC.handleResult(psr::PTAResult{.Query = Loc.Id, .Result = Res});
-  }
-}
-
-static void performBotAnalysis(psr::LLVMProjectIRDB &IRDB,
-                               llvm::ArrayRef<psr::QueryLocation> QueryLocs,
-                               psr::ResultCollector &RC) {
-  psr::LLVMUnionFindAliasSet AliasSet(
-      &IRDB,
-      psr::LLVMUnionFindAliasSet::Config{
-          .AType = psr::UnionFindAliasAnalysisType::BotCtxSens,
-          .ALocality = psr::LLVMUnionFindAliasSet::AnalysisLocality::Global,
-      });
-
-  for (const auto &Loc : QueryLocs) {
-    auto Res = checkLLVMQueryLoc(&AliasSet, Loc.Inst);
-    RC.handleResult(psr::PTAResult{.Query = Loc.Id, .Result = Res});
-  }
-}
-
-static void performIndAnalysis(psr::LLVMProjectIRDB &IRDB,
-                               llvm::ArrayRef<psr::QueryLocation> QueryLocs,
-                               psr::ResultCollector &RC) {
-  psr::LLVMUnionFindAliasSet AliasSet(
-      &IRDB,
-      psr::LLVMUnionFindAliasSet::Config{
-          .AType = psr::UnionFindAliasAnalysisType::IndSens,
-          .ALocality = psr::LLVMUnionFindAliasSet::AnalysisLocality::Global,
-      });
-
-  for (const auto &Loc : QueryLocs) {
-    auto Res = checkLLVMQueryLoc(&AliasSet, Loc.Inst);
-    RC.handleResult(psr::PTAResult{.Query = Loc.Id, .Result = Res});
-  }
-}
-
-int main(int Argc, char *Argv[]) {
-  cl::ParseCommandLineOptions(Argc, Argv);
-
-  auto QFile = psr::openFileForWrite(QueryTablePath);
-  if (!QFile) {
-    return 1;
-  }
-
-  auto AndersFile = psr::openFileForWrite(AndersTablePath);
-  if (!AndersFile) {
-    return 1;
-  }
-
-  auto SteensFile = psr::openFileForWrite(SteensTablePath);
-  if (!SteensFile) {
-    return 1;
-  }
-
-  auto CtxFile = psr::openFileForWrite(CtxTablePath);
-  if (!CtxFile) {
-    return 1;
-  }
-
-  auto BotFile = psr::openFileForWrite(BotTablePath);
-  if (!BotFile) {
-    return 1;
-  }
-
-  auto IndFile = psr::openFileForWrite(IndTablePath);
-  if (!IndFile) {
-    return 1;
-  }
-
-  psr::QuerySerializer QSer(QFile.get());
-  psr::ResultCollector AndersSer(AndersFile.get(), "AndersResult");
-  psr::ResultCollector SteensSer(SteensFile.get(), "SteensResult");
-  psr::ResultCollector CtxSer(CtxFile.get(), "CtxResult");
-  psr::ResultCollector BotSer(BotFile.get(), "BotResult");
-  psr::ResultCollector IndSer(IndFile.get(), "IndResult");
-
-  llvm::SmallVector<std::string, 4> Failures;
-  psr::checkDir(IRPath, Failures, [&](llvm::StringRef FileName) {
-    llvm::errs() << "Analyzing " << FileName << '\n';
-
-    psr::LLVMProjectIRDB IRDB(FileName);
-    auto *Mod = IRDB.getModule();
-    if (!Mod) {
-      return false;
-    }
-
-    llvm::SmallVector<psr::QueryLocation, 4> QueryLocs;
-    llvm::SmallVector<psr::QuerySrcCodeLocation> QuerySrcLocs;
-    psr::findAllQueryLocations(*Mod, QueryLocs, &QuerySrcLocs);
-
-    if (QueryLocs.empty()) {
-      llvm::errs()
-          << "[NOTE]: File does not contain any alias queries. Skip it.\n";
-      return true;
-    }
-
-    for (const auto &[QLoc, QSrcLoc] : llvm::zip(QueryLocs, QuerySrcLocs)) {
-      QSer.handleQuery(QLoc, QSrcLoc);
-    }
-
-    performAndersAnalysis(IRDB, QueryLocs, AndersSer);
-    performSteensAnalysis(IRDB, QueryLocs, SteensSer);
-    performCtxAnalysis(IRDB, QueryLocs, CtxSer);
-    performBotAnalysis(IRDB, QueryLocs, BotSer);
-    performIndAnalysis(IRDB, QueryLocs, IndSer);
-
-    return true;
-  });
-}

From f088458de34d0d62defa37ddee09684ac287c783 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Tue, 17 Mar 2026 16:05:43 +0100
Subject: [PATCH 59/75] Add README

---
 tools/ptaben/README.md                 | 18 ++++++++++++++++++
 tools/ptaben/ptaben_benchmark_tool.cpp | 21 +++++++++++----------
 2 files changed, 29 insertions(+), 10 deletions(-)
 create mode 100644 tools/ptaben/README.md

diff --git a/tools/ptaben/README.md b/tools/ptaben/README.md
new file mode 100644
index 0000000000..d7765f4c1f
--- /dev/null
+++ b/tools/ptaben/README.md
@@ -0,0 +1,18 @@
+# PTABen Benchmark Tool
+
+A sample tool that can be used to benchmark PhASAR's alias analyses against SVF's [Test Suite](https://github.com/SVF-tools/Test-Suite).
+
+To use this tool, we expect that you have a folder with the compiled LLVM bitcode of the relevant PTABen benchmark files that you care about.
+Just provide the path to that folder to `tools/ptaben/ptaben`. It will run the alias analyses on each LLVM bitcode file in that folder (and subfolders) and output a .csv file per alias analysis + one for the ground-truth.
+
+## Supported Analyses
+
+Currently, the benhcmark tool supports the following analyses:
+
+- LLVM's CFLAndersen analysis, wrapped into `psr::LLVMAliasSet`
+- LLVM's CFLSteensgaard analysis, wrapped into `psr::LLVMAliasSet`
+- PhASAR's context-sensitive union-find analysis (same as if passing `--alias-analysis=union-find --union-find-aa=ctx-sens` to `phasar-cli`)
+- PhASAR's indirection-sensitive union-find analysis (same as if passing `--alias-analysis=union-find --union-find-aa=ind-sens` to `phasar-cli`)
+- PhASAR's bottom-up context-sensitive union-find analysis (same as if passing `--alias-analysis=union-find --union-find-aa=botctx-sens` to `phasar-cli`)
+
+Of course, you can extend this tool and provide your own analyses here.
diff --git a/tools/ptaben/ptaben_benchmark_tool.cpp b/tools/ptaben/ptaben_benchmark_tool.cpp
index 0f7047cc41..e24c8f8533 100644
--- a/tools/ptaben/ptaben_benchmark_tool.cpp
+++ b/tools/ptaben/ptaben_benchmark_tool.cpp
@@ -7,14 +7,11 @@
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h"
-#include "phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h"
 #include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
 #include "phasar/Pointer/AliasAnalysisType.h"
 #include "phasar/Pointer/AliasResult.h"
-#include "phasar/Pointer/BottomupUnionFindAA.h"
-#include "phasar/Pointer/UnionFindAA.h"
 #include "phasar/Pointer/UnionFindAliasAnalysisType.h"
 #include "phasar/Utils/FileUtils.hpp"
 
@@ -32,32 +29,35 @@
 
 namespace cl = llvm::cl;
 
+static cl::OptionCategory PTABenCat("PTABen Benhchmark Tool");
+
 static cl::opt<std::string> IRPath(cl::Positional, cl::Required,
-                                   cl::desc("ptaben-ir-directory"));
+                                   cl::desc("ptaben-ir-directory"),
+                                   cl::cat(PTABenCat));
 static cl::opt<std::string>
     QueryTablePath("queries-table",
                    cl::desc("The Output-Path to the queries table"),
-                   cl::init("queries.csv"));
+                   cl::init("queries.csv"), cl::cat(PTABenCat));
 static cl::opt<std::string>
     AndersTablePath("anders-table",
                     cl::desc("The Output-Path to the anders output table"),
-                    cl::init("anders-results.csv"));
+                    cl::init("anders-results.csv"), cl::cat(PTABenCat));
 static cl::opt<std::string>
     SteensTablePath("steens-table",
                     cl::desc("The Output-Path to the steens output table"),
-                    cl::init("steens-results.csv"));
+                    cl::init("steens-results.csv"), cl::cat(PTABenCat));
 static cl::opt<std::string>
     CtxTablePath("ctx-table",
                  cl::desc("The Output-Path to the ctx output table"),
-                 cl::init("ctx-results.csv"));
+                 cl::init("ctx-results.csv"), cl::cat(PTABenCat));
 static cl::opt<std::string>
     BotTablePath("bot-table",
                  cl::desc("The Output-Path to the bot output table"),
-                 cl::init("bot-results.csv"));
+                 cl::init("bot-results.csv"), cl::cat(PTABenCat));
 static cl::opt<std::string>
     IndTablePath("ind-table",
                  cl::desc("The Output-Path to the ind output table"),
-                 cl::init("ind-results.csv"));
+                 cl::init("ind-results.csv"), cl::cat(PTABenCat));
 
 static psr::AliasResult
 checkLLVMQueryLoc(psr::LLVMAliasInfoRef ComputedAliasResult,
@@ -118,6 +118,7 @@ static auto openFileOrExit(llvm::StringRef Filepath) {
 }
 
 int main(int Argc, char *Argv[]) {
+  cl::HideUnrelatedOptions(PTABenCat);
   cl::ParseCommandLineOptions(Argc, Argv);
 
   auto QFile = openFileOrExit(QueryTablePath);

From 9278294d0f011b8f79df40ea763423a9c74ad128 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Tue, 17 Mar 2026 16:07:15 +0100
Subject: [PATCH 60/75] minor

---
 tools/ptaben/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/ptaben/README.md b/tools/ptaben/README.md
index d7765f4c1f..46fda99272 100644
--- a/tools/ptaben/README.md
+++ b/tools/ptaben/README.md
@@ -7,7 +7,7 @@ Just provide the path to that folder to `tools/ptaben/ptaben`. It will run the a
 
 ## Supported Analyses
 
-Currently, the benhcmark tool supports the following analyses:
+Currently, the benchmark tool supports the following analyses:
 
 - LLVM's CFLAndersen analysis, wrapped into `psr::LLVMAliasSet`
 - LLVM's CFLSteensgaard analysis, wrapped into `psr::LLVMAliasSet`

From aef62f0d7553a350672715df570eb5e6293f70ed Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Tue, 24 Mar 2026 22:58:48 +0100
Subject: [PATCH 61/75] added other two analyses + results table

---
 tools/ptaben/README.md                 |  9 +++++++++
 tools/ptaben/ptaben_benchmark_tool.cpp | 17 +++++++++++++++++
 2 files changed, 26 insertions(+)

diff --git a/tools/ptaben/README.md b/tools/ptaben/README.md
index 46fda99272..2297dbb7dc 100644
--- a/tools/ptaben/README.md
+++ b/tools/ptaben/README.md
@@ -14,5 +14,14 @@ Currently, the benchmark tool supports the following analyses:
 - PhASAR's context-sensitive union-find analysis (same as if passing `--alias-analysis=union-find --union-find-aa=ctx-sens` to `phasar-cli`)
 - PhASAR's indirection-sensitive union-find analysis (same as if passing `--alias-analysis=union-find --union-find-aa=ind-sens` to `phasar-cli`)
 - PhASAR's bottom-up context-sensitive union-find analysis (same as if passing `--alias-analysis=union-find --union-find-aa=botctx-sens` to `phasar-cli`)
+- PhASAR's context-sensitive indirection-sensitive union-find analysis (same as if passing `--alias-analysis=union-find --union-find-aa=ctx-ind-sens` to `phasar-cli`)
+- PhASAR's bottom-up context-sensitive indirection-sensitive union-find analysis (same as if passing `--alias-analysis=union-find --union-find-aa=botctx-ind-sens` to `phasar-cli`)
 
 Of course, you can extend this tool and provide your own analyses here.
+
+## Results
+          | anders | steens | ctx-sens | bot-sens | ind-sens | ctx-ind-sens | bot-ctx-ind-sens | overall
+----------+--------+--------+----------+----------+----------+--------------+------------------+---------
+precision | 0.712  | 0.709  | 0.803    | 0.800    | 0.681    | 0.803        | 0.800            | 0.754
+recall    | 0.961  | 0.975  | 0.929    | 0.667    | 0.960    | 0.929        | 0.667            | 0.861
+f1score   | 0.818  | 0.821  | 0.862    | 0.728    | 0.796    | 0.862        | 0.728            | 0.804
diff --git a/tools/ptaben/ptaben_benchmark_tool.cpp b/tools/ptaben/ptaben_benchmark_tool.cpp
index e24c8f8533..7433ac959c 100644
--- a/tools/ptaben/ptaben_benchmark_tool.cpp
+++ b/tools/ptaben/ptaben_benchmark_tool.cpp
@@ -58,6 +58,14 @@ static cl::opt<std::string>
     IndTablePath("ind-table",
                  cl::desc("The Output-Path to the ind output table"),
                  cl::init("ind-results.csv"), cl::cat(PTABenCat));
+static cl::opt<std::string>
+    CtxIndTablePath("ctx-ind-table",
+                    cl::desc("The Output-Path to the ctx-ind output table"),
+                    cl::init("ctx-ind-results.csv"), cl::cat(PTABenCat));
+static cl::opt<std::string> BotCtxIndTablePath(
+    "bot-ctx-ind-table",
+    cl::desc("The Output-Path to the bot-ctx-ind output table"),
+    cl::init("bot-ctx-ind-results.csv"), cl::cat(PTABenCat));
 
 static psr::AliasResult
 checkLLVMQueryLoc(psr::LLVMAliasInfoRef ComputedAliasResult,
@@ -127,6 +135,8 @@ int main(int Argc, char *Argv[]) {
   auto CtxFile = openFileOrExit(CtxTablePath);
   auto BotFile = openFileOrExit(BotTablePath);
   auto IndFile = openFileOrExit(IndTablePath);
+  auto CtxIndFile = openFileOrExit(CtxIndTablePath);
+  auto BotCtxIndFile = openFileOrExit(BotCtxIndTablePath);
 
   psr::ptaben::QuerySerializer QSer(QFile.get());
   psr::ptaben::ResultCollector AndersSer(AndersFile.get(), "AndersResult");
@@ -134,6 +144,9 @@ int main(int Argc, char *Argv[]) {
   psr::ptaben::ResultCollector CtxSer(CtxFile.get(), "CtxResult");
   psr::ptaben::ResultCollector BotSer(BotFile.get(), "BotResult");
   psr::ptaben::ResultCollector IndSer(IndFile.get(), "IndResult");
+  psr::ptaben::ResultCollector CtxIndSer(CtxIndFile.get(), "CtxIndResult");
+  psr::ptaben::ResultCollector BotCtxIndSer(BotCtxIndFile.get(),
+                                            "BotCtxIndResult");
 
   llvm::SmallVector<std::string, 4> Failures;
   psr::ptaben::checkDir(IRPath, Failures, [&](llvm::StringRef FileName) {
@@ -176,6 +189,10 @@ int main(int Argc, char *Argv[]) {
                                   UnionFindAliasAnalysisType::BotCtxSens);
     performUnionFindAliasAnalysis(IRDB, BaseCG, QueryLocs, IndSer,
                                   UnionFindAliasAnalysisType::IndSens);
+    performUnionFindAliasAnalysis(IRDB, BaseCG, QueryLocs, CtxIndSer,
+                                  UnionFindAliasAnalysisType::CtxIndSens);
+    performUnionFindAliasAnalysis(IRDB, BaseCG, QueryLocs, BotCtxIndSer,
+                                  UnionFindAliasAnalysisType::BotCtxIndSens);
 
     return true;
   });

From c047f3e7790010c0468ed8de82db8fcd43b1e02e Mon Sep 17 00:00:00 2001
From: mxHuber <huber.maximilian.leo@gmail.com>
Date: Wed, 25 Mar 2026 10:35:48 +0100
Subject: [PATCH 62/75] fixed table formatting

---
 tools/ptaben/README.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/tools/ptaben/README.md b/tools/ptaben/README.md
index 2297dbb7dc..de3706b892 100644
--- a/tools/ptaben/README.md
+++ b/tools/ptaben/README.md
@@ -20,8 +20,8 @@ Currently, the benchmark tool supports the following analyses:
 Of course, you can extend this tool and provide your own analyses here.
 
 ## Results
-          | anders | steens | ctx-sens | bot-sens | ind-sens | ctx-ind-sens | bot-ctx-ind-sens | overall
-----------+--------+--------+----------+----------+----------+--------------+------------------+---------
-precision | 0.712  | 0.709  | 0.803    | 0.800    | 0.681    | 0.803        | 0.800            | 0.754
-recall    | 0.961  | 0.975  | 0.929    | 0.667    | 0.960    | 0.929        | 0.667            | 0.861
-f1score   | 0.818  | 0.821  | 0.862    | 0.728    | 0.796    | 0.862        | 0.728            | 0.804
+|           | anders | steens | ctx-sens | bot-sens | ind-sens | ctx-ind-sens | bot-ctx-ind-sens | overall |
+|-----------|--------|--------|----------|----------|----------|--------------|------------------|---------|
+| precision | 0.712  | 0.709  | 0.803    | 0.800    | 0.681    | 0.803        | 0.800            | 0.754   |
+| recall    | 0.961  | 0.975  | 0.929    | 0.667    | 0.960    | 0.929        | 0.667            | 0.861   |
+| f1score   | 0.818  | 0.821  | 0.862    | 0.728    | 0.796    | 0.862        | 0.728            | 0.804   |

From bf0449c42d538d356aa71c1575e6cb2c128e7a8c Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Thu, 26 Mar 2026 18:10:47 +0100
Subject: [PATCH 63/75] Some cleanup

---
 .../PhasarLLVM/Pointer/LLVMUnionFindAA.h      |  8 ++++----
 include/phasar/Pointer/AliasResult.h          |  6 +++++-
 include/phasar/Pointer/UnionFindAA.h          | 20 ++++++-------------
 .../Pointer/LLVMPointerAssignmentGraph.cpp    |  7 ++-----
 lib/Pointer/AliasResult.cpp                   | 13 ------------
 .../Pointer/LLVMUnionFindAATest.cpp           |  9 ---------
 6 files changed, 17 insertions(+), 46 deletions(-)

diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
index 1a64df20c2..0cc8351154 100644
--- a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
@@ -120,7 +120,7 @@ struct LLVMUnionFindAliasIteratorMixin {
       return AliasResult::NoAlias;
     }
     if (*ValId1 == *ValId2) {
-      // TODO: Check exactly the conditions for must alias!
+      // XXX: Check exactly the conditions for must alias!
       return !llvm::isa<llvm::LoadInst>(Ptr1) &&
                      !llvm::isa<llvm::LoadInst>(Ptr2)
                  ? AliasResult::MustAlias
@@ -240,7 +240,7 @@ class LLVMLocalUnionFindAliasIteratorMixin
   [[nodiscard]] bool
   mayAlias(ValueId ValId1, ValueId ValId2,
            const llvm::Instruction * /*AtInstruction*/ = nullptr) const {
-    // TODO: Should we filter by AtInstruction-context here as well?
+    // XXX: Should we filter by AtInstruction-context here as well?
     return AARes.mayAlias(ValId1, ValId2);
   }
 
@@ -250,7 +250,7 @@ class LLVMLocalUnionFindAliasIteratorMixin
     auto ValId1 = self().VC->getOrNull(Ptr1);
     auto ValId2 = self().VC->getOrNull(Ptr2);
 
-    // TODO: Should we filter by AtInstruction-context here as well?
+    // XXX: Should we filter by AtInstruction-context here as well?
     return ValId1 && ValId2 && AARes.mayAlias(*ValId1, *ValId2);
   }
 
@@ -263,7 +263,7 @@ class LLVMLocalUnionFindAliasIteratorMixin
       return AliasResult::NoAlias;
     }
     if (*ValId1 == *ValId2) {
-      // TODO: Check exactly the conditions for must alias!
+      // XXX: Check exactly the conditions for must alias!
       return !llvm::isa<llvm::LoadInst>(Ptr1) &&
                      !llvm::isa<llvm::LoadInst>(Ptr2)
                  ? AliasResult::MustAlias
diff --git a/include/phasar/Pointer/AliasResult.h b/include/phasar/Pointer/AliasResult.h
index 79646e006a..ac373b852a 100644
--- a/include/phasar/Pointer/AliasResult.h
+++ b/include/phasar/Pointer/AliasResult.h
@@ -21,7 +21,11 @@ enum class AliasResult {
 };
 
 std::string toString(AliasResult AR);
-[[nodiscard]] llvm::StringRef to_string(AliasResult Res) noexcept;
+
+// for ADL std::to_string compatibility
+[[nodiscard]] inline auto to_string(AliasResult Res) noexcept { // NOLINT
+  return toString(Res);
+}
 
 AliasResult toAliasResult(llvm::StringRef S);
 
diff --git a/include/phasar/Pointer/UnionFindAA.h b/include/phasar/Pointer/UnionFindAA.h
index 861a8ee465..9c879bd18a 100644
--- a/include/phasar/Pointer/UnionFindAA.h
+++ b/include/phasar/Pointer/UnionFindAA.h
@@ -7,6 +7,7 @@
 #include "phasar/Utils/BitSet.h"
 #include "phasar/Utils/ByRef.h"
 #include "phasar/Utils/IotaIterator.h"
+#include "phasar/Utils/Logger.h"
 #include "phasar/Utils/Macros.h"
 #include "phasar/Utils/MapUtils.h"
 #include "phasar/Utils/NonNullPtr.h"
@@ -178,8 +179,6 @@ struct BasicUnionFindAAResult : UnionFindAAResultBase {
     }
 
     if (!Var2Rep.inbounds(Var1) || !Var2Rep.inbounds(Var2)) {
-      llvm::errs()
-          << "ERROR: !Var2Rep.inbounds(Var1) || !Var2Rep.inbounds(Var2)\n";
       return false;
     }
 
@@ -214,8 +213,6 @@ struct CallingContextSensUnionFindAAResult : UnionFindAAResultBase {
 
     // Note: K is mostly small (1 or 2), so below loop should be very cheap
     if (!Var2Rep.inbounds(Var1) || !Var2Rep.inbounds(Var2)) {
-      llvm::errs()
-          << "ERROR: !Var2Rep.inbounds(Var1) || !Var2Rep.inbounds(Var2)\n";
       return false;
     }
     const auto &Reps1 = Var2Rep[Var1];
@@ -268,7 +265,7 @@ struct BasicUnionFindAA {
     Result.Var2Rep.resize(NumVars, InvalidRep);
 
     for (auto VId : iota<ValueId>(NumVars)) {
-      // TODO: Skip only-ret val-ids
+      // XXX: We should skip only-ret val-ids
       auto ObjId = std::invoke(Var2Obj, VId);
       auto Rep = Equiv[ObjId];
       assert(Result.Var2Rep[VId] == InvalidRep &&
@@ -306,9 +303,6 @@ class CallingContextSensUnionFindAA {
 
   void onAddEdge(ValueId From, ValueId To, pag::Edge E,
                  Nullable<n_t> CallSite) {
-    // llvm::errs() << "[CtxAA][onAddEdge]: From: " << int(From)
-    //              << ", To: " << int(To) << ", E: " << to_string(E)
-    //              << ", At: " << llvmIRToString(CallSite) << '\n';
     E.apply(Overloaded{
         [&, this, CallSite](pag::Call) {
           for (const auto &[ArgCtxId, FromObj] : Var2Obj[From]) {
@@ -380,7 +374,7 @@ class CallingContextSensUnionFindAA {
     Result.Var2Rep.resize(NumVars);
 
     for (const auto &[ValId, Objects] : Var2Obj.enumerate()) {
-      // TODO: Skip only-ret val-ids
+      // XXX: We should skip only-ret val-ids
 
       for (const auto &[_, Obj] : Objects) {
         auto Rep = Equiv[Obj];
@@ -389,8 +383,8 @@ class CallingContextSensUnionFindAA {
         }
       }
       if (Objects.empty()) {
-        llvm::errs() << "Warning: Empty Objects-set for Var#" << uint32_t(ValId)
-                     << '\n';
+        PHASAR_LOG_LEVEL_CAT(WARNING, "CallingContextSensUnionFindAA",
+                             "Empty Objects-set for Var#" << uint32_t(ValId));
       }
     }
 
@@ -509,11 +503,9 @@ class IndirectionSensUnionFindAA {
     Var2Obj.emplace_back(generate_tag, [Obj](IndDepth Depth) {
       return IndObjectId(Obj + size_t(Depth));
     });
-    // TODO: For some values, we can already see that depth>=2 does not make
+    // XXX: For some values, we can already see that depth>=2 does not make
     // sense, so we could exit the below loop early
     for (auto Depth : iota<IndDepth>(K)) {
-      // Var2Obj[VId].push_back(IndObjectId(Obj));
-      // Obj++;
       Obj2Var.emplace_back(VId, Depth);
     }
   }
diff --git a/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp b/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp
index 758bff8ff2..254ed238ee 100644
--- a/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp
+++ b/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp
@@ -182,8 +182,6 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
 
   void addEdge(LLVMPBStrategyRef Strategy, ValueId From, ValueId To, Edge E,
                const llvm::Instruction *AtInstruction) {
-    // llvm::errs() << "[addEdge]: " << int(From) << "->" << int(To)
-    //              << " :: " << to_string(E) << '\n';
     if (!E.isa<Store, StorePOI>()) {
       eraseFromSimpleStoreLoad(Strategy, To);
     } else if (OnlyIncomingStoresAndOutgoingLoads.contains(To)) {
@@ -238,8 +236,7 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
 
   void initializeFunctions(const LLVMProjectIRDB &IRDB,
                            LLVMPBStrategyRef Strategy) {
-    // TODO: Use LibrarySummary here
-    // TODO: Skip functions that have been proven unreachable previously
+    // XXX: Skip functions that have been proven unreachable previously
 
     for (const auto *Fun : IRDB.getAllFunctions()) {
       if (!Fun->isDeclaration()) {
@@ -251,7 +248,7 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
   }
 
   void initializeFun(LLVMPBStrategyRef Strategy, const llvm::Function &Fun) {
-    // TODO: RPO Order to profit from OTF-merged values
+    // XXX: RPO Order to profit from OTF-merged values
     for (const auto &BB : Fun) {
       propagateBB(Strategy, BB);
     }
diff --git a/lib/Pointer/AliasResult.cpp b/lib/Pointer/AliasResult.cpp
index 2c589bf513..c0e7851314 100644
--- a/lib/Pointer/AliasResult.cpp
+++ b/lib/Pointer/AliasResult.cpp
@@ -35,16 +35,3 @@ psr::AliasResult psr::toAliasResult(llvm::StringRef S) {
 llvm::raw_ostream &psr::operator<<(llvm::raw_ostream &OS, AliasResult AR) {
   return OS << toString(AR);
 }
-
-llvm::StringRef psr::to_string(AliasResult Res) noexcept {
-  switch (Res) {
-  case AliasResult::NoAlias:
-    return "NoAlias";
-  case AliasResult::MustAlias:
-    return "MustAlias";
-  case AliasResult::MayAlias:
-    return "MayAlias";
-  }
-  llvm_unreachable(
-      "All AliasResult kinds should be handled by the switch above");
-}
diff --git a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
index 971bda2647..c38164bc9c 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMUnionFindAATest.cpp
@@ -91,13 +91,6 @@ void doAnalysisAndCompareResults(
   UnionFindAAResult auto Results =
       computeUnionFindAARaw(IRDB, AABuilder(IRDB, BaseCG), &VC);
 
-  for (const auto &[PtrVar, ExpectedAliasVars] : ExpectedResults) {
-    const auto PtrId = asId(VC, IRDB, PtrVar);
-    const auto ExpectedAliasIds = asIdBased(VC, IRDB, ExpectedAliasVars);
-    const RawAliasSet<ValueId> &ComputedAliasIds =
-        Results.getRawAliasSet(PtrId);
-  }
-
   for (const auto &[PtrVar, ExpectedAliasVars] : ExpectedResults) {
     const auto PtrId = asId(VC, IRDB, PtrVar);
     const auto ExpectedAliasIds = asIdBased(VC, IRDB, ExpectedAliasVars);
@@ -7089,8 +7082,6 @@ TEST(IndirectionSensUnionFindAATest, Indirection07) {
                              .Col = 0,
                              .InFunction = "main",
                              .OpCode = llvm::Instruction::Alloca},
-                // TODO: double check. Probably an overapproximation due to a
-                // loop from 1 and 2 in PointerAssignmentGraph
                 LineColFunOp{.Line = 35,
                              .Col = 0,
                              .InFunction = "main",

From 56a02e056258d64c4159335fe9e684d9c5a56ffd Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Thu, 26 Mar 2026 18:13:00 +0100
Subject: [PATCH 64/75] Add ValueIdMap to use as cache for alias-sets

---
 include/phasar/Pointer/UnionFindAA.h |  16 +-
 include/phasar/Utils/BitSet.h        |  23 +-
 include/phasar/Utils/TypeTraits.h    |  15 +
 include/phasar/Utils/ValueIdMap.h    | 371 ++++++++++++++++++++++
 unittests/Utils/CMakeLists.txt       |   1 +
 unittests/Utils/ValueIdMapTest.cpp   | 445 +++++++++++++++++++++++++++
 6 files changed, 861 insertions(+), 10 deletions(-)
 create mode 100644 include/phasar/Utils/ValueIdMap.h
 create mode 100644 unittests/Utils/ValueIdMapTest.cpp

diff --git a/include/phasar/Pointer/UnionFindAA.h b/include/phasar/Pointer/UnionFindAA.h
index 9c879bd18a..e57701578b 100644
--- a/include/phasar/Pointer/UnionFindAA.h
+++ b/include/phasar/Pointer/UnionFindAA.h
@@ -4,7 +4,6 @@
 #include "phasar/Pointer/CallingContextConstructor.h"
 #include "phasar/Pointer/PointerAssignmentGraph.h"
 #include "phasar/Pointer/RawAliasSet.h"
-#include "phasar/Utils/BitSet.h"
 #include "phasar/Utils/ByRef.h"
 #include "phasar/Utils/IotaIterator.h"
 #include "phasar/Utils/Logger.h"
@@ -19,6 +18,7 @@
 #include "phasar/Utils/UnionFind.h"
 #include "phasar/Utils/Utilities.h"
 #include "phasar/Utils/ValueCompressor.h"
+#include "phasar/Utils/ValueIdMap.h"
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/STLExtras.h"
@@ -101,8 +101,7 @@ template <UnionFindAAResult AAResT, bool ShouldCacheMayAlias = true>
 class CachedUnionFindAAResult {
 public:
   explicit CachedUnionFindAAResult(AAResT &&AARes) : AARes(std::move(AARes)) {
-    Var2AliasVars.resize(this->AARes.size());
-    ComputedAliasSetFor.reserve(this->AARes.size());
+    Cache.reserve(this->AARes.size());
   }
 
   [[nodiscard]] static constexpr bool isCached() noexcept { return true; }
@@ -110,10 +109,11 @@ class CachedUnionFindAAResult {
   [[nodiscard]] constexpr size_t size() const noexcept { return AARes.size(); }
 
   [[nodiscard]] const RawAliasSet<ValueId> &getRawAliasSet(ValueId Var) const {
-    if (ComputedAliasSetFor.tryInsert(Var)) [[unlikely]] {
-      Var2AliasVars[Var] = AARes.getRawAliasSet(Var);
+    auto [It, Inserted] = Cache.try_emplace(Var);
+    if (Inserted) [[unlikely]] {
+      It->second = AARes.getRawAliasSet(Var);
     }
-    return Var2AliasVars[Var];
+    return It->second;
   }
 
   [[nodiscard]] bool mayAlias(ValueId Var1, ValueId Var2) const {
@@ -125,9 +125,7 @@ class CachedUnionFindAAResult {
   }
 
 private:
-  // TODO: Combine Var2AliasVars+ComputedAliasSetFor into a ValueIdMap!
-  mutable TypedVector<ValueId, RawAliasSet<ValueId>> Var2AliasVars;
-  mutable BitSet<ValueId> ComputedAliasSetFor{};
+  mutable ValueIdMap<ValueId, RawAliasSet<ValueId>> Cache;
 
   [[no_unique_address]] AAResT AARes;
 };
diff --git a/include/phasar/Utils/BitSet.h b/include/phasar/Utils/BitSet.h
index 2cc0d5c831..80f07eba0b 100644
--- a/include/phasar/Utils/BitSet.h
+++ b/include/phasar/Utils/BitSet.h
@@ -22,6 +22,7 @@
 #include <cstdint>
 #include <functional>
 #include <iterator>
+#include <optional>
 #include <type_traits>
 
 namespace psr {
@@ -40,10 +41,17 @@ template <SmallIdType IdT, typename BitVectorTy = llvm::BitVector>
 class BitSet {
   static llvm::ArrayRef<uintptr_t> getWords(const llvm::BitVector &BV,
                                             uintptr_t & /*Store*/) {
+    // getData() accesses Bits[0] unconditionally; guard against empty vector.
+    if (BV.empty()) {
+      return {};
+    }
     return BV.getData();
   }
   static llvm::ArrayRef<uintptr_t> getWords(const llvm::SmallBitVector &BV,
                                             uintptr_t &Store) {
+    if (BV.empty()) {
+      return {};
+    }
     return BV.getData(Store);
   }
 
@@ -181,7 +189,20 @@ class BitSet {
   }
   [[nodiscard]] iterator end() const noexcept { return Bits.set_bits_end(); }
 
-  /// Calls the given handler function for each sert bit in the bitset.
+  /// Returns the smallest element in the set, or std::nullopt if empty.
+  [[nodiscard]] std::optional<IdT> findFirst() const noexcept {
+    const int First = Bits.find_first();
+    return First >= 0 ? std::optional<IdT>(IdT(First)) : std::nullopt;
+  }
+
+  /// Returns the smallest element greater than \p Key, or std::nullopt if
+  /// none exists.
+  [[nodiscard]] std::optional<IdT> findNext(IdT Key) const noexcept {
+    const int Next = Bits.find_next(int(uint32_t(Key)));
+    return Next >= 0 ? std::optional<IdT>(IdT(Next)) : std::nullopt;
+  }
+
+  /// Calls the given handler function for each set bit in the bitset.
   ///
   /// This is likely faster than using iterators.
   template <std::invocable<IdT> HandlerFn>
diff --git a/include/phasar/Utils/TypeTraits.h b/include/phasar/Utils/TypeTraits.h
index 2864a17c5d..d266b7e68a 100644
--- a/include/phasar/Utils/TypeTraits.h
+++ b/include/phasar/Utils/TypeTraits.h
@@ -293,6 +293,21 @@ template <typename ArgT> struct DummyFn {
   void operator()(ArgT Arg) const noexcept {}
 };
 
+/// True if T can be relocated by copying its bytes (e.g. via memcpy) without
+/// invoking the move constructor or destructor on the source. Uses Clang's
+/// builtin trait when available (P1144 / P2786), which covers types like
+/// std::unique_ptr that are trivially relocatable but not trivially copyable.
+/// Falls back to std::is_trivially_copyable_v on other compilers.
+template <typename T>
+inline constexpr bool IsTriviallyRelocatable =
+#if defined(__has_builtin) && __has_builtin(__builtin_is_cpp_trivially_relocatable)
+    __builtin_is_cpp_trivially_relocatable(T);
+#elif defined(__has_builtin) && __has_builtin(__is_trivially_relocatable)
+    __is_trivially_relocatable(T);
+#else
+    std::is_trivially_copyable_v<T>;
+#endif
+
 // NOLINTEND(readability-identifier-naming)
 } // namespace psr
 
diff --git a/include/phasar/Utils/ValueIdMap.h b/include/phasar/Utils/ValueIdMap.h
new file mode 100644
index 0000000000..27c43016d6
--- /dev/null
+++ b/include/phasar/Utils/ValueIdMap.h
@@ -0,0 +1,371 @@
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#ifndef PHASAR_UTILS_VALUEIDMAP_H
+#define PHASAR_UTILS_VALUEIDMAP_H
+
+#include "phasar/Utils/BitSet.h"
+#include "phasar/Utils/Macros.h"
+#include "phasar/Utils/TypeTraits.h"
+
+#include <cassert>
+#include <cstddef>
+#include <cstring>
+#include <memory>
+#include <new>
+#include <optional>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
+
+namespace psr {
+
+/// \brief A dense, partially-populated map keyed by a sequential integer-like
+/// id.
+///
+/// Models a subset of the std::unordered_map / llvm::DenseMap interface for
+/// keys that are dense unsigned integer ids (e.g. enum classes over uint32_t).
+/// Entries are stored in flat aligned storage; only explicitly inserted entries
+/// are ever constructed — there is no upfront default-construction of the
+/// entire value array.
+///
+/// Reallocation moves all live entries via their move constructors and then
+/// destroys the originals in one pass. Move constructors are assumed to be
+/// nothrow; the new storage allocation is protected by unique_ptr RAII.
+///
+/// The copy constructor provides the basic exception guarantee: if copying any
+/// value throws, already-copied values are destroyed and the allocation is
+/// freed. For nothrow-copy-constructible types the tracking overhead is
+/// eliminated at compile time.
+///
+/// Iterator and reference validity follows the same rules as std::vector:
+/// insertions that exceed the current capacity invalidate all iterators and
+/// references.
+///
+/// \tparam IdT    Key type. Must satisfy SmallIdType (fits in uint32_t,
+///                losslessly convertible to/from size_t).
+/// \tparam ValueT Mapped value type.
+// operator= takes Other by value -- handles both copy, and move cases
+// NOLINTNEXTLINE(cppcoreguidelines-special-member-functions)
+template <SmallIdType IdT, typename ValueT> class ValueIdMap {
+public:
+  // ── Types ──────────────────────────────────────────────────────────────────
+
+  using key_type = IdT;
+  using mapped_type = ValueT;
+  using value_type = std::pair<const IdT, ValueT>;
+  using size_type = size_t;
+
+  // ── Iterators ──────────────────────────────────────────────────────────────
+
+  /// Forward iterator over present entries. Dereferences to
+  /// std::pair<const IdT, ValueT&> by value; prefer structured bindings
+  /// (`auto [k, v]`) over `auto&` when iterating.
+  template <bool IsConst> class IteratorImpl {
+  public:
+    using MappedRef = std::conditional_t<IsConst, const ValueT &, ValueT &>;
+    using reference = std::pair<const IdT, MappedRef>;
+    using value_type = std::pair<const IdT, ValueT>;
+    using difference_type = ptrdiff_t;
+    using iterator_category = std::forward_iterator_tag;
+
+    constexpr IteratorImpl() noexcept = default;
+
+    /// Implicit conversion iterator → const_iterator.
+    template <bool WasConst>
+      requires(IsConst && !WasConst)
+    constexpr IteratorImpl(const IteratorImpl<WasConst> &Other) noexcept
+        : Map(Other.Map), CurrentKey(Other.CurrentKey) {}
+
+    constexpr reference operator*() const noexcept {
+      return {*CurrentKey, *Map->slotPtr(*CurrentKey)};
+    }
+
+    /// Arrow proxy enabling `it->first` and `it->second`.
+    struct ArrowProxy {
+      reference Ref;
+      constexpr reference *operator->() noexcept { return &Ref; }
+    };
+    constexpr ArrowProxy operator->() const noexcept { return {**this}; }
+
+    constexpr IteratorImpl &operator++() noexcept {
+      CurrentKey = Map->IsSet.findNext(*CurrentKey);
+      return *this;
+    }
+    constexpr IteratorImpl operator++(int) noexcept {
+      auto Ret = *this;
+      ++*this;
+      return Ret;
+    }
+
+    constexpr bool
+    operator==(const IteratorImpl &Other) const noexcept = default;
+
+  private:
+    using MapPtr =
+        std::conditional_t<IsConst, const ValueIdMap *, ValueIdMap *>;
+
+    template <bool> friend class IteratorImpl;
+    friend class ValueIdMap;
+
+    constexpr IteratorImpl(MapPtr Map, std::optional<IdT> Key) noexcept
+        : Map(Map), CurrentKey(Key) {}
+
+    MapPtr Map = nullptr;
+    std::optional<IdT> CurrentKey{};
+  };
+
+  using iterator = IteratorImpl<false>;
+  using const_iterator = IteratorImpl<true>;
+
+  // ── Constructors / destructor ──────────────────────────────────────────────
+
+  constexpr ValueIdMap() noexcept = default;
+
+  /// Pre-allocates storage for \p InitialCapacity entries without constructing
+  /// any values.
+  explicit ValueIdMap(size_t InitialCapacity)
+      : Capacity(InitialCapacity),
+        Slots(InitialCapacity ? new Slot[InitialCapacity] : nullptr) {
+    IsSet.reserve(InitialCapacity);
+  }
+
+  ValueIdMap(const ValueIdMap &Other)
+      : IsSet(Other.IsSet), Capacity(Other.Capacity) {
+    if (!Capacity) {
+      return;
+    }
+    std::unique_ptr<Slot[]> NewSlots(new Slot[Capacity]);
+    Other.IsSet.foreach ([&](IdT Key) {
+      // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+      ::new (NewSlots[size_t(Key)].Data) ValueT(*Other.slotPtr(Key));
+    });
+    Slots = NewSlots.release();
+  }
+
+  ValueIdMap(ValueIdMap &&Other) noexcept
+      : IsSet(std::move(Other.IsSet)),
+        Capacity(std::exchange(Other.Capacity, 0)),
+        Slots(std::exchange(Other.Slots, nullptr)) {}
+
+  ValueIdMap &operator=(ValueIdMap Other) {
+    swap(Other);
+    return *this;
+  }
+
+  ~ValueIdMap() {
+    clear();
+    delete[] Slots;
+  }
+
+  constexpr void swap(ValueIdMap &Other) noexcept {
+    std::swap(Slots, Other.Slots);
+    std::swap(Capacity, Other.Capacity);
+    std::swap(IsSet, Other.IsSet);
+  }
+  friend constexpr void swap(ValueIdMap &Lhs, ValueIdMap &Rhs) noexcept {
+    Lhs.swap(Rhs);
+  }
+
+  // ── Capacity ───────────────────────────────────────────────────────────────
+
+  /// Ensures storage for at least \p N entries without constructing any values.
+  void reserve(size_t N) {
+    if (N > Capacity) {
+      IsSet.reserve(N);
+      grow(N);
+    }
+  }
+
+  /// Returns the number of entries currently present.
+  [[nodiscard]] constexpr size_t size() const noexcept { return IsSet.size(); }
+  [[nodiscard]] constexpr bool empty() const noexcept { return IsSet.empty(); }
+
+  // ── Lookup ─────────────────────────────────────────────────────────────────
+
+  [[nodiscard]] constexpr bool contains(IdT Key) const noexcept {
+    return IsSet.contains(Key);
+  }
+  [[nodiscard]] constexpr size_t count(IdT Key) const noexcept {
+    return contains(Key) ? 1 : 0;
+  }
+
+  [[nodiscard]] constexpr iterator find(IdT Key) noexcept {
+    return contains(Key) ? iterator(this, Key) : end();
+  }
+  [[nodiscard]] constexpr const_iterator find(IdT Key) const noexcept {
+    return contains(Key) ? const_iterator(this, Key) : end();
+  }
+
+  /// Returns a reference to the value for \p Key.
+  /// \throws std::out_of_range if \p Key is not present.
+  [[nodiscard]] ValueT &at(IdT Key) {
+    if (!contains(Key)) {
+      throw std::out_of_range("ValueIdMap::at: key not found");
+    }
+    return *slotPtr(Key);
+  }
+  [[nodiscard]] const ValueT &at(IdT Key) const {
+    if (!contains(Key)) {
+      throw std::out_of_range("ValueIdMap::at: key not found");
+    }
+    return *slotPtr(Key);
+  }
+
+  // ── Element access ─────────────────────────────────────────────────────────
+
+  /// Returns a reference to the value for \p Key, default-constructing it if
+  /// absent (same semantics as std::unordered_map::operator[]).
+  ValueT &operator[](IdT Key) { return try_emplace(Key).first->second; }
+
+  // ── Modifiers ─────────────────────────────────────────────────────────────
+
+  /// Constructs a value from \p Args for \p Key if not already present.
+  /// Returns {iterator-to-entry, true} on insertion and
+  /// {iterator-to-existing-entry, false} otherwise.
+  template <typename... ArgsT>
+  std::pair<iterator, bool> try_emplace(IdT Key, ArgsT &&...Args) {
+    if (!inbounds(Key)) {
+      grow(std::max(size_t(Key) + 1, Capacity ? Capacity * 2 : 8));
+    } else if (IsSet.contains(Key)) {
+      return {iterator(this, Key), false};
+    }
+
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+    ::new (Slots[size_t(Key)].Data) ValueT(PSR_FWD(Args)...);
+    IsSet.insert(Key);
+    return {iterator(this, Key), true};
+  }
+
+  std::pair<iterator, bool> insert(value_type Val) {
+    return try_emplace(Val.first, std::move(Val.second));
+  }
+
+  /// Inserts or replaces the entry for \p Key with \p Obj.
+  template <typename M>
+  // NOLINTNEXTLINE(readability-identifier-naming) -- STL API name
+  std::pair<iterator, bool> insert_or_assign(IdT Key, M &&Obj) {
+    if (IsSet.contains(Key)) {
+      *slotPtr(Key) = std::forward<M>(Obj);
+      return {iterator(this, Key), false};
+    }
+    return try_emplace(Key, std::forward<M>(Obj));
+  }
+
+  /// Removes the entry for \p Key. Returns true if an entry was present.
+  bool erase(IdT Key) noexcept {
+    if (!IsSet.tryErase(Key)) {
+      return false;
+    }
+    slotPtr(Key)->~ValueT();
+    return true;
+  }
+
+  /// Removes the entry pointed to by \p It and returns an iterator to the
+  /// next entry.
+  iterator erase(iterator It) noexcept {
+    IdT Key = It->first;
+    ++It;
+    IsSet.erase(Key);
+    slotPtr(Key)->~ValueT();
+    return It;
+  }
+
+  /// Destroys all present entries without releasing the allocated storage.
+  void clear() noexcept {
+    if constexpr (!std::is_trivially_destructible_v<ValueT>) {
+      IsSet.foreach ([&](IdT Key) { slotPtr(Key)->~ValueT(); });
+    }
+    IsSet.clear();
+  }
+
+  // ── Iteration ─────────────────────────────────────────────────────────────
+
+  [[nodiscard]] constexpr iterator begin() noexcept {
+    return {this, IsSet.findFirst()};
+  }
+  [[nodiscard]] constexpr iterator end() noexcept {
+    return {this, std::nullopt};
+  }
+  [[nodiscard]] constexpr const_iterator begin() const noexcept {
+    return {this, IsSet.findFirst()};
+  }
+  [[nodiscard]] constexpr const_iterator end() const noexcept {
+    return {this, std::nullopt};
+  }
+  [[nodiscard]] constexpr const_iterator cbegin() const noexcept {
+    return begin();
+  }
+  [[nodiscard]] constexpr const_iterator cend() const noexcept { return end(); }
+
+private:
+  // ── Private types ──────────────────────────────────────────────────────────
+
+  // Holds raw bytes of the right size and alignment for one ValueT.
+  // No ValueT object lives here until explicitly placement-new'd.
+  struct alignas(ValueT) Slot {
+    std::byte Data[sizeof(ValueT)];
+  };
+
+  // ── Private helpers ────────────────────────────────────────────────────────
+
+  [[nodiscard]] ValueT *slotPtr(IdT Key) noexcept {
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+    return std::launder(reinterpret_cast<ValueT *>(Slots[size_t(Key)].Data));
+  }
+  [[nodiscard]] const ValueT *slotPtr(IdT Key) const noexcept {
+    return std::launder(
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+        reinterpret_cast<const ValueT *>(Slots[size_t(Key)].Data));
+  }
+
+  [[nodiscard]] constexpr bool inbounds(IdT Key) const noexcept {
+    return size_t(Key) < Capacity;
+  }
+
+  void grow(size_t NewCap) {
+    assert(NewCap > Capacity);
+    std::unique_ptr<Slot[]> New(new Slot[NewCap]);
+
+    if constexpr (IsTriviallyRelocatable<ValueT>) {
+      // Trivially relocatable: a flat memcpy of all used slots suffices.
+      // Uninitialized slots contain indeterminate bytes, which is safe to copy.
+      // No per-slot construction or destruction is needed.
+      if (Slots) {
+        memcpy(New.get(), Slots, Capacity * sizeof(Slot));
+      }
+    } else {
+      // Move-construct each live entry into new storage and destroy the
+      // original in one pass. Assumes nothrow move construction; types with
+      // throwing moves are not supported.
+      IsSet.foreach ([&](IdT Key) {
+        ValueT *Src = slotPtr(Key);
+        ::new (New[size_t(Key)].Data) ValueT(std::move(
+            *Src)); // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+        Src->~ValueT();
+      });
+    }
+
+    delete[] Slots;
+    Slots = New.release();
+    Capacity = NewCap;
+  }
+
+  // ── Data members ───────────────────────────────────────────────────────────
+
+  // IsSet must be declared first so that if its copy constructor throws during
+  // ValueIdMap's copy constructor, Slots has not yet been allocated.
+  BitSet<IdT> IsSet;
+  size_t Capacity = 0;
+  Slot *Slots = nullptr;
+};
+
+} // namespace psr
+
+#endif // PHASAR_UTILS_VALUEIDMAP_H
\ No newline at end of file
diff --git a/unittests/Utils/CMakeLists.txt b/unittests/Utils/CMakeLists.txt
index d84306e783..aca8f680fc 100644
--- a/unittests/Utils/CMakeLists.txt
+++ b/unittests/Utils/CMakeLists.txt
@@ -7,6 +7,7 @@ set(UtilsSources
   LLVMShorthandsTest.cpp
   PAMMTest.cpp
   StableVectorTest.cpp
+  ValueIdMapTest.cpp
   AnalysisPrinterTest.cpp
   OnTheFlyAnalysisPrinterTest.cpp
   SourceMgrPrinterTest.cpp
diff --git a/unittests/Utils/ValueIdMapTest.cpp b/unittests/Utils/ValueIdMapTest.cpp
new file mode 100644
index 0000000000..b9fb992ba7
--- /dev/null
+++ b/unittests/Utils/ValueIdMapTest.cpp
@@ -0,0 +1,445 @@
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
+#include "phasar/Utils/ValueIdMap.h"
+
+#include "gtest/gtest.h"
+
+#include <stdexcept>
+#include <string>
+#include <utility>
+
+using namespace psr;
+
+enum class Id : uint32_t {};
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+static constexpr Id id(uint32_t V) noexcept { return Id(V); }
+
+template <typename MapT> static void expectEmpty(const MapT &M) {
+  EXPECT_TRUE(M.empty());
+  EXPECT_EQ(0u, M.size());
+  EXPECT_EQ(M.end(), M.begin());
+}
+
+// ── Basic construction
+// ────────────────────────────────────────────────────────
+
+TEST(ValueIdMap, DefaultCtorEmpty) {
+  ValueIdMap<Id, int> M;
+  expectEmpty(M);
+  EXPECT_FALSE(M.contains(id(0)));
+  EXPECT_EQ(0u, M.count(id(0)));
+}
+
+TEST(ValueIdMap, ReserveCtorEmpty) {
+  ValueIdMap<Id, int> M(64);
+  expectEmpty(M);
+  EXPECT_FALSE(M.contains(id(0)));
+}
+
+// ── try_emplace
+// ───────────────────────────────────────────────────────────────
+
+TEST(ValueIdMap, TryEmplaceInsert) {
+  ValueIdMap<Id, int> M;
+  auto [It, Inserted] = M.try_emplace(id(3), 42);
+  EXPECT_TRUE(Inserted);
+  EXPECT_EQ(id(3), It->first);
+  EXPECT_EQ(42, It->second);
+  EXPECT_EQ(1u, M.size());
+  EXPECT_TRUE(M.contains(id(3)));
+}
+
+TEST(ValueIdMap, TryEmplaceDuplicate) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(3), 42);
+  auto [It, Inserted] = M.try_emplace(id(3), 99);
+  EXPECT_FALSE(Inserted);
+  EXPECT_EQ(42, It->second); // original value unchanged
+  EXPECT_EQ(1u, M.size());
+}
+
+TEST(ValueIdMap, TryEmplaceMultiple) {
+  ValueIdMap<Id, int> M;
+  for (uint32_t I = 0; I < 10; ++I) {
+    auto [It, Inserted] = M.try_emplace(id(I), int(I * 2));
+    EXPECT_TRUE(Inserted);
+    EXPECT_EQ(int(I * 2), It->second);
+  }
+  EXPECT_EQ(10u, M.size());
+  for (uint32_t I = 0; I < 10; ++I) {
+    EXPECT_TRUE(M.contains(id(I)));
+    EXPECT_EQ(int(I * 2), M.at(id(I)));
+  }
+}
+
+// ── operator[] ───────────────────────────────────────────────────────────────
+
+TEST(ValueIdMap, OperatorBracketInserts) {
+  ValueIdMap<Id, int> M;
+  M[id(5)] = 77;
+  EXPECT_EQ(1u, M.size());
+  EXPECT_EQ(77, M.at(id(5)));
+}
+
+TEST(ValueIdMap, OperatorBracketExisting) {
+  ValueIdMap<Id, int> M;
+  M[id(5)] = 77;
+  M[id(5)] = 99;
+  EXPECT_EQ(1u, M.size());
+  EXPECT_EQ(99, M.at(id(5)));
+}
+
+TEST(ValueIdMap, OperatorBracketDefaultConstructs) {
+  ValueIdMap<Id, int> M;
+  int &Ref = M[id(2)];
+  EXPECT_EQ(0,
+            Ref); // int default-initialised to 0 via value-init in try_emplace
+  EXPECT_EQ(1u, M.size());
+}
+
+// ── insert / insert_or_assign
+// ─────────────────────────────────────────────────
+
+TEST(ValueIdMap, InsertNew) {
+  ValueIdMap<Id, int> M;
+  auto [It, Inserted] = M.insert({id(7), 100});
+  EXPECT_TRUE(Inserted);
+  EXPECT_EQ(100, It->second);
+}
+
+TEST(ValueIdMap, InsertExisting) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(7), 100);
+  auto [It, Inserted] = M.insert({id(7), 200});
+  EXPECT_FALSE(Inserted);
+  EXPECT_EQ(100, It->second);
+}
+
+TEST(ValueIdMap, InsertOrAssignNew) {
+  ValueIdMap<Id, int> M;
+  auto [It, Inserted] = M.insert_or_assign(id(4), 55);
+  EXPECT_TRUE(Inserted);
+  EXPECT_EQ(55, It->second);
+}
+
+TEST(ValueIdMap, InsertOrAssignExisting) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(4), 55);
+  auto [It, Inserted] = M.insert_or_assign(id(4), 88);
+  EXPECT_FALSE(Inserted);
+  EXPECT_EQ(88, It->second);
+  EXPECT_EQ(88, M.at(id(4)));
+}
+
+// ── contains / count / find
+// ───────────────────────────────────────────────────
+
+TEST(ValueIdMap, ContainsFindAbsent) {
+  ValueIdMap<Id, int> M;
+  EXPECT_FALSE(M.contains(id(0)));
+  EXPECT_EQ(0u, M.count(id(0)));
+  EXPECT_EQ(M.end(), M.find(id(0)));
+}
+
+TEST(ValueIdMap, ContainsFindPresent) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(0), 1);
+  EXPECT_TRUE(M.contains(id(0)));
+  EXPECT_EQ(1u, M.count(id(0)));
+  auto It = M.find(id(0));
+  ASSERT_NE(M.end(), It);
+  EXPECT_EQ(1, It->second);
+}
+
+// ── at
+// ────────────────────────────────────────────────────────────────────────
+
+TEST(ValueIdMap, AtPresent) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(2), 42);
+  EXPECT_EQ(42, M.at(id(2)));
+  M.at(id(2)) = 99;
+  EXPECT_EQ(99, M.at(id(2)));
+}
+
+TEST(ValueIdMap, AtAbsentThrows) {
+  ValueIdMap<Id, int> M;
+  EXPECT_THROW(std::ignore = M.at(id(0)), std::out_of_range);
+}
+
+TEST(ValueIdMap, AtConstPresent) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(2), 42);
+  const auto &CM = M;
+  EXPECT_EQ(42, CM.at(id(2)));
+}
+
+TEST(ValueIdMap, AtConstAbsentThrows) {
+  const ValueIdMap<Id, int> M;
+  EXPECT_THROW(std::ignore = M.at(id(0)), std::out_of_range);
+}
+
+// ── erase
+// ─────────────────────────────────────────────────────────────────────
+
+TEST(ValueIdMap, EraseKeyPresent) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(1), 10);
+  EXPECT_TRUE(M.erase(id(1)));
+  EXPECT_EQ(0u, M.size());
+  EXPECT_FALSE(M.contains(id(1)));
+}
+
+TEST(ValueIdMap, EraseKeyAbsent) {
+  ValueIdMap<Id, int> M;
+  EXPECT_FALSE(M.erase(id(1)));
+}
+
+TEST(ValueIdMap, EraseIterator) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(1), 10);
+  M.try_emplace(id(3), 30);
+  M.try_emplace(id(5), 50);
+
+  auto It = M.find(id(3));
+  ASSERT_NE(M.end(), It);
+  It = M.erase(It);
+
+  EXPECT_EQ(2u, M.size());
+  EXPECT_FALSE(M.contains(id(3)));
+  // Iterator should now point at id(5) (the next key)
+  ASSERT_NE(M.end(), It);
+  EXPECT_EQ(id(5), It->first);
+}
+
+TEST(ValueIdMap, EraseIteratorLast) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(2), 20);
+  auto It = M.erase(M.begin());
+  EXPECT_EQ(M.end(), It);
+  EXPECT_TRUE(M.empty());
+}
+
+// ── clear
+// ─────────────────────────────────────────────────────────────────────
+
+TEST(ValueIdMap, ClearInt) {
+  ValueIdMap<Id, int> M;
+  for (uint32_t I = 0; I < 8; ++I) {
+    M.try_emplace(id(I), int(I));
+  }
+  M.clear();
+  expectEmpty(M);
+  EXPECT_FALSE(M.contains(id(0)));
+}
+
+TEST(ValueIdMap, ClearString) {
+  ValueIdMap<Id, std::string> M;
+  for (uint32_t I = 0; I < 8; ++I) {
+    M.try_emplace(id(I), std::to_string(I));
+  }
+  M.clear();
+  expectEmpty(M);
+}
+
+TEST(ValueIdMap, ReuseAfterClear) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(0), 1);
+  M.clear();
+  M.try_emplace(id(0), 2);
+  EXPECT_EQ(1u, M.size());
+  EXPECT_EQ(2, M.at(id(0)));
+}
+
+// ── Iteration
+// ─────────────────────────────────────────────────────────────────
+
+TEST(ValueIdMap, IterationOrder) {
+  // Keys must be visited in ascending order (BitSet property)
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(5), 50);
+  M.try_emplace(id(1), 10);
+  M.try_emplace(id(3), 30);
+
+  std::vector<uint32_t> Keys;
+  for (auto [K, V] : M) {
+    Keys.push_back(uint32_t(K));
+  }
+  ASSERT_EQ(3u, Keys.size());
+  EXPECT_EQ(1u, Keys[0]);
+  EXPECT_EQ(3u, Keys[1]);
+  EXPECT_EQ(5u, Keys[2]);
+}
+
+TEST(ValueIdMap, ConstIteration) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(2), 20);
+  M.try_emplace(id(4), 40);
+
+  const auto &CM = M;
+  int Sum = 0;
+  for (auto [K, V] : CM) {
+    Sum += V;
+  }
+  EXPECT_EQ(60, Sum);
+}
+
+TEST(ValueIdMap, IteratorToConstIterator) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(0), 7);
+  ValueIdMap<Id, int>::iterator It = M.begin();
+  ValueIdMap<Id, int>::const_iterator CIt = It; // implicit conversion
+  EXPECT_EQ(It->second, CIt->second);
+}
+
+// ── Copy / Move
+// ───────────────────────────────────────────────────────────────
+
+TEST(ValueIdMap, CopyCtorInt) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(1), 10);
+  M.try_emplace(id(3), 30);
+
+  ValueIdMap<Id, int> Copy(M);
+  EXPECT_EQ(2u, Copy.size());
+  EXPECT_EQ(10, Copy.at(id(1)));
+  EXPECT_EQ(30, Copy.at(id(3)));
+
+  // Independent
+  M.at(id(1)) = 99;
+  EXPECT_EQ(10, Copy.at(id(1)));
+}
+
+TEST(ValueIdMap, CopyCtorString) {
+  ValueIdMap<Id, std::string> M;
+  M.try_emplace(id(0), "hello");
+  M.try_emplace(id(2), "world");
+
+  ValueIdMap<Id, std::string> Copy(M);
+  EXPECT_EQ("hello", Copy.at(id(0)));
+  EXPECT_EQ("world", Copy.at(id(2)));
+}
+
+TEST(ValueIdMap, CopyCtorEmpty) {
+  ValueIdMap<Id, int> M;
+  ValueIdMap<Id, int> Copy(M);
+  expectEmpty(Copy);
+}
+
+TEST(ValueIdMap, MoveCtorInt) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(1), 10);
+  M.try_emplace(id(3), 30);
+
+  ValueIdMap<Id, int> Moved(std::move(M));
+  EXPECT_EQ(2u, Moved.size());
+  EXPECT_EQ(10, Moved.at(id(1)));
+  EXPECT_EQ(30, Moved.at(id(3)));
+}
+
+TEST(ValueIdMap, CopyAssign) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(0), 5);
+  ValueIdMap<Id, int> Other;
+  Other = M;
+  EXPECT_EQ(5, Other.at(id(0)));
+}
+
+TEST(ValueIdMap, MoveAssign) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(0), 5);
+  ValueIdMap<Id, int> Other;
+  Other = std::move(M);
+  EXPECT_EQ(5, Other.at(id(0)));
+}
+
+TEST(ValueIdMap, SelfAssign) {
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(0), 42);
+  M = M; // NOLINT(clang-diagnostic-self-assign-overloaded)
+  EXPECT_EQ(42, M.at(id(0)));
+}
+
+// ── Reallocation (grow)
+// ───────────────────────────────────────────────────────
+
+TEST(ValueIdMap, GrowTrivial) {
+  // Insert enough keys to force multiple reallocations
+  ValueIdMap<Id, int> M(4);
+  for (uint32_t I = 0; I < 100; ++I) {
+    M.try_emplace(id(I), int(I));
+  }
+  EXPECT_EQ(100u, M.size());
+  for (uint32_t I = 0; I < 100; ++I) {
+    EXPECT_EQ(int(I), M.at(id(I)));
+  }
+}
+
+TEST(ValueIdMap, GrowNonTrivial) {
+  // std::string is not trivially relocatable; exercises the move path in grow()
+  ValueIdMap<Id, std::string> M(4);
+  for (uint32_t I = 0; I < 100; ++I) {
+    M.try_emplace(id(I), std::to_string(I));
+  }
+  EXPECT_EQ(100u, M.size());
+  for (uint32_t I = 0; I < 100; ++I) {
+    EXPECT_EQ(std::to_string(I), M.at(id(I)));
+  }
+}
+
+TEST(ValueIdMap, GrowSparseKeys) {
+  // Sparse insertion: only a few high-valued keys, triggering capacity growth
+  ValueIdMap<Id, int> M;
+  M.try_emplace(id(0), 0);
+  M.try_emplace(id(63), 63);
+  M.try_emplace(id(127), 127);
+  EXPECT_EQ(3u, M.size());
+  EXPECT_EQ(0, M.at(id(0)));
+  EXPECT_EQ(63, M.at(id(63)));
+  EXPECT_EQ(127, M.at(id(127)));
+}
+
+// ── Swap
+// ──────────────────────────────────────────────────────────────────────
+
+TEST(ValueIdMap, Swap) {
+  ValueIdMap<Id, int> A;
+  A.try_emplace(id(1), 10);
+  ValueIdMap<Id, int> B;
+  B.try_emplace(id(2), 20);
+  B.try_emplace(id(3), 30);
+
+  swap(A, B);
+  EXPECT_EQ(2u, A.size());
+  EXPECT_EQ(20, A.at(id(2)));
+  EXPECT_EQ(30, A.at(id(3)));
+  EXPECT_EQ(1u, B.size());
+  EXPECT_EQ(10, B.at(id(1)));
+}
+
+// ── reserve
+// ───────────────────────────────────────────────────────────────────
+
+TEST(ValueIdMap, ReserveNoConstruct) {
+  ValueIdMap<Id, int> M;
+  M.reserve(64);
+  expectEmpty(M);
+  EXPECT_FALSE(M.contains(id(0)));
+  // Inserting within reserved capacity should not reallocate
+  M.try_emplace(id(10), 100);
+  EXPECT_EQ(100, M.at(id(10)));
+}
+
+int main(int Argc, char **Argv) {
+  ::testing::InitGoogleTest(&Argc, Argv);
+  return RUN_ALL_TESTS();
+}

From b8b2afc909c0b2b3bebf35e31bc39067cb8d3205 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Thu, 26 Mar 2026 18:15:17 +0100
Subject: [PATCH 65/75] minor

---
 include/phasar/Utils/ValueIdMap.h | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/include/phasar/Utils/ValueIdMap.h b/include/phasar/Utils/ValueIdMap.h
index 27c43016d6..9837bcccc4 100644
--- a/include/phasar/Utils/ValueIdMap.h
+++ b/include/phasar/Utils/ValueIdMap.h
@@ -36,18 +36,19 @@ namespace psr {
 /// entire value array.
 ///
 /// Reallocation moves all live entries via their move constructors and then
-/// destroys the originals in one pass. Move constructors are assumed to be
-/// nothrow; the new storage allocation is protected by unique_ptr RAII.
+/// destroys the originals in one pass. **Move constructors are assumed to be
+/// nothrow**.
 ///
 /// The copy constructor provides the basic exception guarantee: if copying any
 /// value throws, already-copied values are destroyed and the allocation is
-/// freed. For nothrow-copy-constructible types the tracking overhead is
-/// eliminated at compile time.
+/// freed.
 ///
 /// Iterator and reference validity follows the same rules as std::vector:
 /// insertions that exceed the current capacity invalidate all iterators and
 /// references.
 ///
+/// \remarks Partially implemented by Claude Sonnet 4.6
+///
 /// \tparam IdT    Key type. Must satisfy SmallIdType (fits in uint32_t,
 ///                losslessly convertible to/from size_t).
 /// \tparam ValueT Mapped value type.

From 0db8f4a968743928c2d658e8a76908cb1709ef23 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Thu, 26 Mar 2026 18:17:49 +0100
Subject: [PATCH 66/75] pre-commit

---
 include/phasar/Utils/TypeTraits.h | 3 ++-
 include/phasar/Utils/ValueIdMap.h | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/include/phasar/Utils/TypeTraits.h b/include/phasar/Utils/TypeTraits.h
index d266b7e68a..65d172c1de 100644
--- a/include/phasar/Utils/TypeTraits.h
+++ b/include/phasar/Utils/TypeTraits.h
@@ -300,7 +300,8 @@ template <typename ArgT> struct DummyFn {
 /// Falls back to std::is_trivially_copyable_v on other compilers.
 template <typename T>
 inline constexpr bool IsTriviallyRelocatable =
-#if defined(__has_builtin) && __has_builtin(__builtin_is_cpp_trivially_relocatable)
+#if defined(__has_builtin) &&                                                  \
+    __has_builtin(__builtin_is_cpp_trivially_relocatable)
     __builtin_is_cpp_trivially_relocatable(T);
 #elif defined(__has_builtin) && __has_builtin(__is_trivially_relocatable)
     __is_trivially_relocatable(T);
diff --git a/include/phasar/Utils/ValueIdMap.h b/include/phasar/Utils/ValueIdMap.h
index 9837bcccc4..3bead9adb9 100644
--- a/include/phasar/Utils/ValueIdMap.h
+++ b/include/phasar/Utils/ValueIdMap.h
@@ -369,4 +369,4 @@ template <SmallIdType IdT, typename ValueT> class ValueIdMap {
 
 } // namespace psr
 
-#endif // PHASAR_UTILS_VALUEIDMAP_H
\ No newline at end of file
+#endif // PHASAR_UTILS_VALUEIDMAP_H

From 0906dbfe21f5fabd83e8755d729c5d07911152f2 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Fri, 27 Mar 2026 10:22:57 +0100
Subject: [PATCH 67/75] Cleanup + bug fixing

---
 .github/workflows/deploy-docs.yml             |  1 +
 .../Pointer/LLVMPointerAssignmentGraph.h      |  9 +++
 .../PhasarLLVM/Pointer/LLVMUnionFindAA.h      |  9 +++
 .../Pointer/LLVMUnionFindAliasSet.h           |  9 +++
 .../phasar/PhasarLLVM/Utils/LLVMShorthands.h  | 20 +++++-
 include/phasar/Pointer/BottomupUnionFindAA.h  | 12 +++-
 .../Pointer/CallingContextConstructor.h       |  9 +++
 .../phasar/Pointer/PointerAssignmentGraph.h   | 31 ++++++---
 include/phasar/Pointer/RawAliasSet.h          |  9 +++
 include/phasar/Pointer/UnionFindAA.h          |  9 +++
 include/phasar/Utils/FileUtils.hpp            | 11 ----
 include/phasar/Utils/IO.h                     |  3 +
 include/phasar/Utils/NonNullPtr.h             |  9 +++
 include/phasar/Utils/StrongTypeDef.h          |  9 ++-
 include/phasar/Utils/TypedArray.h             |  9 +++
 include/phasar/Utils/UnionFind.h              |  9 +++
 include/phasar/Utils/ValueCompressor.h        | 11 +++-
 lib/PhasarLLVM/Pointer/FilteredAliasesUtils.h |  9 +++
 .../Pointer/LLVMPointerAssignmentGraph.cpp    | 63 ++++++++++++++++---
 lib/PhasarLLVM/Pointer/SVF/InitSVF.h          |  9 +++
 lib/PhasarLLVM/Utils/LLVMShorthands.cpp       | 15 +++++
 lib/Utils/FileUtils.cpp                       | 25 --------
 lib/Utils/IO.cpp                              | 17 +++++
 tools/ptaben/AliasQueryType.h                 |  9 +++
 tools/ptaben/PTAResult.h                      |  9 +++
 tools/ptaben/PTAUtils.h                       |  9 +++
 tools/ptaben/QueryId.h                        |  9 +++
 tools/ptaben/QueryLocation.h                  |  9 +++
 tools/ptaben/QuerySer.h                       |  9 +++
 tools/ptaben/ResultsCollector.h               |  9 +++
 tools/ptaben/ptaben_benchmark_tool.cpp        |  2 +-
 31 files changed, 321 insertions(+), 61 deletions(-)
 delete mode 100755 include/phasar/Utils/FileUtils.hpp
 delete mode 100755 lib/Utils/FileUtils.cpp

diff --git a/.github/workflows/deploy-docs.yml b/.github/workflows/deploy-docs.yml
index f17f92e0e4..600be9314a 100644
--- a/.github/workflows/deploy-docs.yml
+++ b/.github/workflows/deploy-docs.yml
@@ -8,6 +8,7 @@ permissions:
   contents: write
 jobs:
   build-and-deploy:
+    if: github.repository == 'secure-software-engineering/phasar'
     runs-on: ubuntu-24.04
     strategy:
       fail-fast: true
diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h b/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
index 98539a23da..1a2f152bc0 100644
--- a/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
@@ -1,5 +1,14 @@
 #pragma once
 
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
 #include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
 #include "phasar/PhasarLLVM/Domain/LLVMAnalysisDomain.h"
 #include "phasar/Pointer/PointerAssignmentGraph.h"
diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
index 0cc8351154..64bc9fe146 100644
--- a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
@@ -1,5 +1,14 @@
 #pragma once
 
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
 #include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraph.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h"
diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h
index 9cc84386be..54e098fec9 100644
--- a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h
@@ -1,5 +1,14 @@
 #pragma once
 
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
 #include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCallGraph.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h"
diff --git a/include/phasar/PhasarLLVM/Utils/LLVMShorthands.h b/include/phasar/PhasarLLVM/Utils/LLVMShorthands.h
index 4ef206dabc..3426cffc3a 100644
--- a/include/phasar/PhasarLLVM/Utils/LLVMShorthands.h
+++ b/include/phasar/PhasarLLVM/Utils/LLVMShorthands.h
@@ -262,14 +262,28 @@ bool isGuardVariable(const llvm::Value *V);
  */
 bool isStaticVariableLazyInitializationBranch(const llvm::BranchInst *Inst);
 
+[[nodiscard]] inline bool
+definitelyContainsNoPointerFast(const llvm::Type *Ty) noexcept {
+  return Ty->isIntOrIntVectorTy() || Ty->isFloatingPointTy() ||
+         Ty->isFPOrFPVectorTy() || Ty->isVoidTy();
+}
+
+namespace detail {
+bool definitelyContainsNoPointerImpl(const llvm::Type *Ty) noexcept;
+} // namespace detail
+
 /// Approximates, whether the given LLVM type may not contain a pointer.
 /// This check is designed to be extremely lightweight and is therefore not very
 /// precise.
 ///
 /// \returns True, iff it can be proven that Ty does *not* contain a pointer
-[[nodiscard]] inline bool definitelyContainsNoPointer(const llvm::Type *Ty) {
-  return Ty->isIntOrIntVectorTy() || Ty->isFloatingPointTy() ||
-         Ty->isFPOrFPVectorTy() || Ty->isVoidTy();
+[[nodiscard]] inline bool
+definitelyContainsNoPointer(const llvm::Type *Ty) noexcept {
+  if (definitelyContainsNoPointerFast(Ty)) {
+    return true;
+  }
+
+  return detail::definitelyContainsNoPointerImpl(Ty);
 }
 /// Approximates, whether the given LLVM value may not contain a pointer.
 /// This check is designed to be extremely lightweight and is therefore not very
diff --git a/include/phasar/Pointer/BottomupUnionFindAA.h b/include/phasar/Pointer/BottomupUnionFindAA.h
index 3a7c7b867f..036fb62e88 100644
--- a/include/phasar/Pointer/BottomupUnionFindAA.h
+++ b/include/phasar/Pointer/BottomupUnionFindAA.h
@@ -1,5 +1,14 @@
 #pragma once
 
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
 #include "phasar/ControlFlow/CallGraph.h"
 #include "phasar/ControlFlow/CallGraphBase.h"
 #include "phasar/Pointer/PointerAssignmentGraph.h"
@@ -92,6 +101,7 @@ class BottomupUnionFindAA : BottomupUnionFindAABase {
         IdsForSum[ToSCC].insert(To);
         return;
       }
+      // fallthrough -- intra-SCC edges are context-insensitive
     } else if (E.isa<pag::Return>()) {
       auto FromSCC = SCCOfVal[From];
       auto ToSCC = SCCOfVal[To];
@@ -104,7 +114,7 @@ class BottomupUnionFindAA : BottomupUnionFindAABase {
         IdsForSum[FromSCC].insert(From);
         return;
       }
-      return;
+      // fallthrough -- intra-SCC edges are context-insensitive
     }
 
     Base.onAddEdge(From, To, E, CallSite);
diff --git a/include/phasar/Pointer/CallingContextConstructor.h b/include/phasar/Pointer/CallingContextConstructor.h
index 44bb517bf3..9d3d579f14 100644
--- a/include/phasar/Pointer/CallingContextConstructor.h
+++ b/include/phasar/Pointer/CallingContextConstructor.h
@@ -1,5 +1,14 @@
 #pragma once
 
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
 #include "phasar/ControlFlow/CallGraph.h"
 #include "phasar/DB/ProjectIRDBBase.h"
 #include "phasar/Utils/ByRef.h"
diff --git a/include/phasar/Pointer/PointerAssignmentGraph.h b/include/phasar/Pointer/PointerAssignmentGraph.h
index 59c266d40b..5397e1eed3 100644
--- a/include/phasar/Pointer/PointerAssignmentGraph.h
+++ b/include/phasar/Pointer/PointerAssignmentGraph.h
@@ -1,5 +1,14 @@
 #pragma once
 
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
 #include "phasar/Utils/ByRef.h"
 #include "phasar/Utils/Macros.h"
 #include "phasar/Utils/Nullable.h"
@@ -175,17 +184,20 @@ struct PBStrategyCombinator {
     requires(CanGetNumPossibleValues<FirstT> ||
              CanGetNumPossibleValues<SecondT>)
   {
-    if constexpr (CanGetNumPossibleValues<SecondT>) {
-      return Second.getNumPossibleValues(IRDB);
-    }
-    if constexpr (CanGetNumPossibleValues<FirstT>) {
-      return First.getNumPossibleValues(IRDB);
-    }
+    const auto Retrieve = [&IRDB]<typename S>(const S &Strategy) {
+      if constexpr (CanGetNumPossibleValues<S>) {
+        return Strategy.getNumPossibleValues(IRDB);
+      }
+      return 0;
+    };
+
+    return std::max(Retrieve(First), Retrieve(Second));
   }
 
   constexpr void
   withCalleesOfCallAt(ByConstRef<n_t> CS,
                       llvm::function_ref<void(f_t)> WithCallee) const {
+    // We assume, both are on the same call-graph.
     if constexpr (CanWithCalleesOfCallAt<SecondT>) {
       Second.withCalleesOfCallAt(CS, WithCallee);
     } else {
@@ -194,10 +206,9 @@ struct PBStrategyCombinator {
   }
 
   constexpr auto consumeAAResults(size_t NumVars) &&
-    requires(CanConsumeAAResults<FirstT> && !CanConsumeAAResults<SecondT>)
-  {
-    return std::move(First).consumeAAResults(NumVars);
-  }
+      requires(CanConsumeAAResults<FirstT> && !CanConsumeAAResults<SecondT>) {
+        return std::move(First).consumeAAResults(NumVars);
+      }
 };
 
 template <CanOnAddEdge FirstT, PBStrategyBase SecondT>
diff --git a/include/phasar/Pointer/RawAliasSet.h b/include/phasar/Pointer/RawAliasSet.h
index 8e39d2003b..37cd452457 100644
--- a/include/phasar/Pointer/RawAliasSet.h
+++ b/include/phasar/Pointer/RawAliasSet.h
@@ -1,5 +1,14 @@
 #pragma once
 
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
 #include "phasar/Utils/TypeTraits.h"
 
 #include "llvm/ADT/SparseBitVector.h"
diff --git a/include/phasar/Pointer/UnionFindAA.h b/include/phasar/Pointer/UnionFindAA.h
index e57701578b..41bc4bf0ed 100644
--- a/include/phasar/Pointer/UnionFindAA.h
+++ b/include/phasar/Pointer/UnionFindAA.h
@@ -1,5 +1,14 @@
 #pragma once
 
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
 #include "phasar/ControlFlow/CallGraph.h"
 #include "phasar/Pointer/CallingContextConstructor.h"
 #include "phasar/Pointer/PointerAssignmentGraph.h"
diff --git a/include/phasar/Utils/FileUtils.hpp b/include/phasar/Utils/FileUtils.hpp
deleted file mode 100755
index 7fdc6b5da2..0000000000
--- a/include/phasar/Utils/FileUtils.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#pragma once
-
-#include "llvm/ADT/Twine.h"
-#include "llvm/Support/raw_ostream.h"
-
-#include <memory>
-
-namespace psr {
-std::unique_ptr<llvm::raw_ostream>
-openFileForWrite(const llvm::Twine &FilePath);
-} // namespace psr
diff --git a/include/phasar/Utils/IO.h b/include/phasar/Utils/IO.h
index 081332b9a1..fc332ade83 100644
--- a/include/phasar/Utils/IO.h
+++ b/include/phasar/Utils/IO.h
@@ -52,6 +52,9 @@ void writeTextFile(const llvm::Twine &Path, llvm::StringRef Content);
 [[nodiscard]] std::unique_ptr<llvm::raw_fd_ostream>
 openFileStream(const llvm::Twine &Filename);
 
+std::unique_ptr<llvm::raw_ostream>
+openFileForWrite(const llvm::Twine &FilePath);
+
 } // namespace psr
 
 #endif
diff --git a/include/phasar/Utils/NonNullPtr.h b/include/phasar/Utils/NonNullPtr.h
index f7ed812d93..0a978a5ede 100644
--- a/include/phasar/Utils/NonNullPtr.h
+++ b/include/phasar/Utils/NonNullPtr.h
@@ -1,5 +1,14 @@
 #pragma once
 
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
 #include "phasar/Utils/Utilities.h"
 
 #include "llvm/Support/Compiler.h"
diff --git a/include/phasar/Utils/StrongTypeDef.h b/include/phasar/Utils/StrongTypeDef.h
index 80dae2e5d1..85c906f81f 100644
--- a/include/phasar/Utils/StrongTypeDef.h
+++ b/include/phasar/Utils/StrongTypeDef.h
@@ -1,6 +1,13 @@
 #pragma once
 
-#pragma once
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
 
 #include "phasar/Utils/ByRef.h"
 
diff --git a/include/phasar/Utils/TypedArray.h b/include/phasar/Utils/TypedArray.h
index 82ebd6defb..470c9455b3 100644
--- a/include/phasar/Utils/TypedArray.h
+++ b/include/phasar/Utils/TypedArray.h
@@ -1,5 +1,14 @@
 #pragma once
 
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
 #include "phasar/Utils/ByRef.h"
 #include "phasar/Utils/TypeTraits.h"
 
diff --git a/include/phasar/Utils/UnionFind.h b/include/phasar/Utils/UnionFind.h
index 5dd78257de..6bca925caa 100644
--- a/include/phasar/Utils/UnionFind.h
+++ b/include/phasar/Utils/UnionFind.h
@@ -1,5 +1,14 @@
 #pragma once
 
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
 #include "phasar/Utils/TypeTraits.h"
 
 #include "llvm/ADT/IntEqClasses.h"
diff --git a/include/phasar/Utils/ValueCompressor.h b/include/phasar/Utils/ValueCompressor.h
index e8ab22d37a..b3d9b7c74f 100644
--- a/include/phasar/Utils/ValueCompressor.h
+++ b/include/phasar/Utils/ValueCompressor.h
@@ -1,5 +1,14 @@
 #pragma once
 
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
 #include "phasar/Utils/ByRef.h"
 #include "phasar/Utils/StrongTypeDef.h"
 #include "phasar/Utils/TypedVector.h"
@@ -95,7 +104,7 @@ template <typename T> class ValueCompressor {
   }
 
   [[nodiscard]] size_t size() const noexcept { return Id2Vars.size(); }
-  [[nodiscard]] size_t empty() const noexcept { return Id2Vars.empty(); }
+  [[nodiscard]] bool empty() const noexcept { return Id2Vars.empty(); }
 
 private:
   llvm::DenseMap<T, ValueId> Var2Id;
diff --git a/lib/PhasarLLVM/Pointer/FilteredAliasesUtils.h b/lib/PhasarLLVM/Pointer/FilteredAliasesUtils.h
index 49a6373ac3..a41cd73455 100644
--- a/lib/PhasarLLVM/Pointer/FilteredAliasesUtils.h
+++ b/lib/PhasarLLVM/Pointer/FilteredAliasesUtils.h
@@ -1,5 +1,14 @@
 #pragma once
 
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalAlias.h"
 #include "llvm/IR/GlobalVariable.h"
diff --git a/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp b/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp
index 254ed238ee..63ebf47d58 100644
--- a/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp
+++ b/lib/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.cpp
@@ -73,10 +73,6 @@ struct GlobalCache {
       return Vec;
     }
 
-    if (!llvm::isa<llvm::ConstantAggregate>(Const)) {
-      return {};
-    }
-
     // TODO: Get rid of the recursion
 
     if (const auto *Arr = llvm::dyn_cast<llvm::ConstantAggregate>(Const)) {
@@ -256,6 +252,7 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
 
   void addDelayedEdges(LLVMPBStrategyRef Strategy) {
     OnlyIncomingStoresAndOutgoingLoads.foreach ([this, &Strategy](auto VId) {
+      // TODO: Is this condition correct?
       const bool NeedsStoreSafetyFallback =
           OutgoingLoads[VId].empty() &&
           llvm::any_of(VC.id2vars(VId), [](PAGVariable Var) {
@@ -331,6 +328,14 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
     if (const auto *Select = llvm::dyn_cast<llvm::SelectInst>(&I)) {
       return handleSelect(Strategy, Select);
     }
+
+    if (const auto *EV = llvm::dyn_cast<llvm::ExtractValueInst>(&I)) {
+      return handleExtractValue(Strategy, EV);
+    }
+
+    if (const auto *IV = llvm::dyn_cast<llvm::InsertValueInst>(&I)) {
+      return handleInsertValue(Strategy, IV);
+    }
   }
 
   static void handleOperand(const llvm::Value *RawOp,
@@ -413,7 +418,9 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
     auto OperandObj = getVariable(Op, Strategy);
 
     if (llvm::isa<llvm::GEPOperator>(Cast)) {
-      if (const auto *LocalGeps = psr::getOrNull(this->LocalGeps, Cast)) {
+      // accumulate all known offsets, since we have seen a non-constant GEP on
+      // this pointer-op:
+      if (const auto *LocalGeps = psr::getOrNull(this->LocalGeps, Op)) {
         for (auto [_, Gep] : *LocalGeps) {
           addEdge(Strategy, OperandObj, Gep, Assign{}, nullptr);
         }
@@ -451,6 +458,8 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
           // Do not add an edge! Geps should be decoupled!
           return;
         }
+
+        // fallthrough -- non-constant GEP
       }
 
       handleCastImpl(Strategy, Gep, PointerOp);
@@ -486,7 +495,7 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
     const bool HasLibrarySummary = MLSum.mapFunctionSummary(
         Callee, [&](uint32_t ParamIdx, library_summary::DataFlowFact Dest,
                     pag::Edge E) {
-          if (ParamIdx > Args.size()) {
+          if (ParamIdx >= Args.size()) {
             return;
           }
           const auto HandleArgs = [&](ValueId DestVal) {
@@ -496,6 +505,10 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
           };
           if (const auto *DestParam =
                   Dest.dyn_cast<library_summary::Parameter>()) {
+            if (DestParam->Index >= Args.size()) {
+              // safety fallback if library-summary is wrong
+              return;
+            }
             for (const auto &DestVal : Args[DestParam->Index]) {
               HandleArgs(DestVal);
             }
@@ -621,8 +634,42 @@ struct [[clang::internal_linkage]] LLVMPAGBuilder::PAGBuildData {
     }
     if (!definitelyContainsNoPointer(FalseVal)) {
       handleOperand(FalseVal, [&](const auto *FalseOp) {
-        auto TrueObj = getVariable(FalseOp, Strategy);
-        addEdge(Strategy, TrueObj, SelectObj, Assign{}, Select);
+        auto FalseObj = getVariable(FalseOp, Strategy);
+        addEdge(Strategy, FalseObj, SelectObj, Assign{}, Select);
+      });
+    }
+  }
+
+  void handleExtractValue(LLVMPBStrategyRef Strategy,
+                          const llvm::ExtractValueInst *EV) {
+    if (definitelyContainsNoPointer(EV)) {
+      return;
+    }
+
+    auto ResultObj = getVariable(EV, Strategy);
+    handleOperand(EV->getAggregateOperand(), [&](const auto *AggOp) {
+      auto AggObj = getVariable(AggOp, Strategy);
+      addEdge(Strategy, AggObj, ResultObj, Assign{}, EV);
+    });
+  }
+
+  void handleInsertValue(LLVMPBStrategyRef Strategy,
+                         const llvm::InsertValueInst *IV) {
+    if (definitelyContainsNoPointer(IV)) {
+      return;
+    }
+
+    auto ResultObj = getVariable(IV, Strategy);
+    if (!definitelyContainsNoPointer(IV->getAggregateOperand())) {
+      handleOperand(IV->getAggregateOperand(), [&](const auto *AggOp) {
+        auto AggObj = getVariable(AggOp, Strategy);
+        addEdge(Strategy, AggObj, ResultObj, Assign{}, IV);
+      });
+    }
+    if (!definitelyContainsNoPointer(IV->getInsertedValueOperand())) {
+      handleOperand(IV->getInsertedValueOperand(), [&](const auto *ValOp) {
+        auto ValObj = getVariable(ValOp, Strategy);
+        addEdge(Strategy, ValObj, ResultObj, Assign{}, IV);
       });
     }
   }
diff --git a/lib/PhasarLLVM/Pointer/SVF/InitSVF.h b/lib/PhasarLLVM/Pointer/SVF/InitSVF.h
index 2599a3626e..72472ab55c 100644
--- a/lib/PhasarLLVM/Pointer/SVF/InitSVF.h
+++ b/lib/PhasarLLVM/Pointer/SVF/InitSVF.h
@@ -1,5 +1,14 @@
 #pragma once
 
+/******************************************************************************
+ * Copyright (c) 2025 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
 #include "llvm/Support/Compiler.h"
 
 namespace SVF {
diff --git a/lib/PhasarLLVM/Utils/LLVMShorthands.cpp b/lib/PhasarLLVM/Utils/LLVMShorthands.cpp
index 2e7dba48fa..0b870d0c3c 100644
--- a/lib/PhasarLLVM/Utils/LLVMShorthands.cpp
+++ b/lib/PhasarLLVM/Utils/LLVMShorthands.cpp
@@ -17,6 +17,7 @@
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
 
 #include "phasar/Config/Configuration.h"
+#include "phasar/Utils/Fn.h"
 #include "phasar/Utils/LibrarySummary.h"
 #include "phasar/Utils/Utilities.h"
 
@@ -584,6 +585,20 @@ bool psr::isStaticVariableLazyInitializationBranch(
   return false;
 }
 
+[[nodiscard]] bool
+psr::detail::definitelyContainsNoPointerImpl(const llvm::Type *Ty) noexcept {
+  if (const auto *Arr = llvm::dyn_cast<llvm::ArrayType>(Ty)) {
+    return definitelyContainsNoPointerFast(Arr->getElementType());
+  }
+
+  if (const auto *Struct = llvm::dyn_cast<llvm::StructType>(Ty)) {
+    return llvm::all_of(Struct->elements(),
+                        fn<definitelyContainsNoPointerFast>);
+  }
+
+  return false;
+}
+
 bool psr::isVarAnnotationIntrinsic(const llvm::Function *F) {
   static constexpr llvm::StringLiteral KVarAnnotationName(
       "llvm.var.annotation");
diff --git a/lib/Utils/FileUtils.cpp b/lib/Utils/FileUtils.cpp
deleted file mode 100755
index ceccc5a36c..0000000000
--- a/lib/Utils/FileUtils.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#include "phasar/Utils/FileUtils.hpp"
-
-#include "llvm/ADT/SmallString.h"
-#include "llvm/ADT/Twine.h"
-#include "llvm/Support/raw_ostream.h"
-
-#include <memory>
-#include <system_error>
-
-std::unique_ptr<llvm::raw_ostream>
-psr::openFileForWrite(const llvm::Twine &FilePath) {
-  llvm::SmallString<256> Buf;
-  auto FileName = FilePath.toStringRef(Buf);
-
-  std::error_code EC;
-  auto Ret = std::make_unique<llvm::raw_fd_ostream>(FileName, EC);
-  if (EC) {
-    llvm::errs() << "[ERROR]: Failed to open file '" << FileName
-                 << "' for writing:\n";
-    llvm::errs() << "  > " << EC.message() << '\n';
-    Ret.reset();
-  }
-
-  return Ret;
-}
diff --git a/lib/Utils/IO.cpp b/lib/Utils/IO.cpp
index b016db47d4..05f1514302 100644
--- a/lib/Utils/IO.cpp
+++ b/lib/Utils/IO.cpp
@@ -87,3 +87,20 @@ psr::openFileStream(const llvm::Twine &Filename) {
   }
   return OFS;
 }
+
+std::unique_ptr<llvm::raw_ostream>
+psr::openFileForWrite(const llvm::Twine &FilePath) {
+  llvm::SmallString<256> Buf;
+  auto FileName = FilePath.toStringRef(Buf);
+
+  std::error_code EC;
+  auto Ret = std::make_unique<llvm::raw_fd_ostream>(FileName, EC);
+  if (EC) {
+    llvm::errs() << "[ERROR]: Failed to open file '" << FileName
+                 << "' for writing:\n";
+    llvm::errs() << "  > " << EC.message() << '\n';
+    Ret.reset();
+  }
+
+  return Ret;
+}
diff --git a/tools/ptaben/AliasQueryType.h b/tools/ptaben/AliasQueryType.h
index a83e1f923c..443851b8c3 100755
--- a/tools/ptaben/AliasQueryType.h
+++ b/tools/ptaben/AliasQueryType.h
@@ -1,5 +1,14 @@
 #pragma once
 
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
 #include "phasar/Pointer/AliasResult.h"
 
 #include "llvm/ADT/StringRef.h"
diff --git a/tools/ptaben/PTAResult.h b/tools/ptaben/PTAResult.h
index 6a22290fd1..429b990ff2 100755
--- a/tools/ptaben/PTAResult.h
+++ b/tools/ptaben/PTAResult.h
@@ -1,5 +1,14 @@
 #pragma once
 
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
 #include "phasar/Pointer/AliasResult.h"
 
 #include "llvm/Support/raw_ostream.h"
diff --git a/tools/ptaben/PTAUtils.h b/tools/ptaben/PTAUtils.h
index f2b3093147..e9e920ac40 100755
--- a/tools/ptaben/PTAUtils.h
+++ b/tools/ptaben/PTAUtils.h
@@ -1,5 +1,14 @@
 #pragma once
 
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
 #include "phasar/Pointer/AliasResult.h"
 
 #include "llvm/ADT/SmallVector.h"
diff --git a/tools/ptaben/QueryId.h b/tools/ptaben/QueryId.h
index e9dde07c3b..972df391b5 100755
--- a/tools/ptaben/QueryId.h
+++ b/tools/ptaben/QueryId.h
@@ -1,5 +1,14 @@
 #pragma once
 
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
 #include <cstdint>
 
 namespace psr::ptaben {
diff --git a/tools/ptaben/QueryLocation.h b/tools/ptaben/QueryLocation.h
index 4ea0b3f19f..368247a0ea 100755
--- a/tools/ptaben/QueryLocation.h
+++ b/tools/ptaben/QueryLocation.h
@@ -1,5 +1,14 @@
 #pragma once
 
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
 #include "AliasQueryType.h"
 #include "QueryId.h"
 
diff --git a/tools/ptaben/QuerySer.h b/tools/ptaben/QuerySer.h
index 48931eed88..55ee864f3d 100755
--- a/tools/ptaben/QuerySer.h
+++ b/tools/ptaben/QuerySer.h
@@ -1,5 +1,14 @@
 #pragma once
 
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
 #include "llvm/Support/raw_ostream.h"
 
 #include "PTAUtils.h"
diff --git a/tools/ptaben/ResultsCollector.h b/tools/ptaben/ResultsCollector.h
index 3cb77e4787..273098e44f 100755
--- a/tools/ptaben/ResultsCollector.h
+++ b/tools/ptaben/ResultsCollector.h
@@ -1,5 +1,14 @@
 #pragma once
 
+/******************************************************************************
+ * Copyright (c) 2026 Fabian Schiebel.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel and others
+ *****************************************************************************/
+
 #include "llvm/Support/raw_ostream.h"
 
 #include "PTAResult.h"
diff --git a/tools/ptaben/ptaben_benchmark_tool.cpp b/tools/ptaben/ptaben_benchmark_tool.cpp
index 7433ac959c..a59feaa4e7 100644
--- a/tools/ptaben/ptaben_benchmark_tool.cpp
+++ b/tools/ptaben/ptaben_benchmark_tool.cpp
@@ -13,7 +13,7 @@
 #include "phasar/Pointer/AliasAnalysisType.h"
 #include "phasar/Pointer/AliasResult.h"
 #include "phasar/Pointer/UnionFindAliasAnalysisType.h"
-#include "phasar/Utils/FileUtils.hpp"
+#include "phasar/Utils/IO.h"
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"

From cd3ccb98842438f4b0d255455f9792a25f1a37ae Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Fri, 27 Mar 2026 11:49:00 +0100
Subject: [PATCH 68/75] Add Doxygen comments to new alias-analysis headers

Documents edge types, concepts, strategy combinators, analysis variants
(BasicUnionFindAA, CallingContextSens, IndirectionSens, BottomupUnionFindAA),
LLVM adapters, and utility types (RawAliasSet, UnionFind, ValueCompressor,
TypedArray, CallingContextConstructor).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../Pointer/LLVMPointerAssignmentGraph.h      | 15 +++++++
 .../PhasarLLVM/Pointer/LLVMUnionFindAA.h      | 44 +++++++++++++++++++
 .../Pointer/LLVMUnionFindAliasSet.h           | 21 +++++++++
 include/phasar/Pointer/BottomupUnionFindAA.h  | 19 ++++++++
 .../Pointer/CallingContextConstructor.h       | 20 +++++++++
 .../phasar/Pointer/PointerAssignmentGraph.h   | 35 +++++++++++++++
 include/phasar/Pointer/RawAliasSet.h          | 10 +++++
 include/phasar/Pointer/UnionFindAA.h          | 38 +++++++++++++---
 include/phasar/Utils/TypedArray.h             |  8 ++++
 include/phasar/Utils/UnionFind.h              | 17 +++++++
 include/phasar/Utils/ValueCompressor.h        |  9 ++++
 11 files changed, 230 insertions(+), 6 deletions(-)

diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h b/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
index 1a2f152bc0..7f118a7d4b 100644
--- a/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMPointerAssignmentGraph.h
@@ -91,13 +91,28 @@ struct PAGVariable : public llvm::PointerIntPair<const llvm::Value *, 1, bool> {
 
 [[nodiscard]] std::string to_string(PAGVariable Var);
 
+/// Analysis domain for LLVM-IR pointer-assignment graphs.
+/// Uses \c PAGVariable as the variable type and the standard LLVM instruction /
+/// function / project-IRDB types from \c LLVMAnalysisDomainDefault.
 struct LLVMPAGDomain : LLVMAnalysisDomainDefault {
   using v_t = PAGVariable;
 };
 
+/// Concrete \c PAGBuilder for LLVM IR.
+///
+/// Traverses all functions in the given \c LLVMProjectIRDB and emits PAG
+/// nodes and edges to the provided \c PBStrategyRef.
+///
+/// Achieves basic field sensitivity by handlking constant GEPs in an ad-hoc
+/// manner.
+///
+/// An optional \c LLVMFunctionDataFlowFacts object can be supplied to apply
+/// pre-computed library summaries at potentially declaration-only calls.
 class LLVMPAGBuilder : public PAGBuilder<LLVMPAGDomain> {
 public:
   constexpr LLVMPAGBuilder() noexcept = default;
+  /// \param MLSum Pre-computed library summary facts. If non-null, callee
+  ///   analysis for matched library functions is replaced by these summaries.
   constexpr LLVMPAGBuilder(
       const library_summary::LLVMFunctionDataFlowFacts *MLSum) noexcept
       : MLSum(MLSum) {}
diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
index 64bc9fe146..30972bc9c7 100644
--- a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAA.h
@@ -35,6 +35,9 @@ extern template class CallingContextSensUnionFindAA<LLVMPAGDomain>;
 extern template class IndirectionSensUnionFindAA<LLVMPAGDomain>;
 extern template class BottomupUnionFindAA<LLVMPAGDomain>;
 
+/// Returns a \c ValueId handler suitable for \c RawAliasSet::foreach() that
+/// maps each alias \c ValueId back to all of its underlying \c llvm::Value*
+/// (via \p VC), forwarding non-null values to \p Callback.
 constexpr std::invocable<ValueId> auto
 llvmUnionFindAliasHandler(const ValueCompressor<PAGVariable> &VC,
                           std::invocable<const llvm::Value *> auto Callback) {
@@ -67,6 +70,18 @@ class LLVMCGProvider : public LLVMPAGDomain {
 };
 } // namespace pag
 
+/// CRTP mixin that adds the LLVM alias-iterator interface to a class that
+/// holds a \c UnionFindAAResult and a \c ValueCompressor<PAGVariable>.
+///
+/// Provides \c forallAliasesOf(), \c mayAlias(), and \c alias() overloads
+/// accepting both \c llvm::Value* and \c ValueId arguments.  Results are
+/// reported as \c llvm::Value* via the stored \c ValueCompressor.
+///
+/// The derived class must expose a \c VC member (pointer to a
+/// \c ValueCompressor<PAGVariable>).
+///
+/// \tparam Derived The CRTP derived class.
+/// \tparam AAResT  A type satisfying \c UnionFindAAResult.
 template <typename Derived, typename AAResT>
   requires UnionFindAAResult<std::remove_cvref_t<AAResT>>
 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
@@ -178,6 +193,15 @@ class LLVMLocalUnionFindAliasIteratorBase {
 };
 } // namespace detail
 
+/// CRTP mixin adding a function-local view on top of a global
+/// \c UnionFindAAResult.
+///
+/// Extends \c LLVMUnionFindAliasIteratorMixin with \c forallAliasesOf()
+/// overloads that accept an \c llvm::Function* or \c llvm::Instruction*
+/// context.  When a non-null context is provided, alias sets are intersected
+/// with the set of variables that are visible in that function (globals plus
+/// locals defined in that function), giving a function-local result even
+/// though the underlying analysis is interprocedural.
 template <typename Derived, typename AAResT>
 class LLVMLocalUnionFindAliasIteratorMixin
     : public detail::LLVMLocalUnionFindAliasIteratorBase {
@@ -309,6 +333,17 @@ class LLVMLocalUnionFindAliasIterator
   NonNullPtr<const ValueCompressor<PAGVariable>> VC;
 };
 
+/// Low-level entry point: builds the PAG for \p IRDB using the given
+/// \p AnalysisT strategy, and returns the raw alias-analysis result (not
+/// wrapped in an \c LLVMUnionFindAliasIterator).
+///
+/// \param IRDB   The project to analyze.
+/// \param Ana    A \c PBStrategy instance (e.g., \c BasicUnionFindAA,
+///               \c BottomupUnionFindAA).  Taken by forwarding reference and
+///               consumed when results are extracted.
+/// \param VC     Optional pre-populated \c ValueCompressor.  A new one is
+///               allocated if null.
+/// \param Impl   PAG builder implementation (default: \c LLVMPAGBuilder).
 template <pag::PBStrategy AnalysisT,
           std::derived_from<PAGBuilder<LLVMPAGDomain>> PAGBuilderImpl =
               LLVMPAGBuilder>
@@ -361,6 +396,15 @@ computeBotCtxIndSensUnionFindAARaw(
     const LLVMProjectIRDB &IRDB, const LLVMBasedCallGraph &CG,
     MaybeUniquePtr<ValueCompressor<PAGVariable>> VC = nullptr);
 
+/// Builds the PAG and returns a \c LLVMUnionFindAliasIterator (owns the \c
+/// ValueCompressor and the raw result) that implements the \c
+/// IsLLVMAliasIterator concept.
+///
+/// \param IRDB   The project to analyze.
+/// \param Ana    A \c PBStrategy instance. Consumed when results are extracted.
+/// \param VC     Optional pre-populated \c ValueCompressor. A new one is
+///               allocated if null; the iterator takes ownership.
+/// \param Impl   PAG builder implementation (default: \c LLVMPAGBuilder).
 template <pag::PBStrategy AnalysisT,
           std::derived_from<PAGBuilder<LLVMPAGDomain>> PAGBuilderImpl =
               LLVMPAGBuilder>
diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h
index 54e098fec9..06675f30da 100644
--- a/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h
+++ b/include/phasar/PhasarLLVM/Pointer/LLVMUnionFindAliasSet.h
@@ -41,6 +41,19 @@ template <>
 struct AliasInfoTraits<LLVMUnionFindAliasSet>
     : DefaultAATraits<const llvm::Value *, const llvm::Instruction *> {};
 
+/// Concrete \c IsAliasInfo implementation backed by a union-find alias
+/// analysis.
+///
+/// Constructed once from an \c LLVMProjectIRDB and a call graph; the chosen
+/// analysis variant is determined by \c Config.  Alias sets are materialized
+/// lazily on first query and cached per \c ValueId in \c AliasSets.
+///
+/// \note When \c AnalysisLocality::FunctionLocal is selected, alias sets are
+///   filtered to variables visible in the function that contains the query
+///   instruction.  The per-\c ValueId cache does **not** account for the
+///   instruction context, so the first caller's function wins — do not mix
+///   queries to local pointers from different functions for the same value in
+///   local mode.
 class LLVMUnionFindAliasSet
     : public AnalysisPropertiesMixin<LLVMUnionFindAliasSet> {
 public:
@@ -51,14 +64,22 @@ class LLVMUnionFindAliasSet
   using AliasSetPtrTy = traits_t::AliasSetPtrTy;
   using AllocationSiteSetPtrTy = traits_t::AllocationSiteSetPtrTy;
 
+  /// Whether alias sets are reported globally or filtered to the function
+  /// containing the query instruction.
   enum class AnalysisLocality : uint8_t {
+    /// All aliases across all functions are reported.
     Global,
+    /// Aliases are intersected with variables visible in the querying function
+    /// (globals + function-local values).
     FunctionLocal,
   };
 
   struct Config {
+    /// The specific union-find analysis variant to run (default:
+    /// \c BotCtxIndSens — bottom-up, context- and indirection-sensitive).
     UnionFindAliasAnalysisType AType =
         UnionFindAliasAnalysisType::BotCtxIndSens;
+    /// Controls whether alias sets are scoped to the querying function.
     AnalysisLocality ALocality = AnalysisLocality::Global;
   };
 
diff --git a/include/phasar/Pointer/BottomupUnionFindAA.h b/include/phasar/Pointer/BottomupUnionFindAA.h
index 036fb62e88..d4a69ee9ca 100644
--- a/include/phasar/Pointer/BottomupUnionFindAA.h
+++ b/include/phasar/Pointer/BottomupUnionFindAA.h
@@ -40,6 +40,25 @@ struct BottomupUnionFindAABase {
   static constexpr llvm::StringLiteral LogCategory = "BottomupUnionFindAA";
 };
 
+/// SCC-based, bottom-up union-find alias analysis.
+///
+/// Interprocedural Steensgaard-style analysis with summary propagation along
+/// the SCC DAG of the call graph.
+///
+/// When \p SoundnessFlag is \c Soundness::Soundy (default), a top-down pass
+/// propagates parameter aliasing information back to callers for soundness.
+/// Set it to \c Soundness::Unsound to skip this pass and trade precision for
+/// speed.
+///
+/// Intra-SCC Call/Return edges (mutual recursion) are handled
+/// context-insensitively.
+///
+/// Implements \c pag::PBStrategy. After \c buildPAG() completes, call
+/// \c consumeAAResults() to obtain a \c BasicUnionFindAAResult.
+///
+/// \tparam AnalysisDomainT The analysis domain, e.g., \c LLVMPAGDomain.
+/// \tparam SoundnessFlag   Controls whether the top-down parameter-aliasing
+///                         pass is performed.
 template <typename AnalysisDomainT, Soundness SoundnessFlag = Soundness::Soundy>
 class BottomupUnionFindAA : BottomupUnionFindAABase {
   struct ParamInfo {
diff --git a/include/phasar/Pointer/CallingContextConstructor.h b/include/phasar/Pointer/CallingContextConstructor.h
index 9d3d579f14..41ef39c16a 100644
--- a/include/phasar/Pointer/CallingContextConstructor.h
+++ b/include/phasar/Pointer/CallingContextConstructor.h
@@ -22,9 +22,13 @@
 #include <cstdint>
 
 namespace psr {
+/// A K-limited call-string context.  Stores the \p K most recent call-sites
+/// that led to the current execution point (index 0 = most recent).  The
+/// default \p K = 1 gives a 1-call-site context (CFA/k-CFA style).
 template <typename N, unsigned K = 1> struct CallingContext {
   using n_t = N;
 
+  /// The K most recent call-sites; index 0 is the most recent.
   std::array<n_t, K> Callers{};
 
   [[nodiscard]] friend auto hash_value(const CallingContext &CC) {
@@ -80,6 +84,17 @@ PHASAR_STRONG_TYPEDEF(psr, uint32_t, CallingContextId, None = 0);
 
 namespace psr {
 
+/// Manages the set of calling contexts encountered for a given analysis and
+/// maps them to dense sequential \c CallingContextId values.
+///
+/// Used by \c CallingContextSensUnionFindAA to enumerate all call-string
+/// prefixes of length ≤ K for each function.  Contexts are interned in a
+/// \c Compressor; \c CallingContextId::None (id 0) always represents the
+/// "no calling context" (top-level / uncalled) entry.
+///
+/// \tparam N  Node type (call-site).
+/// \tparam F  Function type.
+/// \tparam K  Maximum call-string depth (must be in [1, 9]).
 template <typename N, typename F, unsigned K = 1>
 class CallingContextConstructor {
 public:
@@ -95,6 +110,9 @@ class CallingContextConstructor {
     CC2Id.getOrInsert(CallingContext<n_t, K>{});
   }
 
+  /// Enumerates all call-string prefixes of length ≤ K that lead to \p Fun
+  /// and invokes \p CCVisitor(firstCallSite, contextId) for each one.
+  /// If \p Fun has no callers (or K is exhausted), the "None" context is used.
   template <typename DBTy>
   void visitAllCallingContexts(
       const llvm::Function *Fun, const CallGraph<n_t, f_t> &CG,
@@ -104,6 +122,8 @@ class CallingContextConstructor {
     visitAllCallingContextsImpl<0>(Fun, CG, IRDB, CCVisitor, Ctx);
   }
 
+  /// Enumerates all calling contexts that include \p Call as their most recent
+  /// call-site and invokes \p CCVisitor(contextId) for each one.
   template <typename DBTy>
   void visitContextsAtCall(ByConstRef<n_t> Call, const CallGraph<n_t, f_t> &CG,
                            const ProjectIRDBBase<DBTy> &IRDB,
diff --git a/include/phasar/Pointer/PointerAssignmentGraph.h b/include/phasar/Pointer/PointerAssignmentGraph.h
index 5397e1eed3..f111659f4b 100644
--- a/include/phasar/Pointer/PointerAssignmentGraph.h
+++ b/include/phasar/Pointer/PointerAssignmentGraph.h
@@ -29,19 +29,31 @@
 namespace psr {
 
 namespace pag {
+/// Direct pointer assignment: `To = From`.
 struct Assign {};
+/// GEP (field-access) edge. \p Offset holds the byte offset when statically
+/// known; \c std::nullopt for non-constant GEPs.
 struct Gep {
   std::optional<int16_t> Offset;
 };
+/// Passing an argument at a call site. \p ArgNo is the 0-based parameter index.
 struct Call {
   uint16_t ArgNo;
 };
+/// Return value flows from callee to caller call-site.
 struct Return {};
+/// Load of a pointer: `To = *From`.
 struct Load {};
+/// Store of a non-aliased pointer: `*To = From`.
 struct Store {};
+/// Store of a potentially aliased pointer: `*To = From`.
 struct StorePOI {};
+/// Block-copy of aggregate memory (e.g., memcpy/memmove): all pointer fields
+/// inside the source are assumed to flow to the corresponding fields of the
+/// destination.
 struct Copy {};
 
+/// Tagged union of all PAG edge kinds, see above.
 struct Edge : public std::variant<Assign, Gep, Call, Return, Load, Store,
                                   StorePOI, Copy> {
   using Base =
@@ -117,6 +129,9 @@ concept CanWithCalleesOfCallAt =
       CStrategy.withCalleesOfCallAt(Inst, [](typename T::f_t Callee) {});
     };
 
+/// Minimal requirements for a PAG-builder strategy: analysis-domain type
+/// members plus \c withCalleesOfCallAt.  Does not require \c onAddEdge; use
+/// \c PBStrategy for the full requirement set.
 template <typename T>
 concept PBStrategyBase =
     CanWithCalleesOfCallAt<T> &&
@@ -136,6 +151,8 @@ concept CanOnAddValue = requires(T &Strategy, const T::v_t &Var) {
   Strategy.onAddValue(Var, ValueId{});
 };
 
+/// A PAG-strategy that can provide a capacity hint for the
+/// number of PAG nodes (used to pre-allocate internal buffers).
 template <typename T>
 concept CanGetNumPossibleValues =
     requires(const T &CStrategy, const T::db_t &IRDB) {
@@ -148,6 +165,12 @@ template <typename T>
 concept CanConsumeAAResults =
     requires(T Strategy) { std::move(Strategy).consumeAAResults(size_t(0)); };
 
+/// Fans out every PAG-builder callback to two independent strategies.
+/// \p FirstT must be a full \c PBStrategy; \p SecondT only needs to satisfy
+/// \c CanOnAddEdge (it borrows the \c withCalleesOfCallAt and analysis-domain
+/// types from \p FirstT).
+///
+/// Useful for intersecting alias analyses.
 template <PBStrategy FirstT, CanOnAddEdgeN<typename FirstT::n_t> SecondT>
 // requires(std::same_as<typename FirstT::n_t, typename SecondT::n_t> &&
 //          std::same_as<typename FirstT::v_t, typename SecondT::v_t> &&
@@ -211,6 +234,14 @@ struct PBStrategyCombinator {
       }
 };
 
+/// Upgrades a \c CanOnAddEdge type to a full \c PBStrategy by mixing in the
+/// analysis-domain types and \c withCalleesOfCallAt from a separate
+/// \c PBStrategyBase.  Typical use: wrap an edge-listener (e.g., a union-find
+/// accumulator) that does not own a call-graph with a call-graph provider.
+///
+/// \tparam FirstT  The edge-listener. Must satisfy \c CanOnAddEdge.
+/// \tparam SecondT The call-graph / domain provider. Must satisfy
+///                 \c PBStrategyBase.
 template <CanOnAddEdge FirstT, PBStrategyBase SecondT>
 struct PBMixin : public FirstT {
   using n_t = typename SecondT::n_t;
@@ -235,6 +266,10 @@ struct PBMixin : public FirstT {
   }
 };
 
+/// Debug-only PAG-builder strategy that emits the PAG as a Graphviz DOT
+/// digraph to \c llvm::errs().  The opening \c "digraph PAG {" is printed in
+/// the constructor and the closing brace in the destructor (move-construction
+/// transfers ownership, preventing a double-close).
 struct TracingPBStrategy {
   bool Engaged = true;
 
diff --git a/include/phasar/Pointer/RawAliasSet.h b/include/phasar/Pointer/RawAliasSet.h
index 37cd452457..2aa70f0f31 100644
--- a/include/phasar/Pointer/RawAliasSet.h
+++ b/include/phasar/Pointer/RawAliasSet.h
@@ -17,6 +17,9 @@
 
 namespace psr {
 
+/// Concept for alias-set containers used inside the union-find analyses.
+/// The container must support set insertion, membership test, bitwise
+/// union/intersection/difference, a \c foreach() visitor, and comparison.
 template <typename ASet>
 concept IsRawAliasSet = requires(ASet &MutSet, const ASet &ConstSet,
                                  typename ASet::value_type ValId) {
@@ -42,6 +45,13 @@ concept IsRawAliasSet = requires(ASet &MutSet, const ASet &ConstSet,
   { ConstSet.size() } noexcept -> std::convertible_to<size_t>;
 };
 
+/// Sparse bit-set used to represent alias sets in union-find analyses.
+///
+/// Currently backed by \c llvm::SparseBitVector for compact storage when ids
+/// are scattered in a large range and dense storage when ids are clustered.
+/// Satisfies \c IsRawAliasSet.
+///
+/// \tparam IdT Integer-like id type (e.g., \c ValueId).
 template <SmallIdType IdT> class RawAliasSet {
 public:
   using value_type = IdT;
diff --git a/include/phasar/Pointer/UnionFindAA.h b/include/phasar/Pointer/UnionFindAA.h
index 41bc4bf0ed..b7f52cf4a4 100644
--- a/include/phasar/Pointer/UnionFindAA.h
+++ b/include/phasar/Pointer/UnionFindAA.h
@@ -79,6 +79,10 @@ struct UnionFindAAResultIntersection {
   [[no_unique_address]] SecondT Second;
 };
 
+/// Specialization of \c PBStrategyCombinator for two union-find analyses whose
+/// results should be intersected for better precision.  Both analyses must
+/// operate on the same analysis domain. After \c buildPAG() completes, call
+/// \c consumeAAResults() to obtain a \c UnionFindAAResultIntersection.
 template <pag::PBStrategy FirstT, pag::CanOnAddEdge SecondT>
   requires(std::same_as<typename FirstT::n_t, typename SecondT::n_t> &&
            std::same_as<typename FirstT::v_t, typename SecondT::v_t> &&
@@ -104,8 +108,17 @@ template <typename FirstT, typename SecondT>
 UnionFindAACombinator(FirstT, SecondT)
     -> UnionFindAACombinator<FirstT, SecondT>;
 
-/// Lazy caching of union-find alias-analysis results. This class is *not*
-/// thread-safe!
+/// Lazy cache that wraps any \c UnionFindAAResult and memoises
+/// \c getRawAliasSet() results in a \c ValueIdMap.
+///
+/// Not thread-safe. Each unique \p ValueId is computed at most once on first
+/// access.
+///
+/// \tparam ShouldCacheMayAlias  When \c true (default), \c mayAlias() is
+///   answered via the cached alias sets (one set look-up).  When \c false,
+///   \c mayAlias() is forwarded directly to the underlying result without
+///   materializing a set, which can be faster for analyses whose
+///   \c mayAlias() implementation is already O(1).
 template <UnionFindAAResult AAResT, bool ShouldCacheMayAlias = true>
 class CachedUnionFindAAResult {
 public:
@@ -156,17 +169,25 @@ struct UnionFindAliasIterator {
   }
 };
 
-/// Common base-class of union-find alias-analysis results.
+/// Common storage for union-find alias-analysis results: a \c BackwardView
+/// that maps each equivalence-class representative (\c ObjectRepId) to the
+/// set of all \c ValueId members in that class.
 struct UnionFindAAResultBase {
+  /// Opaque id for equivalence-class representatives after \c compress().
   enum class ObjectRepId : uint32_t {};
 
+  /// Maps each \c ObjectRepId (equivalence class) to the set of \c ValueId
+  /// members it contains.
   TypedVector<ObjectRepId, RawAliasSet<ValueId>> BackwardView;
 
   void dump(llvm::raw_ostream &OS = llvm::errs(), uint32_t Indent = 0) const;
 };
 
-/// Basic implementation of union-find alias-analysis results.
+/// Alias-analysis result for flow- and context-insensitive union-find
+/// analyses.  Each \c ValueId maps to exactly one \c ObjectRepId
+/// (its equivalence-class representative).
 struct BasicUnionFindAAResult : UnionFindAAResultBase {
+  /// Maps each \c ValueId to its equivalence-class representative.
   TypedVector<ValueId, ObjectRepId> Var2Rep;
 
   [[nodiscard]] static constexpr bool isCached() noexcept { return true; }
@@ -195,9 +216,14 @@ struct BasicUnionFindAAResult : UnionFindAAResultBase {
   }
 };
 
-/// Union-find alias-analysis results for an analysis that achieves (partial)
-/// calling-context sensitivity through heap cloning.
+/// Alias-analysis result for calling-context-sensitive union-find analyses.
+///
+/// A single \c ValueId can belong to multiple equivalence classes (one per
+/// calling context it was cloned into), so \c Var2Rep holds a small vector
+/// of \c ObjectRepId values per variable.
 struct CallingContextSensUnionFindAAResult : UnionFindAAResultBase {
+  /// Maps each \c ValueId to the set of equivalence-class representatives it
+  /// belongs to (one per calling context).
   TypedVector<ValueId, llvm::SmallVector<ObjectRepId, 2>> Var2Rep{};
 
   [[nodiscard]] static constexpr bool isCached() noexcept { return false; }
diff --git a/include/phasar/Utils/TypedArray.h b/include/phasar/Utils/TypedArray.h
index 470c9455b3..be1aa0fbba 100644
--- a/include/phasar/Utils/TypedArray.h
+++ b/include/phasar/Utils/TypedArray.h
@@ -19,9 +19,17 @@
 
 namespace psr {
 
+/// Tag type for the generator constructor of \c TypedArray.
 struct generate_tag_t {};
+/// Tag value passed to the \c TypedArray generator constructor.
 inline constexpr generate_tag_t generate_tag{};
 
+/// Fixed-size array indexed by a strongly-typed id \p IdT instead of
+/// \c size_t.
+///
+/// \tparam IdT    Index type.  Must satisfy \c IdType (fits in \c size_t).
+/// \tparam ValueT Element type.
+/// \tparam N      Compile-time size.
 template <IdType IdT, typename ValueT, unsigned N>
 class TypedArray : public std::array<ValueT, N> {
   using Base = std::array<ValueT, N>;
diff --git a/include/phasar/Utils/UnionFind.h b/include/phasar/Utils/UnionFind.h
index 6bca925caa..3589179b84 100644
--- a/include/phasar/Utils/UnionFind.h
+++ b/include/phasar/Utils/UnionFind.h
@@ -18,6 +18,15 @@ namespace psr {
 template <SmallIdType IdT = uint32_t, SmallIdType MappedIdT = IdT>
 class CompressedUnionFind;
 
+/// Mutable union-find (disjoint-set) data structure over integer-like ids.
+///
+/// Supports \c join() (union by rank with path compression, via
+/// \c llvm::IntEqClasses) and \c find() (representative look-up). When all
+/// unions have been performed, call \c compress() to obtain a
+/// \c CompressedUnionFind that assigns dense sequential class indices.
+///
+/// \tparam IdT  Element type.  Must satisfy \c SmallIdType (fits in
+///              \c uint32_t).
 template <SmallIdType IdT = uint32_t> class UnionFind {
 public:
   UnionFind() noexcept = default;
@@ -38,6 +47,14 @@ template <SmallIdType IdT = uint32_t> class UnionFind {
   llvm::IntEqClasses Equiv;
 };
 
+/// Read-only view of a compressed union-find: maps each original element to a
+/// dense sequential class index in the range [0, numClasses()).
+///
+/// Obtained by calling \c UnionFind::compress<MappedIdT>(); not directly
+/// constructible.
+///
+/// \tparam IdT       Original element type.
+/// \tparam MappedIdT Type for the dense class indices.
 template <SmallIdType IdT, SmallIdType MappedIdT> class CompressedUnionFind {
 public:
   [[nodiscard]] size_t numClasses() const noexcept {
diff --git a/include/phasar/Utils/ValueCompressor.h b/include/phasar/Utils/ValueCompressor.h
index b3d9b7c74f..d325841586 100644
--- a/include/phasar/Utils/ValueCompressor.h
+++ b/include/phasar/Utils/ValueCompressor.h
@@ -66,6 +66,9 @@ template <typename T> class ValueCompressor {
     return Var2Id;
   }
 
+  /// Inserts \p Var and assigns it a fresh \c ValueId, or returns the existing
+  /// id if \p Var was already present.
+  /// \returns {id, true} on first insertion; {id, false} if already present.
   std::pair<ValueId, bool> insert(ByConstRef<T> Var) {
     auto [It, Inserted] = Var2Id.try_emplace(Var, ValueId(Id2Vars.size()));
     if (Inserted) {
@@ -74,6 +77,10 @@ template <typename T> class ValueCompressor {
     return {It->second, Inserted};
   }
 
+  /// Registers \p Var as an additional name for the existing \p Id (aliasing).
+  /// \p Id must already exist.  If \p Var already maps to some id, this is a
+  /// no-op and returns \c false; otherwise the mapping is added and \c true is
+  /// returned.
   bool addAlias(ByConstRef<T> Var, ValueId Id) {
     assert(Id2Vars.inbounds(Id) &&
            "Can only add an alias to an already existing Id!");
@@ -84,6 +91,8 @@ template <typename T> class ValueCompressor {
     return false;
   }
 
+  /// Allocates a fresh \c ValueId with no associated variable (a placeholder
+  /// or sentinel slot).
   [[nodiscard]] ValueId addDummy() {
     auto Ret = ValueId(Id2Vars.size());
     Id2Vars.emplace_back();

From fea1d900b034c68f621f86cb0674c23b4e6fc7de Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Fri, 27 Mar 2026 13:00:02 +0100
Subject: [PATCH 69/75] minor

---
 tools/ptaben/README.md | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/tools/ptaben/README.md b/tools/ptaben/README.md
index de3706b892..8fdb75307f 100644
--- a/tools/ptaben/README.md
+++ b/tools/ptaben/README.md
@@ -19,9 +19,10 @@ Currently, the benchmark tool supports the following analyses:
 
 Of course, you can extend this tool and provide your own analyses here.
 
-## Results
-|           | anders | steens | ctx-sens | bot-sens | ind-sens | ctx-ind-sens | bot-ctx-ind-sens | overall |
-|-----------|--------|--------|----------|----------|----------|--------------|------------------|---------|
-| precision | 0.712  | 0.709  | 0.803    | 0.800    | 0.681    | 0.803        | 0.800            | 0.754   |
-| recall    | 0.961  | 0.975  | 0.929    | 0.667    | 0.960    | 0.929        | 0.667            | 0.861   |
-| f1score   | 0.818  | 0.821  | 0.862    | 0.728    | 0.796    | 0.862        | 0.728            | 0.804   |
+## Preliminary Results
+
+|           | anders | steens | ctx-sens | bot-sens | ind-sens | ctx-ind-sens | bot-ctx-ind-sens |
+|-----------|--------|--------|----------|----------|----------|--------------|------------------|
+| precision | 0.712  | 0.709  | 0.803    | 0.800    | 0.681    | 0.803        | 0.800            |
+| recall    | 0.961  | 0.975  | 0.929    | 0.667    | 0.960    | 0.929        | 0.667            |
+| f1score   | 0.818  | 0.821  | 0.862    | 0.728    | 0.796    | 0.862        | 0.728            |

From 0ef96dd20488acbeac3e7f21f0707eecfa423760 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Sun, 29 Mar 2026 20:11:02 +0200
Subject: [PATCH 70/75] Make ValueIdMap allocator-aware

---
 include/phasar/Utils/ValueIdMap.h | 280 ++++++++++++++++++++++--------
 1 file changed, 207 insertions(+), 73 deletions(-)

diff --git a/include/phasar/Utils/ValueIdMap.h b/include/phasar/Utils/ValueIdMap.h
index 3bead9adb9..608abdd87e 100644
--- a/include/phasar/Utils/ValueIdMap.h
+++ b/include/phasar/Utils/ValueIdMap.h
@@ -18,7 +18,7 @@
 #include <cstddef>
 #include <cstring>
 #include <memory>
-#include <new>
+#include <memory_resource>
 #include <optional>
 #include <stdexcept>
 #include <type_traits>
@@ -31,30 +31,26 @@ namespace psr {
 ///
 /// Models a subset of the std::unordered_map / llvm::DenseMap interface for
 /// keys that are dense unsigned integer ids (e.g. enum classes over uint32_t).
-/// Entries are stored in flat aligned storage; only explicitly inserted entries
-/// are ever constructed — there is no upfront default-construction of the
-/// entire value array.
+/// Entries are stored in a flat array of uninitialized ValueT storage;
+/// only explicitly inserted entries are ever constructed — there is no upfront
+/// default-construction of the entire value array.
 ///
 /// Reallocation moves all live entries via their move constructors and then
 /// destroys the originals in one pass. **Move constructors are assumed to be
 /// nothrow**.
 ///
-/// The copy constructor provides the basic exception guarantee: if copying any
-/// value throws, already-copied values are destroyed and the allocation is
-/// freed.
-///
-/// Iterator and reference validity follows the same rules as std::vector:
-/// insertions that exceed the current capacity invalidate all iterators and
-/// references.
-///
 /// \remarks Partially implemented by Claude Sonnet 4.6
 ///
-/// \tparam IdT    Key type. Must satisfy SmallIdType (fits in uint32_t,
-///                losslessly convertible to/from size_t).
-/// \tparam ValueT Mapped value type.
-// operator= takes Other by value -- handles both copy, and move cases
-// NOLINTNEXTLINE(cppcoreguidelines-special-member-functions)
-template <SmallIdType IdT, typename ValueT> class ValueIdMap {
+/// \tparam IdT       Key type. Must satisfy SmallIdType (fits in uint32_t,
+///                   losslessly convertible to/from size_t).
+/// \tparam ValueT    Mapped value type.
+/// \tparam Allocator Allocator whose value_type is ValueT.
+///                   Defaults to std::allocator<ValueT>.
+template <SmallIdType IdT, typename ValueT,
+          typename Allocator = std::allocator<ValueT>>
+class ValueIdMap {
+  using AllocTraits = std::allocator_traits<Allocator>;
+
 public:
   // ── Types ──────────────────────────────────────────────────────────────────
 
@@ -62,6 +58,7 @@ template <SmallIdType IdT, typename ValueT> class ValueIdMap {
   using mapped_type = ValueT;
   using value_type = std::pair<const IdT, ValueT>;
   using size_type = size_t;
+  using allocator_type = Allocator;
 
   // ── Iterators ──────────────────────────────────────────────────────────────
 
@@ -85,7 +82,7 @@ template <SmallIdType IdT, typename ValueT> class ValueIdMap {
         : Map(Other.Map), CurrentKey(Other.CurrentKey) {}
 
     constexpr reference operator*() const noexcept {
-      return {*CurrentKey, *Map->slotPtr(*CurrentKey)};
+      return {*CurrentKey, *Map->slot(*CurrentKey)};
     }
 
     /// Arrow proxy enabling `it->first` and `it->second`.
@@ -127,50 +124,160 @@ template <SmallIdType IdT, typename ValueT> class ValueIdMap {
 
   // ── Constructors / destructor ──────────────────────────────────────────────
 
-  constexpr ValueIdMap() noexcept = default;
+  /// Default constructor. The allocator is value-initialised.
+  ValueIdMap() noexcept(std::is_nothrow_default_constructible_v<Allocator>) =
+      default;
+
+  /// Constructs an empty map with the given allocator.
+  constexpr explicit ValueIdMap(const allocator_type &A) noexcept(
+      std::is_nothrow_copy_constructible_v<Allocator>)
+      : Alloc(A) {}
 
   /// Pre-allocates storage for \p InitialCapacity entries without constructing
   /// any values.
-  explicit ValueIdMap(size_t InitialCapacity)
-      : Capacity(InitialCapacity),
-        Slots(InitialCapacity ? new Slot[InitialCapacity] : nullptr) {
+  explicit ValueIdMap(size_t InitialCapacity,
+                      const allocator_type &A = allocator_type{})
+      : Alloc(A), Capacity(InitialCapacity),
+        Slots(InitialCapacity ? AllocTraits::allocate(Alloc, InitialCapacity)
+                              : nullptr) {
     IsSet.reserve(InitialCapacity);
   }
 
+  /// Copy constructor. The allocator is obtained via
+  /// allocator_traits::select_on_container_copy_construction.
   ValueIdMap(const ValueIdMap &Other)
-      : IsSet(Other.IsSet), Capacity(Other.Capacity) {
+      : ValueIdMap(Other, AllocTraits::select_on_container_copy_construction(
+                              Other.Alloc)) {}
+
+  /// Copy constructor with explicit allocator.
+  ValueIdMap(const ValueIdMap &Other, const allocator_type &A)
+      : Alloc(A), IsSet(Other.IsSet), Capacity(Other.Capacity) {
     if (!Capacity) {
       return;
     }
-    std::unique_ptr<Slot[]> NewSlots(new Slot[Capacity]);
-    Other.IsSet.foreach ([&](IdT Key) {
-      // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-      ::new (NewSlots[size_t(Key)].Data) ValueT(*Other.slotPtr(Key));
-    });
-    Slots = NewSlots.release();
+    Slots = AllocTraits::allocate(Alloc, Capacity);
+    try {
+      Other.IsSet.foreach ([&](IdT Key) {
+        AllocTraits::construct(Alloc, slot(Key), *Other.slot(Key));
+      });
+    } catch (...) {
+      freeStorage();
+      IsSet.clear();
+      throw;
+    }
   }
 
+  /// Move constructor. The allocator is move-constructed from \p Other.
   ValueIdMap(ValueIdMap &&Other) noexcept
-      : IsSet(std::move(Other.IsSet)),
+      : Alloc(std::move(Other.Alloc)), IsSet(std::move(Other.IsSet)),
         Capacity(std::exchange(Other.Capacity, 0)),
         Slots(std::exchange(Other.Slots, nullptr)) {}
 
-  ValueIdMap &operator=(ValueIdMap Other) {
-    swap(Other);
+  /// Move constructor with explicit allocator.
+  ///
+  /// If the supplied allocator compares equal to Other's allocator the
+  /// storage is stolen in O(1); otherwise each live element is move-constructed
+  /// individually using the supplied allocator.
+  ValueIdMap(ValueIdMap &&Other, const allocator_type &A) : Alloc(A) {
+    if (Alloc == Other.Alloc) {
+      stealFrom(Other);
+    } else {
+      // Allocators differ: move elements individually into fresh storage.
+      IsSet = Other.IsSet;
+      if (Other.Capacity) {
+        Capacity = Other.Capacity;
+        Slots = AllocTraits::allocate(Alloc, Capacity);
+        Other.IsSet.foreach ([&](IdT Key) {
+          ValueT *Src = Other.slot(Key);
+          AllocTraits::construct(Alloc, slot(Key), std::move(*Src));
+          AllocTraits::destroy(Other.Alloc, Src);
+        });
+        Other.IsSet.clear();
+        Other.freeStorage();
+      }
+    }
+  }
+
+  /// Copy assignment. Propagates the allocator when
+  /// allocator_traits::propagate_on_container_copy_assignment is true.
+  ValueIdMap &operator=(const ValueIdMap &Other) {
+    if (this == &Other) {
+      return *this;
+    }
+    clear();
+    if constexpr (AllocTraits::propagate_on_container_copy_assignment::value) {
+      if (Alloc != Other.Alloc) {
+        freeStorage();
+        Alloc = Other.Alloc;
+      }
+    }
+    reallocAtLeast(Other.Capacity);
+    IsSet = Other.IsSet;
+    Other.IsSet.foreach ([&](IdT Key) {
+      AllocTraits::construct(Alloc, slot(Key), *Other.slot(Key));
+    });
+    return *this;
+  }
+
+  /// Move assignment. Propagates the allocator when
+  /// allocator_traits::propagate_on_container_move_assignment is true.
+  ValueIdMap &operator=(ValueIdMap &&Other) noexcept(
+      AllocTraits::propagate_on_container_move_assignment::value ||
+      AllocTraits::is_always_equal::value) {
+    if (this == &Other) {
+      return *this;
+    }
+    clear();
+    if constexpr (AllocTraits::propagate_on_container_move_assignment::value) {
+      freeStorage();
+      Alloc = std::move(Other.Alloc);
+      stealFrom(Other);
+    } else if (Alloc == Other.Alloc) {
+      freeStorage();
+      stealFrom(Other);
+    } else {
+      // Unequal allocators, no propagation: move elements individually.
+      reallocAtLeast(Other.Capacity);
+      IsSet = Other.IsSet;
+      Other.IsSet.foreach ([&](IdT Key) {
+        ValueT *Src = Other.slot(Key);
+        AllocTraits::construct(Alloc, slot(Key), std::move(*Src));
+        AllocTraits::destroy(Other.Alloc, Src);
+      });
+      Other.IsSet.clear();
+      Other.freeStorage();
+    }
     return *this;
   }
 
   ~ValueIdMap() {
     clear();
-    delete[] Slots;
+    freeStorage();
+  }
+
+  /// Returns the allocator associated with this container.
+  // NOLINTNEXTLINE(readability-identifier-naming) -- STL API name
+  [[nodiscard]] constexpr allocator_type get_allocator() const noexcept {
+    return Alloc;
   }
 
-  constexpr void swap(ValueIdMap &Other) noexcept {
+  /// Swap. Propagates allocators when
+  /// allocator_traits::propagate_on_container_swap is true; otherwise the
+  /// behaviour is undefined if the two allocators are not equal (per the
+  /// AllocatorAwareContainer requirement).
+  void swap(ValueIdMap &Other) noexcept(
+      (!AllocTraits::propagate_on_container_swap::value ||
+       std::is_nothrow_swappable_v<Allocator>) &&
+      std::is_nothrow_swappable_v<BitSet<IdT>>) {
+    if constexpr (AllocTraits::propagate_on_container_swap::value) {
+      std::swap(Alloc, Other.Alloc);
+    }
     std::swap(Slots, Other.Slots);
     std::swap(Capacity, Other.Capacity);
     std::swap(IsSet, Other.IsSet);
   }
-  friend constexpr void swap(ValueIdMap &Lhs, ValueIdMap &Rhs) noexcept {
+  friend void swap(ValueIdMap &Lhs,
+                   ValueIdMap &Rhs) noexcept(noexcept(Lhs.swap(Rhs))) {
     Lhs.swap(Rhs);
   }
 
@@ -206,17 +313,17 @@ template <SmallIdType IdT, typename ValueT> class ValueIdMap {
 
   /// Returns a reference to the value for \p Key.
   /// \throws std::out_of_range if \p Key is not present.
-  [[nodiscard]] ValueT &at(IdT Key) {
+  [[nodiscard]] constexpr ValueT &at(IdT Key) {
     if (!contains(Key)) {
       throw std::out_of_range("ValueIdMap::at: key not found");
     }
-    return *slotPtr(Key);
+    return *slot(Key);
   }
-  [[nodiscard]] const ValueT &at(IdT Key) const {
+  [[nodiscard]] constexpr const ValueT &at(IdT Key) const {
     if (!contains(Key)) {
       throw std::out_of_range("ValueIdMap::at: key not found");
     }
-    return *slotPtr(Key);
+    return *slot(Key);
   }
 
   // ── Element access ─────────────────────────────────────────────────────────
@@ -237,9 +344,7 @@ template <SmallIdType IdT, typename ValueT> class ValueIdMap {
     } else if (IsSet.contains(Key)) {
       return {iterator(this, Key), false};
     }
-
-    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-    ::new (Slots[size_t(Key)].Data) ValueT(PSR_FWD(Args)...);
+    AllocTraits::construct(Alloc, slot(Key), PSR_FWD(Args)...);
     IsSet.insert(Key);
     return {iterator(this, Key), true};
   }
@@ -253,7 +358,7 @@ template <SmallIdType IdT, typename ValueT> class ValueIdMap {
   // NOLINTNEXTLINE(readability-identifier-naming) -- STL API name
   std::pair<iterator, bool> insert_or_assign(IdT Key, M &&Obj) {
     if (IsSet.contains(Key)) {
-      *slotPtr(Key) = std::forward<M>(Obj);
+      *slot(Key) = std::forward<M>(Obj);
       return {iterator(this, Key), false};
     }
     return try_emplace(Key, std::forward<M>(Obj));
@@ -264,7 +369,7 @@ template <SmallIdType IdT, typename ValueT> class ValueIdMap {
     if (!IsSet.tryErase(Key)) {
       return false;
     }
-    slotPtr(Key)->~ValueT();
+    AllocTraits::destroy(Alloc, slot(Key));
     return true;
   }
 
@@ -274,14 +379,14 @@ template <SmallIdType IdT, typename ValueT> class ValueIdMap {
     IdT Key = It->first;
     ++It;
     IsSet.erase(Key);
-    slotPtr(Key)->~ValueT();
+    AllocTraits::destroy(Alloc, slot(Key));
     return It;
   }
 
   /// Destroys all present entries without releasing the allocated storage.
   void clear() noexcept {
     if constexpr (!std::is_trivially_destructible_v<ValueT>) {
-      IsSet.foreach ([&](IdT Key) { slotPtr(Key)->~ValueT(); });
+      IsSet.foreach ([&](IdT Key) { AllocTraits::destroy(Alloc, slot(Key)); });
     }
     IsSet.clear();
   }
@@ -306,67 +411,96 @@ template <SmallIdType IdT, typename ValueT> class ValueIdMap {
   [[nodiscard]] constexpr const_iterator cend() const noexcept { return end(); }
 
 private:
-  // ── Private types ──────────────────────────────────────────────────────────
-
-  // Holds raw bytes of the right size and alignment for one ValueT.
-  // No ValueT object lives here until explicitly placement-new'd.
-  struct alignas(ValueT) Slot {
-    std::byte Data[sizeof(ValueT)];
-  };
-
   // ── Private helpers ────────────────────────────────────────────────────────
 
-  [[nodiscard]] ValueT *slotPtr(IdT Key) noexcept {
+  [[nodiscard]] constexpr ValueT *slot(IdT Key) noexcept {
     // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-    return std::launder(reinterpret_cast<ValueT *>(Slots[size_t(Key)].Data));
+    return Slots + size_t(Key);
   }
-  [[nodiscard]] const ValueT *slotPtr(IdT Key) const noexcept {
-    return std::launder(
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-        reinterpret_cast<const ValueT *>(Slots[size_t(Key)].Data));
+  [[nodiscard]] constexpr const ValueT *slot(IdT Key) const noexcept {
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+    return Slots + size_t(Key);
   }
 
   [[nodiscard]] constexpr bool inbounds(IdT Key) const noexcept {
     return size_t(Key) < Capacity;
   }
 
+  /// Frees current storage and allocates a fresh array of \p N elements.
+  /// No-op if N <= Capacity.
+  constexpr void reallocAtLeast(size_t N) {
+    if (N > Capacity) {
+      freeStorage();
+      Slots = AllocTraits::allocate(Alloc, N);
+      Capacity = N;
+    }
+  }
+
+  /// Deallocates the storage array if non-null and resets Slots/Capacity.
+  constexpr void freeStorage() noexcept {
+    if (Slots) {
+      AllocTraits::deallocate(Alloc, Slots, Capacity);
+      Slots = nullptr;
+      Capacity = 0;
+    }
+  }
+
+  /// Takes ownership of Other's storage (Other must have been cleared first).
+  void stealFrom(ValueIdMap &Other) noexcept {
+    IsSet = std::move(Other.IsSet);
+    Capacity = std::exchange(Other.Capacity, 0);
+    Slots = std::exchange(Other.Slots, nullptr);
+  }
+
   void grow(size_t NewCap) {
     assert(NewCap > Capacity);
-    std::unique_ptr<Slot[]> New(new Slot[NewCap]);
+    ValueT *New = AllocTraits::allocate(Alloc, NewCap);
 
     if constexpr (IsTriviallyRelocatable<ValueT>) {
       // Trivially relocatable: a flat memcpy of all used slots suffices.
       // Uninitialized slots contain indeterminate bytes, which is safe to copy.
-      // No per-slot construction or destruction is needed.
+      // No per-element construction or destruction is needed.
       if (Slots) {
-        memcpy(New.get(), Slots, Capacity * sizeof(Slot));
+        memcpy(New, Slots, Capacity * sizeof(ValueT));
       }
     } else {
       // Move-construct each live entry into new storage and destroy the
       // original in one pass. Assumes nothrow move construction; types with
       // throwing moves are not supported.
       IsSet.foreach ([&](IdT Key) {
-        ValueT *Src = slotPtr(Key);
-        ::new (New[size_t(Key)].Data) ValueT(std::move(
-            *Src)); // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-        Src->~ValueT();
+        ValueT *Src = slot(Key);
+        AllocTraits::construct(Alloc, New + size_t(Key), // NOLINT
+                               std::move(*Src));
+        AllocTraits::destroy(Alloc, Src);
       });
     }
 
-    delete[] Slots;
-    Slots = New.release();
+    if (Slots) {
+      AllocTraits::deallocate(Alloc, Slots, Capacity);
+    }
+    Slots = New;
     Capacity = NewCap;
   }
 
   // ── Data members ───────────────────────────────────────────────────────────
 
-  // IsSet must be declared first so that if its copy constructor throws during
-  // ValueIdMap's copy constructor, Slots has not yet been allocated.
+  // Alloc must be declared first so it is available for deallocation when
+  // other members are destroyed. [[no_unique_address]] enables the empty-base
+  // optimisation for stateless allocators such as std::allocator.
+  [[no_unique_address]] Allocator Alloc{};
+  // IsSet must be declared before Slots so that if its copy constructor throws
+  // during ValueIdMap's copy constructor, Slots has not yet been allocated.
   BitSet<IdT> IsSet;
   size_t Capacity = 0;
-  Slot *Slots = nullptr;
+  ValueT *Slots = nullptr;
 };
 
+namespace pmr {
+template <SmallIdType IdT, typename ValueT>
+using ValueIdMap =
+    psr::ValueIdMap<IdT, ValueT, std::pmr::polymorphic_allocator<ValueT>>;
+} // namespace pmr
+
 } // namespace psr
 
 #endif // PHASAR_UTILS_VALUEIDMAP_H

From d0173b944dd0246389eff0e981798a76139e4b80 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Sun, 29 Mar 2026 20:27:39 +0200
Subject: [PATCH 71/75] Extend ValueIdMap STL API: range ctor, ilist
 ctor/assign, erase(const_iterator), operator==, max_size

- Add iterator-range constructor with O(1) reserve for random-access iterators
- Add initializer_list constructor (delegating to range ctor) and assignment operator,
  both accepting any V constructible to ValueT to avoid unnecessary copies
- Replace erase(iterator) with erase(const_iterator) per STL convention
- Add operator== hidden friend: compares IsSet bitsets first, then values directly
  via slot() without find(), for lower constant vs. a naive lookup-per-element
- Add max_size() capped at INT_MAX (llvm::BitVector internal limit)
- Add missing type aliases: difference_type, reference, const_reference, pointer,
  const_pointer
- Add #include <limits> and <initializer_list>

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 include/phasar/Utils/ValueIdMap.h | 72 ++++++++++++++++++++++++++++++-
 1 file changed, 70 insertions(+), 2 deletions(-)

diff --git a/include/phasar/Utils/ValueIdMap.h b/include/phasar/Utils/ValueIdMap.h
index 608abdd87e..bce7bd6cf6 100644
--- a/include/phasar/Utils/ValueIdMap.h
+++ b/include/phasar/Utils/ValueIdMap.h
@@ -17,6 +17,8 @@
 #include <cassert>
 #include <cstddef>
 #include <cstring>
+#include <initializer_list>
+#include <limits>
 #include <memory>
 #include <memory_resource>
 #include <optional>
@@ -58,7 +60,12 @@ class ValueIdMap {
   using mapped_type = ValueT;
   using value_type = std::pair<const IdT, ValueT>;
   using size_type = size_t;
+  using difference_type = ptrdiff_t;
   using allocator_type = Allocator;
+  using reference = value_type &;
+  using const_reference = const value_type &;
+  using pointer = value_type *;
+  using const_pointer = const value_type *;
 
   // ── Iterators ──────────────────────────────────────────────────────────────
 
@@ -143,6 +150,32 @@ class ValueIdMap {
     IsSet.reserve(InitialCapacity);
   }
 
+  /// Constructs from an initializer list. \p V need not equal \p ValueT;
+  /// any type constructible to \p ValueT is accepted, avoiding an
+  /// intermediate copy (e.g. string literals when ValueT is std::string).
+  /// Duplicate keys are silently dropped (first occurrence wins).
+  template <typename V = ValueT>
+    requires std::is_constructible_v<ValueT, const V &>
+  ValueIdMap(std::initializer_list<std::pair<const IdT, V>> Init,
+             const allocator_type &A = allocator_type{})
+      : ValueIdMap(Init.begin(), Init.end(), A) {}
+
+  /// Constructs from an iterator range \p [First, Last).
+  /// Duplicate keys are silently dropped (first occurrence wins).
+  template <typename InputIt>
+  ValueIdMap(InputIt First, InputIt Last,
+             const allocator_type &A = allocator_type{})
+      : ValueIdMap(A) {
+    if constexpr (std::is_base_of_v<std::random_access_iterator_tag,
+                                    typename std::iterator_traits<
+                                        InputIt>::iterator_category>) {
+      reserve(static_cast<size_t>(std::distance(First, Last)));
+    }
+    for (; First != Last; ++First) {
+      try_emplace(First->first, First->second);
+    }
+  }
+
   /// Copy constructor. The allocator is obtained via
   /// allocator_traits::select_on_container_copy_construction.
   ValueIdMap(const ValueIdMap &Other)
@@ -219,6 +252,19 @@ class ValueIdMap {
     return *this;
   }
 
+  /// Replaces the contents with those of \p Init.
+  /// Duplicate keys are silently dropped (first occurrence wins).
+  template <typename V = ValueT>
+    requires std::is_constructible_v<ValueT, const V &>
+  ValueIdMap &operator=(std::initializer_list<std::pair<const IdT, V>> Init) {
+    clear();
+    reserve(Init.size());
+    for (auto &&[Key, Val] : Init) {
+      try_emplace(Key, Val);
+    }
+    return *this;
+  }
+
   /// Move assignment. Propagates the allocator when
   /// allocator_traits::propagate_on_container_move_assignment is true.
   ValueIdMap &operator=(ValueIdMap &&Other) noexcept(
@@ -281,6 +327,20 @@ class ValueIdMap {
     Lhs.swap(Rhs);
   }
 
+  friend bool operator==(const ValueIdMap &Lhs, const ValueIdMap &Rhs) noexcept(
+      noexcept(std::declval<const ValueT &>() ==
+               std::declval<const ValueT &>())) {
+    if (Lhs.IsSet != Rhs.IsSet) {
+      return false;
+    }
+    for (auto [Key, Val] : Lhs) {
+      if (*Rhs.slot(Key) != Val) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   // ── Capacity ───────────────────────────────────────────────────────────────
 
   /// Ensures storage for at least \p N entries without constructing any values.
@@ -294,6 +354,14 @@ class ValueIdMap {
   /// Returns the number of entries currently present.
   [[nodiscard]] constexpr size_t size() const noexcept { return IsSet.size(); }
   [[nodiscard]] constexpr bool empty() const noexcept { return IsSet.empty(); }
+  /// Returns the maximum number of elements the container can hold.
+  /// Capped at INT_MAX because llvm::BitVector (which backs BitSet) uses
+  /// an int-sized bit count internally.
+  // NOLINTNEXTLINE(readability-identifier-naming) -- STL API name
+  [[nodiscard]] constexpr size_type max_size() const noexcept {
+    return std::min(AllocTraits::max_size(Alloc),
+                    size_type(std::numeric_limits<int>::max()));
+  }
 
   // ── Lookup ─────────────────────────────────────────────────────────────────
 
@@ -375,12 +443,12 @@ class ValueIdMap {
 
   /// Removes the entry pointed to by \p It and returns an iterator to the
   /// next entry.
-  iterator erase(iterator It) noexcept {
+  iterator erase(const_iterator It) noexcept {
     IdT Key = It->first;
     ++It;
     IsSet.erase(Key);
     AllocTraits::destroy(Alloc, slot(Key));
-    return It;
+    return iterator(this, It.CurrentKey);
   }
 
   /// Destroys all present entries without releasing the allocated storage.

From 1f6735bc55e2fd90ae20966871e5275f7ea99496 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Sun, 29 Mar 2026 21:30:29 +0200
Subject: [PATCH 72/75] LLVM 17 compatibility

---
 include/phasar/Utils/TypedVector.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/phasar/Utils/TypedVector.h b/include/phasar/Utils/TypedVector.h
index 417c97eb31..7b2679e336 100644
--- a/include/phasar/Utils/TypedVector.h
+++ b/include/phasar/Utils/TypedVector.h
@@ -118,13 +118,13 @@ class TypedVector {
   drop_front(size_t Offs) && noexcept = delete;
 
   [[nodiscard]] auto enumerate() const noexcept {
-    return llvm::map_range(llvm::enumerate(Vec), [](const auto &IndexAndVal) {
+    return llvm::map_range(llvm::enumerate(Vec), [](auto &&IndexAndVal) {
       return std::pair<IdT, ByConstRef<ValueT>>{IdT(IndexAndVal.index()),
                                                 IndexAndVal.value()};
     });
   }
   [[nodiscard]] auto enumerate() noexcept {
-    return llvm::map_range(llvm::enumerate(Vec), [](auto &IndexAndVal) {
+    return llvm::map_range(llvm::enumerate(Vec), [](auto &&IndexAndVal) {
       return std::pair<IdT, ValueT &>{IdT(IndexAndVal.index()),
                                       IndexAndVal.value()};
     });

From feafdfffcd7756e5c2ebfcede37dee6cbde03054 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Sun, 29 Mar 2026 21:41:10 +0200
Subject: [PATCH 73/75] Fix library-summary relocation with C++20 modules

---
 lib/PhasarLLVM/DataFlow/IfdsIde/IfdsIde.cppm | 11 -----------
 lib/PhasarLLVM/Utils/Utils.cppm              |  6 ++++++
 lib/Utils/Utils.cppm                         | 10 ++++++++++
 3 files changed, 16 insertions(+), 11 deletions(-)

diff --git a/lib/PhasarLLVM/DataFlow/IfdsIde/IfdsIde.cppm b/lib/PhasarLLVM/DataFlow/IfdsIde/IfdsIde.cppm
index 94a9f38607..22bbc7d9e2 100644
--- a/lib/PhasarLLVM/DataFlow/IfdsIde/IfdsIde.cppm
+++ b/lib/PhasarLLVM/DataFlow/IfdsIde/IfdsIde.cppm
@@ -1,7 +1,6 @@
 module;
 
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/DefaultAliasAwareIDEProblem.h"
-#include "phasar/PhasarLLVM/DataFlow/IfdsIde/LibCSummary.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/ExtendedTaintAnalysis/AbstractMemoryLocation.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/ExtendedTaintAnalysis/AbstractMemoryLocationFactory.h"
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/ExtendedTaintAnalysis/AllSanitized.h"
@@ -106,7 +105,6 @@ using psr::JoinLatticeTraits;
 using psr::to_string;
 using psr::operator<<;
 using psr::CSTDFILEIOTypeStateDescription;
-using psr::getLibCSummary;
 using psr::IDETypeStateAnalysis;
 using psr::OpenSSLEVPKDFCTXDescription;
 using psr::OpenSSLEVPKDFCTXState;
@@ -125,15 +123,6 @@ export namespace std {
 using std::hash;
 } // namespace std
 
-export namespace psr::library_summary {
-using psr::library_summary::DataFlowFact;
-using psr::library_summary::FunctionDataFlowFacts;
-using psr::library_summary::LLVMFunctionDataFlowFacts;
-using psr::library_summary::Parameter;
-using psr::library_summary::readFromFDFF;
-using psr::library_summary::ReturnValue;
-} // namespace psr::library_summary
-
 export namespace llvm {
 using llvm::DenseMapInfo;
 } // namespace llvm
diff --git a/lib/PhasarLLVM/Utils/Utils.cppm b/lib/PhasarLLVM/Utils/Utils.cppm
index 44043bc45d..964a3ab8ec 100644
--- a/lib/PhasarLLVM/Utils/Utils.cppm
+++ b/lib/PhasarLLVM/Utils/Utils.cppm
@@ -5,6 +5,7 @@ module;
 #include "phasar/PhasarLLVM/Utils/DataFlowAnalysisType.h"
 #include "phasar/PhasarLLVM/Utils/LLVMBasedContainerConfig.h"
 #include "phasar/PhasarLLVM/Utils/LLVMCXXShorthands.h"
+#include "phasar/PhasarLLVM/Utils/LLVMFunctionDataFlowFacts.h"
 #include "phasar/PhasarLLVM/Utils/LLVMIRToSrc.h"
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
 #include "phasar/PhasarLLVM/Utils/LLVMSourceManager.h"
@@ -74,3 +75,8 @@ using psr::SourceCodeInfo;
 using psr::SourceMgrPrinter;
 using psr::to_json;
 } // namespace psr
+
+export namespace psr::library_summary {
+using psr::library_summary::LLVMFunctionDataFlowFacts;
+using psr::library_summary::readFromFDFF;
+} // namespace psr::library_summary
diff --git a/lib/Utils/Utils.cppm b/lib/Utils/Utils.cppm
index f75c6aa46f..42f1f1af2e 100644
--- a/lib/Utils/Utils.cppm
+++ b/lib/Utils/Utils.cppm
@@ -20,11 +20,13 @@ module;
 #include "phasar/Utils/EnumFlags.h"
 #include "phasar/Utils/EquivalenceClassMap.h"
 #include "phasar/Utils/ErrorHandling.h"
+#include "phasar/Utils/FunctionDataFlowFacts.h"
 #include "phasar/Utils/GraphTraits.h"
 #include "phasar/Utils/IO.h"
 #include "phasar/Utils/InitPhasar.h"
 #include "phasar/Utils/IotaIterator.h"
 #include "phasar/Utils/JoinLattice.h"
+#include "phasar/Utils/LibCSummary.h"
 #include "phasar/Utils/Macros.h"
 #include "phasar/Utils/MaybeUniquePtr.h"
 #include "phasar/Utils/NullAnalysisPrinter.h"
@@ -168,6 +170,7 @@ using psr::DummyUnorderedTable1d;
 using psr::ElementType;
 using psr::FalseFn;
 using psr::forward_like;
+using psr::getLibCSummary;
 using psr::has_adl_to_string_v;
 using psr::has_erase_iterator_v;
 using psr::has_getAsJson;
@@ -221,3 +224,10 @@ using psr::UnorderedTable1d;
 using psr::variant_idx;
 
 } // namespace psr
+
+export namespace psr::library_summary {
+using psr::library_summary::DataFlowFact;
+using psr::library_summary::FunctionDataFlowFacts;
+using psr::library_summary::Parameter;
+using psr::library_summary::ReturnValue;
+} // namespace psr::library_summary

From a5725ed5009e9f8b4a38128dd6f76a387625f39a Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Sun, 29 Mar 2026 21:47:26 +0200
Subject: [PATCH 74/75] Fix new dependency of phasar_llvm_pointer to
 phasar_controlflow

---
 lib/PhasarLLVM/Pointer/CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/PhasarLLVM/Pointer/CMakeLists.txt b/lib/PhasarLLVM/Pointer/CMakeLists.txt
index 2825505ba5..1736a41820 100644
--- a/lib/PhasarLLVM/Pointer/CMakeLists.txt
+++ b/lib/PhasarLLVM/Pointer/CMakeLists.txt
@@ -6,6 +6,7 @@ add_phasar_library(phasar_llvm_pointer
   LINKS
     phasar_utils
     phasar_pointer
+    phasar_controlflow
     phasar_llvm_utils
     phasar_llvm_db
 

From 510eb6bcb73c6bd0417d6e411632b9b575a5c7e9 Mon Sep 17 00:00:00 2001
From: Fabian Schiebel <fabianbs@mail.upb.de>
Date: Mon, 30 Mar 2026 18:25:59 +0200
Subject: [PATCH 75/75] ci: ccache dedup per llvm version

---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index bb040a7d53..7cf419c0e3 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -51,7 +51,7 @@ jobs:
       - name: ccache  # This should always come after the actions/checkout step.
         uses: hendrikmuhs/ccache-action@v1.2
         with:
-          key: ${{ github.job }}-${{ matrix.os }}-${{ matrix.build }}
+          key: ${{ github.job }}-${{ matrix.os }}-llvm${{ matrix.llvm-version }}-${{ matrix.build }}
 
       - name: Install Phasar Dependencies
         shell: bash