dtaresolver deprecated and test fixes

include/phasar/PhasarLLVM/ControlFlow/LLVMVFTableProvider.h

@@ -18,7 +18,7 @@
 
 namespace llvm {
 class Module;
-class StructType;
+class DIType;
 class GlobalVariable;
 } // namespace llvm
 
@@ -30,17 +30,12 @@ class LLVMVFTableProvider {
   explicit LLVMVFTableProvider(const llvm::Module &Mod);
   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;
-  [[nodiscard]] const LLVMVFTable *
   getVFTableOrNull(const llvm::DIType *Type) const;
 
 private:
-  std::unordered_map<const llvm::StructType *, LLVMVFTable> TypeVFTMap;
-  std::unordered_map<const llvm::DIType *, LLVMVFTable> DITypeVFTMap;
-  std::map<const llvm::DIType *, const llvm::Type *> DITypeToType;
+  std::unordered_map<const llvm::DIType *, LLVMVFTable> TypeVFTMap;
 };
 } // namespace psr
 

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

@@ -45,27 +45,33 @@ class DTAResolver : public CHAResolver {
    * An heuristic that return true if the bitcast instruction is interesting to
    * take into the DTA relational graph
    */
-  static bool
+  [[deprecated("Does not work with opaque pointers anymore")]] static bool
   heuristicAntiConstructorThisType(const llvm::BitCastInst *BitCast);
 
   /**
    * Another heuristic that return true if the bitcast instruction is
    * interesting to take into the DTA relational graph (use the presence or not
    * of vtable)
    */
-  bool heuristicAntiConstructorVtablePos(const llvm::BitCastInst *BitCast);
+  [[deprecated("Does not work with opaque pointers anymore")]] bool
+  heuristicAntiConstructorVtablePos(const llvm::BitCastInst *BitCast);
 
 public:
-  DTAResolver(const LLVMProjectIRDB *IRDB, const LLVMVFTableProvider *VTP,
-              const DIBasedTypeHierarchy *TH);
+  [[deprecated("Does not work with opaque pointers anymore")]] DTAResolver(
+      const LLVMProjectIRDB *IRDB, const LLVMVFTableProvider *VTP,
+      const DIBasedTypeHierarchy *TH);
 
   ~DTAResolver() override = default;
 
-  FunctionSetTy resolveVirtualCall(const llvm::CallBase *CallSite) override;
+  [[deprecated("Does not work with opaque pointers anymore")]] FunctionSetTy
+  resolveVirtualCall(const llvm::CallBase *CallSite) override;
 
-  void otherInst(const llvm::Instruction *Inst) override;
+  [[deprecated("Does not work with opaque pointers anymore")]] void
+  otherInst(const llvm::Instruction *Inst) override;
 
-  [[nodiscard]] std::string str() const override;
+  [[nodiscard]] [[deprecated(
+      "Does not work with opaque pointers anymore")]] std::string
+  str() const override;
 };
 } // namespace psr
 

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

@@ -67,10 +67,6 @@ class Resolver {
   getNonPureVirtualVFTEntry(const llvm::DIType *T, unsigned Idx,
                             const llvm::CallBase *CallSite);
 
-  const llvm::Function *
-  getNonPureVirtualVFTEntry(const llvm::StructType *T, unsigned Idx,
-                            const llvm::CallBase *CallSite);
-
 public:
   using FunctionSetTy = llvm::SmallDenseSet<const llvm::Function *, 4>;
 

include/phasar/PhasarLLVM/TypeHierarchy/LLVMVFTable.h

@@ -31,7 +31,6 @@ namespace psr {
  */
 class LLVMVFTable : public VFTable<const llvm::Function *> {
 private:
-  friend class LLVMTypeHierarchy;
   friend class DIBasedTypeHierarchy;
   std::vector<const llvm::Function *> VFT;
 

lib/PhasarLLVM/ControlFlow/LLVMVFTableProvider.cpp

@@ -6,6 +6,7 @@
 #include "phasar/PhasarLLVM/Utils/LLVMIRToSrc.h"
 #include "phasar/Utils/Logger.h"
 
+#include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/Demangle/Demangle.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugInfoMetadata.h"
@@ -15,57 +16,41 @@
 
 using namespace psr;
 
-static std::vector<const llvm::Function *> getVirtualFunctions(
-    const llvm::StringMap<const llvm::GlobalVariable *> &ClearNameTVMap,
-    const llvm::StructType &Type) {
-  auto ClearName =
-      DIBasedTypeHierarchy::removeStructOrClassPrefix(Type.getName());
-
-  auto It = ClearNameTVMap.find(ClearName);
-
-  if (It != ClearNameTVMap.end()) {
-    if (const auto *TI = llvm::dyn_cast<llvm::GlobalVariable>(It->second)) {
-      if (!TI->hasInitializer()) {
-        PHASAR_LOG_LEVEL_CAT(DEBUG, "DIBasedTypeHierarchy",
-                             ClearName << " does not have initializer");
-        return {};
-      }
-      if (const auto *I =
-              llvm::dyn_cast<llvm::ConstantStruct>(TI->getInitializer())) {
-        return LLVMVFTable::getVFVectorFromIRVTable(*I);
-      }
-    }
+static std::string getTypeName(const llvm::DIType *DITy) {
+  if (const auto *CompTy = llvm::dyn_cast<llvm::DICompositeType>(DITy)) {
+    auto Ident = CompTy->getIdentifier();
+    return Ident.empty() ? llvm::demangle(CompTy->getName().str())
+                         : llvm::demangle(Ident.str());
   }
-  return {};
+  return llvm::demangle(DITy->getName().str());
 }
 
-static std::vector<const llvm::Function *> getVirtualFunctionsDIBased(
+static std::vector<const llvm::Function *> getVirtualFunctions(
     const llvm::StringMap<const llvm::GlobalVariable *> &ClearNameTVMap,
-    const llvm::DIType &Type) {
-  auto ClearName =
-      DIBasedTypeHierarchy::removeStructOrClassPrefix(Type.getName());
+    const llvm::DIType *Type) {
+  auto ClearName = getTypeName(Type);
+
+  if (ClearName.substr(0, 18) == "typeinfo name for ") {
+    ClearName = ClearName.substr(18, ClearName.size() - 1);
+  }
 
   auto It = ClearNameTVMap.find(ClearName);
 
   if (It != ClearNameTVMap.end()) {
-    if (const auto *TI = llvm::dyn_cast<llvm::GlobalVariable>(It->second)) {
-      if (!TI->hasInitializer()) {
-        PHASAR_LOG_LEVEL_CAT(DEBUG, "DIBasedTypeHierarchy",
-                             ClearName << " does not have initializer");
-        return {};
-      }
-      if (const auto *I =
-              llvm::dyn_cast<llvm::ConstantStruct>(TI->getInitializer())) {
-        return LLVMVFTable::getVFVectorFromIRVTable(*I);
-      }
+    if (!It->second->hasInitializer()) {
+      PHASAR_LOG_LEVEL_CAT(DEBUG, "DIBasedTypeHierarchy",
+                           ClearName << " does not have initializer");
+      return {};
+    }
+    if (const auto *I = llvm::dyn_cast<llvm::ConstantStruct>(
+            It->second->getInitializer())) {
+      return LLVMVFTable::getVFVectorFromIRVTable(*I);
     }
   }
   return {};
 }
 
 LLVMVFTableProvider::LLVMVFTableProvider(const llvm::Module &Mod) {
-  auto StructTypes = Mod.getIdentifiedStructTypes();
-
   llvm::StringMap<const llvm::GlobalVariable *> ClearNameTVMap;
 
   for (const auto &Glob : Mod.globals()) {
@@ -76,63 +61,33 @@ LLVMVFTableProvider::LLVMVFTableProvider(const llvm::Module &Mod) {
     }
   }
 
-  for (const auto *Ty : StructTypes) {
-    TypeVFTMap.try_emplace(Ty, getVirtualFunctions(ClearNameTVMap, *Ty));
-  }
-}
-
-LLVMVFTableProvider::LLVMVFTableProvider(const LLVMProjectIRDB &IRDB)
-    : LLVMVFTableProvider(*IRDB.getModule()) {
-  for (const auto *Instr : IRDB.getAllInstructions()) {
-    if (const auto *Val = llvm::dyn_cast<llvm::Value>(Instr)) {
-      if (const auto *DILocalVar = getDILocalVariable(Val)) {
-        if (const auto *DerivedTy =
-                llvm::dyn_cast<llvm::DIDerivedType>(DILocalVar->getType())) {
-          DITypeToType[DerivedTy->getBaseType()] = Val->getType();
-          continue;
+  llvm::DebugInfoFinder DIF;
+  DIF.processModule(Mod);
+  for (const auto *Ty : DIF.types()) {
+    if (const auto *DerivedTy = llvm::dyn_cast<llvm::DIDerivedType>(Ty)) {
+      if (const auto *BaseTy = DerivedTy->getBaseType()) {
+        if (const auto *CompTy =
+                llvm::dyn_cast<llvm::DICompositeType>(BaseTy)) {
+          if (CompTy->getTag() == llvm::dwarf::DW_TAG_class_type ||
+              CompTy->getTag() == llvm::dwarf::DW_TAG_structure_type) {
+            TypeVFTMap.try_emplace(CompTy,
+                                   getVirtualFunctions(ClearNameTVMap, CompTy));
+          }
         }
-        DITypeToType[DILocalVar->getType()] = Val->getType();
       }
     }
   }
-
-  llvm::StringMap<const llvm::GlobalVariable *> ClearNameTVMap;
-
-  for (const auto &Glob : IRDB.getModule()->globals()) {
-    if (DIBasedTypeHierarchy::isVTable(Glob.getName())) {
-      auto Demang = llvm::demangle(Glob.getName().str());
-      auto ClearName = DIBasedTypeHierarchy::removeVTablePrefix(Demang);
-      ClearNameTVMap.try_emplace(ClearName, &Glob);
-    }
-  }
-
-  for (const auto &Elem : DITypeToType) {
-    DITypeVFTMap.try_emplace(
-        Elem.first, getVirtualFunctionsDIBased(ClearNameTVMap, *Elem.first));
-  }
 }
 
-bool LLVMVFTableProvider::hasVFTable(const llvm::StructType *Type) const {
-  return TypeVFTMap.count(Type);
-}
+LLVMVFTableProvider::LLVMVFTableProvider(const LLVMProjectIRDB &IRDB)
+    : LLVMVFTableProvider(*IRDB.getModule()) {}
 
 bool LLVMVFTableProvider::hasVFTable(const llvm::DIType *Type) const {
-  return DITypeToType.count(Type);
+  return TypeVFTMap.count(Type);
 }
 
 const LLVMVFTable *
-LLVMVFTableProvider::getVFTableOrNull(const llvm::StructType *Type) const {
+LLVMVFTableProvider::getVFTableOrNull(const llvm::DIType *Type) const {
   auto It = TypeVFTMap.find(Type);
   return It != TypeVFTMap.end() ? &It->second : nullptr;
 }
-
-const LLVMVFTable *
-LLVMVFTableProvider::getVFTableOrNull(const llvm::DIType *Type) const {
-  if (const auto *Ty = DITypeToType.at(Type)) {
-    if (const auto *StructTy = llvm::dyn_cast<llvm::StructType>(Ty)) {
-      return getVFTableOrNull(StructTy);
-    }
-  }
-
-  return nullptr;
-}

lib/PhasarLLVM/ControlFlow/Resolver/DTAResolver.cpp

@@ -33,6 +33,7 @@
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/ErrorHandling.h"
 
 #include <memory>
 
@@ -45,6 +46,10 @@ DTAResolver::DTAResolver(const LLVMProjectIRDB *IRDB,
 
 bool DTAResolver::heuristicAntiConstructorThisType(
     const llvm::BitCastInst *BitCast) {
+
+  llvm::report_fatal_error("Does not work with opaque pointers anymore");
+
+#if 0
   // We check if the caller is a constructor, and if the this argument has the
   // same type as the source type of the bitcast. If it is the case, it returns
   // false, true otherwise.
@@ -62,13 +67,20 @@ bool DTAResolver::heuristicAntiConstructorThisType(
   }
 
   return true;
+#endif
 }
 
 bool DTAResolver::heuristicAntiConstructorVtablePos(
     const llvm::BitCastInst *BitCast) {
+
+  llvm::report_fatal_error("Does not work with opaque pointers anymore");
+
+#if 0 
+
   // Better heuristic than the previous one, can handle the CRTP. Based on the
   // previous one.
 
+
   if (heuristicAntiConstructorThisType(BitCast)) {
     return true;
   }
@@ -142,9 +154,14 @@ bool DTAResolver::heuristicAntiConstructorVtablePos(
   }
 
   return (BitcastNum > VtableNum);
+#endif
 }
 
 void DTAResolver::otherInst(const llvm::Instruction *Inst) {
+
+  llvm::report_fatal_error("Does not work with opaque pointers anymore");
+
+#if 0
   if (Inst->getType()->isOpaquePointerTy()) {
     /// XXX: We may want to get these information on a different way, e.g. by
     /// analyzing the debug info
@@ -165,10 +182,13 @@ void DTAResolver::otherInst(const llvm::Instruction *Inst) {
       TypeGraph.addLink(DestStructType, SrcStructType);
     }
   }
+#endif
 }
-
 auto DTAResolver::resolveVirtualCall(const llvm::CallBase *CallSite)
     -> FunctionSetTy {
+  llvm::report_fatal_error("Does not work with opaque pointers anymore");
+
+#if 0
   FunctionSetTy PossibleCallTargets;
 
   PHASAR_LOG_LEVEL(DEBUG,
@@ -220,6 +240,7 @@ auto DTAResolver::resolveVirtualCall(const llvm::CallBase *CallSite)
 #endif
 
   return PossibleCallTargets;
+#endif
 }
 
 std::string DTAResolver::str() const { return "DTA"; }

lib/PhasarLLVM/ControlFlow/Resolver/Resolver.cpp

@@ -179,27 +179,6 @@ Resolver::getNonPureVirtualVFTEntry(const llvm::DIType *T, unsigned Idx,
     return nullptr;
   }
 
-  if (const auto *StructTy =
-          llvm::dyn_cast<llvm::StructType>(DITypeToType[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;
-}
-
-const llvm::Function *
-Resolver::getNonPureVirtualVFTEntry(const llvm::StructType *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 &&
@@ -208,6 +187,7 @@ Resolver::getNonPureVirtualVFTEntry(const llvm::StructType *T, unsigned Idx,
       return Target;
     }
   }
+
   return nullptr;
 }
 

unittests/PhasarLLVM/ControlFlow/LLVMBasedICFG_DTATest.cpp

@@ -11,8 +11,8 @@
 
 using namespace std;
 using namespace psr;
-
 TEST(LLVMBasedICFG_DTATest, VirtualCallSite_5) {
+#if 0
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "call_graphs/virtual_call_5_cpp.ll");
   DIBasedTypeHierarchy TH(IRDB);
@@ -38,9 +38,11 @@ TEST(LLVMBasedICFG_DTATest, VirtualCallSite_5) {
     ASSERT_TRUE(llvm::is_contained(ICFG.getCallersOf(VFuncA), I));
     ASSERT_TRUE(llvm::is_contained(ICFG.getCallersOf(VFuncB), I));
   }
+#endif
 }
 
 TEST(LLVMBasedICFG_DTATest, VirtualCallSite_6) {
+#if 0
   LLVMProjectIRDB IRDB(unittest::PathToLLTestFiles +
                        "call_graphs/virtual_call_6_cpp.ll");
   DIBasedTypeHierarchy TH(IRDB);
@@ -57,6 +59,7 @@ TEST(LLVMBasedICFG_DTATest, VirtualCallSite_6) {
   const auto &Callers = ICFG.getCallersOf(VFuncA);
   ASSERT_EQ(Callers.size(), 1U);
   ASSERT_TRUE(llvm::is_contained(Callers, I));
+#endif
 }
 
 int main(int Argc, char **Argv) {