diff --git a/include/phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h b/include/phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h
index 7cd8e7182..dd363f5c8 100644
--- a/include/phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h
+++ b/include/phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h
@@ -23,6 +23,7 @@
 #include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCFG.h"
 #include "phasar/PhasarLLVM/ControlFlow/LLVMVFTableProvider.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
 #include "phasar/PhasarLLVM/Utils/LLVMBasedContainerConfig.h"
 #include "phasar/Utils/Soundness.h"
 
@@ -38,7 +39,7 @@
 #include <memory>
 
 namespace psr {
-class LLVMTypeHierarchy;
+class DIBasedTypeHierarchy;
 class LLVMProjectIRDB;
 class Resolver;
 
@@ -82,7 +83,7 @@ class LLVMBasedICFG : public LLVMBasedCFG, public ICFGBase<LLVMBasedICFG> {
   /// IRDB. True by default
   explicit LLVMBasedICFG(LLVMProjectIRDB *IRDB, CallGraphAnalysisType CGType,
                          llvm::ArrayRef<std::string> EntryPoints = {},
-                         LLVMTypeHierarchy *TH = nullptr,
+                         DIBasedTypeHierarchy *TH = nullptr,
                          LLVMAliasInfoRef PT = nullptr,
                          Soundness S = Soundness::Soundy,
                          bool IncludeGlobals = true);
@@ -102,7 +103,7 @@ class LLVMBasedICFG : public LLVMBasedCFG, public ICFGBase<LLVMBasedICFG> {
   explicit LLVMBasedICFG(LLVMProjectIRDB *IRDB,
                          const nlohmann::json &SerializedCG);
 
-  // Deleter of LLVMTypeHierarchy may be unknown here...
+  // Deleter of DIBasedTypeHierarchy may be unknown here...
   ~LLVMBasedICFG();
 
   LLVMBasedICFG(const LLVMBasedICFG &) = delete;
@@ -173,6 +174,7 @@ class LLVMBasedICFG : public LLVMBasedCFG, public ICFGBase<LLVMBasedICFG> {
   CallGraph<const llvm::Instruction *, const llvm::Function *> CG;
   LLVMProjectIRDB *IRDB = nullptr;
   LLVMVFTableProvider VTP;
+  std::map<const llvm::DIType *, const llvm::StructType *> DITypeToValueType;
 };
 
 extern template class ICFGBase<LLVMBasedICFG>;
diff --git a/include/phasar/PhasarLLVM/ControlFlow/LLVMVFTableProvider.h b/include/phasar/PhasarLLVM/ControlFlow/LLVMVFTableProvider.h
index 4206070fc..126251da8 100644
--- a/include/phasar/PhasarLLVM/ControlFlow/LLVMVFTableProvider.h
+++ b/include/phasar/PhasarLLVM/ControlFlow/LLVMVFTableProvider.h
@@ -12,6 +12,8 @@
 
 #include "phasar/PhasarLLVM/TypeHierarchy/LLVMVFTable.h"
 
+#include "llvm/IR/DebugInfoMetadata.h"
+
 #include <unordered_map>
 
 namespace llvm {
@@ -29,11 +31,13 @@ class LLVMVFTableProvider {
   explicit LLVMVFTableProvider(const LLVMProjectIRDB &IRDB);
 
   [[nodiscard]] bool hasVFTable(const llvm::StructType *Type) const;
+  [[nodiscard]] bool hasVFTable(const llvm::DIType *Type) const;
   [[nodiscard]] const LLVMVFTable *
   getVFTableOrNull(const llvm::StructType *Type) const;
 
 private:
   std::unordered_map<const llvm::StructType *, LLVMVFTable> TypeVFTMap;
+  std::map<const llvm::DIType *, const llvm::StructType *> DITypeToStructType;
 };
 } // namespace psr
 
diff --git a/include/phasar/PhasarLLVM/ControlFlow/Resolver/CHAResolver.h b/include/phasar/PhasarLLVM/ControlFlow/Resolver/CHAResolver.h
index 299a600ea..0b72ef94f 100644
--- a/include/phasar/PhasarLLVM/ControlFlow/Resolver/CHAResolver.h
+++ b/include/phasar/PhasarLLVM/ControlFlow/Resolver/CHAResolver.h
@@ -18,6 +18,7 @@
 #define PHASAR_PHASARLLVM_CONTROLFLOW_RESOLVER_CHARESOLVER_H_
 
 #include "phasar/PhasarLLVM/ControlFlow/Resolver/Resolver.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
 #include "phasar/Utils/MaybeUniquePtr.h"
 
 namespace llvm {
@@ -26,11 +27,11 @@ class Function;
 } // namespace llvm
 
 namespace psr {
-class LLVMTypeHierarchy;
+class DIBasedTypeHierarchy;
 class CHAResolver : public Resolver {
 public:
   CHAResolver(const LLVMProjectIRDB *IRDB, const LLVMVFTableProvider *VTP,
-              const LLVMTypeHierarchy *TH);
+              const DIBasedTypeHierarchy *TH);
 
   ~CHAResolver() override = default;
 
@@ -39,7 +40,7 @@ class CHAResolver : public Resolver {
   [[nodiscard]] std::string str() const override;
 
 protected:
-  MaybeUniquePtr<const LLVMTypeHierarchy, true> TH;
+  MaybeUniquePtr<const DIBasedTypeHierarchy, true> TH;
 };
 } // namespace psr
 
diff --git a/include/phasar/PhasarLLVM/ControlFlow/Resolver/DTAResolver.h b/include/phasar/PhasarLLVM/ControlFlow/Resolver/DTAResolver.h
index 7b4484f6e..3e8e1ed95 100644
--- a/include/phasar/PhasarLLVM/ControlFlow/Resolver/DTAResolver.h
+++ b/include/phasar/PhasarLLVM/ControlFlow/Resolver/DTAResolver.h
@@ -19,6 +19,7 @@
 
 #include "phasar/PhasarLLVM/ControlFlow/Resolver/CHAResolver.h"
 #include "phasar/PhasarLLVM/Pointer/TypeGraphs/CachedTypeGraph.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
 // To switch the TypeGraph
 // #include "phasar/PhasarLLVM/Pointer/TypeGraphs/LazyTypeGraph.h"
 
@@ -56,7 +57,7 @@ class DTAResolver : public CHAResolver {
 
 public:
   DTAResolver(const LLVMProjectIRDB *IRDB, const LLVMVFTableProvider *VTP,
-              const LLVMTypeHierarchy *TH);
+              const DIBasedTypeHierarchy *TH);
 
   ~DTAResolver() override = default;
 
diff --git a/include/phasar/PhasarLLVM/ControlFlow/Resolver/RTAResolver.h b/include/phasar/PhasarLLVM/ControlFlow/Resolver/RTAResolver.h
index 6010443f0..a17ceedc3 100644
--- a/include/phasar/PhasarLLVM/ControlFlow/Resolver/RTAResolver.h
+++ b/include/phasar/PhasarLLVM/ControlFlow/Resolver/RTAResolver.h
@@ -32,7 +32,7 @@ namespace psr {
 class RTAResolver : public CHAResolver {
 public:
   RTAResolver(const LLVMProjectIRDB *IRDB, const LLVMVFTableProvider *VTP,
-              const LLVMTypeHierarchy *TH);
+              const DIBasedTypeHierarchy *TH);
 
   ~RTAResolver() override = default;
 
diff --git a/include/phasar/PhasarLLVM/ControlFlow/Resolver/Resolver.h b/include/phasar/PhasarLLVM/ControlFlow/Resolver/Resolver.h
index 5cbf894b2..d2e311daa 100644
--- a/include/phasar/PhasarLLVM/ControlFlow/Resolver/Resolver.h
+++ b/include/phasar/PhasarLLVM/ControlFlow/Resolver/Resolver.h
@@ -18,7 +18,7 @@
 #define PHASAR_PHASARLLVM_CONTROLFLOW_RESOLVER_RESOLVER_H_
 
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h"
-#include "phasar/Utils/IRDBOpaquePtrTypes.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
 
 #include "llvm/ADT/DenseSet.h"
 
@@ -30,23 +30,22 @@ namespace llvm {
 class Instruction;
 class CallBase;
 class Function;
-class StructType;
+class DIType;
 } // namespace llvm
 
 namespace psr {
 class LLVMProjectIRDB;
 class LLVMVFTableProvider;
-class LLVMTypeHierarchy;
+class DIBasedTypeHierarchy;
 enum class CallGraphAnalysisType;
 
 [[nodiscard]] std::optional<unsigned>
 getVFTIndex(const llvm::CallBase *CallSite);
 
-[[nodiscard]] const llvm::StructType *
-getReceiverType(const llvm::CallBase *CallSite, const LLVMProjectIRDB *IRDB);
+[[nodiscard]] const llvm::DIType *
+getReceiverType(const llvm::CallBase *CallSite);
 
-[[nodiscard]] std::string getReceiverTypeName(const llvm::CallBase *CallSite,
-                                              const LLVMProjectIRDB *IRDB);
+[[nodiscard]] std::string getReceiverTypeName(const llvm::CallBase *CallSite);
 
 [[nodiscard]] bool isConsistentCall(const llvm::CallBase *CallSite,
                                     const llvm::Function *DestFun);
@@ -55,12 +54,13 @@ class Resolver {
 protected:
   const LLVMProjectIRDB *IRDB;
   const LLVMVFTableProvider *VTP;
-  IRDBOpaquePtrTypes OpaquePtrTypes;
+  std::map<const llvm::DIType *, const llvm::StructType *> DITypeToStructType;
 
   Resolver(const LLVMProjectIRDB *IRDB);
+  void initializeTypeMap();
 
   const llvm::Function *
-  getNonPureVirtualVFTEntry(const llvm::StructType *T, unsigned Idx,
+  getNonPureVirtualVFTEntry(const llvm::DIType *T, unsigned Idx,
                             const llvm::CallBase *CallSite);
 
 public:
@@ -88,7 +88,7 @@ class Resolver {
   static std::unique_ptr<Resolver> create(CallGraphAnalysisType Ty,
                                           const LLVMProjectIRDB *IRDB,
                                           const LLVMVFTableProvider *VTP,
-                                          const LLVMTypeHierarchy *TH,
+                                          const DIBasedTypeHierarchy *TH,
                                           LLVMAliasInfoRef PT = nullptr);
 };
 } // namespace psr
diff --git a/include/phasar/PhasarLLVM/DataFlow/Mono/Problems/InterMonoSolverTest.h b/include/phasar/PhasarLLVM/DataFlow/Mono/Problems/InterMonoSolverTest.h
index 8674ff564..a280365a5 100644
--- a/include/phasar/PhasarLLVM/DataFlow/Mono/Problems/InterMonoSolverTest.h
+++ b/include/phasar/PhasarLLVM/DataFlow/Mono/Problems/InterMonoSolverTest.h
@@ -36,7 +36,7 @@ class StructType;
 
 namespace psr {
 
-class LLVMTypeHierarchy;
+class DIBasedTypeHierarchy;
 
 struct InterMonoSolverTestDomain : LLVMAnalysisDomainDefault {
   using mono_container_t = BitVectorSet<LLVMAnalysisDomainDefault::d_t>;
@@ -52,8 +52,9 @@ class InterMonoSolverTest : public InterMonoProblem<InterMonoSolverTestDomain> {
   using i_t = InterMonoSolverTestDomain::i_t;
   using mono_container_t = InterMonoSolverTestDomain::mono_container_t;
 
-  InterMonoSolverTest(const LLVMProjectIRDB *IRDB, const LLVMTypeHierarchy *TH,
-                      const LLVMBasedICFG *ICF, LLVMAliasInfoRef PT,
+  InterMonoSolverTest(const LLVMProjectIRDB *IRDB,
+                      const DIBasedTypeHierarchy *TH, const LLVMBasedICFG *ICF,
+                      LLVMAliasInfoRef PT,
                       std::vector<std::string> EntryPoints = {});
 
   ~InterMonoSolverTest() override = default;
diff --git a/include/phasar/PhasarLLVM/DataFlow/Mono/Problems/IntraMonoSolverTest.h b/include/phasar/PhasarLLVM/DataFlow/Mono/Problems/IntraMonoSolverTest.h
index 13c5ac42f..75e31f25e 100644
--- a/include/phasar/PhasarLLVM/DataFlow/Mono/Problems/IntraMonoSolverTest.h
+++ b/include/phasar/PhasarLLVM/DataFlow/Mono/Problems/IntraMonoSolverTest.h
@@ -37,7 +37,7 @@ namespace psr {
 
 class LLVMBasedCFG;
 class LLVMBasedICFG;
-class LLVMTypeHierarchy;
+class DIBasedTypeHierarchy;
 
 struct IntraMonoSolverTestAnalysisDomain : public LLVMAnalysisDomainDefault {
   using mono_container_t = BitVectorSet<LLVMAnalysisDomainDefault::d_t>;
@@ -54,8 +54,9 @@ class IntraMonoSolverTest
   using i_t = IntraMonoSolverTestAnalysisDomain::i_t;
   using mono_container_t = IntraMonoSolverTestAnalysisDomain::mono_container_t;
 
-  IntraMonoSolverTest(const LLVMProjectIRDB *IRDB, const LLVMTypeHierarchy *TH,
-                      const LLVMBasedCFG *CF, LLVMAliasInfoRef PT,
+  IntraMonoSolverTest(const LLVMProjectIRDB *IRDB,
+                      const DIBasedTypeHierarchy *TH, const LLVMBasedCFG *CF,
+                      LLVMAliasInfoRef PT,
                       std::vector<std::string> EntryPoints = {});
 
   ~IntraMonoSolverTest() override = default;
diff --git a/include/phasar/PhasarLLVM/HelperAnalyses.h b/include/phasar/PhasarLLVM/HelperAnalyses.h
index f8cb8029b..2c6f06000 100644
--- a/include/phasar/PhasarLLVM/HelperAnalyses.h
+++ b/include/phasar/PhasarLLVM/HelperAnalyses.h
@@ -26,7 +26,7 @@ class Module;
 
 namespace psr {
 class LLVMProjectIRDB;
-class LLVMTypeHierarchy;
+class DIBasedTypeHierarchy;
 class LLVMBasedICFG;
 class LLVMBasedCFG;
 class LLVMAliasSet;
@@ -60,14 +60,14 @@ class HelperAnalyses { // NOLINT(cppcoreguidelines-special-member-functions)
 
   [[nodiscard]] LLVMProjectIRDB &getProjectIRDB();
   [[nodiscard]] LLVMAliasSet &getAliasInfo();
-  [[nodiscard]] LLVMTypeHierarchy &getTypeHierarchy();
+  [[nodiscard]] DIBasedTypeHierarchy &getTypeHierarchy();
   [[nodiscard]] LLVMBasedICFG &getICFG();
   [[nodiscard]] LLVMBasedCFG &getCFG();
 
 private:
   std::unique_ptr<LLVMProjectIRDB> IRDB;
   std::unique_ptr<LLVMAliasSet> PT;
-  std::unique_ptr<LLVMTypeHierarchy> TH;
+  std::unique_ptr<DIBasedTypeHierarchy> TH;
   std::unique_ptr<LLVMBasedICFG> ICF;
   std::unique_ptr<LLVMBasedCFG> CFG;
 
diff --git a/include/phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h b/include/phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h
index dc7df6ea4..34b194350 100644
--- a/include/phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h
+++ b/include/phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h
@@ -31,6 +31,9 @@ class DIBasedTypeHierarchy
   using ClassType = const llvm::DIType *;
   using f_t = const llvm::Function *;
 
+  static inline constexpr llvm::StringLiteral PureVirtualCallName =
+      "__cxa_pure_virtual";
+
   explicit DIBasedTypeHierarchy(const LLVMProjectIRDB &IRDB);
   ~DIBasedTypeHierarchy() override = default;
 
@@ -83,6 +86,7 @@ class DIBasedTypeHierarchy
   void printAsDot(llvm::raw_ostream &OS = llvm::outs()) const;
 
   [[nodiscard]] nlohmann::json getAsJson() const override;
+  void printAsJson(llvm::raw_ostream &OS = llvm::outs()) const;
 
 private:
   [[nodiscard]] llvm::iterator_range<const ClassType *>
diff --git a/include/phasar/PhasarLLVM/Utils/LLVMIRToSrc.h b/include/phasar/PhasarLLVM/Utils/LLVMIRToSrc.h
index 9432e9c92..b36149fbe 100644
--- a/include/phasar/PhasarLLVM/Utils/LLVMIRToSrc.h
+++ b/include/phasar/PhasarLLVM/Utils/LLVMIRToSrc.h
@@ -17,6 +17,8 @@
 #ifndef PHASAR_PHASARLLVM_UTILS_LLVMIRTOSRC_H
 #define PHASAR_PHASARLLVM_UTILS_LLVMIRTOSRC_H
 
+#include "llvm/IR/DebugInfoMetadata.h"
+
 #include "nlohmann/json.hpp"
 
 #include <optional>
@@ -58,6 +60,8 @@ getLineAndColFromIR(const llvm::Value *V);
 
 [[nodiscard]] std::string getModuleIDFromIR(const llvm::Value *V);
 
+[[nodiscard]] llvm::DILocalVariable *getDILocalVariable(const llvm::Value *V);
+
 struct SourceCodeInfo {
   std::string SourceCodeLine;
   std::string SourceCodeFilename;
diff --git a/include/phasar/Utils/IRDBOpaquePtrTypes.h b/include/phasar/Utils/IRDBOpaquePtrTypes.h
deleted file mode 100644
index afd7e1ebc..000000000
--- a/include/phasar/Utils/IRDBOpaquePtrTypes.h
+++ /dev/null
@@ -1,29 +0,0 @@
-
-#include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
-
-#include "llvm/IR/DebugInfoMetadata.h"
-#include "llvm/IR/Type.h"
-#include "llvm/IR/Value.h"
-
-#include <map>
-
-namespace psr {
-
-class IRDBOpaquePtrTypes {
-public:
-  IRDBOpaquePtrTypes(const LLVMProjectIRDB *IRDB);
-  const llvm::Type *getTypeOfPtr(const llvm::Value *Value);
-
-private:
-  std::map<const llvm::Value *, const llvm::DIType *> ValueToDIType;
-  std::map<const llvm::DIType *, const llvm::Value *> DITypeToValue;
-  std::map<const llvm::DISubprogram *,
-           std::vector<const llvm::DILocalVariable *>>
-      SubprogamVars;
-  std::map<const llvm::Value *, const llvm::Type *> ValueToType;
-
-  const llvm::DIType *getBaseType(const llvm::DIDerivedType *DerivedTy);
-  const llvm::Type *getPtrType(const llvm::Value *Value);
-};
-
-} // namespace psr
\ No newline at end of file
diff --git a/lib/Controller/AnalysisController.cpp b/lib/Controller/AnalysisController.cpp
index fd77d2ec5..32922b2c9 100644
--- a/lib/Controller/AnalysisController.cpp
+++ b/lib/Controller/AnalysisController.cpp
@@ -10,7 +10,7 @@
 #include "phasar/Controller/AnalysisController.h"
 
 #include "phasar/PhasarLLVM/Passes/GeneralStatisticsAnalysis.h"
-#include "phasar/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchy.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
 #include "phasar/Utils/NlohmannLogging.h"
 
 #include "AnalysisControllerInternal.h"
diff --git a/lib/PhasarLLVM/ControlFlow/LLVMBasedICFG.cpp b/lib/PhasarLLVM/ControlFlow/LLVMBasedICFG.cpp
index 7c4a5abcf..6ebd3af3d 100644
--- a/lib/PhasarLLVM/ControlFlow/LLVMBasedICFG.cpp
+++ b/lib/PhasarLLVM/ControlFlow/LLVMBasedICFG.cpp
@@ -17,7 +17,6 @@
 #include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
-#include "phasar/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchy.h"
 #include "phasar/PhasarLLVM/Utils/LLVMBasedContainerConfig.h"
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
 #include "phasar/Utils/Logger.h"
@@ -234,15 +233,14 @@ bool LLVMBasedICFG::Builder::processFunction(const llvm::Function *F) {
 }
 
 static bool internalIsVirtualFunctionCall(const llvm::Instruction *Inst,
-                                          const LLVMVFTableProvider &VTP,
-                                          const LLVMProjectIRDB *IRDB) {
+                                          const LLVMVFTableProvider &VTP) {
   assert(Inst != nullptr);
   const auto *CallSite = llvm::dyn_cast<llvm::CallBase>(Inst);
   if (!CallSite) {
     return false;
   }
   // check potential receiver type
-  const auto *RecType = getReceiverType(CallSite, IRDB);
+  const auto *RecType = getReceiverType(CallSite);
   if (!RecType) {
     return false;
   }
@@ -274,7 +272,7 @@ bool LLVMBasedICFG::Builder::constructDynamicCall(const llvm::Instruction *CS) {
     // call the resolve routine
 
     assert(VTP != nullptr);
-    auto PossibleTargets = internalIsVirtualFunctionCall(CallSite, *VTP, IRDB)
+    auto PossibleTargets = internalIsVirtualFunctionCall(CallSite, *VTP)
                                ? Res->resolveVirtualCall(CallSite)
                                : Res->resolveFunctionPointer(CallSite);
 
@@ -339,7 +337,7 @@ void LLVMBasedICFG::initialize(LLVMProjectIRDB *IRDB, Resolver &CGResolver,
 LLVMBasedICFG::LLVMBasedICFG(LLVMProjectIRDB *IRDB,
                              CallGraphAnalysisType CGType,
                              llvm::ArrayRef<std::string> EntryPoints,
-                             LLVMTypeHierarchy *TH, LLVMAliasInfoRef PT,
+                             DIBasedTypeHierarchy *TH, LLVMAliasInfoRef PT,
                              Soundness S, bool IncludeGlobals)
     : IRDB(IRDB), VTP(*IRDB) {
   assert(IRDB != nullptr);
@@ -413,7 +411,7 @@ bool LLVMBasedICFG::isPhasarGenerated(const llvm::Function &F) noexcept {
 }
 
 [[nodiscard]] bool LLVMBasedICFG::isVirtualFunctionCallImpl(n_t Inst) const {
-  return internalIsVirtualFunctionCall(Inst, VTP, IRDB);
+  return internalIsVirtualFunctionCall(Inst, VTP);
 }
 
 [[nodiscard]] auto LLVMBasedICFG::allNonCallStartNodesImpl() const
diff --git a/lib/PhasarLLVM/ControlFlow/LLVMVFTableProvider.cpp b/lib/PhasarLLVM/ControlFlow/LLVMVFTableProvider.cpp
index b34384bd2..0c4f20143 100644
--- a/lib/PhasarLLVM/ControlFlow/LLVMVFTableProvider.cpp
+++ b/lib/PhasarLLVM/ControlFlow/LLVMVFTableProvider.cpp
@@ -3,11 +3,13 @@
 #include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
 #include "phasar/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchy.h"
 #include "phasar/PhasarLLVM/TypeHierarchy/LLVMVFTable.h"
+#include "phasar/PhasarLLVM/Utils/LLVMIRToSrc.h"
 #include "phasar/Utils/Logger.h"
 
 #include "llvm/Demangle/Demangle.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Module.h"
+#include "llvm/Support/Casting.h"
 
 using namespace psr;
 
@@ -49,6 +51,13 @@ LLVMVFTableProvider::LLVMVFTableProvider(const llvm::Module &Mod) {
   for (const auto *Ty : StructTypes) {
     TypeVFTMap.try_emplace(Ty, getVirtualFunctions(ClearNameTVMap, *Ty));
   }
+
+  for (const auto *StructTy : StructTypes) {
+    if (const auto *Val = llvm::dyn_cast<llvm::Value>(StructTy)) {
+      const auto *DILocalVar = getDILocalVariable(Val);
+      DITypeToStructType[DILocalVar->getType()] = StructTy;
+    }
+  }
 }
 
 LLVMVFTableProvider::LLVMVFTableProvider(const LLVMProjectIRDB &IRDB)
@@ -58,6 +67,10 @@ bool LLVMVFTableProvider::hasVFTable(const llvm::StructType *Type) const {
   return TypeVFTMap.count(Type);
 }
 
+bool LLVMVFTableProvider::hasVFTable(const llvm::DIType *Type) const {
+  return DITypeToStructType.count(Type);
+}
+
 const LLVMVFTable *
 LLVMVFTableProvider::getVFTableOrNull(const llvm::StructType *Type) const {
   auto It = TypeVFTMap.find(Type);
diff --git a/lib/PhasarLLVM/ControlFlow/Resolver/CHAResolver.cpp b/lib/PhasarLLVM/ControlFlow/Resolver/CHAResolver.cpp
index 9ee78fe92..7428f9fd8 100644
--- a/lib/PhasarLLVM/ControlFlow/Resolver/CHAResolver.cpp
+++ b/lib/PhasarLLVM/ControlFlow/Resolver/CHAResolver.cpp
@@ -33,10 +33,10 @@ using namespace psr;
 
 CHAResolver::CHAResolver(const LLVMProjectIRDB *IRDB,
                          const LLVMVFTableProvider *VTP,
-                         const LLVMTypeHierarchy *TH)
+                         const DIBasedTypeHierarchy *TH)
     : Resolver(IRDB, VTP), TH(TH) {
   if (!TH) {
-    this->TH = std::make_unique<LLVMTypeHierarchy>(*IRDB);
+    this->TH = std::make_unique<DIBasedTypeHierarchy>(*IRDB);
   }
 }
 
@@ -63,7 +63,7 @@ auto CHAResolver::resolveVirtualCall(const llvm::CallBase *CallSite)
 
   PHASAR_LOG_LEVEL(DEBUG, "Virtual function table entry is: " << VtableIndex);
 
-  const auto *ReceiverTy = getReceiverType(CallSite, IRDB);
+  const auto *ReceiverTy = getReceiverType(CallSite);
 
   // also insert all possible subtypes vtable entries
   auto FallbackTys = TH->getSubTypes(ReceiverTy);
diff --git a/lib/PhasarLLVM/ControlFlow/Resolver/DTAResolver.cpp b/lib/PhasarLLVM/ControlFlow/Resolver/DTAResolver.cpp
index 5f44717b1..adfc97934 100644
--- a/lib/PhasarLLVM/ControlFlow/Resolver/DTAResolver.cpp
+++ b/lib/PhasarLLVM/ControlFlow/Resolver/DTAResolver.cpp
@@ -17,12 +17,13 @@
 #include "phasar/PhasarLLVM/ControlFlow/Resolver/DTAResolver.h"
 
 #include "phasar/PhasarLLVM/ControlFlow/LLVMVFTableProvider.h"
-#include "phasar/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchy.h"
+#include "phasar/PhasarLLVM/Utils/LLVMIRToSrc.h"
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
 #include "phasar/Utils/Logger.h"
 #include "phasar/Utils/Utilities.h"
 
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/InstIterator.h"
@@ -30,6 +31,8 @@
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
+#include "llvm/IR/Value.h"
+#include "llvm/Support/Casting.h"
 
 #include <memory>
 
@@ -37,7 +40,7 @@ using namespace psr;
 
 DTAResolver::DTAResolver(const LLVMProjectIRDB *IRDB,
                          const LLVMVFTableProvider *VTP,
-                         const LLVMTypeHierarchy *TH)
+                         const DIBasedTypeHierarchy *TH)
     : CHAResolver(IRDB, VTP, TH) {}
 
 bool DTAResolver::heuristicAntiConstructorThisType(
@@ -185,9 +188,9 @@ auto DTAResolver::resolveVirtualCall(const llvm::CallBase *CallSite)
 
   PHASAR_LOG_LEVEL(DEBUG, "Virtual function table entry is: " << VtableIndex);
 
-  const auto *ReceiverType = getReceiverType(CallSite, IRDB);
+  const auto *ReceiverType = getReceiverType(CallSite);
 
-  auto PossibleTypes = TypeGraph.getTypes(ReceiverType);
+  auto PossibleTypes = TypeGraph.getTypes(DITypeToStructType[ReceiverType]);
 
   // WARNING We deactivated the check on allocated because it is
   // unabled to get the types allocated in the used libraries
@@ -197,10 +200,15 @@ auto DTAResolver::resolveVirtualCall(const llvm::CallBase *CallSite)
     if (const auto *PossibleTypeStruct =
             llvm::dyn_cast<llvm::StructType>(PossibleType)) {
       // if ( allocated_types.find(possible_type_struct) != end_it ) {
-      const auto *Target =
-          getNonPureVirtualVFTEntry(PossibleTypeStruct, VtableIndex, CallSite);
-      if (Target) {
-        PossibleCallTargets.insert(Target);
+      if (const auto *Val = llvm::dyn_cast<llvm::Value>(PossibleTypeStruct)) {
+        if (const auto *DITy =
+                llvm::dyn_cast<llvm::DIType>(getDILocalVariable(Val))) {
+          const auto *Target =
+              getNonPureVirtualVFTEntry(DITy, VtableIndex, CallSite);
+          if (Target) {
+            PossibleCallTargets.insert(Target);
+          }
+        }
       }
     }
   }
diff --git a/lib/PhasarLLVM/ControlFlow/Resolver/RTAResolver.cpp b/lib/PhasarLLVM/ControlFlow/Resolver/RTAResolver.cpp
index 79c2bfcf2..1cd9cad40 100644
--- a/lib/PhasarLLVM/ControlFlow/Resolver/RTAResolver.cpp
+++ b/lib/PhasarLLVM/ControlFlow/Resolver/RTAResolver.cpp
@@ -17,7 +17,9 @@
 #include "phasar/PhasarLLVM/ControlFlow/Resolver/RTAResolver.h"
 
 #include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
 #include "phasar/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchy.h"
+#include "phasar/PhasarLLVM/Utils/LLVMIRToSrc.h"
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
 #include "phasar/Utils/Logger.h"
 #include "phasar/Utils/Utilities.h"
@@ -37,7 +39,7 @@ using namespace psr;
 
 RTAResolver::RTAResolver(const LLVMProjectIRDB *IRDB,
                          const LLVMVFTableProvider *VTP,
-                         const LLVMTypeHierarchy *TH)
+                         const DIBasedTypeHierarchy *TH)
     : CHAResolver(IRDB, VTP, TH) {
   resolveAllocatedStructTypes();
 }
@@ -64,7 +66,7 @@ auto RTAResolver::resolveVirtualCall(const llvm::CallBase *CallSite)
 
   PHASAR_LOG_LEVEL(DEBUG, "Virtual function table entry is: " << VtableIndex);
 
-  const auto *ReceiverType = getReceiverType(CallSite, IRDB);
+  const auto *ReceiverType = getReceiverType(CallSite);
 
   // also insert all possible subtypes vtable entries
   auto ReachableTypes = TH->getSubTypes(ReceiverType);
@@ -75,11 +77,16 @@ auto RTAResolver::resolveVirtualCall(const llvm::CallBase *CallSite)
   for (const auto *PossibleType : AllocatedStructTypes) {
     if (const auto *PossibleTypeStruct =
             llvm::dyn_cast<llvm::StructType>(PossibleType)) {
-      if (ReachableTypes.find(PossibleTypeStruct) != EndIt) {
-        const auto *Target = getNonPureVirtualVFTEntry(PossibleTypeStruct,
-                                                       VtableIndex, CallSite);
-        if (Target) {
-          PossibleCallTargets.insert(Target);
+      if (const auto *Val = llvm::dyn_cast<llvm::Value>(PossibleTypeStruct)) {
+        if (const auto *DITy =
+                llvm::dyn_cast<llvm::DIType>(getDILocalVariable(Val))) {
+          if (ReachableTypes.find(DITy) != EndIt) {
+            const auto *Target =
+                getNonPureVirtualVFTEntry(DITy, VtableIndex, CallSite);
+            if (Target) {
+              PossibleCallTargets.insert(Target);
+            }
+          }
         }
       }
     }
diff --git a/lib/PhasarLLVM/ControlFlow/Resolver/Resolver.cpp b/lib/PhasarLLVM/ControlFlow/Resolver/Resolver.cpp
index bff1fb881..03bff4eca 100644
--- a/lib/PhasarLLVM/ControlFlow/Resolver/Resolver.cpp
+++ b/lib/PhasarLLVM/ControlFlow/Resolver/Resolver.cpp
@@ -24,7 +24,8 @@
 #include "phasar/PhasarLLVM/ControlFlow/Resolver/OTFResolver.h"
 #include "phasar/PhasarLLVM/ControlFlow/Resolver/RTAResolver.h"
 #include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
-#include "phasar/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchy.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
+#include "phasar/PhasarLLVM/Utils/LLVMIRToSrc.h"
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
 #include "phasar/Utils/Logger.h"
 
@@ -37,6 +38,7 @@
 #include "llvm/IR/Instructions.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/raw_ostream.h"
 
 #include <memory>
 #include <optional>
@@ -60,8 +62,7 @@ std::optional<unsigned> psr::getVFTIndex(const llvm::CallBase *CallSite) {
   return std::nullopt;
 }
 
-const llvm::StructType *psr::getReceiverType(const llvm::CallBase *CallSite,
-                                             const LLVMProjectIRDB *IRDB) {
+const llvm::DIType *psr::getReceiverType(const llvm::CallBase *CallSite) {
   if (CallSite->arg_empty() ||
       (CallSite->hasStructRetAttr() && CallSite->arg_size() < 2)) {
     return nullptr;
@@ -75,22 +76,31 @@ const llvm::StructType *psr::getReceiverType(const llvm::CallBase *CallSite,
   }
 
   if (Receiver->getType()->isOpaquePointerTy()) {
-    return nullptr;
+    if (const auto *Load = llvm::dyn_cast<llvm::LoadInst>(Receiver)) {
+      if (const auto *DerivedTy = llvm::dyn_cast<llvm::DIDerivedType>(
+              getDILocalVariable(Load->getPointerOperand())->getType())) {
+        return DerivedTy->getBaseType();
+      }
+    }
   }
 
   if (!Receiver->getType()->isOpaquePointerTy()) {
     if (const auto *ReceiverTy = llvm::dyn_cast<llvm::StructType>(
             Receiver->getType()->getNonOpaquePointerElementType())) {
-      return ReceiverTy;
+      if (const auto *ValueTy = llvm::dyn_cast<llvm::Value>(ReceiverTy)) {
+        if (const auto *DerivedTy = llvm::dyn_cast<llvm::DIDerivedType>(
+                getDILocalVariable(ValueTy))) {
+          return DerivedTy->getBaseType();
+        }
+      }
     }
   }
 
   return nullptr;
 }
 
-std::string psr::getReceiverTypeName(const llvm::CallBase *CallSite,
-                                     const LLVMProjectIRDB *IRDB) {
-  const auto *RT = getReceiverType(CallSite, IRDB);
+std::string psr::getReceiverTypeName(const llvm::CallBase *CallSite) {
+  const auto *RT = getReceiverType(CallSite);
   if (RT) {
     return RT->getName().str();
   }
@@ -113,27 +123,35 @@ bool psr::isConsistentCall(const llvm::CallBase *CallSite,
 
 namespace psr {
 
-Resolver::Resolver(const LLVMProjectIRDB *IRDB)
-    : IRDB(IRDB), VTP(nullptr), OpaquePtrTypes(IRDB) {
+Resolver::Resolver(const LLVMProjectIRDB *IRDB) : IRDB(IRDB), VTP(nullptr) {
   assert(IRDB != nullptr);
+  initializeTypeMap();
 }
 
 Resolver::Resolver(const LLVMProjectIRDB *IRDB, const LLVMVFTableProvider *VTP)
-    : IRDB(IRDB), VTP(VTP), OpaquePtrTypes(IRDB) {}
+    : IRDB(IRDB), VTP(VTP) {
+  initializeTypeMap();
+}
 
 const llvm::Function *
-Resolver::getNonPureVirtualVFTEntry(const llvm::StructType *T, unsigned Idx,
+Resolver::getNonPureVirtualVFTEntry(const llvm::DIType *T, unsigned Idx,
                                     const llvm::CallBase *CallSite) {
   if (!VTP) {
     return nullptr;
   }
-  if (const auto *VT = VTP->getVFTableOrNull(T)) {
-    const auto *Target = VT->getFunction(Idx);
-    if (Target && Target->getName() != LLVMTypeHierarchy::PureVirtualCallName &&
-        isConsistentCall(CallSite, Target)) {
-      return Target;
+
+  if (const auto *StructTy =
+          llvm::dyn_cast<llvm::StructType>(DITypeToStructType[T])) {
+    if (const auto *VT = VTP->getVFTableOrNull(StructTy)) {
+      const auto *Target = VT->getFunction(Idx);
+      if (Target &&
+          Target->getName() != DIBasedTypeHierarchy::PureVirtualCallName &&
+          isConsistentCall(CallSite, Target)) {
+        return Target;
+      }
     }
   }
+
   return nullptr;
 }
 
@@ -167,7 +185,7 @@ void Resolver::otherInst(const llvm::Instruction *Inst) {}
 std::unique_ptr<Resolver> Resolver::create(CallGraphAnalysisType Ty,
                                            const LLVMProjectIRDB *IRDB,
                                            const LLVMVFTableProvider *VTP,
-                                           const LLVMTypeHierarchy *TH,
+                                           const DIBasedTypeHierarchy *TH,
                                            LLVMAliasInfoRef PT) {
   assert(IRDB != nullptr);
   assert(VTP != nullptr);
@@ -198,4 +216,16 @@ std::unique_ptr<Resolver> Resolver::create(CallGraphAnalysisType Ty,
                    "above switch");
 }
 
+void Resolver::initializeTypeMap() {
+  for (const auto *Instr : IRDB->getAllInstructions()) {
+    if (const auto *Val = llvm::dyn_cast<llvm::Value>(Instr)) {
+      const auto *DILocalVar = getDILocalVariable(Val);
+      if (const auto *StructTy =
+              llvm::dyn_cast<llvm::StructType>(Val->getType())) {
+        DITypeToStructType[DILocalVar->getType()] = StructTy;
+      }
+    }
+  }
+}
+
 } // namespace psr
diff --git a/lib/PhasarLLVM/DataFlow/Mono/Problems/InterMonoSolverTest.cpp b/lib/PhasarLLVM/DataFlow/Mono/Problems/InterMonoSolverTest.cpp
index 5d14d7fa4..51b8a9260 100644
--- a/lib/PhasarLLVM/DataFlow/Mono/Problems/InterMonoSolverTest.cpp
+++ b/lib/PhasarLLVM/DataFlow/Mono/Problems/InterMonoSolverTest.cpp
@@ -12,7 +12,7 @@
 #include "phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h"
 #include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h"
-#include "phasar/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchy.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
 #include "phasar/Utils/Utilities.h"
 
@@ -26,7 +26,7 @@
 namespace psr {
 
 InterMonoSolverTest::InterMonoSolverTest(const LLVMProjectIRDB *IRDB,
-                                         const LLVMTypeHierarchy *TH,
+                                         const DIBasedTypeHierarchy *TH,
                                          const LLVMBasedICFG *ICF,
                                          LLVMAliasInfoRef PT,
                                          std::vector<std::string> EntryPoints)
diff --git a/lib/PhasarLLVM/HelperAnalyses.cpp b/lib/PhasarLLVM/HelperAnalyses.cpp
index 815f9d887..ce9b2f095 100644
--- a/lib/PhasarLLVM/HelperAnalyses.cpp
+++ b/lib/PhasarLLVM/HelperAnalyses.cpp
@@ -3,7 +3,7 @@
 #include "phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h"
 #include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
-#include "phasar/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchy.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
 
 #include <memory>
 #include <string>
@@ -79,9 +79,9 @@ LLVMAliasSet &HelperAnalyses::getAliasInfo() {
   return *PT;
 }
 
-LLVMTypeHierarchy &HelperAnalyses::getTypeHierarchy() {
+DIBasedTypeHierarchy &HelperAnalyses::getTypeHierarchy() {
   if (!TH) {
-    TH = std::make_unique<LLVMTypeHierarchy>(getProjectIRDB());
+    TH = std::make_unique<DIBasedTypeHierarchy>(getProjectIRDB());
   }
   return *TH;
 }
diff --git a/lib/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.cpp b/lib/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.cpp
index fd01a0759..4d581373e 100644
--- a/lib/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.cpp
+++ b/lib/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.cpp
@@ -241,6 +241,11 @@ void DIBasedTypeHierarchy::print(llvm::raw_ostream &OS) const {
   llvm::report_fatal_error("Not implemented");
 }
 
+void DIBasedTypeHierarchy::printAsJson(llvm::raw_ostream &OS) const {
+  /// TODO: implement
+  llvm::report_fatal_error("Not implemented");
+}
+
 void DIBasedTypeHierarchy::printAsDot(llvm::raw_ostream &OS) const {
   OS << "digraph TypeHierarchy{\n";
   scope_exit CloseBrace = [&OS] { OS << "}\n"; };
diff --git a/lib/PhasarLLVM/Utils/LLVMIRToSrc.cpp b/lib/PhasarLLVM/Utils/LLVMIRToSrc.cpp
index 01dd07603..d4b9372a9 100644
--- a/lib/PhasarLLVM/Utils/LLVMIRToSrc.cpp
+++ b/lib/PhasarLLVM/Utils/LLVMIRToSrc.cpp
@@ -12,7 +12,6 @@
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Demangle/Demangle.h"
-#include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
@@ -56,7 +55,7 @@ static llvm::DbgVariableIntrinsic *getDbgVarIntrinsic(const llvm::Value *V) {
   return nullptr;
 }
 
-static llvm::DILocalVariable *getDILocalVariable(const llvm::Value *V) {
+llvm::DILocalVariable *getDILocalVariable(const llvm::Value *V) {
   if (auto *DbgIntr = getDbgVarIntrinsic(V)) {
     if (auto *DDI = llvm::dyn_cast<llvm::DbgDeclareInst>(DbgIntr)) {
       return DDI->getVariable();
diff --git a/lib/PhasarPass/PhasarPass.cpp b/lib/PhasarPass/PhasarPass.cpp
index d16a1fb78..7d133b761 100644
--- a/lib/PhasarPass/PhasarPass.cpp
+++ b/lib/PhasarPass/PhasarPass.cpp
@@ -32,7 +32,7 @@
 #include "phasar/PhasarLLVM/DataFlow/Mono/Problems/IntraMonoSolverTest.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
 #include "phasar/PhasarLLVM/TaintConfig/LLVMTaintConfig.h"
-#include "phasar/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchy.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
 #include "phasar/PhasarLLVM/Utils/DataFlowAnalysisType.h"
 #include "phasar/PhasarPass/Options.h"
 #include "phasar/Utils/EnumFlags.h"
@@ -62,7 +62,7 @@ bool PhasarPass::runOnModule(llvm::Module &M) {
   }
   // set up the call-graph algorithm to be used
   CallGraphAnalysisType CGTy = toCallGraphAnalysisType(CallGraphAnalysis);
-  LLVMTypeHierarchy H(DB);
+  DIBasedTypeHierarchy H(DB);
   LLVMAliasSet PT(&DB);
   // LLVMBasedCFG CFG;
   LLVMBasedICFG I(&DB, CGTy, EntryPoints, &H, &PT);
diff --git a/lib/Utils/IRDBOpaquePtrTypes.cpp b/lib/Utils/IRDBOpaquePtrTypes.cpp
deleted file mode 100644
index 36c94b77d..000000000
--- a/lib/Utils/IRDBOpaquePtrTypes.cpp
+++ /dev/null
@@ -1,126 +0,0 @@
-#include "phasar/Utils/IRDBOpaquePtrTypes.h"
-
-#include "llvm/IR/DebugInfo.h"
-#include "llvm/IR/DebugInfoMetadata.h"
-#include "llvm/IR/DerivedTypes.h"
-#include "llvm/IR/IntrinsicInst.h"
-#include "llvm/Support/Casting.h"
-#include "llvm/Support/ErrorHandling.h"
-
-namespace psr {
-
-IRDBOpaquePtrTypes::IRDBOpaquePtrTypes(const LLVMProjectIRDB *IRDB) {
-  llvm::DebugInfoFinder DIF;
-  const auto *M = IRDB->getModule();
-  DIF.processModule(*M);
-
-  for (const auto *Instr : IRDB->getAllInstructions()) {
-    if (Instr->getType()->isOpaquePointerTy()) {
-      llvm::outs() << "is opaque pointer\n";
-    }
-  }
-
-  // Map values to DITypes
-  for (const auto *Instr : IRDB->getAllInstructions()) {
-    // Check if the current instruction has debug information
-    if (const auto *DbgDeclare = llvm::dyn_cast<llvm::DbgDeclareInst>(Instr)) {
-      if (auto *Var = llvm::dyn_cast<llvm::DILocalVariable>(
-              DbgDeclare->getVariable())) {
-        for (const auto *DIFType : DIF.types()) {
-          if (Var->getType() == DIFType) {
-            ValueToDIType.try_emplace(DbgDeclare->getAddress(), DIFType);
-          }
-        }
-      }
-    }
-  }
-
-  // Map local variables to their according subprograms
-  for (const auto *DITy : DIF.types()) {
-    if (const auto *Var = llvm::dyn_cast<llvm::DILocalVariable>(DITy)) {
-      llvm::outs() << "cast to localVar successful\n";
-      if (SubprogamVars.find(Var->getScope()->getSubprogram()) ==
-          SubprogamVars.end()) {
-        std::vector<const llvm::DILocalVariable *> InitVector;
-        SubprogamVars.try_emplace(Var->getScope()->getSubprogram(),
-                                  std::move(InitVector));
-      }
-      SubprogamVars[Var->getScope()->getSubprogram()].push_back(Var);
-    }
-  }
-
-  // Map pointers to the type they are pointing to
-  for (const auto *Instr : IRDB->getAllInstructions()) {
-    if (const auto *Value = llvm::dyn_cast<llvm::Value>(Instr)) {
-      if (Value->getType()->isOpaquePointerTy()) {
-        ValueToType.try_emplace(Value, getPtrType(Value));
-      }
-    }
-  }
-
-  llvm::outs() << "ValueToDIType map:\n";
-  for (const auto &[Key, Val] : ValueToDIType) {
-    llvm::outs() << "Key: " << *Key << " Value: " << *Val << "\n";
-  }
-
-  llvm::outs() << "DITypeToValue map:\n";
-  for (const auto &[Key, Val] : DITypeToValue) {
-    llvm::outs() << "Key: " << *Key << " Value: " << *Val << "\n";
-  }
-
-  llvm::outs() << "\nSubprogamVars map:\n";
-  for (const auto &[Key, Val] : SubprogamVars) {
-    llvm::outs() << "Key: " << Key << " Values\n{";
-    for (const auto &Elem : Val) {
-      llvm::outs() << Elem << ", ";
-    }
-    llvm::outs() << "}\n";
-  }
-  llvm::outs() << "\nValueToType map:\n";
-  for (const auto &[Key, Val] : ValueToType) {
-    llvm::outs() << "Key: " << Key << " Value: " << Val << "\n";
-  }
-}
-
-const llvm::Type *IRDBOpaquePtrTypes::getTypeOfPtr(const llvm::Value *Value) {
-  return ValueToType[Value];
-}
-
-const llvm::DIType *
-IRDBOpaquePtrTypes::getBaseType(const llvm::DIDerivedType *DerivedTy) {
-  if (const auto *BaseTy =
-          llvm::dyn_cast<llvm::DIBasicType>(DerivedTy->getBaseType())) {
-    return BaseTy;
-  };
-
-  if (const auto *CompTy =
-          llvm::dyn_cast<llvm::DICompositeType>(DerivedTy->getBaseType())) {
-    return CompTy;
-  }
-
-  // case: getBaseType() is a derived type itself
-  if (const auto *BaseIsDerivedTy =
-          llvm::dyn_cast<llvm::DIDerivedType>(DerivedTy->getBaseType())) {
-    return getBaseType(BaseIsDerivedTy);
-  }
-
-  // case: getBaseType() returns a DISubroutineType, in which we need to
-  // find the type inside the corresponding subprogram
-  /*
-  if (const auto *BaseIsInSubprogram =
-          llvm::dyn_cast<llvm::DISubroutineType>(DerivedTy)) {
-    return;
-  }*/
-  llvm::report_fatal_error("No base type found");
-}
-
-const llvm::Type *IRDBOpaquePtrTypes::getPtrType(const llvm::Value *Value) {
-  const auto *CorrespondingDIType = ValueToDIType[Value];
-  if (const auto *DerivedTyTy =
-          llvm::dyn_cast<llvm::DIDerivedType>(CorrespondingDIType)) {
-    return DITypeToValue[getBaseType(DerivedTyTy)]->getType();
-  }
-  llvm::report_fatal_error("Value is not a derived type");
-}
-
-} // namespace psr
diff --git a/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFGExportTest.cpp b/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFGExportTest.cpp
index d89cd9931..d8c05b849 100644
--- a/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFGExportTest.cpp
+++ b/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFGExportTest.cpp
@@ -4,7 +4,7 @@
 #include "phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h"
 #include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
 #include "phasar/PhasarLLVM/Passes/ValueAnnotationPass.h"
-#include "phasar/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchy.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
 #include "phasar/PhasarLLVM/Utils/LLVMIRToSrc.h"
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
 #include "phasar/Utils/IO.h"
@@ -43,7 +43,7 @@ class LLVMBasedICFGExportTest : public ::testing::Test {
   nlohmann::json exportICFG(const std::string &TestFile,
                             bool AsSrcCode = false) {
     LLVMProjectIRDB IRDB(PathToLLFiles + TestFile);
-    LLVMTypeHierarchy TH(IRDB);
+    DIBasedTypeHierarchy TH(IRDB);
     LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::OTF, {"main"}, &TH,
                        nullptr, Soundness::Soundy, /*IncludeGlobals*/ false);
 
@@ -189,7 +189,7 @@ class LLVMBasedICFGExportTest : public ::testing::Test {
   void verifyExportICFG(const llvm::Twine &TestFile,
                         bool WithDebugOutput = false) {
     LLVMProjectIRDB IRDB(PathToLLFiles + TestFile);
-    LLVMTypeHierarchy TH(IRDB);
+    DIBasedTypeHierarchy TH(IRDB);
     LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::OTF, {"main"}, &TH,
                        nullptr, Soundness::Soundy, /*IncludeGlobals*/ false);
 
diff --git a/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFGGlobCtorDtorTest.cpp b/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFGGlobCtorDtorTest.cpp
index 0977c8189..6e95f9c1a 100644
--- a/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFGGlobCtorDtorTest.cpp
+++ b/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFGGlobCtorDtorTest.cpp
@@ -15,7 +15,7 @@
 #include "phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IDELinearConstantAnalysis.h"
 #include "phasar/PhasarLLVM/Passes/ValueAnnotationPass.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
-#include "phasar/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchy.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
 #include "phasar/Utils/Logger.h"
 
@@ -83,7 +83,7 @@ class LLVMBasedICFGGlobCtorDtorTest : public ::testing::Test {
 TEST_F(LLVMBasedICFGGlobCtorDtorTest, CtorTest) {
 
   LLVMProjectIRDB IRDB(PathToLLFiles + "globals_ctor_1_cpp.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::OTF, {"main"}, &TH, &PT,
                      Soundness::Soundy, /*IncludeGlobals*/ true);
@@ -114,7 +114,7 @@ TEST_F(LLVMBasedICFGGlobCtorDtorTest, CtorTest2) {
   ASSERT_FALSE(LinkerError);
 
   LLVMProjectIRDB IRDB(std::move(M1), /*DoPreprocessing*/ true);
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::OTF, {"main"}, &TH, &PT,
                      Soundness::Soundy, /*IncludeGlobals*/ true);
@@ -132,7 +132,7 @@ TEST_F(LLVMBasedICFGGlobCtorDtorTest, CtorTest2) {
 TEST_F(LLVMBasedICFGGlobCtorDtorTest, DtorTest1) {
 
   LLVMProjectIRDB IRDB(PathToLLFiles + "globals_dtor_1_cpp.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::OTF, {"main"}, &TH, &PT,
                      Soundness::Soundy, /*IncludeGlobals*/ true);
@@ -167,7 +167,7 @@ TEST_F(LLVMBasedICFGGlobCtorDtorTest, DtorTest1) {
 TEST_F(LLVMBasedICFGGlobCtorDtorTest, LCATest1) {
 
   LLVMProjectIRDB IRDB(PathToLLFiles + "globals_lca_1_cpp.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::OTF, {"main"}, &TH, &PT,
                      Soundness::Soundy, /*IncludeGlobals*/ true);
@@ -203,7 +203,7 @@ TEST_F(LLVMBasedICFGGlobCtorDtorTest, LCATest1) {
 TEST_F(LLVMBasedICFGGlobCtorDtorTest, LCATest2) {
 
   LLVMProjectIRDB IRDB(PathToLLFiles + "globals_lca_2_cpp.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::OTF, {"main"}, &TH, &PT,
                      Soundness::Soundy, /*IncludeGlobals*/ true);
@@ -244,7 +244,7 @@ TEST_F(LLVMBasedICFGGlobCtorDtorTest, LCATest2) {
 TEST_F(LLVMBasedICFGGlobCtorDtorTest, LCATest3) {
 
   LLVMProjectIRDB IRDB(PathToLLFiles + "globals_lca_3_cpp.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::OTF, {"main"}, &TH, &PT,
                      Soundness::Soundy, /*IncludeGlobals*/ true);
@@ -288,7 +288,7 @@ TEST_F(LLVMBasedICFGGlobCtorDtorTest, LCATest3) {
 TEST_F(LLVMBasedICFGGlobCtorDtorTest, DISABLED_LCATest4) {
 
   LLVMProjectIRDB IRDB(PathToLLFiles + "globals_lca_4_cpp.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(
       &IRDB, CallGraphAnalysisType::OTF, {"main"}, &TH, &PT, Soundness::Soundy,
@@ -321,7 +321,7 @@ TEST_F(LLVMBasedICFGGlobCtorDtorTest, DISABLED_LCATest4) {
 TEST_F(LLVMBasedICFGGlobCtorDtorTest, LCATest4_1) {
 
   LLVMProjectIRDB IRDB(PathToLLFiles + "globals_lca_4_1_cpp.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(
       &IRDB, CallGraphAnalysisType::OTF, {"main"}, &TH, &PT, Soundness::Soundy,
@@ -354,7 +354,7 @@ TEST_F(LLVMBasedICFGGlobCtorDtorTest, LCATest4_1) {
 TEST_F(LLVMBasedICFGGlobCtorDtorTest, LCATest5) {
 
   LLVMProjectIRDB IRDB(PathToLLFiles + "globals_lca_5_cpp.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::OTF, {"main"}, &TH, &PT,
                      Soundness::Soundy,
diff --git a/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFGTest.cpp b/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFGTest.cpp
index 249283fde..aa9b79ded 100644
--- a/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFGTest.cpp
+++ b/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFGTest.cpp
@@ -3,10 +3,9 @@
 #include "phasar/Config/Configuration.h"
 #include "phasar/ControlFlow/CallGraphAnalysisType.h"
 #include "phasar/PhasarLLVM/ControlFlow/LLVMBasedCFG.h"
-#include "phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h"
 #include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
-#include "phasar/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchy.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
 
 #include "llvm/Support/raw_ostream.h"
@@ -28,7 +27,7 @@ template <typename T> static auto makeSet(T &&Vec) {
 TEST(LLVMBasedICFGTest, StaticCallSite_1) {
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "call_graphs/static_callsite_1_c.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::CHA, {"main"}, &TH, &PT);
   const llvm::Function *F = IRDB.getFunctionDefinition("main");
@@ -49,7 +48,7 @@ TEST(LLVMBasedICFGTest, StaticCallSite_1) {
 TEST(LLVMBasedICFGTest, StaticCallSite_2a) {
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "call_graphs/static_callsite_2_c.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::CHA, {"main"}, &TH, &PT,
                      Soundness::Soundy, false);
@@ -76,7 +75,7 @@ TEST(LLVMBasedICFGTest, StaticCallSite_2a) {
 TEST(LLVMBasedICFGTest, StaticCallSite_2b) {
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "call_graphs/static_callsite_2_c.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::CHA, {"main"}, &TH, &PT);
   const llvm::Function *F = IRDB.getFunctionDefinition("main");
@@ -110,7 +109,7 @@ TEST(LLVMBasedICFGTest, StaticCallSite_2b) {
 TEST(LLVMBasedICFGTest, VirtualCallSite_1) {
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "call_graphs/virtual_call_1_cpp.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::CHA, {"main"}, &TH, &PT);
   const llvm::Function *F = IRDB.getFunctionDefinition("main");
@@ -130,7 +129,7 @@ TEST(LLVMBasedICFGTest, VirtualCallSite_1) {
 TEST(LLVMBasedICFGTest, FunctionPointer_1) {
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "call_graphs/function_pointer_1_c.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::CHA, {"main"}, &TH, &PT);
   const llvm::Function *F = IRDB.getFunctionDefinition("main");
@@ -149,7 +148,7 @@ TEST(LLVMBasedICFGTest, FunctionPointer_1) {
 TEST(LLVMBasedICFGTest, StaticCallSite_3) {
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "call_graphs/static_callsite_3_c.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::CHA, {"main"}, &TH, &PT);
   const llvm::Function *Factorial = IRDB.getFunctionDefinition("factorial");
@@ -169,7 +168,7 @@ TEST(LLVMBasedICFGTest, StaticCallSite_3) {
 TEST(LLVMBasedICFGTest, StaticCallSite_4) {
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "call_graphs/static_callsite_4_cpp.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::CHA, {"main"}, &TH, &PT);
   const llvm::Function *F = IRDB.getFunctionDefinition("main");
@@ -202,7 +201,7 @@ TEST(LLVMBasedICFGTest, StaticCallSite_4) {
 TEST(LLVMBasedICFGTest, StaticCallSite_5) {
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "call_graphs/static_callsite_5_cpp.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::CHA, {"main"}, &TH, &PT);
   const llvm::Function *F = IRDB.getFunctionDefinition("main");
@@ -225,7 +224,7 @@ TEST(LLVMBasedICFGTest, StaticCallSite_5) {
 TEST(LLVMBasedICFGTest, StaticCallSite_6) {
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "call_graphs/static_callsite_6_cpp.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::CHA, {"main"}, &TH, &PT);
   const llvm::Function *F = IRDB.getFunctionDefinition("main");
@@ -251,7 +250,7 @@ TEST(LLVMBasedICFGTest, StaticCallSite_6) {
 TEST(LLVMBasedICFGTest, StaticCallSite_7) {
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "call_graphs/static_callsite_7_cpp.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::CHA, {"main"}, &TH, &PT);
   const llvm::Function *Main = IRDB.getFunctionDefinition("main");
@@ -275,7 +274,7 @@ TEST(LLVMBasedICFGTest, StaticCallSite_7) {
 TEST(LLVMBasedICFGTest, StaticCallSite_8) {
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "call_graphs/static_callsite_8_cpp.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::CHA, {"main"}, &TH, &PT);
   const llvm::Function *F = IRDB.getFunctionDefinition("main");
@@ -299,7 +298,7 @@ TEST(LLVMBasedICFGTest, StaticCallSite_8) {
 TEST(LLVMBasedICFGTest, GlobalCtorDtor_1) {
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "call_graphs/global_ctor_dtor_1_cpp.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::CHA, {"main"}, &TH, &PT,
                      Soundness::Soundy, true);
@@ -326,7 +325,7 @@ TEST(LLVMBasedICFGTest, GlobalCtorDtor_1) {
 TEST(LLVMBasedICFGTest, GlobalCtorDtor_2) {
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "call_graphs/global_ctor_dtor_2_cpp.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::CHA, {"main"}, &TH, &PT,
                      Soundness::Soundy, true);
@@ -350,7 +349,7 @@ TEST(LLVMBasedICFGTest, GlobalCtorDtor_2) {
 TEST(LLVMBasedICFGTest, GlobalCtorDtor_3) {
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "call_graphs/global_ctor_dtor_3_cpp.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::CHA, {"main"}, &TH, &PT,
                      Soundness::Soundy, true);
@@ -371,7 +370,7 @@ TEST(LLVMBasedICFGTest, GlobalCtorDtor_3) {
 TEST(LLVMBasedICFGTest, GlobalCtorDtor_4) {
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "call_graphs/global_ctor_dtor_4_cpp.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::CHA, {"main"}, &TH, &PT,
                      Soundness::Soundy, true);
diff --git a/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFG_DTATest.cpp b/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFG_DTATest.cpp
index 07f5b80b9..73e3aa948 100644
--- a/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFG_DTATest.cpp
+++ b/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFG_DTATest.cpp
@@ -15,7 +15,7 @@ using namespace psr;
 TEST(LLVMBasedICFG_DTATest, VirtualCallSite_5) {
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "call_graphs/virtual_call_5_cpp.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::DTA, {"main"}, &TH, &PT);
   const llvm::Function *F = IRDB.getFunctionDefinition("main");
@@ -43,7 +43,7 @@ TEST(LLVMBasedICFG_DTATest, VirtualCallSite_5) {
 TEST(LLVMBasedICFG_DTATest, VirtualCallSite_6) {
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "call_graphs/virtual_call_6_cpp.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::DTA, {"main"}, &TH, &PT);
   const llvm::Function *F = IRDB.getFunctionDefinition("main");
diff --git a/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFG_OTFTest.cpp b/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFG_OTFTest.cpp
index ebe5345d4..43de67881 100644
--- a/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFG_OTFTest.cpp
+++ b/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFG_OTFTest.cpp
@@ -20,7 +20,7 @@ using namespace psr;
 TEST(LLVMBasedICFG_OTFTest, VirtualCallSite_7) {
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "call_graphs/virtual_call_7_cpp_dbg.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB, false);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::OTF, {"main"}, &TH, &PT);
 
@@ -50,7 +50,7 @@ TEST(LLVMBasedICFG_OTFTest, VirtualCallSite_7) {
 // TEST(LLVMBasedICFG_OTFTest, VirtualCallSite_8) {
 //   ProjectIRDB IRDB({pathToLLFiles + "call_graphs/virtual_call_8_cpp.ll"},
 //                    IRDBOptions::WPA);
-//   LLVMTypeHierarchy TH(IRDB);
+//   DIBasedTypeHierarchy TH(IRDB);
 //   LLVMAliasInfo PT(IRDB);
 //   LLVMBasedICFG ICFG(IRDB, CallGraphAnalysisType::OTF, {"main"}, &TH, &PT);
 //   const llvm::Function *F = IRDB.getFunctionDefinition("main");
@@ -71,7 +71,7 @@ TEST(LLVMBasedICFG_OTFTest, VirtualCallSite_7) {
 TEST(LLVMBasedICFG_OTFTest, FunctionPtrCall_2) {
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "call_graphs/function_pointer_2_cpp.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB, false);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::OTF, {"main"}, &TH, &PT);
 
@@ -109,7 +109,7 @@ TEST(LLVMBasedICFG_OTFTest, FunctionPtrCall_2) {
 TEST(LLVMBasedICFG_OTFTest, FunctionPtrCall_3) {
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "call_graphs/function_pointer_3_cpp.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB, false);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::OTF, {"main"}, &TH, &PT);
 
diff --git a/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFG_RTATest.cpp b/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFG_RTATest.cpp
index 7503bca44..c807f5512 100644
--- a/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFG_RTATest.cpp
+++ b/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFG_RTATest.cpp
@@ -3,7 +3,7 @@
 #include "phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h"
 #include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
-#include "phasar/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchy.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
 
 #include "TestConfig.h"
@@ -15,7 +15,7 @@ using namespace psr;
 TEST(LLVMBasedICFG_RTATest, VirtualCallSite_9) {
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "call_graphs/virtual_call_9_cpp.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::RTA, {"main"}, &TH, &PT);
   const llvm::Function *F = IRDB.getFunctionDefinition("main");
@@ -41,7 +41,7 @@ TEST(LLVMBasedICFG_RTATest, VirtualCallSite_9) {
 TEST(LLVMBasedICFG_RTATest, VirtualCallSite_3) {
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "call_graphs/virtual_call_3_cpp.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::RTA, {"main"}, &TH, &PT);
   const llvm::Function *F = IRDB.getFunctionDefinition("main");
@@ -61,7 +61,7 @@ TEST(LLVMBasedICFG_RTATest, VirtualCallSite_3) {
 TEST(LLVMBasedICFG_RTATest, StaticCallSite_13) {
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "call_graphs/static_callsite_13_cpp.ll");
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMAliasSet PT(&IRDB);
   LLVMBasedICFG ICFG(&IRDB, CallGraphAnalysisType::RTA, {"main"}, &TH, &PT);
   const llvm::Function *F = IRDB.getFunctionDefinition("main");
diff --git a/unittests/PhasarLLVM/DataFlow/PathSensitivity/PathTracingTest.cpp b/unittests/PhasarLLVM/DataFlow/PathSensitivity/PathTracingTest.cpp
index 0194d0eea..262073e92 100644
--- a/unittests/PhasarLLVM/DataFlow/PathSensitivity/PathTracingTest.cpp
+++ b/unittests/PhasarLLVM/DataFlow/PathSensitivity/PathTracingTest.cpp
@@ -11,7 +11,7 @@
 #include "phasar/PhasarLLVM/Passes/ValueAnnotationPass.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasSet.h"
 #include "phasar/PhasarLLVM/TaintConfig/LLVMTaintConfig.h"
-#include "phasar/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchy.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
 #include "phasar/PhasarLLVM/Utils/LLVMShorthands.h"
 #include "phasar/Utils/AdjacencyList.h"
 #include "phasar/Utils/DFAMinimizer.h"
@@ -81,7 +81,7 @@ class PathTracingTest : public ::testing::Test {
   psr::FlowPathSequence<const llvm::Instruction *>
   doAnalysis(const std::string &LlvmFilePath, bool PrintDump = false) {
     IRDB = std::make_unique<psr::LLVMProjectIRDB>(PathToLlFiles + LlvmFilePath);
-    psr::LLVMTypeHierarchy TH(*IRDB);
+    psr::DIBasedTypeHierarchy TH(*IRDB);
     psr::LLVMAliasSet PT(IRDB.get());
     psr::LLVMBasedICFG ICFG(IRDB.get(), psr::CallGraphAnalysisType::OTF,
                             {"main"}, &TH, &PT, psr::Soundness::Soundy,
@@ -113,7 +113,7 @@ class PathTracingTest : public ::testing::Test {
   doLambdaAnalysis(const std::string &LlvmFilePath,
                    size_t MaxDAGDepth = SIZE_MAX) {
     IRDB = std::make_unique<psr::LLVMProjectIRDB>(PathToLlFiles + LlvmFilePath);
-    psr::LLVMTypeHierarchy TH(*IRDB);
+    psr::DIBasedTypeHierarchy TH(*IRDB);
     psr::LLVMAliasSet PT(IRDB.get());
     psr::LLVMBasedICFG ICFG(IRDB.get(), psr::CallGraphAnalysisType::OTF,
                             {"main"}, &TH, &PT, psr::Soundness::Soundy,
@@ -797,7 +797,7 @@ std::vector<std::vector<std::string>> getPaths(const GraphTy &G) {
 
 TEST(PathsDAGTest, InLLVMSSA) {
   psr::LLVMProjectIRDB IRDB(PathTracingTest::PathToLlFiles + "inter_01_cpp.ll");
-  psr::LLVMTypeHierarchy TH(IRDB);
+  psr::DIBasedTypeHierarchy TH(IRDB);
   psr::LLVMAliasSet PT(&IRDB);
   psr::LLVMBasedICFG ICFG(&IRDB, psr::CallGraphAnalysisType::OTF, {"main"}, &TH,
                           &PT, psr::Soundness::Soundy,
diff --git a/unittests/PhasarLLVM/Pointer/LLVMAliasSetTest.cpp b/unittests/PhasarLLVM/Pointer/LLVMAliasSetTest.cpp
index b6144d68b..74a242dec 100644
--- a/unittests/PhasarLLVM/Pointer/LLVMAliasSetTest.cpp
+++ b/unittests/PhasarLLVM/Pointer/LLVMAliasSetTest.cpp
@@ -5,7 +5,7 @@
 #include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
 #include "phasar/PhasarLLVM/Passes/ValueAnnotationPass.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMPointsToUtils.h"
-#include "phasar/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchy.h"
+#include "phasar/PhasarLLVM/TypeHierarchy/DIBasedTypeHierarchy.h"
 
 #include "TestConfig.h"
 #include "gtest/gtest.h"
@@ -32,7 +32,7 @@ TEST(LLVMAliasSet, Inter_01) {
   ValueAnnotationPass::resetValueID();
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles + "pointers/call_01_cpp.ll");
   LLVMAliasSet PTS(&IRDB, false);
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMBasedICFG ICF(&IRDB, CallGraphAnalysisType::OTF, {"main"}, &TH, &PTS);
   const auto *Main = IRDB.getFunctionDefinition("main");
   for (const auto &BB : *Main) {
@@ -49,7 +49,7 @@ TEST(LLVMAliasSet, Global_01) {
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "pointers/global_01_cpp.ll");
   LLVMAliasSet PTS(&IRDB, false);
-  LLVMTypeHierarchy TH(IRDB);
+  DIBasedTypeHierarchy TH(IRDB);
   LLVMBasedICFG ICF(&IRDB, CallGraphAnalysisType::OTF, {"main"}, &TH, &PTS);
   const auto *Main = IRDB.getFunctionDefinition("main");
   for (const auto &G : Main->getParent()->globals()) {