[opaque pointer type] Query the GEP for its source element type directly rather than...

[oota-llvm.git] / lib / IR / DebugInfo.cpp

diff --git a/lib/IR/DebugInfo.cpp b/lib/IR/DebugInfo.cpp
index 3ffd13064d4d4b2f487bf50e0714507184a31bca..719c28b547f12764755d1c99b5190e664169fcf2 100644 (file)
--- a/lib/IR/DebugInfo.cpp
+++ b/lib/IR/DebugInfo.cpp
@@ -33,30 +33,6 @@
 using namespace llvm;
 using namespace llvm::dwarf;
 
-//===----------------------------------------------------------------------===//
-// Simple Descriptor Constructors and other Methods
-//===----------------------------------------------------------------------===//
-
-DIScopeRef DIScope::getRef() const { return MDScopeRef::get(get()); }
-
-void DICompileUnit::replaceSubprograms(DIArray Subprograms) {
-  get()->replaceSubprograms(MDSubprogramArray(Subprograms));
-}
-
-void DICompileUnit::replaceGlobalVariables(DIArray GlobalVariables) {
-  get()->replaceGlobalVariables(MDGlobalVariableArray(GlobalVariables));
-}
-
-DIVariable llvm::createInlinedVariable(MDNode *DV, MDNode *InlinedScope,
-                                       LLVMContext &VMContext) {
-  return cast<MDLocalVariable>(DV)
-      ->withInline(cast_or_null<MDLocation>(InlinedScope));
-}
-
-DIVariable llvm::cleanseInlinedVariable(MDNode *DV, LLVMContext &VMContext) {
-  return cast<MDLocalVariable>(DV)->withoutInline();
-}
-
 DISubprogram llvm::getDISubprogram(const MDNode *Scope) {
   if (auto *LocalScope = dyn_cast_or_null<MDLocalScope>(Scope))
     return LocalScope->getSubprogram();
@@ -89,8 +65,7 @@ DICompositeType llvm::getDICompositeType(DIType T) {
     // not generate identifier for types, so using an empty map to resolve
     // DerivedFrom should be fine.
     DITypeIdentifierMap EmptyMap;
-    return getDICompositeType(
-        DIDerivedType(D).getTypeDerivedFrom().resolve(EmptyMap));
+    return getDICompositeType(D->getBaseType().resolve(EmptyMap));
   }
 
   return nullptr;
@@ -100,20 +75,20 @@ DITypeIdentifierMap
 llvm::generateDITypeIdentifierMap(const NamedMDNode *CU_Nodes) {
   DITypeIdentifierMap Map;
   for (unsigned CUi = 0, CUe = CU_Nodes->getNumOperands(); CUi != CUe; ++CUi) {
-    DICompileUnit CU = cast<MDCompileUnit>(CU_Nodes->getOperand(CUi));
-    DIArray Retain = CU.getRetainedTypes();
+    auto *CU = cast<MDCompileUnit>(CU_Nodes->getOperand(CUi));
+    DIArray Retain = CU->getRetainedTypes();
     for (unsigned Ti = 0, Te = Retain.size(); Ti != Te; ++Ti) {
       if (!isa<MDCompositeType>(Retain[Ti]))
         continue;
-      DICompositeType Ty = cast<MDCompositeType>(Retain[Ti]);
-      if (MDString *TypeId = Ty.getIdentifier()) {
+      auto *Ty = cast<MDCompositeType>(Retain[Ti]);
+      if (MDString *TypeId = Ty->getRawIdentifier()) {
         // Definition has priority over declaration.
         // Try to insert (TypeId, Ty) to Map.
         std::pair<DITypeIdentifierMap::iterator, bool> P =
             Map.insert(std::make_pair(TypeId, Ty));
         // If TypeId already exists in Map and this is a definition, replace
         // whatever we had (declaration or definition) with the definition.
-        if (!P.second && !Ty.isForwardDecl())
+        if (!P.second && !Ty->isForwardDecl())
           P.first->second = Ty;
       }
     }
@@ -186,22 +161,22 @@ void DebugInfoFinder::processLocation(const Module &M, DILocation Loc) {
 void DebugInfoFinder::processType(DIType DT) {
   if (!addType(DT))
     return;
-  processScope(DT.getContext().resolve(TypeIdentifierMap));
-  if (DICompositeType DCT = dyn_cast<MDCompositeTypeBase>(DT)) {
-    processType(DCT.getTypeDerivedFrom().resolve(TypeIdentifierMap));
-    if (DISubroutineType ST = dyn_cast<MDSubroutineType>(DCT)) {
+  processScope(DT->getScope().resolve(TypeIdentifierMap));
+  if (auto *DCT = dyn_cast<MDCompositeTypeBase>(DT)) {
+    processType(DCT->getBaseType().resolve(TypeIdentifierMap));
+    if (auto *ST = dyn_cast<MDSubroutineType>(DCT)) {
       for (MDTypeRef Ref : ST->getTypeArray())
         processType(Ref.resolve(TypeIdentifierMap));
       return;
     }
-    for (Metadata *D : DCT->getElements()->operands()) {
-      if (DIType T = dyn_cast<MDType>(D))
+    for (Metadata *D : DCT->getElements()) {
+      if (auto *T = dyn_cast<MDType>(D))
         processType(T);
       else if (DISubprogram SP = dyn_cast<MDSubprogram>(D))
         processSubprogram(SP);
     }
-  } else if (DIDerivedType DDT = dyn_cast<MDDerivedTypeBase>(DT)) {
-    processType(DDT.getTypeDerivedFrom().resolve(TypeIdentifierMap));
+  } else if (auto *DDT = dyn_cast<MDDerivedTypeBase>(DT)) {
+    processType(DDT->getBaseType().resolve(TypeIdentifierMap));
   }
 }
 
@@ -332,35 +307,6 @@ bool DebugInfoFinder::addScope(DIScope Scope) {
   return true;
 }
 
-//===----------------------------------------------------------------------===//
-// DIDescriptor: dump routines for all descriptors.
-//===----------------------------------------------------------------------===//
-
-void DIDescriptor::dump() const {
-  print(dbgs());
-  dbgs() << '\n';
-}
-
-void DIDescriptor::print(raw_ostream &OS) const {
-  if (!get())
-    return;
-  get()->print(OS);
-}
-
-template <>
-DIDescriptor
-DIRef<DIDescriptor>::resolve(const DITypeIdentifierMap &Map) const {
-  return DIDescriptor(DebugNodeRef(Val).resolve(Map));
-}
-template <>
-DIScope DIRef<DIScope>::resolve(const DITypeIdentifierMap &Map) const {
-  return MDScopeRef(Val).resolve(Map);
-}
-template <>
-DIType DIRef<DIType>::resolve(const DITypeIdentifierMap &Map) const {
-  return MDTypeRef(Val).resolve(Map);
-}
-
 bool llvm::stripDebugInfo(Function &F) {
   bool Changed = false;
   for (BasicBlock &BB : F) {