Adapt to MD* => DI* renaming of debug info types

Applied the upgrade script from r236120 (LLVM) and r236121 (CFE).  This is the
final step of rdar://problem/20434113.



Swift SVN r27925

lib/IRGen/IRGenDebugInfo.cpp

@@ -96,12 +96,11 @@ static void mangleIdent(llvm::raw_string_ostream &OS, StringRef Id) {
 }
 
 /// Return the size reported by a type.
-static unsigned getSizeInBits(llvm::MDType *Ty,
-                              const TrackingDIRefMap &Map) {
+static unsigned getSizeInBits(llvm::DIType *Ty, const TrackingDIRefMap &Map) {
   // Follow derived types until we reach a type that
   // reports back a size.
-  while (isa<llvm::MDDerivedType>(Ty) && !Ty->getSizeInBits()) {
-    auto *DT = cast<llvm::MDDerivedType>(Ty);
+  while (isa<llvm::DIDerivedType>(Ty) && !Ty->getSizeInBits()) {
+    auto *DT = cast<llvm::DIDerivedType>(Ty);
     Ty = DT->getBaseType().resolve(Map);
     if (!Ty)
       return 0;
@@ -110,9 +109,9 @@ static unsigned getSizeInBits(llvm::MDType *Ty,
 }
 
 /// Return the size reported by the variable's type.
-static unsigned getSizeInBits(const llvm::MDLocalVariable *Var,
+static unsigned getSizeInBits(const llvm::DILocalVariable *Var,
                               const TrackingDIRefMap &Map) {
-  llvm::MDType *Ty = Var->getType().resolve(Map);
+  llvm::DIType *Ty = Var->getType().resolve(Map);
   return getSizeInBits(Ty, Map);
 }
 
@@ -311,8 +310,8 @@ llvm::MDNode* IRGenDebugInfo::createInlinedAt(SILDebugScope *InlinedScope) {
 
 #ifndef NDEBUG
   auto *S = getOrCreateScope(InlinedScope);
-  while (!isa<llvm::MDSubprogram>(S)) {
-    auto *LB = dyn_cast<llvm::MDLexicalBlockBase>(S);
+  while (!isa<llvm::DISubprogram>(S)) {
+    auto *LB = dyn_cast<llvm::DILexicalBlockBase>(S);
     S = LB->getScope();
     assert(S && "Lexical block parent chain must contain a subprogram");
   }
@@ -424,14 +423,14 @@ void IRGenDebugInfo::setCurrentLoc(IRBuilder &Builder, SILDebugScope *DS,
 }
 
 /// getOrCreateScope - Translate a SILDebugScope into an llvm::DIDescriptor.
-llvm::MDScope *IRGenDebugInfo::getOrCreateScope(SILDebugScope *DS) {
+llvm::DIScope *IRGenDebugInfo::getOrCreateScope(SILDebugScope *DS) {
   if (DS == 0)
     return MainFile;
 
   // Try to find it in the cache first.
   auto CachedScope = ScopeCache.find(DS);
   if (CachedScope != ScopeCache.end())
-    return cast<llvm::MDScope>(CachedScope->second);
+    return cast<llvm::DIScope>(CachedScope->second);
 
   // If this is a (inlined) function scope, the function may
   // not have been created yet.
@@ -448,7 +447,7 @@ llvm::MDScope *IRGenDebugInfo::getOrCreateScope(SILDebugScope *DS) {
 
     auto CachedScope = ScopeCache.find(FnScope);
     if (CachedScope != ScopeCache.end())
-      return cast<llvm::MDScope>(CachedScope->second);
+      return cast<llvm::DIScope>(CachedScope->second);
 
     // Force the debug info for the function to be emitted, even if it
     // is external or has been inlined.
@@ -462,13 +461,13 @@ llvm::MDScope *IRGenDebugInfo::getOrCreateScope(SILDebugScope *DS) {
     return SP;
   }
 
-  llvm::MDScope *Parent = getOrCreateScope(DS->Parent);
+  llvm::DIScope *Parent = getOrCreateScope(DS->Parent);
   if (Opts.DebugInfoKind == IRGenDebugInfoKind::LineTables)
     return Parent;
 
   assert(DS->Parent && "lexical block must have a parent subprogram");
   Location L = getStartLocation(SM, DS->Loc);
-  llvm::MDFile *File = getOrCreateFile(L.Filename);
+  llvm::DIFile *File = getOrCreateFile(L.Filename);
   auto *DScope = DBuilder.createLexicalBlock(Parent, File, L.Line, L.Col);
 
   // Cache it.
@@ -490,7 +489,7 @@ StringRef IRGenDebugInfo::getCurrentDirname() {
 }
 
 /// getOrCreateFile - Translate filenames into DIFiles.
-llvm::MDFile *IRGenDebugInfo::getOrCreateFile(const char *Filename) {
+llvm::DIFile *IRGenDebugInfo::getOrCreateFile(const char *Filename) {
   if (!Filename)
     return MainFile;
 
@@ -500,14 +499,14 @@ llvm::MDFile *IRGenDebugInfo::getOrCreateFile(const char *Filename) {
   if (CachedFile != DIFileCache.end()) {
     // Verify that the information still exists.
     if (llvm::Metadata *V = CachedFile->second)
-      return cast<llvm::MDFile>(V);
+      return cast<llvm::DIFile>(V);
   }
 
   // Create a new one.
   StringRef File = BumpAllocatedString(llvm::sys::path::filename(Filename));
   llvm::SmallString<512> Path(Filename);
   llvm::sys::path::remove_filename(Path);
-  llvm::MDFile *F = DBuilder.createFile(File, BumpAllocatedString(Path));
+  llvm::DIFile *F = DBuilder.createFile(File, BumpAllocatedString(Path));
 
   // Cache it.
   DIFileCache[Filename] = llvm::TrackingMDNodeRef(F);
@@ -575,7 +574,7 @@ static CanSILFunctionType getFunctionType(SILType SILTy) {
 }
 
 /// Build the context chain for a given DeclContext.
-llvm::MDScope *IRGenDebugInfo::getOrCreateContext(DeclContext *DC) {
+llvm::DIScope *IRGenDebugInfo::getOrCreateContext(DeclContext *DC) {
   if (!DC)
     return TheCU;
 
@@ -591,7 +590,7 @@ llvm::MDScope *IRGenDebugInfo::getOrCreateContext(DeclContext *DC) {
   case DeclContextKind::ExtensionDecl:
     return getOrCreateContext(DC->getParent());
   case DeclContextKind::TopLevelCodeDecl:
-    return cast<llvm::MDScope>(EntryPointFn);
+    return cast<llvm::DIScope>(EntryPointFn);
   case DeclContextKind::Module: {
     auto File = getOrCreateFile(getFilenameFromDC(DC));
     return getOrCreateModule(TheCU, cast<Module>(DC)->getName().str(), File);
@@ -605,7 +604,7 @@ llvm::MDScope *IRGenDebugInfo::getOrCreateContext(DeclContext *DC) {
     if (CachedType != DITypeCache.end()) {
       // Verify that the information still exists.
       if (llvm::Metadata *Val = CachedType->second)
-        return cast<llvm::MDType>(Val);
+        return cast<llvm::DIType>(Val);
     }
 
     // Create a Forward-declared type.
@@ -634,7 +633,7 @@ void IRGenDebugInfo::createParameterType(
 }
 
 /// Create the array of function parameters for FnTy. SIL Version.
-llvm::MDTypeRefArray
+llvm::DITypeRefArray
 IRGenDebugInfo::createParameterTypes(SILType SILTy, DeclContext *DeclCtx) {
   if (!SILTy)
     return nullptr;
@@ -642,7 +641,7 @@ IRGenDebugInfo::createParameterTypes(SILType SILTy, DeclContext *DeclCtx) {
 }
 
 /// Create the array of function parameters for a function type.
-llvm::MDTypeRefArray
+llvm::DITypeRefArray
 IRGenDebugInfo::createParameterTypes(CanSILFunctionType FnTy,
                                      DeclContext *DeclCtx) {
   SmallVector<llvm::Metadata *, 16> Parameters;
@@ -669,14 +668,13 @@ static bool isAllocatingConstructor(SILFunctionTypeRepresentation Rep,
           && DeclCtx && isa<ConstructorDecl>(DeclCtx);
 }
 
-llvm::MDSubprogram *IRGenDebugInfo::
-emitFunction(SILModule &SILMod, SILDebugScope *DS, llvm::Function *Fn,
-             SILFunctionTypeRepresentation Rep, SILType SILTy,
-             DeclContext *DeclCtx) {
+llvm::DISubprogram *IRGenDebugInfo::emitFunction(
+    SILModule &SILMod, SILDebugScope *DS, llvm::Function *Fn,
+    SILFunctionTypeRepresentation Rep, SILType SILTy, DeclContext *DeclCtx) {
   // Returned a previously cached entry for an abstract (inlined) function.
   auto cached = ScopeCache.find(DS);
   if (cached != ScopeCache.end())
-    return cast<llvm::MDSubprogram>(cached->second);
+    return cast<llvm::DISubprogram>(cached->second);
 
   StringRef LinkageName;
   if (Fn)
@@ -724,9 +722,9 @@ emitFunction(SILModule &SILMod, SILDebugScope *DS, llvm::Function *Fn,
   auto Params = Opts.DebugInfoKind == IRGenDebugInfoKind::LineTables
     ? nullptr
     : createParameterTypes(SILTy, DeclCtx);
-  llvm::MDSubroutineType *DIFnTy = DBuilder.createSubroutineType(File, Params);
+  llvm::DISubroutineType *DIFnTy = DBuilder.createSubroutineType(File, Params);
   llvm::MDNode *TemplateParameters = nullptr;
-  llvm::MDSubprogram *Decl = nullptr;
+  llvm::DISubprogram *Decl = nullptr;
 
   // Various flags
   bool IsLocalToUnit = Fn ? Fn->hasInternalLinkage() : true;
@@ -745,15 +743,15 @@ emitFunction(SILModule &SILMod, SILDebugScope *DS, llvm::Function *Fn,
       // never want to set a breakpoint there.
       (Rep == SILFunctionTypeRepresentation::ObjCMethod) ||
       isAllocatingConstructor(Rep, DeclCtx)) {
-    Flags |= llvm::DebugNode::FlagArtificial;
+    Flags |= llvm::DINode::FlagArtificial;
     ScopeLine = 0;
   }
 
   if (FnTy && FnTy->getRepresentation()
         == SILFunctionType::Representation::Block)
-    Flags |= llvm::DebugNode::FlagAppleBlock;
+    Flags |= llvm::DINode::FlagAppleBlock;
 
-  llvm::MDSubprogram *SP = DBuilder.createFunction(
+  llvm::DISubprogram *SP = DBuilder.createFunction(
       Scope, Name, LinkageName, File, Line, DIFnTy, IsLocalToUnit, IsDefinition,
       ScopeLine, Flags, IsOptimized, Fn, TemplateParameters, Decl);
 
@@ -839,9 +837,9 @@ void IRGenDebugInfo::createImportedModule(StringRef Name, StringRef Mangled,
 }
 
 /// Return a cached module for an access path or create a new one.
-llvm::MDModule *IRGenDebugInfo::getOrCreateModule(llvm::MDScope *Parent,
+llvm::MDModule *IRGenDebugInfo::getOrCreateModule(llvm::DIScope *Parent,
                                                   std::string Name,
-                                                  llvm::MDFile *File) {
+                                                  llvm::DIFile *File) {
   // Look in the cache first.
   auto CachedM = DIModuleCache.find(Name);
 
@@ -855,7 +853,7 @@ llvm::MDModule *IRGenDebugInfo::getOrCreateModule(llvm::MDScope *Parent,
   return M;
 }
 
-llvm::MDSubprogram *IRGenDebugInfo::emitFunction(SILFunction &SILFn,
+llvm::DISubprogram *IRGenDebugInfo::emitFunction(SILFunction &SILFn,
                                                  llvm::Function *Fn) {
   auto *DS = SILFn.getDebugScope();
   if (DS && !DS->SILFn)
@@ -925,17 +923,17 @@ void IRGenDebugInfo::emitArgVariableDeclaration(
                             Indirection, IsArtificial);
 }
 
-/// Return the MDFile that is the ancestor of Scope.
-llvm::MDFile *IRGenDebugInfo::getFile(llvm::MDScope *Scope) {
-  while (!isa<llvm::MDFile>(Scope)) {
+/// Return the DIFile that is the ancestor of Scope.
+llvm::DIFile *IRGenDebugInfo::getFile(llvm::DIScope *Scope) {
+  while (!isa<llvm::DIFile>(Scope)) {
     switch (Scope->getTag()) {
     case llvm::dwarf::DW_TAG_lexical_block:
-      Scope = cast<llvm::MDLexicalBlock>(Scope)->getScope();
+      Scope = cast<llvm::DILexicalBlock>(Scope)->getScope();
       break;
     case llvm::dwarf::DW_TAG_subprogram: {
       // Scopes are not indexed by UID.
       llvm::DITypeIdentifierMap EmptyMap;
-      Scope = cast<llvm::MDSubprogram>(Scope)->getScope().resolve(EmptyMap);
+      Scope = cast<llvm::DISubprogram>(Scope)->getScope().resolve(EmptyMap);
       break;
     }
     default:
@@ -944,7 +942,7 @@ llvm::MDFile *IRGenDebugInfo::getFile(llvm::MDScope *Scope) {
     if (Scope)
       return MainFile;
   }
-  return cast<llvm::MDFile>(Scope);
+  return cast<llvm::DIFile>(Scope);
 }
 
 /// Return the storage size of an explosion value.
@@ -963,10 +961,10 @@ static uint64_t getSizeFromExplosionValue(const clang::TargetInfo &TI,
 /// composite type.
 class ElementSizes {
   const TrackingDIRefMap &DIRefMap;
-  SmallVector<const llvm::MDType *, 12> Stack;
+  SmallVector<const llvm::DIType *, 12> Stack;
 
 public:
-  ElementSizes(const llvm::MDType *DITy, const TrackingDIRefMap &DIRefMap)
+  ElementSizes(const llvm::DIType *DITy, const TrackingDIRefMap &DIRefMap)
       : DIRefMap(DIRefMap), Stack(1, DITy) {}
 
   struct SizeAlign {
@@ -978,9 +976,9 @@ public:
       return {0, 0};
 
     auto *Cur = Stack.pop_back_val();
-    if (isa<llvm::MDCompositeType>(Cur) &&
+    if (isa<llvm::DICompositeType>(Cur) &&
         Cur->getTag() != llvm::dwarf::DW_TAG_subroutine_type) {
-      auto *CTy = cast<llvm::MDCompositeType>(Cur);
+      auto *CTy = cast<llvm::DICompositeType>(Cur);
       auto Elts = CTy->getElements();
       unsigned N = Cur->getTag() == llvm::dwarf::DW_TAG_union_type
         ? std::min(1U, Elts.size()) // For unions, pick any one.
@@ -991,7 +989,7 @@ public:
         // FIXME: With a little more state we don't need to actually
         // store them on the Stack.
         for (unsigned I = N; I > 0; --I)
-          Stack.push_back(cast<llvm::MDType>(Elts[I - 1]));
+          Stack.push_back(cast<llvm::DIType>(Elts[I - 1]));
         return getNext();
       }
     }
@@ -999,7 +997,7 @@ public:
     case llvm::dwarf::DW_TAG_member:
     case llvm::dwarf::DW_TAG_typedef: {
       // Replace top of stack.
-      auto *DTy = cast<llvm::MDDerivedType>(Cur);
+      auto *DTy = cast<llvm::DIDerivedType>(Cur);
       Stack.push_back(DTy->getBaseType().resolve(DIRefMap));
       return getNext();
     }
@@ -1032,29 +1030,29 @@ void IRGenDebugInfo::emitVariableDeclaration(
   if (!DbgTy.size)
     DbgTy.size = getStorageSize(IGM.DataLayout, Storage);
 
-  auto *Scope = dyn_cast<llvm::MDLocalScope>(getOrCreateScope(DS));
+  auto *Scope = dyn_cast<llvm::DILocalScope>(getOrCreateScope(DS));
   assert(Scope && "variable has no local scope");
   Location Loc = getLoc(SM, DbgTy.getDecl());
 
   // FIXME: this should be the scope of the type's declaration.
   // If this is an argument, attach it to the current function scope.
   if (ArgNo > 0) {
-    while (isa<llvm::MDLexicalBlock>(Scope))
-      Scope = cast<llvm::MDLexicalBlock>(Scope)->getScope();
+    while (isa<llvm::DILexicalBlock>(Scope))
+      Scope = cast<llvm::DILexicalBlock>(Scope)->getScope();
   }
-  assert(Scope && isa<llvm::MDScope>(Scope) && "variable has no scope");
-  llvm::MDFile *Unit = getFile(Scope);
-  llvm::MDType *DITy = getOrCreateType(DbgTy);
+  assert(Scope && isa<llvm::DIScope>(Scope) && "variable has no scope");
+  llvm::DIFile *Unit = getFile(Scope);
+  llvm::DIType *DITy = getOrCreateType(DbgTy);
   assert(DITy && "could not determine debug type of variable");
 
   unsigned Line = Loc.Line;
   unsigned Flags = 0;
   if (Artificial || DITy->isArtificial() || DITy == InternalType)
-    Flags |= llvm::DebugNode::FlagArtificial;
+    Flags |= llvm::DINode::FlagArtificial;
 
   // Create the descriptor for the variable.
-  llvm::MDLocalVariable *Var = nullptr;
-  llvm::MDExpression *Expr = DBuilder.createExpression();
+  llvm::DILocalVariable *Var = nullptr;
+  llvm::DIExpression *Expr = DBuilder.createExpression();
 
   if (Indirection) {
     // Classes are always passed by reference.
@@ -1126,12 +1124,12 @@ void IRGenDebugInfo::emitVariableDeclaration(
   }
 }
 
-void IRGenDebugInfo::
-emitDbgIntrinsic(llvm::BasicBlock *BB,
-                 llvm::Value* Storage, llvm::MDLocalVariable *Var,
-                 llvm::MDExpression *Expr,
-                 unsigned Line, unsigned Col, llvm::MDLocalScope *Scope,
-                 SILDebugScope *DS) {
+void IRGenDebugInfo::emitDbgIntrinsic(llvm::BasicBlock *BB,
+                                      llvm::Value *Storage,
+                                      llvm::DILocalVariable *Var,
+                                      llvm::DIExpression *Expr, unsigned Line,
+                                      unsigned Col, llvm::DILocalScope *Scope,
+                                      SILDebugScope *DS) {
   // Set the location/scope of the intrinsic.
   llvm::MDNode *InlinedAt = nullptr;
   if (DS && DS->InlinedCallSite) {
@@ -1155,7 +1153,7 @@ void IRGenDebugInfo::emitGlobalVariableDeclaration(llvm::GlobalValue *Var,
   if (Opts.DebugInfoKind == IRGenDebugInfoKind::LineTables)
     return;
 
-  llvm::MDType *Ty = getOrCreateType(DbgTy);
+  llvm::DIType *Ty = getOrCreateType(DbgTy);
   if (Ty->isArtificial() || Ty == InternalType ||
       Var->getVisibility() == llvm::GlobalValue::HiddenVisibility)
     // FIXME: Really these should be marked as artificial, but LLVM
@@ -1189,9 +1187,10 @@ StringRef IRGenDebugInfo::getMangledName(DebugTypeInfo DbgTy) {
 }
 
 /// Create a member of a struct, class, tuple, or enum.
-llvm::MDDerivedType *IRGenDebugInfo::createMemberType(
-    DebugTypeInfo DbgTy, StringRef Name, unsigned &OffsetInBits,
-    llvm::MDScope *Scope, llvm::MDFile *File, unsigned Flags) {
+llvm::DIDerivedType *
+IRGenDebugInfo::createMemberType(DebugTypeInfo DbgTy, StringRef Name,
+                                 unsigned &OffsetInBits, llvm::DIScope *Scope,
+                                 llvm::DIFile *File, unsigned Flags) {
   unsigned SizeOfByte = CI.getTargetInfo().getCharWidth();
   auto *Ty = getOrCreateType(DbgTy);
   auto *DITy = DBuilder.createMemberType(
@@ -1204,8 +1203,8 @@ llvm::MDDerivedType *IRGenDebugInfo::createMemberType(
 }
 
 /// Return an array with the DITypes for each of a tuple's elements.
-llvm::DebugNodeArray IRGenDebugInfo::getTupleElements(
-    TupleType *TupleTy, llvm::MDScope *Scope, llvm::MDFile *File,
+llvm::DINodeArray IRGenDebugInfo::getTupleElements(
+    TupleType *TupleTy, llvm::DIScope *Scope, llvm::DIFile *File,
     unsigned Flags, DeclContext *DeclContext, unsigned &SizeInBits) {
   SmallVector<llvm::Metadata *, 16> Elements;
   unsigned OffsetInBits = 0;
@@ -1223,12 +1222,10 @@ llvm::DebugNodeArray IRGenDebugInfo::getTupleElements(
 }
 
 /// Return an array with the DITypes for each of a struct's elements.
-llvm::DebugNodeArray IRGenDebugInfo::getStructMembers(NominalTypeDecl *D,
-                                                      Type BaseTy,
-                                                      llvm::MDScope *Scope,
-                                                      llvm::MDFile *File,
-                                                      unsigned Flags,
-                                                      unsigned &SizeInBits) {
+llvm::DINodeArray
+IRGenDebugInfo::getStructMembers(NominalTypeDecl *D, Type BaseTy,
+                                 llvm::DIScope *Scope, llvm::DIFile *File,
+                                 unsigned Flags, unsigned &SizeInBits) {
   SmallVector<llvm::Metadata *, 16> Elements;
   unsigned OffsetInBits = 0;
   for (VarDecl *VD : D->getStoredProperties()) {
@@ -1247,11 +1244,11 @@ llvm::DebugNodeArray IRGenDebugInfo::getStructMembers(NominalTypeDecl *D,
 
 /// Create a temporary forward declaration for a struct and add it to
 /// the type cache so we can safely build recursive types.
-llvm::MDCompositeType *IRGenDebugInfo::createStructType(
+llvm::DICompositeType *IRGenDebugInfo::createStructType(
     DebugTypeInfo DbgTy, NominalTypeDecl *Decl, Type BaseTy,
-    llvm::MDScope *Scope, llvm::MDFile *File, unsigned Line,
+    llvm::DIScope *Scope, llvm::DIFile *File, unsigned Line,
     unsigned SizeInBits, unsigned AlignInBits, unsigned Flags,
-    llvm::MDType *DerivedFrom, unsigned RuntimeLang, StringRef UniqueID) {
+    llvm::DIType *DerivedFrom, unsigned RuntimeLang, StringRef UniqueID) {
   StringRef Name = Decl->getName().str();
 
   // Forward declare this first because types may be recursive.
@@ -1279,11 +1276,11 @@ llvm::MDCompositeType *IRGenDebugInfo::createStructType(
 }
 
 /// Return an array with the DITypes for each of an enum's elements.
-llvm::DebugNodeArray IRGenDebugInfo::getEnumElements(DebugTypeInfo DbgTy,
-                                                     EnumDecl *D,
-                                                     llvm::MDScope *Scope,
-                                                     llvm::MDFile *File,
-                                                     unsigned Flags) {
+llvm::DINodeArray IRGenDebugInfo::getEnumElements(DebugTypeInfo DbgTy,
+                                                  EnumDecl *D,
+                                                  llvm::DIScope *Scope,
+                                                  llvm::DIFile *File,
+                                                  unsigned Flags) {
   SmallVector<llvm::Metadata *, 16> Elements;
   for (auto *ElemDecl : D->getAllElements()) {
     // FIXME <rdar://problem/14845818> Support enums.
@@ -1316,11 +1313,9 @@ llvm::DebugNodeArray IRGenDebugInfo::getEnumElements(DebugTypeInfo DbgTy,
 
 /// Create a temporary forward declaration for an enum and add it to
 /// the type cache so we can safely build recursive types.
-llvm::MDCompositeType *
-IRGenDebugInfo::createEnumType(DebugTypeInfo DbgTy, EnumDecl *Decl,
-                               StringRef MangledName, llvm::MDScope *Scope,
-                               llvm::MDFile *File, unsigned Line,
-                               unsigned Flags) {
+llvm::DICompositeType *IRGenDebugInfo::createEnumType(
+    DebugTypeInfo DbgTy, EnumDecl *Decl, StringRef MangledName,
+    llvm::DIScope *Scope, llvm::DIFile *File, unsigned Line, unsigned Flags) {
   unsigned SizeOfByte = CI.getTargetInfo().getCharWidth();
   unsigned SizeInBits = DbgTy.size.getValue() * SizeOfByte;
   unsigned AlignInBits = DbgTy.align.getValue() * SizeOfByte;
@@ -1345,8 +1340,8 @@ IRGenDebugInfo::createEnumType(DebugTypeInfo DbgTy, EnumDecl *Decl,
   return DITy;
 }
 
-/// Return a MDType for Ty reusing any DeclContext found in DbgTy.
-llvm::MDType *IRGenDebugInfo::getOrCreateDesugaredType(Type Ty,
+/// Return a DIType for Ty reusing any DeclContext found in DbgTy.
+llvm::DIType *IRGenDebugInfo::getOrCreateDesugaredType(Type Ty,
                                                        DebugTypeInfo DbgTy) {
   DebugTypeInfo BlandDbgTy(Ty, DbgTy.StorageType, DbgTy.size, DbgTy.align,
                            DbgTy.getDeclContext());
@@ -1370,8 +1365,8 @@ uint64_t IRGenDebugInfo::getSizeOfBasicType(DebugTypeInfo DbgTy) {
 }
 
 /// Convenience function that creates a forward declaration for PointeeTy.
-llvm::MDType *IRGenDebugInfo::createPointerSizedStruct(
-    llvm::MDScope *Scope, StringRef Name, llvm::MDFile *File, unsigned Line,
+llvm::DIType *IRGenDebugInfo::createPointerSizedStruct(
+    llvm::DIScope *Scope, StringRef Name, llvm::DIFile *File, unsigned Line,
     unsigned Flags, StringRef MangledName) {
   auto FwdDecl = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
                                             Name, Scope, File, Line,
@@ -1382,9 +1377,9 @@ llvm::MDType *IRGenDebugInfo::createPointerSizedStruct(
 
 /// Create a pointer-sized struct with a mangled name and a single
 /// member of PointeeTy.
-llvm::MDType *IRGenDebugInfo::createPointerSizedStruct(
-    llvm::MDScope *Scope, StringRef Name, llvm::MDType *PointeeTy,
-    llvm::MDFile *File, unsigned Line, unsigned Flags, StringRef MangledName) {
+llvm::DIType *IRGenDebugInfo::createPointerSizedStruct(
+    llvm::DIScope *Scope, StringRef Name, llvm::DIType *PointeeTy,
+    llvm::DIFile *File, unsigned Line, unsigned Flags, StringRef MangledName) {
   unsigned PtrSize = CI.getTargetInfo().getPointerWidth(0);
   unsigned PtrAlign = CI.getTargetInfo().getPointerAlign(0);
   auto PtrTy = DBuilder.createPointerType(PointeeTy, PtrSize, PtrAlign);
@@ -1399,7 +1394,7 @@ llvm::MDType *IRGenDebugInfo::createPointerSizedStruct(
       nullptr, MangledName);
 }
 
-/// Construct a MDType from a DebugTypeInfo object.
+/// Construct a DIType from a DebugTypeInfo object.
 ///
 /// At this point we do not plan to emit full DWARF for all swift
 /// types, the goal is to emit only the name and provenance of the
@@ -1411,10 +1406,10 @@ llvm::MDType *IRGenDebugInfo::createPointerSizedStruct(
 /// The ultimate goal is to emit something like a
 /// DW_TAG_APPLE_ast_ref_type (an external reference) instead of a
 /// local reference to the type.
-llvm::MDType *IRGenDebugInfo::createType(DebugTypeInfo DbgTy,
-                                        StringRef MangledName,
-                                        llvm::MDScope *Scope,
-                                        llvm::MDFile *File) {
+llvm::DIType *IRGenDebugInfo::createType(DebugTypeInfo DbgTy,
+                                         StringRef MangledName,
+                                         llvm::DIScope *Scope,
+                                         llvm::DIFile *File) {
   // FIXME: For SizeInBits, clang uses the actual size of the type on
   // the target machine instead of the storage size that is alloca'd
   // in the LLVM IR. For all types that are boxed in a struct, we are
@@ -1665,7 +1660,7 @@ llvm::MDType *IRGenDebugInfo::createType(DebugTypeInfo DbgTy,
   case TypeKind::ExistentialMetatype:
   case TypeKind::Metatype: {
     // Metatypes are (mostly) singleton type descriptors, often without storage.
-    Flags |= llvm::DebugNode::FlagArtificial;
+    Flags |= llvm::DINode::FlagArtificial;
     Location L = getLoc(SM, DbgTy.getDecl());
     auto File = getOrCreateFile(L.Filename);
     return DBuilder.createStructType(
@@ -1832,11 +1827,11 @@ static bool canMangle(TypeBase *Ty) {
   }
 }
 
-/// Get the MDType corresponding to this DebugTypeInfo from the cache,
-/// or build a fresh MDType otherwise.  There is the underlying
+/// Get the DIType corresponding to this DebugTypeInfo from the cache,
+/// or build a fresh DIType otherwise.  There is the underlying
 /// assumption that no two types that share the same canonical type
 /// can have different storage size or alignment.
-llvm::MDType *IRGenDebugInfo::getOrCreateType(DebugTypeInfo DbgTy) {
+llvm::DIType *IRGenDebugInfo::getOrCreateType(DebugTypeInfo DbgTy) {
   // Is this an empty type?
   if (DbgTy.isNull())
     // We can't use the empty type as an index into DenseMap.
@@ -1847,7 +1842,7 @@ llvm::MDType *IRGenDebugInfo::getOrCreateType(DebugTypeInfo DbgTy) {
   if (CachedType != DITypeCache.end()) {
     // Verify that the information still exists.
     if (llvm::Metadata *Val = CachedType->second) {
-      auto DITy = cast<llvm::MDType>(Val);
+      auto DITy = cast<llvm::DIType>(Val);
       return DITy;
     }
   }
@@ -1861,7 +1856,7 @@ llvm::MDType *IRGenDebugInfo::getOrCreateType(DebugTypeInfo DbgTy) {
     MangledName = getMangledName(DbgTy);
     UID = llvm::MDString::get(IGM.getLLVMContext(), MangledName);
     if (llvm::Metadata *CachedTy = DIRefMap.lookup(UID)) {
-      auto DITy = cast<llvm::MDType>(CachedTy);
+      auto DITy = cast<llvm::DIType>(CachedTy);
       return DITy;
     }
   }
@@ -1874,15 +1869,15 @@ llvm::MDType *IRGenDebugInfo::getOrCreateType(DebugTypeInfo DbgTy) {
   DeclContext *Context = DbgTy.getType()->getNominalOrBoundGenericNominal();
   if (Context)
     Context = Context->getParent();
-  llvm::MDScope *Scope = getOrCreateContext(Context);
-  llvm::MDType *DITy = createType(DbgTy, MangledName, Scope, getFile(Scope));
+  llvm::DIScope *Scope = getOrCreateContext(Context);
+  llvm::DIType *DITy = createType(DbgTy, MangledName, Scope, getFile(Scope));
 
   // Incrementally build the DIRefMap.
-  if (auto *CTy = dyn_cast<llvm::MDCompositeType>(DITy)) {
+  if (auto *CTy = dyn_cast<llvm::DICompositeType>(DITy)) {
 #ifndef NDEBUG
     // Sanity check.
     if (llvm::Metadata *V = DIRefMap.lookup(UID)) {
-      auto *CachedTy = cast<llvm::MDType>(V);
+      auto *CachedTy = cast<llvm::DIType>(V);
       assert(CachedTy == DITy && "conflicting types for one UID");
     }
 #endif

lib/IRGen/IRGenDebugInfo.h

@@ -90,12 +90,12 @@ class IRGenDebugInfo {
   llvm::SmallString<256> MainFilename;
   llvm::BumpPtrAllocator DebugInfoNames;
   StringRef CWDName;               /// The current working directory.
-  llvm::MDCompileUnit *TheCU = nullptr; /// The current compilation unit.
-  llvm::MDFile *MainFile     = nullptr; /// The main file.
+  llvm::DICompileUnit *TheCU = nullptr; /// The current compilation unit.
+  llvm::DIFile *MainFile = nullptr;     /// The main file.
   llvm::MDModule *MainModule = nullptr; /// The current module.
   llvm::MDNode *EntryPointFn;      /// Scope of SWIFT_ENTRY_POINT_FUNCTION.
   TypeAliasDecl *MetadataTypeDecl; /// The type decl for swift.type.
-  llvm::MDType *InternalType;      /// Catch-all type for opaque internal types.
+  llvm::DIType *InternalType; /// Catch-all type for opaque internal types.
 
   Location LastDebugLoc;    /// The last location that was emitted.
   SILDebugScope *LastScope; /// The scope of that last location.
@@ -172,14 +172,13 @@ public:
   /// \param Fn The IR representation of the function.
   /// \param Rep The calling convention of the function.
   /// \param Ty The signature of the function.
-  llvm::MDSubprogram *emitFunction(SILModule &SILMod, SILDebugScope *DS,
+  llvm::DISubprogram *emitFunction(SILModule &SILMod, SILDebugScope *DS,
                                    llvm::Function *Fn,
                                    SILFunctionTypeRepresentation Rep,
-                                   SILType Ty,
-                                   DeclContext *DeclCtx = nullptr);
+                                   SILType Ty, DeclContext *DeclCtx = nullptr);
 
   /// Emit debug info for a given SIL function.
-  llvm::MDSubprogram *emitFunction(SILFunction &SILFn, llvm::Function *Fn);
+  llvm::DISubprogram *emitFunction(SILFunction &SILFn, llvm::Function *Fn);
 
   /// Convenience function useful for functions without any source
   /// location. Internally calls emitFunction, emits a debug
@@ -220,8 +219,8 @@ public:
 
   /// Emit a dbg.declare or dbg.value intrinsic, depending on Storage.
   void emitDbgIntrinsic(llvm::BasicBlock *BB, llvm::Value *Storage,
-                        llvm::MDLocalVariable *Var, llvm::MDExpression *Expr,
-                        unsigned Line, unsigned Col, llvm::MDLocalScope *Scope,
+                        llvm::DILocalVariable *Var, llvm::DIExpression *Expr,
+                        unsigned Line, unsigned Col, llvm::DILocalScope *Scope,
                         SILDebugScope *DS);
 
   /// Create debug metadata for a global variable.
@@ -251,65 +250,62 @@ private:
   void createImportedModule(StringRef Name, StringRef MangledPrefix,
                             llvm::MDModule *Module, unsigned Line);
 
-  llvm::MDType *createType(DebugTypeInfo DbgTy, StringRef MangledName,
-                           llvm::MDScope *Scope, llvm::MDFile *File);
-  llvm::MDType *getOrCreateType(DebugTypeInfo DbgTy);
-  llvm::MDScope *getOrCreateScope(SILDebugScope *DS);
-  llvm::MDScope *getOrCreateContext(DeclContext *DC);
+  llvm::DIType *createType(DebugTypeInfo DbgTy, StringRef MangledName,
+                           llvm::DIScope *Scope, llvm::DIFile *File);
+  llvm::DIType *getOrCreateType(DebugTypeInfo DbgTy);
+  llvm::DIScope *getOrCreateScope(SILDebugScope *DS);
+  llvm::DIScope *getOrCreateContext(DeclContext *DC);
   llvm::MDNode *createInlinedAt(SILDebugScope *Scope);
 
   StringRef getCurrentDirname();
-  llvm::MDFile *getOrCreateFile(const char *Filename);
-  llvm::MDType *getOrCreateDesugaredType(Type Ty, DebugTypeInfo DTI);
+  llvm::DIFile *getOrCreateFile(const char *Filename);
+  llvm::DIType *getOrCreateDesugaredType(Type Ty, DebugTypeInfo DTI);
   StringRef getName(const FuncDecl &FD);
   StringRef getName(SILLocation L);
   StringRef getMangledName(TypeAliasDecl *Decl);
   StringRef getMangledName(DebugTypeInfo DTI);
-  llvm::MDTypeRefArray createParameterTypes(CanSILFunctionType FnTy,
+  llvm::DITypeRefArray createParameterTypes(CanSILFunctionType FnTy,
                                             DeclContext *DeclCtx);
-  llvm::MDTypeRefArray createParameterTypes(SILType SILTy,
+  llvm::DITypeRefArray createParameterTypes(SILType SILTy,
                                             DeclContext *DeclCtx);
   void createParameterType(llvm::SmallVectorImpl<llvm::Metadata *> &Parameters,
                            SILType CanTy, DeclContext *DeclCtx);
-  llvm::DebugNodeArray getTupleElements(TupleType *TupleTy,
-                                        llvm::MDScope *Scope,
-                                        llvm::MDFile *File, unsigned Flags,
-                                        DeclContext *DeclContext,
-                                        unsigned &SizeInBits);
-  llvm::MDFile *getFile(llvm::MDScope *Scope);
-  llvm::MDModule *getOrCreateModule(llvm::MDScope *Parent, std::string Name,
-                                    llvm::MDFile *File);
-  llvm::MDScope *getModule(StringRef MangledName);
-  llvm::DebugNodeArray getStructMembers(NominalTypeDecl *D, Type BaseTy,
-                                        llvm::MDScope *Scope,
-                                        llvm::MDFile *File,
-                                        unsigned Flags, unsigned &SizeInBits);
-  llvm::MDCompositeType *
+  llvm::DINodeArray getTupleElements(TupleType *TupleTy, llvm::DIScope *Scope,
+                                     llvm::DIFile *File, unsigned Flags,
+                                     DeclContext *DeclContext,
+                                     unsigned &SizeInBits);
+  llvm::DIFile *getFile(llvm::DIScope *Scope);
+  llvm::MDModule *getOrCreateModule(llvm::DIScope *Parent, std::string Name,
+                                    llvm::DIFile *File);
+  llvm::DIScope *getModule(StringRef MangledName);
+  llvm::DINodeArray getStructMembers(NominalTypeDecl *D, Type BaseTy,
+                                     llvm::DIScope *Scope, llvm::DIFile *File,
+                                     unsigned Flags, unsigned &SizeInBits);
+  llvm::DICompositeType *
   createStructType(DebugTypeInfo DbgTy, NominalTypeDecl *Decl, Type BaseTy,
-                   llvm::MDScope *Scope, llvm::MDFile *File, unsigned Line,
+                   llvm::DIScope *Scope, llvm::DIFile *File, unsigned Line,
                    unsigned SizeInBits, unsigned AlignInBits, unsigned Flags,
-                   llvm::MDType *DerivedFrom, unsigned RuntimeLang,
+                   llvm::DIType *DerivedFrom, unsigned RuntimeLang,
                    StringRef UniqueID);
-  llvm::MDDerivedType *createMemberType(DebugTypeInfo DTI, StringRef Name,
+  llvm::DIDerivedType *createMemberType(DebugTypeInfo DTI, StringRef Name,
                                         unsigned &OffsetInBits,
-                                        llvm::MDScope *Scope,
-                                        llvm::MDFile *File, unsigned Flags);
-  llvm::DebugNodeArray getEnumElements(DebugTypeInfo DbgTy, EnumDecl *D,
-                                       llvm::MDScope *Scope, llvm::MDFile *File,
-                                       unsigned Flags);
-  llvm::MDCompositeType *createEnumType(DebugTypeInfo DbgTy, EnumDecl *Decl,
+                                        llvm::DIScope *Scope,
+                                        llvm::DIFile *File, unsigned Flags);
+  llvm::DINodeArray getEnumElements(DebugTypeInfo DbgTy, EnumDecl *D,
+                                    llvm::DIScope *Scope, llvm::DIFile *File,
+                                    unsigned Flags);
+  llvm::DICompositeType *createEnumType(DebugTypeInfo DbgTy, EnumDecl *Decl,
                                         StringRef MangledName,
-                                        llvm::MDScope *Scope,
-                                        llvm::MDFile *File, unsigned Line,
+                                        llvm::DIScope *Scope,
+                                        llvm::DIFile *File, unsigned Line,
                                         unsigned Flags);
-  llvm::MDType *createPointerSizedStruct(llvm::MDScope *Scope,
-                                        StringRef Name, llvm::MDFile *File,
-                                        unsigned Line, unsigned Flags,
-                                        StringRef MangledName);
-  llvm::MDType *createPointerSizedStruct(llvm::MDScope *Scope,
-                                        StringRef Name, llvm::MDType *PointeeTy,
-                                        llvm::MDFile *File, unsigned Line,
-                                        unsigned Flags, StringRef MangledName);
+  llvm::DIType *createPointerSizedStruct(llvm::DIScope *Scope, StringRef Name,
+                                         llvm::DIFile *File, unsigned Line,
+                                         unsigned Flags, StringRef MangledName);
+  llvm::DIType *createPointerSizedStruct(llvm::DIScope *Scope, StringRef Name,
+                                         llvm::DIType *PointeeTy,
+                                         llvm::DIFile *File, unsigned Line,
+                                         unsigned Flags, StringRef MangledName);
   uint64_t getSizeOfBasicType(DebugTypeInfo DbgTy);
   TypeAliasDecl *getMetadataType();
 };

test/DebugInfo/Constructors.swift

@@ -1,7 +1,7 @@
 // RUN: %target-swift-frontend %s -emit-ir -g -o - | FileCheck %s
 struct Foo {
   // Allocating constructor - should have no line table info.
-  // CHECK: !MDSubprogram(name: "init", linkageName: "_TFV12Constructors3FooCfMS0_FT1xSi_S0_",
+  // CHECK: !DISubprogram(name: "init", linkageName: "_TFV12Constructors3FooCfMS0_FT1xSi_S0_",
   // CHECK-SAME:          line: [[@LINE+3]]
   // CHECK-NOT:           scopeLine: 0
   // CHECK-SAME:          isDefinition: true

test/DebugInfo/Destructors.swift

@@ -1,7 +1,7 @@
 // RUN: %target-swift-frontend %s -emit-ir -g -o - | FileCheck %s
 
 class Foo {
-  // CHECK: !MDSubprogram(name: "deinit", linkageName: "_TFC11Destructors3FooD"
+  // CHECK: !DISubprogram(name: "deinit", linkageName: "_TFC11Destructors3FooD"
   // CHECK-SAME:          line: [[@LINE-2]]
   // CHECK-SAME:          isDefinition: true
   var x : Int

test/DebugInfo/DynamicSelf.swift

@@ -10,7 +10,7 @@ class C {
 extension C {
   class func Factory() -> Self {
     // Currently we emit the static type C for r.
-    // CHECK: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "r", {{.*}}line: [[@LINE+1]]
+    // CHECK: !DILocalVariable(tag: DW_TAG_auto_variable, name: "r", {{.*}}line: [[@LINE+1]]
     let r = self(number: 0)
     return r
   }

test/DebugInfo/Imports.swift

@@ -5,14 +5,14 @@
 // RUN: %target-swift-frontend -c -module-name Foo %s -I %t -g -o - | llvm-dwarfdump - | FileCheck --check-prefix=DWARF %s
 
 // CHECK-DAG: ![[FOOMODULE:[0-9]+]] = !MDModule(name: "Foo"
-// CHECK-DAG: !MDImportedEntity(tag: DW_TAG_imported_module, scope: ![[THISFILE:[0-9]+]], entity: ![[FOOMODULE]]
-// CHECK-DAG: ![[THISFILE]] = !MDFile(filename: "Imports.swift", directory: "{{.*}}test/DebugInfo")
-// CHECK-DAG: ![[SWIFTFILE:[0-9]+]] = !MDFile(filename: "Swift.swiftmodule"
+// CHECK-DAG: !DIImportedEntity(tag: DW_TAG_imported_module, scope: ![[THISFILE:[0-9]+]], entity: ![[FOOMODULE]]
+// CHECK-DAG: ![[THISFILE]] = !DIFile(filename: "Imports.swift", directory: "{{.*}}test/DebugInfo")
+// CHECK-DAG: ![[SWIFTFILE:[0-9]+]] = !DIFile(filename: "Swift.swiftmodule"
 // CHECK-DAG: ![[SWIFTMODULE:[0-9]+]] = !MDModule(name: "Swift"
-// CHECK-DAG: !MDImportedEntity(tag: DW_TAG_imported_module, scope: ![[SWIFTFILE]], entity: ![[SWIFTMODULE]]
-// CHECK-DAG: ![[BASICFILE:[0-9]+]] = !MDFile(filename: "basic.swiftmodule"
+// CHECK-DAG: !DIImportedEntity(tag: DW_TAG_imported_module, scope: ![[SWIFTFILE]], entity: ![[SWIFTMODULE]]
+// CHECK-DAG: ![[BASICFILE:[0-9]+]] = !DIFile(filename: "basic.swiftmodule"
 // CHECK-DAG: ![[BASICMODULE:[0-9]+]] = !MDModule(name: "basic"
-// CHECK-DAG: !MDImportedEntity(tag: DW_TAG_imported_module, scope: ![[BASICFILE]], entity: ![[BASICMODULE]]
+// CHECK-DAG: !DIImportedEntity(tag: DW_TAG_imported_module, scope: ![[BASICFILE]], entity: ![[BASICMODULE]]
 import basic
 import typealias Swift.Optional
 

test/DebugInfo/PrivateDiscriminator.swift

@@ -1,15 +1,15 @@
 // Private discriminators should only be emitted for multi-file projects.
 
 // RUN: %target-swift-frontend -emit-ir %s -g -o - | FileCheck --check-prefix=SINGLE %s
-// SINGLE-NOT: !MDCompileUnit({{.*}}-private-discriminator
+// SINGLE-NOT: !DICompileUnit({{.*}}-private-discriminator
 
 // RUN: %target-swift-frontend %S/../Inputs/empty.swift -primary-file %s -emit-ir -g | FileCheck %s
-// CHECK: !MDCompileUnit({{.*}}flags: {{[^,]*}}-private-discriminator [[DISCRIMINATOR:_[A-Z0-9]+]]
+// CHECK: !DICompileUnit({{.*}}flags: {{[^,]*}}-private-discriminator [[DISCRIMINATOR:_[A-Z0-9]+]]
 
 private class A {
   init(val : Int) { member = val }
   private let member : Int
-  // CHECK: !MDSubprogram(name: "getMember"
+  // CHECK: !DISubprogram(name: "getMember"
   // CHECK-SAME:          linkageName: "{{[^"]*}}[[DISCRIMINATOR]]
   // CHECK-SAME:          line: [[@LINE+2]]
   // CHECK-SAME:          isLocal: true, isDefinition: true 

test/DebugInfo/ProtocolContainer.swift

@@ -13,9 +13,9 @@ class AClass : AProtocol {
 // CHECK-NEXT: entry:
 // CHECK-NEXT: %[[X:.*]] = alloca %P17ProtocolContainer9AProtocol_, align {{(4|8)}}
 // CHECK:      call void @llvm.dbg.declare(metadata %P17ProtocolContainer9AProtocol_* %[[X]], metadata ![[XMD:.*]], metadata !{{[0-9]+}})
-// CHECK-NOT: !MDLocalVariable({{.*}} name: "x"
-// CHECK: ![[XMD]] = !MDLocalVariable(tag: DW_TAG_arg_variable, name: "x", {{.*}}line: [[@LINE+2]]
-// CHECK-NOT: !MDLocalVariable({{.*}} name: "x"
+// CHECK-NOT: !DILocalVariable({{.*}} name: "x"
+// CHECK: ![[XMD]] = !DILocalVariable(tag: DW_TAG_arg_variable, name: "x", {{.*}}line: [[@LINE+2]]
+// CHECK-NOT: !DILocalVariable({{.*}} name: "x"
 func foo (var x : AProtocol) {
 	x.print() // Set breakpoint here
 }

test/DebugInfo/accessors.swift

@@ -1,8 +1,8 @@
 // RUN: %target-swift-frontend -primary-file %s -emit-ir -g -o - | FileCheck %s
 
 // Verify that we generate appropriate names for accessors.
-// CHECK: !MDSubprogram(name: "x.get"
-// CHECK: !MDSubprogram(name: "x.set"
+// CHECK: !DISubprogram(name: "x.get"
+// CHECK: !DISubprogram(name: "x.set"
 
 // Variable getter/setter
 var _x : Int = 0

test/DebugInfo/anonymous.swift

@@ -1,7 +1,7 @@
 // RUN: %target-swift-frontend -primary-file %s -emit-ir -g -o - | FileCheck %s
 
 // Don't crash when emitting debug info for anonymous variables.
-// CHECK: !MDLocalVariable({{.*}} name: "_"
+// CHECK: !DILocalVariable({{.*}} name: "_"
 protocol F_ {
   func successor() -> Self
 }

test/DebugInfo/any.swift

@@ -2,9 +2,9 @@
 
 func main() {
   // CHECK: call void @llvm.dbg.declare(metadata %"protocol<>"* {{.*}}, metadata ![[S:.*]], metadata !{{[0-9]+}}), !dbg ![[DBG:.*]]
-  // CHECK: ![[S]] = !MDLocalVariable(tag: DW_TAG_auto_variable, name: "s", {{.*}}line: [[@LINE+3]]
-  // CHECK: ![[SCOPE:.*]] = distinct !MDLexicalBlock({{.*}}line: 3, column: 13)
-  // CHECK: ![[DBG]] = !MDLocation(line: [[@LINE+1]], column: 6, scope: ![[SCOPE]])
+  // CHECK: ![[S]] = !DILocalVariable(tag: DW_TAG_auto_variable, name: "s", {{.*}}line: [[@LINE+3]]
+  // CHECK: ![[SCOPE:.*]] = distinct !DILexicalBlock({{.*}}line: 3, column: 13)
+  // CHECK: ![[DBG]] = !DILocation(line: [[@LINE+1]], column: 6, scope: ![[SCOPE]])
 	var s : Any = "hello world"
 	var n : Any = 12
 	var t : Any = (1,2)

test/DebugInfo/apple-types-accel.swift

@@ -17,7 +17,7 @@
 // CHECK-DWARF-NEXT: AT_linkage_name( "_TtC4main3foo" )
 
 // Verify the IR interface:
-// CHECK: !MDCompositeType(tag: DW_TAG_structure_type, name: "foo"
+// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "foo"
 // CHECK-SAME:             line: [[@LINE+2]]
 // CHECK-SAME:             identifier: "_TtC4main3foo"
 class foo {

test/DebugInfo/archetype.swift

@@ -9,15 +9,15 @@ protocol RandomAccessIndexType : IntegerArithmeticType {
   static func uncheckedSubtract(lhs: Self, rhs: Self) -> (Distance, Bool)
 }
 
-// CHECK: !MDCompositeType(tag: DW_TAG_structure_type, name: "_TtTQQq_F9archetype16ExistentialTuple
+// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "_TtTQQq_F9archetype16ExistentialTuple
 // CHECK-SAME:             identifier: [[TT:".+"]])
 // archetype.ExistentialTuple <A : RandomAccessIndexType, B>(x : A, y : A) -> B
-// CHECK: !MDSubprogram(name: "ExistentialTuple", linkageName: "_TF9archetype16ExistentialTuple
+// CHECK: !DISubprogram(name: "ExistentialTuple", linkageName: "_TF9archetype16ExistentialTuple
 // CHECK-SAME:          line: [[@LINE+2]]
 // CHECK-SAME:          isDefinition: true
 func ExistentialTuple<T: RandomAccessIndexType>(x: T, y: T) -> T.Distance {
   // (B, Swift.Bool)
-  // CHECK: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "tmp"
+  // CHECK: !DILocalVariable(tag: DW_TAG_auto_variable, name: "tmp"
   // CHECK-SAME:             line: [[@LINE+2]]
   // CHECK-SAME:             type: ![[TT]]
   var tmp : (T.Distance, Bool) = T.uncheckedSubtract(x, rhs: y)

test/DebugInfo/archetypes2.swift

@@ -1,10 +1,10 @@
 // RUN: %target-swift-frontend %s -emit-ir -verify -g -o - | FileCheck %s
 
 class C<A> {
-// CHECK-DAG: ![[A:[0-9]+]] = !MDCompositeType(tag: DW_TAG_structure_type, name: "_TtQq_C11archetypes21C"
-// CHECK-DAG: ![[B:[0-9]+]] = !MDCompositeType(tag: DW_TAG_structure_type, name: "_TtQq_FC11archetypes21C3foo
-// CHECK-DAG: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "x", {{.*}}line: [[@LINE+2]],{{.*}}type: ![[A]]
-// CHECK-DAG: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "y", {{.*}}line: [[@LINE+1]],{{.*}}type: ![[B]]
+// CHECK-DAG: ![[A:[0-9]+]] = !DICompositeType(tag: DW_TAG_structure_type, name: "_TtQq_C11archetypes21C"
+// CHECK-DAG: ![[B:[0-9]+]] = !DICompositeType(tag: DW_TAG_structure_type, name: "_TtQq_FC11archetypes21C3foo
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_arg_variable, name: "x", {{.*}}line: [[@LINE+2]],{{.*}}type: ![[A]]
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_arg_variable, name: "y", {{.*}}line: [[@LINE+1]],{{.*}}type: ![[B]]
 	func foo <B> (var x : A, var y : B)
 	{
 		println("hello world")

test/DebugInfo/argument.swift

@@ -1,52 +1,52 @@
 // RUN: %target-swift-frontend -primary-file %s -emit-ir -g -o - | FileCheck %s
 
-// CHECK-DAG: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "arg", arg: 1,{{.*}} line: [[@LINE+1]]
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_arg_variable, name: "arg", arg: 1,{{.*}} line: [[@LINE+1]]
 func a(arg : Int)
 {
-// CHECK-DAG: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "local",{{.*}} line: [[@LINE+1]]
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_auto_variable, name: "local",{{.*}} line: [[@LINE+1]]
   var local = arg
 }
 
 // Why is c arg: 4?  Note that "b" shows up as both arg 2 and 3.
-// CHECK-DAG: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "a", arg: 1,{{.*}} line: [[@LINE+3]]
-// CHECK-DAG: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "b", arg: 2,{{.*}} line: [[@LINE+2]]
-// CHECK-DAG: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "c", arg: 4,{{.*}} line: [[@LINE+1]]
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_arg_variable, name: "a", arg: 1,{{.*}} line: [[@LINE+3]]
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_arg_variable, name: "b", arg: 2,{{.*}} line: [[@LINE+2]]
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_arg_variable, name: "c", arg: 4,{{.*}} line: [[@LINE+1]]
 func many(a: Int, b: (Int, Int), c: Int) -> Int {
-// CHECK-DAG: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "i1",{{.*}} line: [[@LINE+1]]
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_auto_variable, name: "i1",{{.*}} line: [[@LINE+1]]
   var i1 = a
-// CHECK-DAG: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "i2",{{.*}} line: [[@LINE+2]]
-// CHECK-DAG: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "i3",{{.*}} line: [[@LINE+1]]
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_auto_variable, name: "i2",{{.*}} line: [[@LINE+2]]
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_auto_variable, name: "i3",{{.*}} line: [[@LINE+1]]
   var (i2, i3) : (Int, Int) = b
-// CHECK-DAG: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "i4",{{.*}} line: [[@LINE+1]]
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_auto_variable, name: "i4",{{.*}} line: [[@LINE+1]]
   var i4 = c
   return i1+i2+i3+i4
 }
 
 class A {
   var member : Int
-// CHECK-DAG: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "a", arg: 1,{{.*}} line: [[@LINE+1]]
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_arg_variable, name: "a", arg: 1,{{.*}} line: [[@LINE+1]]
   init(a: Int) { member = a }
 
-// CHECK-DAG: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "offset", arg: 1,{{.*}} line: [[@LINE+2]]
-// CHECK-DAG: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "self", arg: 2,{{.*}} line: [[@LINE+1]]
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_arg_variable, name: "offset", arg: 1,{{.*}} line: [[@LINE+2]]
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_arg_variable, name: "self", arg: 2,{{.*}} line: [[@LINE+1]]
   func getValuePlus(offset: Int) -> Int {
-// CHECK-DAG: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "a",{{.*}} line: [[@LINE+1]]
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_auto_variable, name: "a",{{.*}} line: [[@LINE+1]]
     var a = member
     return a+offset
   }
 
-// CHECK-DAG: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "factor", arg: 1,{{.*}} line: [[@LINE+3]]
-// CHECK-DAG: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "offset", arg: 2,{{.*}} line: [[@LINE+2]]
-// CHECK-DAG: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "self", arg: 3,{{.*}} line: [[@LINE+1]]
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_arg_variable, name: "factor", arg: 1,{{.*}} line: [[@LINE+3]]
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_arg_variable, name: "offset", arg: 2,{{.*}} line: [[@LINE+2]]
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_arg_variable, name: "self", arg: 3,{{.*}} line: [[@LINE+1]]
   func getValueTimesPlus(factor: Int, offset: Int) -> Int {
-// CHECK-DAG: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "a",{{.*}} line: [[@LINE+1]]
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_auto_variable, name: "a",{{.*}} line: [[@LINE+1]]
     var a = member
-// CHECK-DAG: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "f",{{.*}} line: [[@LINE+1]]
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_auto_variable, name: "f",{{.*}} line: [[@LINE+1]]
     var f = factor
     return a*f+offset
   }
 
-// CHECK: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "self", arg: 1,{{.*}} line: [[@LINE+1]]
+// CHECK: !DILocalVariable(tag: DW_TAG_arg_variable, name: "self", arg: 1,{{.*}} line: [[@LINE+1]]
   deinit {
     println(member)
   }
@@ -54,14 +54,14 @@ class A {
 }
 
 // Curried functions have their arguments backwards.
-// CHECK: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "b", arg: 1,{{.*}} line: [[@LINE+2]]
-// CHECK: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "a", arg: 2,{{.*}} line: [[@LINE+1]]
+// CHECK: !DILocalVariable(tag: DW_TAG_arg_variable, name: "b", arg: 1,{{.*}} line: [[@LINE+2]]
+// CHECK: !DILocalVariable(tag: DW_TAG_arg_variable, name: "a", arg: 2,{{.*}} line: [[@LINE+1]]
 func uncurry (a: Int) (b: Int) -> (Int, Int) {
   return (a, b)
 }
 
-// CHECK: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "x", arg: 1,{{.*}} line: [[@LINE+2]]
-// CHECK: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "y", arg: 2,{{.*}} line: [[@LINE+1]]
+// CHECK: !DILocalVariable(tag: DW_TAG_arg_variable, name: "x", arg: 1,{{.*}} line: [[@LINE+2]]
+// CHECK: !DILocalVariable(tag: DW_TAG_arg_variable, name: "y", arg: 2,{{.*}} line: [[@LINE+1]]
 func tuple(x: Int, y: (Int, Float, String)) -> Int {
   return x+y.0;
 }

test/DebugInfo/attributes.swift

@@ -2,12 +2,12 @@
 
 // REQUIRES: objc_interop
 
-// CHECK-DAG: !MDCompositeType(tag: DW_TAG_structure_type, name: "ObjCClass",{{.*}} line: [[@LINE+1]],{{.*}} runtimeLang: DW_LANG_Swift,{{.*}} identifier: [[TY0:"[^"]*"]])
+// CHECK-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "ObjCClass",{{.*}} line: [[@LINE+1]],{{.*}} runtimeLang: DW_LANG_Swift,{{.*}} identifier: [[TY0:"[^"]*"]])
 @objc class ObjCClass {
       @IBAction func click(_: AnyObject?) -> () {}
 }
 // DW_LANG_Swift = 0xa000 [FIXME: this number will change!]
-// CHECK-DAG: ![[TY1:[0-9]+]] = !MDCompositeType(tag: DW_TAG_structure_type, name: "SwiftClass",{{.*}} line: [[@LINE+1]],{{.*}} runtimeLang: DW_LANG_Swift
+// CHECK-DAG: ![[TY1:[0-9]+]] = !DICompositeType(tag: DW_TAG_structure_type, name: "SwiftClass",{{.*}} line: [[@LINE+1]],{{.*}} runtimeLang: DW_LANG_Swift
 class SwiftClass {
       @objc func objcmethod() -> () {}
       func swiftmethod() -> () {}
@@ -20,13 +20,13 @@ class SwiftClass {
 // an artificial variable.
 // DISABLED: [ DW_TAG_variable ] [OBJC_METACLASS_$__TtC10attributes9ObjCClass]
 
-// CHECK-DAG: !MDGlobalVariable(name: "strongRef0",{{.*}}line: [[@LINE+1]],{{.*}} type: ![[TY0]],{{.*}} isLocal: false, isDefinition: true
+// CHECK-DAG: !DIGlobalVariable(name: "strongRef0",{{.*}}line: [[@LINE+1]],{{.*}} type: ![[TY0]],{{.*}} isLocal: false, isDefinition: true
 var strongRef0 : ObjCClass
 var strongRef1 : SwiftClass = SwiftClass()
 
-// CHECK-DAG: !MDDerivedType(tag: DW_TAG_typedef, name: "_TtXwGSqC10attributes10SwiftClass_",{{.*}} line: [[@LINE+1]]
+// CHECK-DAG: !DIDerivedType(tag: DW_TAG_typedef, name: "_TtXwGSqC10attributes10SwiftClass_",{{.*}} line: [[@LINE+1]]
 weak var    weakRef1    : SwiftClass? = strongRef1
-// CHECK-DAG: !MDDerivedType(tag: DW_TAG_typedef, name: "_TtXoC10attributes10SwiftClass",{{.*}} line: [[@LINE+1]]
+// CHECK-DAG: !DIDerivedType(tag: DW_TAG_typedef, name: "_TtXoC10attributes10SwiftClass",{{.*}} line: [[@LINE+1]]
 unowned var unownedRef1 : SwiftClass
 
 protocol Protocol1 : class {

test/DebugInfo/autoclosure.swift

@@ -22,9 +22,9 @@ func &&&&&(lhs: BooleanType, @autoclosure rhs: ()->BooleanType) -> Bool {
 func call_me(var input: Int) -> Void {
 // rdar://problem/14627460
 // An autoclosure should have a line number in the debug info and a scope line of 0.
-// CHECK-DAG: !MDSubprogram({{.*}}linkageName: "_TFF11autoclosure7call_meFSiT_u_KT_PSs11BooleanType_",{{.*}} line: [[@LINE+3]],{{.*}} isLocal: false, isDefinition: true
+// CHECK-DAG: !DISubprogram({{.*}}linkageName: "_TFF11autoclosure7call_meFSiT_u_KT_PSs11BooleanType_",{{.*}} line: [[@LINE+3]],{{.*}} isLocal: false, isDefinition: true
 // But not in the line table.
-// CHECK-DAG: ![[DBG]] = !MDLocation(line: [[@LINE+1]],
+// CHECK-DAG: ![[DBG]] = !DILocation(line: [[@LINE+1]],
     if input != 0 &&&&& ( get_truth (input * 2 + 1) > 0 )
     {
         println ("Whew, passed that test.")

test/DebugInfo/basic.swift

@@ -22,11 +22,11 @@
 //
 // CHECK: foo
 // CHECK-DAG: ret{{.*}}, !dbg ![[RET:[0-9]+]]
-// CHECK-DAG: ![[FOO:[0-9]+]] = !MDSubprogram(name: "foo",{{.*}} line: [[@LINE+2]],{{.*}} type: ![[FOOTYPE:[0-9]+]]
+// CHECK-DAG: ![[FOO:[0-9]+]] = !DISubprogram(name: "foo",{{.*}} line: [[@LINE+2]],{{.*}} type: ![[FOOTYPE:[0-9]+]]
 public
 func foo(var a: Int64, var _ b: Int64) -> Int64 {
-     // CHECK-DAG: !MDLexicalBlock(scope: ![[FOO]],{{.*}} line: [[@LINE-1]], column: 49)
-     // CHECK-DAG: ![[ASCOPE:.*]] = !MDLocation(line: [[@LINE-2]], column: 14, scope: ![[FOO]])
+     // CHECK-DAG: !DILexicalBlock(scope: ![[FOO]],{{.*}} line: [[@LINE-1]], column: 49)
+     // CHECK-DAG: ![[ASCOPE:.*]] = !DILocation(line: [[@LINE-2]], column: 14, scope: ![[FOO]])
      // Check that a is the first and b is the second argument.
      // CHECK-DAG: store i64 %0, i64* [[AVAL:.*]], align 8
      // CHECK-DAG: store i64 %1, i64* [[BVAL:.*]], align 8
@@ -34,22 +34,22 @@ func foo(var a: Int64, var _ b: Int64) -> Int64 {
      // CHECK-DAG: [[BVAL]] = getelementptr inbounds {{.*}}, [[BMEM:.*]], i32 0, i32 0
      // CHECK-DAG: call void @llvm.dbg.declare(metadata [[AMEM]], metadata ![[AARG:.*]], metadata !{{[0-9]+}}), !dbg ![[ASCOPE]]
      // CHECK-DAG: call void @llvm.dbg.declare(metadata [[BMEM]], metadata ![[BARG:.*]], metadata !{{[0-9]+}})
-     // CHECK-DAG: ![[AARG]] = !MDLocalVariable(tag: DW_TAG_arg_variable, name: "a"
-     // CHECK-DAG: ![[BARG]] = !MDLocalVariable(tag: DW_TAG_arg_variable, name: "b"
+     // CHECK-DAG: ![[AARG]] = !DILocalVariable(tag: DW_TAG_arg_variable, name: "a"
+     // CHECK-DAG: ![[BARG]] = !DILocalVariable(tag: DW_TAG_arg_variable, name: "b"
      if b != 0 {
-       // CHECK-DAG: !MDLexicalBlock({{.*}} line: [[@LINE-1]]
+       // CHECK-DAG: !DILexicalBlock({{.*}} line: [[@LINE-1]]
        // Transparent inlined multiply:
        // CHECK-DAG: smul{{.*}}, !dbg ![[MUL:[0-9]+]]
-       // CHECK-DAG: [[MUL]] = !MDLocation(line: [[@LINE+4]], column: 16,
+       // CHECK-DAG: [[MUL]] = !DILocation(line: [[@LINE+4]], column: 16,
        // Runtime call to multiply function:
        // CHECK-NOSIL: @_TZFSsoi1mFTVSs5Int64S__S_{{.*}}, !dbg ![[MUL:[0-9]+]]
-       // CHECK-NOSIL: [[MUL]] = !MDLocation(line: [[@LINE+1]], column: 16,
+       // CHECK-NOSIL: [[MUL]] = !DILocation(line: [[@LINE+1]], column: 16,
        return a*b
      } else {
-       // CHECK-DAG: [[PARENT:[0-9]+]] = distinct !MDLexicalBlock({{.*}} line: [[@LINE-1]], column: 13)
+       // CHECK-DAG: [[PARENT:[0-9]+]] = distinct !DILexicalBlock({{.*}} line: [[@LINE-1]], column: 13)
        var c: Int64 = 42
        if a == 0 {
-         // CHECK-DAG: !MDLexicalBlock(scope: ![[PARENT]],{{.*}} line: [[@LINE-1]], column: 18)
+         // CHECK-DAG: !DILexicalBlock(scope: ![[PARENT]],{{.*}} line: [[@LINE-1]], column: 18)
          // What about a nested scope?
          return 0
        }
@@ -57,20 +57,20 @@ func foo(var a: Int64, var _ b: Int64) -> Int64 {
      }
 }
 
-// CHECK-DAG: ![[MAINFILE:[0-9]+]] = !MDFile(filename: "basic.swift", directory: "{{.*}}DebugInfo")
-// CHECK-DAG: !MDCompileUnit({{.*}}file: ![[MAINFILE]],{{.*}} producer: "{{.*}}Swift version{{.*}},{{.*}} flags: "{{[^"]*}}-emit-ir
-// CHECK-DAG: !MDSubprogram(name: "main"
+// CHECK-DAG: ![[MAINFILE:[0-9]+]] = !DIFile(filename: "basic.swift", directory: "{{.*}}DebugInfo")
+// CHECK-DAG: !DICompileUnit({{.*}}file: ![[MAINFILE]],{{.*}} producer: "{{.*}}Swift version{{.*}},{{.*}} flags: "{{[^"]*}}-emit-ir
+// CHECK-DAG: !DISubprogram(name: "main"
 
 // Function type for foo.
-// CHECK-DAG: ![[FOOTYPE]] = !MDSubroutineType(types: ![[PARAMTYPES:[0-9]+]])
+// CHECK-DAG: ![[FOOTYPE]] = !DISubroutineType(types: ![[PARAMTYPES:[0-9]+]])
 // CHECK-DAG: ![[PARAMTYPES]] = !{!"_TtVSs5Int64", !"_TtVSs5Int64", !"_TtVSs5Int64"}
 // Import of the main module.
-// CHECK-DAG: !MDImportedEntity(tag: DW_TAG_imported_module, scope: ![[MAINFILE]], entity: ![[MAINMODULE:[0-9]+]], line: 1)
+// CHECK-DAG: !DIImportedEntity(tag: DW_TAG_imported_module, scope: ![[MAINFILE]], entity: ![[MAINMODULE:[0-9]+]], line: 1)
 // CHECK-DAG: ![[MAINMODULE]] = !MDModule(name: "basic"
 
 // Import of the swift standard library.
-// CHECK-DAG: ![[SWIFTFILE:[0-9]+]] = !MDFile(filename: "{{.*}}Swift.swiftmodule",
-// CHECK-DAG: !MDImportedEntity(tag: DW_TAG_imported_module, scope: ![[SWIFTFILE]], entity: ![[SWIFTMODULE:[0-9]+]])
+// CHECK-DAG: ![[SWIFTFILE:[0-9]+]] = !DIFile(filename: "{{.*}}Swift.swiftmodule",
+// CHECK-DAG: !DIImportedEntity(tag: DW_TAG_imported_module, scope: ![[SWIFTFILE]], entity: ![[SWIFTMODULE:[0-9]+]])
 // CHECK-DAG: ![[SWIFTMODULE]] = !MDModule(name: "Swift"
 
 // DWARF Version

test/DebugInfo/bool.swift

@@ -1,7 +1,7 @@
 // RUN: %target-swift-frontend %s -emit-ir -g -o - | FileCheck %s
 
 // Int1 uses 1 bit, but is aligned at 8 bits.
-// CHECK: !MDBasicType(name: "_TtBi1_", size: 1, align: 8, encoding: DW_ATE_unsigned)
+// CHECK: !DIBasicType(name: "_TtBi1_", size: 1, align: 8, encoding: DW_ATE_unsigned)
 func main()
 {
 	var t = true

test/DebugInfo/bound-namealiastype.swift

@@ -3,8 +3,8 @@
 // REQUIRES: objc_interop
 
 import Dispatch
-// CHECK-DAG: !MDCompositeType(tag: DW_TAG_union_type, {{.*}}identifier: "_TtGSQaSC21dispatch_queue_attr_t_"
-// CHECK-DAG: !MDGlobalVariable(name: "queue",{{.*}} line: [[@LINE+1]], type: !"_TtGSQaSC21dispatch_queue_attr_t_"
+// CHECK-DAG: !DICompositeType(tag: DW_TAG_union_type, {{.*}}identifier: "_TtGSQaSC21dispatch_queue_attr_t_"
+// CHECK-DAG: !DIGlobalVariable(name: "queue",{{.*}} line: [[@LINE+1]], type: !"_TtGSQaSC21dispatch_queue_attr_t_"
 var queue = dispatch_queue_create("queue", nil)
 
 dispatch_sync(queue) { println("Hello world"); }

test/DebugInfo/byref-capture.swift

@@ -6,8 +6,8 @@ func makeIncrementor(inc : Int) -> () -> Int
   // CHECK: define {{.*}}5inner
   func inner() -> Int {
     // CHECK: call void @llvm.dbg.declare(metadata %Si** %{{.*}}, metadata ![[SUM_CAPTURE:[0-9]+]], metadata ![[DEREF:[0-9]+]])
-    // CHECK-DAG: ![[SUM_CAPTURE]] = !MDLocalVariable(tag: DW_TAG_arg_variable, name: "sum",{{.*}} line: [[@LINE-4]]
-    // CHECK-DAG: ![[DEREF]] = !MDExpression(DW_OP_deref
+    // CHECK-DAG: ![[SUM_CAPTURE]] = !DILocalVariable(tag: DW_TAG_arg_variable, name: "sum",{{.*}} line: [[@LINE-4]]
+    // CHECK-DAG: ![[DEREF]] = !DIExpression(DW_OP_deref
     sum += inc
     return sum
   }

test/DebugInfo/callexpr.swift

@@ -7,8 +7,8 @@ func foo(a : Int, _ b : Int) -> Int {
 // CHECK: call {{.*}}foo{{.*}}, !dbg ![[ARG1:.*]]
 // CHECK: call {{.*}}foo{{.*}}, !dbg ![[ARG2:.*]]
 // CHECK: call {{.*}}foo{{.*}}, !dbg ![[OUTER:.*]]
-let r = foo(foo(1, 23), // CHECK: ![[ARG1]] = !MDLocation(line: [[@LINE]],
-            foo(2, 42)  // CHECK: ![[ARG2]] = !MDLocation(line: [[@LINE]],
-           )            // CHECK: ![[OUTER]] = !MDLocation(line: [[@LINE]],
+let r = foo(foo(1, 23), // CHECK: ![[ARG1]] = !DILocation(line: [[@LINE]],
+            foo(2, 42)  // CHECK: ![[ARG2]] = !DILocation(line: [[@LINE]],
+           )            // CHECK: ![[OUTER]] = !DILocation(line: [[@LINE]],
 println(r)
 

test/DebugInfo/class.swift

@@ -1,7 +1,7 @@
 // RUN: %target-swift-frontend -primary-file %s -emit-ir -g -o - | FileCheck %s
 
 // FIXME: This is more of a crash test than anything else.
-// CHECK: !MDCompositeType(tag: DW_TAG_structure_type, name: "Tree",{{.*}} line: [[@LINE+1]]
+// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "Tree",{{.*}} line: [[@LINE+1]]
 class Tree<T> {
   var l, r: Tree<T>?
 }

test/DebugInfo/closure-args.swift

@@ -17,26 +17,26 @@ func main() -> Void
     // stack pointer will be decremented after it.
     // CHECK-NOT: !dbg
     // CHECK-NEXT: call void @llvm.dbg.declare(metadata %SS** %[[RHS_ADDR]], metadata !{{.*}}, metadata !{{[0-9]+}}), !dbg
-    // CHECK-DAG: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "lhs",{{.*}} line: [[@LINE+5]],
-    // CHECK-DAG: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "rhs",{{.*}} line: [[@LINE+4]],
-    // CHECK-DAG: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "random_string",{{.*}} line: 8,
-    // CHECK-DAG: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "random_int",{{.*}} line: 9,
-    // CHECK-DAG: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "out_only",{{.*}} line: 10,
+    // CHECK-DAG: !DILocalVariable(tag: DW_TAG_arg_variable, name: "lhs",{{.*}} line: [[@LINE+5]],
+    // CHECK-DAG: !DILocalVariable(tag: DW_TAG_arg_variable, name: "rhs",{{.*}} line: [[@LINE+4]],
+    // CHECK-DAG: !DILocalVariable(tag: DW_TAG_arg_variable, name: "random_string",{{.*}} line: 8,
+    // CHECK-DAG: !DILocalVariable(tag: DW_TAG_arg_variable, name: "random_int",{{.*}} line: 9,
+    // CHECK-DAG: !DILocalVariable(tag: DW_TAG_arg_variable, name: "out_only",{{.*}} line: 10,
         { (lhs : String, rhs : String) -> Bool in
             if rhs == random_string
                || count(rhs.unicodeScalars) == random_int
             {
             // Ensure the two local_vars are in different lexical scopes.
-            // CHECK-DAG: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "local_var", scope: ![[THENSCOPE:[0-9]+]],{{.*}} line: [[@LINE+2]],
-            // CHECK-DAG: ![[THENSCOPE]] = distinct !MDLexicalBlock({{.*}} line: [[@LINE-3]]
+            // CHECK-DAG: !DILocalVariable(tag: DW_TAG_auto_variable, name: "local_var", scope: ![[THENSCOPE:[0-9]+]],{{.*}} line: [[@LINE+2]],
+            // CHECK-DAG: ![[THENSCOPE]] = distinct !DILexicalBlock({{.*}} line: [[@LINE-3]]
                 var local_var : Int = 10
                 print ("I have an int here \(local_var).\n")
                 return false
             }
             else
             {
-            // CHECK-DAG: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "local_var", scope: ![[ELSESCOPE:[0-9]+]],{{.*}} line: [[@LINE+2]]
-            // CHECK-DAG: ![[ELSESCOPE]] = distinct !MDLexicalBlock({{.*}} line: [[@LINE-2]],
+            // CHECK-DAG: !DILocalVariable(tag: DW_TAG_auto_variable, name: "local_var", scope: ![[ELSESCOPE:[0-9]+]],{{.*}} line: [[@LINE+2]]
+            // CHECK-DAG: ![[ELSESCOPE]] = distinct !DILexicalBlock({{.*}} line: [[@LINE-2]],
                 var local_var : String = "g"
                 print ("I have another string here \(local_var).\n")
                 // Assign to all the captured variables to inhibit capture promotion.

test/DebugInfo/closure-args2.swift

@@ -10,10 +10,10 @@ func main () -> Void
         { (lhs : String, rhs : String) -> Bool in
 
     // CHECK-NOT: llvm.dbg.{{.*}}%swift.refcounted*
-    // CHECK: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "lhs"
-    // CHECK: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "rhs"
-    // CHECK: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "random_string"
-    // CHECK: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "random_int"
+    // CHECK: !DILocalVariable(tag: DW_TAG_arg_variable, name: "lhs"
+    // CHECK: !DILocalVariable(tag: DW_TAG_arg_variable, name: "rhs"
+    // CHECK: !DILocalVariable(tag: DW_TAG_arg_variable, name: "random_string"
+    // CHECK: !DILocalVariable(tag: DW_TAG_arg_variable, name: "random_int"
 
             if rhs == random_string
             || count(rhs.unicodeScalars) == random_int {

test/DebugInfo/closure-multivalue.swift

@@ -7,11 +7,11 @@
 // CHECK: call void @llvm.dbg.value(metadata i8*{{.*}}, metadata ![[B:.*]], metadata ![[P1]])
 // CHECK: call void @llvm.dbg.value(metadata i{{[0-9]+}} {{.*}}, metadata ![[B]], metadata ![[P2]])
 // CHECK: call void @llvm.dbg.value(metadata i{{[0-9]+}} {{.*}}, metadata ![[B]], metadata ![[P3]])
-// CHECK-DAG: ![[A]] = !MDLocalVariable({{.*}} name: "a",{{.*}} line: 15
-// CHECK-DAG: ![[B]] = !MDLocalVariable({{.*}} name: "b",{{.*}} line: 15
-// CHECK-DAG: ![[P1]] = !MDExpression(DW_OP_bit_piece, 0, {{(32|64)}})
-// CHECK-DAG: ![[P2]] = !MDExpression(DW_OP_bit_piece, {{(32, 32|64, 64)}})
-// CHECK-DAG: ![[P3]] = !MDExpression(DW_OP_bit_piece, {{(64, 32|128, 64)}})
+// CHECK-DAG: ![[A]] = !DILocalVariable({{.*}} name: "a",{{.*}} line: 15
+// CHECK-DAG: ![[B]] = !DILocalVariable({{.*}} name: "b",{{.*}} line: 15
+// CHECK-DAG: ![[P1]] = !DIExpression(DW_OP_bit_piece, 0, {{(32|64)}})
+// CHECK-DAG: ![[P2]] = !DIExpression(DW_OP_bit_piece, {{(32, 32|64, 64)}})
+// CHECK-DAG: ![[P3]] = !DIExpression(DW_OP_bit_piece, {{(64, 32|128, 64)}})
 func sort(a : String, b : String) -> Bool {
   println("Sorting..\(a) & \(b)")
   return (a < b)
@@ -32,11 +32,11 @@ demo()
 // RUN: %target-swift-frontend %s -emit-ir -g -o - | FileCheck %s --check-prefix=CHECK-O0
 // Verify that a reabstraction thunk does not have a line number.
 // CHECK-O0-NOT: DW_OP_bit_piece
-// CHECK-O0: !MDSubprogram({{.*}}linkageName: "_TTRXFo_oSSoSS_dSb_XFo_iSSiSS_dSb_"
+// CHECK-O0: !DISubprogram({{.*}}linkageName: "_TTRXFo_oSSoSS_dSb_XFo_iSSiSS_dSb_"
 // CHECK-O0-NOT: line:
 // CHECK-O0-SAME: ){{$}}
 // CHECK-O0-NOT: DW_OP_bit_piece
-// CHECK-O0: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "a",{{.*}} line: 15,
+// CHECK-O0: !DILocalVariable(tag: DW_TAG_arg_variable, name: "a",{{.*}} line: 15,
 // CHECK-O0-NOT: DW_OP_bit_piece
-// CHECK-O0: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "b",{{.*}} line: 15,
+// CHECK-O0: !DILocalVariable(tag: DW_TAG_arg_variable, name: "b",{{.*}} line: 15,
 // CHECK-O0-NOT: DW_OP_bit_piece

test/DebugInfo/closure.swift

@@ -12,8 +12,8 @@ func foldl1<T>(list: [T], _ function: (a: T, b: T) -> T) -> T {
 var a = [Int](count: 10, repeatedValue: 0)
 for i in 0..<10 { a[i] = i }
 // A closure is not an artificial function (the last i32 0).
-// CHECK: !MDSubprogram({{.*}}linkageName: "_TF7closureU_FTSiSi_Si",{{.*}} line: 18,{{.*}} scopeLine: 18,
-// CHECK: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "$0",{{.*}} line: [[@LINE+2]],
-// CHECK: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "$1",{{.*}} line: [[@LINE+1]],
+// CHECK: !DISubprogram({{.*}}linkageName: "_TF7closureU_FTSiSi_Si",{{.*}} line: 18,{{.*}} scopeLine: 18,
+// CHECK: !DILocalVariable(tag: DW_TAG_arg_variable, name: "$0",{{.*}} line: [[@LINE+2]],
+// CHECK: !DILocalVariable(tag: DW_TAG_arg_variable, name: "$1",{{.*}} line: [[@LINE+1]],
 var sum:Int = foldl1(a, { $0 + $1 })
 println(sum)

test/DebugInfo/dynamic_layout.swift

@@ -6,7 +6,7 @@ class Class <T> {
 	init(_x : T) {x = _x}
 
   // Verify that the mangling of the decl context of the type U is correct.
-  // CHECK: !MDCompositeType({{.*}}name: "{{[^"]*}}_TtQq_FC14dynamic_layout5Class3foo{{[^"]*}}"
+  // CHECK: !DICompositeType({{.*}}name: "{{[^"]*}}_TtQq_FC14dynamic_layout5Class3foo{{[^"]*}}"
 	func foo <U> (y : U) -> (T,U) {
 		var tuple = (x,y)
 		return tuple

test/DebugInfo/enum.swift

@@ -1,27 +1,27 @@
 // RUN: %target-swift-frontend %s -emit-ir -g -o - | FileCheck %s
 
 // CHECK: ![[EMPTY:.*]] = !{}
-// CHECK: !MDCompositeType(tag: DW_TAG_union_type, name: "Color",
+// CHECK: !DICompositeType(tag: DW_TAG_union_type, name: "Color",
 // CHECK-SAME:             line: [[@LINE+3]]
 // CHECK-SAME:             size: 8, align: 8,
 // CHECK-SAME:             identifier: "_TtO4enum5Color"
 enum Color : UInt {
-// CHECK: !MDDerivedType(tag: DW_TAG_member, name: "Red"
+// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "Red"
 // CHECK-SAME:           baseType: !"_TtSu"
 // CHECK-SAME:           size: 8, align: 8{{[,)]}}
   case Red, Green, Blue
 }
 
-// CHECK: !MDCompositeType(tag: DW_TAG_union_type, name: "MaybeIntPair",
+// CHECK: !DICompositeType(tag: DW_TAG_union_type, name: "MaybeIntPair",
 // CHECK-SAME:             line: [[@LINE+3]],
 // CHECK-SAME:             size: 136, align: 64{{[,)]}}
 // CHECK-SAME:             identifier: "_TtO4enum12MaybeIntPair"
 enum MaybeIntPair {
-// CHECK: !MDDerivedType(tag: DW_TAG_member, name: "None"
+// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "None"
 // CHECK-SAME:           baseType: !"_TtSi"
 // CHECK-SAME:           size: 136, align: 64{{[,)]}}
 case None
-// CHECK: !MDDerivedType(tag: DW_TAG_member, name: "Just"
+// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "Just"
 // CHECK-SAME:           baseType: !"_TtTVSs5Int64S__"
 // CHECK-SAME:           size: 136, align: 64{{[,)]}}
   case Just(Int64, Int64)
@@ -34,7 +34,7 @@ enum Maybe<T> {
 
 let r = Color.Red
 let c = MaybeIntPair.Just(74, 75)
-// CHECK: !MDCompositeType(tag: DW_TAG_union_type, name: "Maybe",
+// CHECK: !DICompositeType(tag: DW_TAG_union_type, name: "Maybe",
 // CHECK-SAME:             line: [[@LINE-8]],
 // CHECK-SAME:             size: 8, align: 8{{[,)]}}
 // CHECK-SAME:             identifier: "_TtGO4enum5MaybeOS_5Color_"
@@ -42,4 +42,4 @@ let movie : Maybe<Color> = .None
 
 public enum Nothing { }
 public func foo(empty : Nothing) { }
-// CHECK: !MDCompositeType({{.*}}name: "Nothing", {{.*}}elements: ![[EMPTY]]
+// CHECK: !DICompositeType({{.*}}name: "Nothing", {{.*}}elements: ![[EMPTY]]

test/DebugInfo/fnptr.swift

@@ -1,8 +1,8 @@
 // RUN: %target-swift-frontend %s -emit-ir -g -o - | FileCheck %s
 
-// CHECK-DAG: ![[SINODE:.*]] = !MDCompositeType(tag: DW_TAG_structure_type, name: "Int",{{.*}} identifier: [[SI:.*]])
-// CHECK-DAG: ![[SFNODE:.*]] = !MDCompositeType(tag: DW_TAG_structure_type, name: "Float",{{.*}} identifier: [[SF:.*]])
-// CHECK-DAG: ![[VOIDNODE:.*]] = !MDCompositeType(tag: DW_TAG_structure_type, name: "_TtT_",{{.*}} identifier: [[VOID:.*]])
+// CHECK-DAG: ![[SINODE:.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Int",{{.*}} identifier: [[SI:.*]])
+// CHECK-DAG: ![[SFNODE:.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Float",{{.*}} identifier: [[SF:.*]])
+// CHECK-DAG: ![[VOIDNODE:.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "_TtT_",{{.*}} identifier: [[VOID:.*]])
 func bar() {
     print ("bar()")
 }
@@ -10,32 +10,32 @@ func baz(i: Float) -> Int { return 0; }
 func barz(i: Float, _ j: Float) -> Int { return 0; }
 func main() -> Int {
 
-    // CHECK-DAG: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "bar_function_pointer",{{.*}} line: [[@LINE+1]],{{.*}} type: !"[[BARPT:[^,]+]]"
+    // CHECK-DAG: !DILocalVariable(tag: DW_TAG_auto_variable, name: "bar_function_pointer",{{.*}} line: [[@LINE+1]],{{.*}} type: !"[[BARPT:[^,]+]]"
     var bar_function_pointer = bar
-    // CHECK-DAG: !MDCompositeType(tag: DW_TAG_structure_type, name: "[[BARPT]]",{{.*}} elements: ![[BARMEMBERS:[0-9]+]]
+    // CHECK-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "[[BARPT]]",{{.*}} elements: ![[BARMEMBERS:[0-9]+]]
     // CHECK-DAG: ![[BARMEMBERS]] = !{![[BARMEMBER:.*]]}
-    // CHECK-DAG: ![[BARMEMBER]] = !MDDerivedType(tag: DW_TAG_member,{{.*}} baseType: ![[BARPTR:[0-9]+]]
-    // CHECK-DAG: ![[BARPTR]] = !MDDerivedType(tag: DW_TAG_pointer_type,{{.*}} baseType: ![[BART:[0-9]+]]
-    // CHECK-DAG: ![[BART]] = !MDSubroutineType(types: ![[BARARGS:[0-9]+]])
+    // CHECK-DAG: ![[BARMEMBER]] = !DIDerivedType(tag: DW_TAG_member,{{.*}} baseType: ![[BARPTR:[0-9]+]]
+    // CHECK-DAG: ![[BARPTR]] = !DIDerivedType(tag: DW_TAG_pointer_type,{{.*}} baseType: ![[BART:[0-9]+]]
+    // CHECK-DAG: ![[BART]] = !DISubroutineType(types: ![[BARARGS:[0-9]+]])
     // CHECK-DAG: ![[BARARGS]] = !{!"_TtT_"}
     bar_function_pointer();// Set breakpoint here
 
-    // CHECK-DAG: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "baz_function_pointer",{{.*}} type: !"[[BAZPT:[^,]+]]"
-    // CHECK-DAG: !MDCompositeType(tag: DW_TAG_structure_type, name: "[[BAZPT]]",{{.*}} elements: ![[BAZMEMBERS:[0-9]+]]
+    // CHECK-DAG: !DILocalVariable(tag: DW_TAG_auto_variable, name: "baz_function_pointer",{{.*}} type: !"[[BAZPT:[^,]+]]"
+    // CHECK-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "[[BAZPT]]",{{.*}} elements: ![[BAZMEMBERS:[0-9]+]]
     // CHECK-DAG: ![[BAZMEMBERS]] = !{![[BAZMEMBER:.*]]}
-    // CHECK-DAG: ![[BAZMEMBER]] = !MDDerivedType(tag: DW_TAG_member,{{.*}} baseType: ![[BAZPTR:[0-9]+]]
-    // CHECK-DAG: ![[BAZPTR]] = !MDDerivedType(tag: DW_TAG_pointer_type,{{.*}} baseType: ![[BAZT:[0-9]+]]
-    // CHECK-DAG: ![[BAZT]] = !MDSubroutineType(types: ![[BAZARGS:.*]])
+    // CHECK-DAG: ![[BAZMEMBER]] = !DIDerivedType(tag: DW_TAG_member,{{.*}} baseType: ![[BAZPTR:[0-9]+]]
+    // CHECK-DAG: ![[BAZPTR]] = !DIDerivedType(tag: DW_TAG_pointer_type,{{.*}} baseType: ![[BAZT:[0-9]+]]
+    // CHECK-DAG: ![[BAZT]] = !DISubroutineType(types: ![[BAZARGS:.*]])
     // CHECK-DAG: ![[BAZARGS]] = !{!"_TtSi", !"_TtSf"}
     var baz_function_pointer = baz
     baz_function_pointer(2.89)
 
-    // CHECK-DAG: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "barz_function_pointer",{{.*}} type: !"[[BARZPT:[^,]+]]"
-    // CHECK-DAG: !MDCompositeType(tag: DW_TAG_structure_type, name: "[[BARZPT]]",{{.*}} elements: ![[BARZMEMBERS:[0-9]+]]
+    // CHECK-DAG: !DILocalVariable(tag: DW_TAG_auto_variable, name: "barz_function_pointer",{{.*}} type: !"[[BARZPT:[^,]+]]"
+    // CHECK-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "[[BARZPT]]",{{.*}} elements: ![[BARZMEMBERS:[0-9]+]]
     // CHECK-DAG: ![[BARZMEMBERS]] = !{![[BARZMEMBER:.*]]}
-    // CHECK-DAG: ![[BARZMEMBER]] = !MDDerivedType(tag: DW_TAG_member,{{.*}} baseType: ![[BARZPTR:[0-9]+]]
-    // CHECK-DAG: ![[BARZPTR]] = !MDDerivedType(tag: DW_TAG_pointer_type,{{.*}} baseType: ![[BARZT:[0-9]+]]
-    // CHECK-DAG: ![[BARZT]] = !MDSubroutineType(types: ![[BARZARGS:.*]])
+    // CHECK-DAG: ![[BARZMEMBER]] = !DIDerivedType(tag: DW_TAG_member,{{.*}} baseType: ![[BARZPTR:[0-9]+]]
+    // CHECK-DAG: ![[BARZPTR]] = !DIDerivedType(tag: DW_TAG_pointer_type,{{.*}} baseType: ![[BARZT:[0-9]+]]
+    // CHECK-DAG: ![[BARZT]] = !DISubroutineType(types: ![[BARZARGS:.*]])
     // CHECK-DAG: ![[BARZARGS]] = !{!"_TtSi", !"_TtSf", !"_TtSf"}
     var barz_function_pointer = barz
     return barz_function_pointer(2.89, -1.0)

test/DebugInfo/generic_arg2.swift

@@ -7,7 +7,7 @@
 // Make sure there is no conflicting dbg.value for this variable.x
 // CHECK-NOT: dbg.value{{.*}}metadata ![[U]]
 class Class <T> {
-// CHECK: ![[U]] = !MDLocalVariable(tag: DW_TAG_arg_variable, name: "y",{{.*}} line: [[@LINE+1]],
+// CHECK: ![[U]] = !DILocalVariable(tag: DW_TAG_arg_variable, name: "y",{{.*}} line: [[@LINE+1]],
 	func foo <U> (var x : T, var y : U)
 	{
 		println("hello world")

test/DebugInfo/generic_args.swift

@@ -11,14 +11,14 @@ class AnotherClass : AProtocol {
 }
 
 
-// CHECK-DAG: !MDCompositeType(tag: DW_TAG_structure_type, name: "_TtQq_F12generic_args9aFunction{{.*}}",{{.*}} elements: ![[PROTOS:[0-9]+]]
+// CHECK-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "_TtQq_F12generic_args9aFunction{{.*}}",{{.*}} elements: ![[PROTOS:[0-9]+]]
 // CHECK-DAG: ![[PROTOS]] = !{![[INHERIT:.*]]}
-// CHECK-DAG: ![[INHERIT]] = !MDDerivedType(tag: DW_TAG_inheritance,{{.*}} baseType: ![[PROTOCOL:"[^"]+"]]
-// CHECK-DAG: !MDCompositeType(tag: DW_TAG_structure_type, name: "_TtMP12generic_args9AProtocol_",{{.*}} identifier: [[PROTOCOL]]
-// CHECK-DAG: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "x", arg: 1,{{.*}} type: ![[T:.*]])
-// CHECK-DAG: ![[T]] = !MDCompositeType(tag: DW_TAG_structure_type, name: "_TtQq_F12generic_args9aFunction{{.*}}
-// CHECK-DAG: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "y", arg: 2,{{.*}} type: ![[Q:.*]])
-// CHECK-DAG: ![[Q]] = !MDCompositeType(tag: DW_TAG_structure_type, name: "_TtQq0_F12generic_args9aFunction{{.*}}
+// CHECK-DAG: ![[INHERIT]] = !DIDerivedType(tag: DW_TAG_inheritance,{{.*}} baseType: ![[PROTOCOL:"[^"]+"]]
+// CHECK-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "_TtMP12generic_args9AProtocol_",{{.*}} identifier: [[PROTOCOL]]
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_arg_variable, name: "x", arg: 1,{{.*}} type: ![[T:.*]])
+// CHECK-DAG: ![[T]] = !DICompositeType(tag: DW_TAG_structure_type, name: "_TtQq_F12generic_args9aFunction{{.*}}
+// CHECK-DAG: !DILocalVariable(tag: DW_TAG_arg_variable, name: "y", arg: 2,{{.*}} type: ![[Q:.*]])
+// CHECK-DAG: ![[Q]] = !DICompositeType(tag: DW_TAG_structure_type, name: "_TtQq0_F12generic_args9aFunction{{.*}}
 func aFunction<T : AProtocol, Q : AProtocol>(var x: T, var _ y: Q, _ z: String) {
      println("I am in \(z): \(x.f()) \(y.f())")
 }
@@ -28,15 +28,15 @@ aFunction(AClass(),AnotherClass(),"aFunction")
 struct Wrapper<T: AProtocol> {
 
   init<U: AProtocol>(from : Wrapper<U>) {
-  // CHECK-DAG: !MDCompositeType(tag: DW_TAG_structure_type, name: "Wrapper",{{.*}} identifier: "_TtGV12generic_args7WrapperQq_FS0_cUS_9AProtocol__FMGS0_Q__US1___FT4fromGS0_Q___GS0_Qd____")
+  // CHECK-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "Wrapper",{{.*}} identifier: "_TtGV12generic_args7WrapperQq_FS0_cUS_9AProtocol__FMGS0_Q__US1___FT4fromGS0_Q___GS0_Qd____")
     var wrapped = from
   }
 
   func passthrough(t: T) -> T {
-    // CHECK-DAG: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "local",{{.*}} line: [[@LINE+1]],{{.*}} type: ![[LOCAL_T:[0-9]+]]
+    // CHECK-DAG: !DILocalVariable(tag: DW_TAG_auto_variable, name: "local",{{.*}} line: [[@LINE+1]],{{.*}} type: ![[LOCAL_T:[0-9]+]]
     var local = t
     // The type of local should have the context Wrapper<T>.
-    // CHECK-DAG: ![[LOCAL_T]] = !MDCompositeType(tag: DW_TAG_structure_type, name: "_TtQq_V12generic_args7Wrapper"
+    // CHECK-DAG: ![[LOCAL_T]] = !DICompositeType(tag: DW_TAG_structure_type, name: "_TtQq_V12generic_args7Wrapper"
     return local
   }
 }

test/DebugInfo/generic_enum.swift

@@ -14,8 +14,8 @@ func unwrapTrivialGeneric<T, U>(tg: TrivialGeneric<T, U>) -> (T, U) {
 func wrapTrivialGeneric<T, U>(t: T, u: U) -> TrivialGeneric<T, U> {
   return .x(t, u)
 }
-// CHECK-DAG: !MDGlobalVariable(name: "tg",{{.*}} line: [[@LINE+2]],{{.*}} type: !"_TtGO12generic_enum14TrivialGenericSiSS_",{{.*}} isLocal: false, isDefinition: true
-// CHECK-DAG: !MDCompositeType(tag: DW_TAG_union_type, name: "TrivialGeneric", {{.*}}identifier: "_TtGO12generic_enum14TrivialGenericSiSS_"
+// CHECK-DAG: !DIGlobalVariable(name: "tg",{{.*}} line: [[@LINE+2]],{{.*}} type: !"_TtGO12generic_enum14TrivialGenericSiSS_",{{.*}} isLocal: false, isDefinition: true
+// CHECK-DAG: !DICompositeType(tag: DW_TAG_union_type, name: "TrivialGeneric", {{.*}}identifier: "_TtGO12generic_enum14TrivialGenericSiSS_"
 var tg : TrivialGeneric<Int, String> = .x(23, "skidoo")
 switch tg {
 case .x(var t, var u):

test/DebugInfo/generic_enum_closure.swift

@@ -9,7 +9,7 @@ struct CErrorOr<T>
     // CHECK-NOT: define
     // This is a SIL-level debug_value_addr instruction.
     // CHECK: call void @llvm.dbg.value({{.*}}, metadata ![[SELF:.*]], metadata !{{[0-9]+}})
-    // CHECK-DAG: ![[SELF]] = !MDLocalVariable(tag: DW_TAG_auto_variable, name: "self",{{.*}} type: !"_TtGV20generic_enum_closure8CErrorOrQq_S0__"
+    // CHECK-DAG: ![[SELF]] = !DILocalVariable(tag: DW_TAG_auto_variable, name: "self",{{.*}} type: !"_TtGV20generic_enum_closure8CErrorOrQq_S0__"
     value = .None
   }
   func isError() -> Bool {

test/DebugInfo/hello.swift

@@ -1,4 +1,4 @@
 // RUN: %target-swift-frontend %s -emit-ir -g -o - | FileCheck %s
 
 println("Hello World!")
-// CHECK: !MDFile(filename: "Swift.swiftmodule",
+// CHECK: !DIFile(filename: "Swift.swiftmodule",

test/DebugInfo/implicitdecl.swift

@@ -2,7 +2,7 @@
 
 // REQUIRES: objc_interop
 
-// CHECK: !MDCompositeType(tag: DW_TAG_structure_type, name: "Protocol",
+// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "Protocol",
 // CHECK-SAME:             scope: ![[ObjectiveC:[0-9]+]]
 // CHECK-SAME:             identifier: "_TtCSo8Protocol"
 // CHECK: ![[ObjectiveC]] = !MDModule(name: "ObjectiveC"

test/DebugInfo/initializer.swift

@@ -13,7 +13,7 @@ protocol Named {
 // CHECK: define hidden %C11initializer6Person* @_TFC11initializer6PersonCfMS0_FT_S0_(%swift.type*) {
 // CHECK:  call %C11initializer6Person* @_TFC11initializer6PersoncfMS0_FT_S0_(%C11initializer6Person* %3), !dbg ![[ALLOCATING_INIT:.*]]
 
-// CHECK-DAG: ![[ALLOCATING_INIT]]  = !MDLocation(line: 0, scope
+// CHECK-DAG: ![[ALLOCATING_INIT]]  = !DILocation(line: 0, scope
 class Person : Named {
     var name : String { get { return "No Name" } }
     var age = 0

test/DebugInfo/inlinescopes.swift

@@ -7,25 +7,25 @@
 
 // CHECK: define i32 @main
 // CHECK: tail call { i64, i1 } @llvm.smul.with.overflow.i64(i64 %[[C:.*]], i64 %[[C]]), !dbg ![[MULSCOPE:.*]]
-// CHECK-DAG: ![[TOPLEVEL:.*]] = !MDFile(filename: "inlinescopes.swift"
-// CHECK-DAG: ![[MAIN:.*]] = !MDSubprogram(name: "main"
-// CHECK-DAG: ![[INLINED_TOPLEVEL:.*]] = !MDLocation(line: 0, scope: ![[MAIN:.*]])
+// CHECK-DAG: ![[TOPLEVEL:.*]] = !DIFile(filename: "inlinescopes.swift"
+// CHECK-DAG: ![[MAIN:.*]] = !DISubprogram(name: "main"
+// CHECK-DAG: ![[INLINED_TOPLEVEL:.*]] = !DILocation(line: 0, scope: ![[MAIN:.*]])
 
 import FooBar
 
 func square(x: Int64) -> Int64 {
-// CHECK-DAG: ![[MULSCOPE]] = !MDLocation(line: [[@LINE+2]], column: {{.*}}, scope: ![[MUL:.*]], inlinedAt: ![[INLINED:.*]])
-// CHECK-DAG: ![[MUL:.*]] = distinct !MDLexicalBlock(
+// CHECK-DAG: ![[MULSCOPE]] = !DILocation(line: [[@LINE+2]], column: {{.*}}, scope: ![[MUL:.*]], inlinedAt: ![[INLINED:.*]])
+// CHECK-DAG: ![[MUL:.*]] = distinct !DILexicalBlock(
   let res = x * x
 // *(Int, Int) is a transparent function and should not show up in the debug info.
-// TRANSPARENT-CHECK-NOT: !MDSubprogram(name: "_TFSsoi1mFTSiSi_Si"
+// TRANSPARENT-CHECK-NOT: !DISubprogram(name: "_TFSsoi1mFTSiSi_Si"
   return res
 }
 let c = Int64(x)
-// CHECK-DAG ![[INLINED]] = !MDLocation(i32 [[@LINE+1]], column: {{.*}}, scope: !{{.*}}, inlinedAt: ![[INLINED_TOPLEVEL:.*]])
-// CHECK-DAG: !MDGlobalVariable(name: "y",{{.*}} file: ![[TOPLEVEL]],{{.*}} line: [[@LINE+1]]
+// CHECK-DAG ![[INLINED]] = !DILocation(i32 [[@LINE+1]], column: {{.*}}, scope: !{{.*}}, inlinedAt: ![[INLINED_TOPLEVEL:.*]])
+// CHECK-DAG: !DIGlobalVariable(name: "y",{{.*}} file: ![[TOPLEVEL]],{{.*}} line: [[@LINE+1]]
 let y = square(c)
 println(y)
 
 // Check if the inlined and removed square function still has the correct linkage name in the debug info.
-// CHECK-DAG: !MDSubprogram(name: "square", linkageName: "_TF4main6squareFVSs5Int64S0_"
+// CHECK-DAG: !DISubprogram(name: "square", linkageName: "_TF4main6squareFVSs5Int64S0_"

test/DebugInfo/inout.swift

@@ -18,14 +18,14 @@ typealias MyFloat = Float
 // PROMO-CHECK: define {{.*}}@_TTSf2d_i___TFF5inout13modifyFooHeapFTRSiSf_T_U_FT_Si
 // PROMO-CHECK: call void @llvm.dbg.declare(metadata {{(i32|i64)}}* %{{.*}}, metadata ![[A1:[0-9]+]], metadata ![[EMPTY_EXPR:[0-9]+]])
 
-// PROMO-CHECK-DAG: ![[EMPTY_EXPR]] = !MDExpression()
-// PROMO-CHECK-DAG: ![[REFINT:.*]] = !MDCompositeType(tag: DW_TAG_structure_type, name: "_TtRSi"
-// PROMO-CHECK-DAG: ![[A1]] = !MDLocalVariable(tag: DW_TAG_arg_variable, name: "a",{{.*}} type: !"_TtSi"
-// PROMO-CHECK-DAG: !MDCompositeType(tag: DW_TAG_structure_type, name: "_TtRSi"
+// PROMO-CHECK-DAG: ![[EMPTY_EXPR]] = !DIExpression()
+// PROMO-CHECK-DAG: ![[REFINT:.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "_TtRSi"
+// PROMO-CHECK-DAG: ![[A1]] = !DILocalVariable(tag: DW_TAG_arg_variable, name: "a",{{.*}} type: !"_TtSi"
+// PROMO-CHECK-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "_TtRSi"
 func modifyFooHeap(inout a: Int,
-// CHECK-DAG: ![[A]] = !MDLocalVariable(tag: DW_TAG_arg_variable, name: "a",{{.*}} line: [[@LINE-1]],{{.*}} type: !"_TtRSi"
-// CHECK-DAG: ![[B]] = !MDLocalVariable(tag: DW_TAG_arg_variable, name: "b",{{.*}} line: [[@LINE+2]],{{.*}} type: ![[MYFLOAT:[0-9]+]]
-// CHECK-DAG: ![[MYFLOAT]] = !MDDerivedType(tag: DW_TAG_typedef, name: "_Tta5inout7MyFloat",{{.*}} baseType: !"_TtSf"
+// CHECK-DAG: ![[A]] = !DILocalVariable(tag: DW_TAG_arg_variable, name: "a",{{.*}} line: [[@LINE-1]],{{.*}} type: !"_TtRSi"
+// CHECK-DAG: ![[B]] = !DILocalVariable(tag: DW_TAG_arg_variable, name: "b",{{.*}} line: [[@LINE+2]],{{.*}} type: ![[MYFLOAT:[0-9]+]]
+// CHECK-DAG: ![[MYFLOAT]] = !DIDerivedType(tag: DW_TAG_typedef, name: "_Tta5inout7MyFloat",{{.*}} baseType: !"_TtSf"
                    var _ b: MyFloat)
 {
     if (b > 2.71) {
@@ -39,12 +39,12 @@ func modifyFooHeap(inout a: Int,
 // Inout reference type.
 // FOO-CHECK: define {{.*}}@_TF5inout9modifyFooFTRSiSf_T_
 // FOO-CHECK: call void @llvm.dbg.declare(metadata %Si** %{{.*}}, metadata ![[U:[0-9]+]], metadata ![[EMPTY_EXPR:.*]])
-// FOO-CHECK-DAG: ![[EMPTY_EXPR]] = !MDExpression()
+// FOO-CHECK-DAG: ![[EMPTY_EXPR]] = !DIExpression()
 func modifyFoo(inout u: Int,
-// FOO-CHECK-DAG: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "v",{{.*}} line: [[@LINE+2]],{{.*}} type: ![[MYFLOAT:[0-9]+]]
-// FOO-CHECK-DAG: [[U]] = !MDLocalVariable(tag: DW_TAG_arg_variable, name: "u",{{.*}} line: [[@LINE-2]],{{.*}} type: !"_TtRSi"
+// FOO-CHECK-DAG: !DILocalVariable(tag: DW_TAG_arg_variable, name: "v",{{.*}} line: [[@LINE+2]],{{.*}} type: ![[MYFLOAT:[0-9]+]]
+// FOO-CHECK-DAG: [[U]] = !DILocalVariable(tag: DW_TAG_arg_variable, name: "u",{{.*}} line: [[@LINE-2]],{{.*}} type: !"_TtRSi"
                var _ v: MyFloat)
-// FOO-CHECK-DAG: ![[MYFLOAT]] = !MDDerivedType(tag: DW_TAG_typedef, name: "_Tta5inout7MyFloat",{{.*}} baseType: !"_TtSf"
+// FOO-CHECK-DAG: ![[MYFLOAT]] = !DIDerivedType(tag: DW_TAG_typedef, name: "_Tta5inout7MyFloat",{{.*}} baseType: !"_TtSf"
 {
     if (v > 2.71) {
       u = u - 41

test/DebugInfo/inout2.swift

@@ -21,13 +21,13 @@ struct Struct {
 }
 
 func foo (inout x : Class) {
-// CHECK: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "x",{{.*}} line: [[@LINE-1]]
+// CHECK: !DILocalVariable(tag: DW_TAG_arg_variable, name: "x",{{.*}} line: [[@LINE-1]]
 	println(x.ivar)
 	x.ivar++ // Set breakpoint here
 }
 
 func foo(inout x : Struct) {
-// CHECK: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "x",{{.*}} line: [[@LINE-1]]
+// CHECK: !DILocalVariable(tag: DW_TAG_arg_variable, name: "x",{{.*}} line: [[@LINE-1]]
 	println(x.ivar)
 	x.ivar++ // Set breakpoint here
 }

test/DebugInfo/iteration.swift

@@ -3,8 +3,8 @@
 
 var puzzleInput = "great minds think alike"
 var puzzleOutput = ""
-// CHECK-NOT: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "$letter$generator"
-// CHECK: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "letter",
+// CHECK-NOT: !DILocalVariable(tag: DW_TAG_auto_variable, name: "$letter$generator"
+// CHECK: !DILocalVariable(tag: DW_TAG_auto_variable, name: "letter",
 // CHECK-SAME:             line: [[@LINE+1]]
 for letter in puzzleInput {
     switch letter {
@@ -18,8 +18,8 @@ println(puzzleOutput)
 
 
 func count() {
-// CHECK-NOT: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "$i$generator"
-// CHECK: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "i",
+// CHECK-NOT: !DILocalVariable(tag: DW_TAG_auto_variable, name: "$i$generator"
+// CHECK: !DILocalVariable(tag: DW_TAG_auto_variable, name: "i",
 // CHECK-SAME:             line: [[@LINE+1]]
   for i in 0...100 {
     println(i)

test/DebugInfo/iuo_arg.swift

@@ -19,7 +19,7 @@ class MyClass {
     // Test that image is in an alloca, but not an indirect location.
     // CHECK: store {{(i32|i64)}} %0, {{(i32|i64)}}* %[[ALLOCA:.*]],
     // CHECK: call void @llvm.dbg.declare(metadata {{(i32|i64)}}* %[[ALLOCA]], metadata ![[IMAGE:.*]], metadata !{{[0-9]+}})
-    // CHECK: ![[IMAGE]] = !MDLocalVariable(tag: DW_TAG_arg_variable, name: "image"
+    // CHECK: ![[IMAGE]] = !DILocalVariable(tag: DW_TAG_arg_variable, name: "image"
     // CHECK-NOT:                           flags:
     // CHECK-SAME:                          line: [[@LINE-7]]
     // CHECK-NOT:                           flags:

test/DebugInfo/let.swift

@@ -7,11 +7,11 @@ class DeepThought {
 func foo() -> Int {
   // CHECK: call void @llvm.dbg.declare(metadata %C3let11DeepThought** {{.*}}, metadata ![[A:.*]], metadata !{{[0-9]+}})
   // CHECK ![[A]] = {{.*}}i32 0} ; [ DW_TAG_auto_variable ] [machine] [line [[@LINE+1]]]
-  // CHECK: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "machine"
+  // CHECK: !DILocalVariable(tag: DW_TAG_auto_variable, name: "machine"
   // CHECK-NOT:              flags:
   // CHECK-SAME:             line: [[@LINE+1]],
   let machine = DeepThought()
-  // CHECK: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "a"
+  // CHECK: !DILocalVariable(tag: DW_TAG_auto_variable, name: "a"
   // CHECK-SAME:             line: [[@LINE+1]],
   let a = machine.query()
   return a

test/DebugInfo/letclause.swift

@@ -7,7 +7,7 @@ func peek() -> Symbol? { return Symbol() }
 func foo() {
 // CHECK: define {{.*}}foo
 // CHECK: call void @llvm.dbg.declare(metadata %V9letclause6Symbol undef, metadata ![[S:.*]], metadata !{{[0-9]+}})
-// CHECK: ![[S]] = !MDLocalVariable(tag: DW_TAG_auto_variable, name: "s"
+// CHECK: ![[S]] = !DILocalVariable(tag: DW_TAG_auto_variable, name: "s"
 // CHECK-SAME:                      line: [[@LINE+1]],
   while let s = peek() {
     print(s)

test/DebugInfo/letstring.swift

@@ -14,9 +14,9 @@ class AppDelegate {
     // CHECK-NOT: call void @llvm.dbg.value({{.*}}, metadata ![[SELF]], metadata !{{[0-9]+}})
     // CHECK: call void @llvm.dbg.declare({{.*}}, metadata ![[A:.*]], metadata !{{[0-9]+}})
     // CHECK-NOT: call void @llvm.dbg.value({{.*}}, metadata ![[A]], metadata !{{[0-9]+}})
-    // CHECK-DAG: ![[A]] = !MDLocalVariable(tag: DW_TAG_auto_variable, name: "a",{{.*}} line: [[@LINE-4]],
-    // CHECK-DAG: ![[SELF]] = !MDLocalVariable(tag: DW_TAG_arg_variable, name: "self",{{.*}} line: [[@LINE-10]],
-    // CHECK-DAG: ![[B]] = !MDLocalVariable(tag: DW_TAG_auto_variable, name: "b",{{.*}} line: [[@LINE+1]],
+    // CHECK-DAG: ![[A]] = !DILocalVariable(tag: DW_TAG_auto_variable, name: "a",{{.*}} line: [[@LINE-4]],
+    // CHECK-DAG: ![[SELF]] = !DILocalVariable(tag: DW_TAG_arg_variable, name: "self",{{.*}} line: [[@LINE-10]],
+    // CHECK-DAG: ![[B]] = !DILocalVariable(tag: DW_TAG_auto_variable, name: "b",{{.*}} line: [[@LINE+1]],
     var b = "var"
     self.window = UIWindow()
     return true

test/DebugInfo/linetable-cleanups.swift

@@ -22,6 +22,6 @@ func main() {
 // CHECK:  call void {{.*}}elease({{.*}}) {{#[0-9]+}}, !dbg ![[CLEANUPS:.*]]
 // CHECK-NEXT:  !dbg ![[CLEANUPS]]
 // CHECK-NEXT:  ret void, !dbg ![[CLEANUPS]]
-// CHECK: ![[CLEANUPS]] = !MDLocation(line: [[@LINE+1]], column: 1,
+// CHECK: ![[CLEANUPS]] = !DILocation(line: [[@LINE+1]], column: 1,
 }
 main()

test/DebugInfo/linetable.swift

@@ -39,7 +39,7 @@ func main(x: Int) -> Void
 // CHECK: call {{.*}} @swift_release {{.*}}
 // CHECK: call {{.*}} @swift_release {{.*}}, !dbg ![[CLOSURE_END:.*]]
 // CHECK-NEXT: ret void, !dbg ![[CLOSURE_END]]
-// CHECK: ![[CLOSURE_END]] = !MDLocation(line: [[@LINE+1]],
+// CHECK: ![[CLOSURE_END]] = !DILocation(line: [[@LINE+1]],
         }
     )
 

test/DebugInfo/mangling-stdlib.swift

@@ -1,3 +1,3 @@
 // RUN: %target-swift-frontend -parse-stdlib %s -emit-ir -g -o - | FileCheck %s
-// CHECK:  !MDDerivedType(tag: DW_TAG_typedef, name: "_TtBb",
+// CHECK:  !DIDerivedType(tag: DW_TAG_typedef, name: "_TtBb",
 var bo : Builtin.BridgeObject

test/DebugInfo/mangling.swift

@@ -2,25 +2,25 @@
 
 // Type:
 // Swift.Dictionary<Swift.Int64, Swift.String>
-// CHECK: !MDCompositeType(tag: DW_TAG_structure_type, name: "Dictionary",{{.*}} identifier: [[DT:[^,)]+]])
-// CHECK: !MDCompositeType(tag: DW_TAG_structure_type, name: "_TtT4NameSS2IdSi_",{{.*}} identifier: [[TT1:[^,)]+]])
-// CHECK: !MDCompositeType(tag: DW_TAG_structure_type, name: "_TtTSS2IdSi_",{{.*}} identifier: [[TT2:[^,)]+]])
+// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "Dictionary",{{.*}} identifier: [[DT:[^,)]+]])
+// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "_TtT4NameSS2IdSi_",{{.*}} identifier: [[TT1:[^,)]+]])
+// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "_TtTSS2IdSi_",{{.*}} identifier: [[TT2:[^,)]+]])
 
 // Variable:
 // mangling.myDict : Swift.Dictionary<Swift.Int64, Swift.String>
-// CHECK: !MDGlobalVariable(name: "myDict", linkageName: "_Tv8mangling6myDictGVSs10DictionarySiSS_",
+// CHECK: !DIGlobalVariable(name: "myDict", linkageName: "_Tv8mangling6myDictGVSs10DictionarySiSS_",
 // CHECK-SAME:              line: [[@LINE+2]]
 // CHECK-SAME:              type: ![[DT]]
 var myDict = Dictionary<Int, String>()
 myDict[12] = "Hello!"
 
 // mangling.myTuple1 : (Name : Swift.String, Id : Swift.Int64)
-// CHECK: !MDGlobalVariable(name: "myTuple1", linkageName: "_Tv8mangling8myTuple1T4NameSS2IdSi_",
+// CHECK: !DIGlobalVariable(name: "myTuple1", linkageName: "_Tv8mangling8myTuple1T4NameSS2IdSi_",
 // CHECK-SAME:              line: [[@LINE+2]]
 // CHECK-SAME:              type: ![[TT1]]
 var myTuple1 : (Name: String, Id: Int) = ("A", 1)
 // mangling.myTuple2 : (Swift.String, Id : Swift.Int64)
-// CHECK: !MDGlobalVariable(name: "myTuple2", linkageName: "_Tv8mangling8myTuple2TSS2IdSi_",
+// CHECK: !DIGlobalVariable(name: "myTuple2", linkageName: "_Tv8mangling8myTuple2TSS2IdSi_",
 // CHECK-SAME:              line: [[@LINE+2]]
 // CHECK-SAME:              type: ![[TT2]]
 var myTuple2 : (      String, Id: Int) = ("B", 2)

test/DebugInfo/multi-file.swift

@@ -2,7 +2,7 @@
 // RUN: %target-swift-frontend %S/../Inputs/empty.swift -primary-file %s -emit-ir -g -module-name multi | FileCheck %s
 // RUN: %target-swift-frontend -primary-file %S/../Inputs/empty.swift %s -emit-ir -g -module-name multi | FileCheck %s --check-prefix=CHECK-OTHER
 // RUN: %target-swift-frontend %s -primary-file %S/../Inputs/empty.swift -emit-ir -g -module-name multi | FileCheck %s --check-prefix=CHECK-OTHER
-// CHECK: !MDCompileUnit({{.*}}file: ![[FILE:[0-9]+]]
-// CHECK: ![[FILE]] = !MDFile(filename: "multi-file.swift"
-// CHECK-OTHER: !MDCompileUnit({{.*}}file: ![[FILE:[0-9]+]]
-// CHECK-OTHER: ![[FILE]] = !MDFile(filename: "empty.swift"
+// CHECK: !DICompileUnit({{.*}}file: ![[FILE:[0-9]+]]
+// CHECK: ![[FILE]] = !DIFile(filename: "multi-file.swift"
+// CHECK-OTHER: !DICompileUnit({{.*}}file: ![[FILE:[0-9]+]]
+// CHECK-OTHER: ![[FILE]] = !DIFile(filename: "empty.swift"

test/DebugInfo/nested_functions.swift

@@ -4,7 +4,7 @@ func outer(a: Int) -> Int {
      // Inner functions have a linkage name of "closure[0-9]+", but
      // their DW_AT_name is preserved.
 
-     // CHECK: !MDSubprogram(name: "inner", linkageName: "_TFF16nested_functions5outerFSiSiL_5innerfSiSi"
+     // CHECK: !DISubprogram(name: "inner", linkageName: "_TFF16nested_functions5outerFSiSiL_5innerfSiSi"
      // CHECK-SAME:          line: [[@LINE+1]]
      func inner(b: Int) -> Int {
        return a+b

test/DebugInfo/nostorage.swift

@@ -17,7 +17,7 @@ func app() {
 	var ac : AClass = AnotherClass()
         // No members? No storage! Emitted as a constant 0, because.
         // CHECK: call void @llvm.dbg.value(metadata {{.*}}, i64 0, metadata ![[AT:.*]], metadata !{{[0-9]+}}), !dbg
-        // CHECK: ![[AT]] = !MDLocalVariable(tag: DW_TAG_auto_variable, name: "at",
+        // CHECK: ![[AT]] = !DILocalVariable(tag: DW_TAG_auto_variable, name: "at",
         // CHECK-SAME:                       line: [[@LINE+1]]
 	var at = AStruct()
 	println("\(ac.f()) \(at.f())")

test/DebugInfo/patternmatching.swift

@@ -22,27 +22,27 @@ func classifyPoint2(p: (Double, Double)) {
           // CHECK:   call double {{.*}}return_same{{.*}}, !dbg ![[LOC1:.*]]
           // CHECK: br {{.*}}, label {{.*}}, label {{.*}}, !dbg ![[LOC2:.*]]
           // CHECK: builtinStringLiteral{{.*}}, !dbg ![[LOC3:.*]]
-          // CHECK: ![[LOC1]] = !MDLocation(line: [[@LINE+2]],
-          // CHECK: ![[LOC2]] = !MDLocation(line: [[@LINE+1]],
+          // CHECK: ![[LOC1]] = !DILocation(line: [[@LINE+2]],
+          // CHECK: ![[LOC2]] = !DILocation(line: [[@LINE+1]],
                             return_same(x) == return_same(y):
-          // CHECK: ![[LOC3]] = !MDLocation(line: [[@LINE+1]],
+          // CHECK: ![[LOC3]] = !DILocation(line: [[@LINE+1]],
           println("(\(x), \(y)) is on the + diagonal")
           // SIL-CHECK:  dealloc_stack{{.*}}line:[[@LINE-1]]:54:cleanup
           // Verify that the branch has a location >= the cleanup.
           // SIL-CHECK-NEXT:  br{{.*}}line:[[@LINE-3]]:54:cleanup
         case (var x, var y) where x == -y:
           // Verify that all variables end up in the appropriate scopes.
-          // CHECK-SCOPES: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "x", scope: ![[SCOPE1:[0-9]+]],{{.*}} line: [[@LINE-2]]
-          // CHECK-SCOPES: ![[SCOPE1]] = distinct !MDLexicalBlock(
+          // CHECK-SCOPES: !DILocalVariable(tag: DW_TAG_auto_variable, name: "x", scope: ![[SCOPE1:[0-9]+]],{{.*}} line: [[@LINE-2]]
+          // CHECK-SCOPES: ![[SCOPE1]] = distinct !DILexicalBlock(
           println("on the - diagonal")
         case (var x, var y) where x >= -10 && x < 10 && y >= -10 && y < 10:
-          // CHECK-SCOPES: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "x", scope: ![[SCOPE2:[0-9]+]],{{.*}} line: [[@LINE-1]]
-          // CHECK-SCOPES: ![[SCOPE2]] = distinct !MDLexicalBlock(
+          // CHECK-SCOPES: !DILocalVariable(tag: DW_TAG_auto_variable, name: "x", scope: ![[SCOPE2:[0-9]+]],{{.*}} line: [[@LINE-1]]
+          // CHECK-SCOPES: ![[SCOPE2]] = distinct !DILexicalBlock(
           println("near the origin")
         case (var x, var y):
-          // CHECK-SCOPES: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "x", scope: ![[SCOPE3:[0-9]+]],{{.*}} line: [[@LINE-1]]
-          // CHECK-SCOPES: ![[SCOPE3]] = distinct !MDLexicalBlock(
+          // CHECK-SCOPES: !DILocalVariable(tag: DW_TAG_auto_variable, name: "x", scope: ![[SCOPE3:[0-9]+]],{{.*}} line: [[@LINE-1]]
+          // CHECK-SCOPES: ![[SCOPE3]] = distinct !DILexicalBlock(
           println("sqrt(\(x*x + y*y)) units from the origin")
         }
-  // CHECK: !MDLocation(line: [[@LINE+1]],
+  // CHECK: !DILocation(line: [[@LINE+1]],
     }

test/DebugInfo/pcomp.swift

@@ -26,7 +26,7 @@ class SomeOtherClass : SomeClass {
 	override func f() -> Int { return 1 }
 }
 // This is an indirect value.
-// CHECK-DAG: !MDCompositeType(tag: DW_TAG_structure_type, name: "SomeProto",{{.*}} identifier: "_TtP5pcomp9SomeProto_"
+// CHECK-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "SomeProto",{{.*}} identifier: "_TtP5pcomp9SomeProto_"
 func main() {
 	var p : SomeProto = SomeOtherClass()
 	println("\(p.f())")

test/DebugInfo/protocol.swift

@@ -33,9 +33,9 @@ func main() -> Int64 {
 }
 
 // Self should be artificial.
-// CHECK: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "self",{{.*}} line: 16
+// CHECK: !DILocalVariable(tag: DW_TAG_arg_variable, name: "self",{{.*}} line: 16
 // CHECK-SAME:             DIFlagArtificial
 
-// CHECK: ![[LOC]] = !MDLocalVariable(tag: DW_TAG_auto_variable, name: "loc2d",{{.*}} line: [[@LINE-10]]
+// CHECK: ![[LOC]] = !DILocalVariable(tag: DW_TAG_auto_variable, name: "loc2d",{{.*}} line: [[@LINE-10]]
 
 main()

test/DebugInfo/protocolarg.swift

@@ -1,7 +1,7 @@
 // RUN: %target-swift-frontend %s -emit-ir -g -o - | FileCheck %s
 
 // FIXME: Should be DW_TAG_interface_type
-// CHECK: !MDCompositeType(tag: DW_TAG_structure_type, name: "IGiveOutInts"
+// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "IGiveOutInts"
 // CHECK-SAME:             identifier: [[PT:"[^"]+"]]
 protocol IGiveOutInts {
 	func callMe() -> Int
@@ -25,7 +25,7 @@ class AFancierImplementor : IGiveOutInts {
 }
 
 func printSomeNumbers(var gen: IGiveOutInts) {
-  // CHECK: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "gen",
+  // CHECK: !DILocalVariable(tag: DW_TAG_arg_variable, name: "gen",
   // CHECK-SAME:             line: [[@LINE-2]]
   // CHECK-SAME:             type: ![[PT]]
 	var i = 1

test/DebugInfo/return.swift

@@ -19,6 +19,6 @@ public func ifelseexpr() -> Int {
   // CHECK:  @swift_release to void (%C6return1X*)*)(%C6return1X* [[X]])
   // CHECK:  @swift_release to void (%C6return1X*)*)(%C6return1X* [[X]]) {{.*}}, !dbg ![[RET:.*]]
   // CHECK:  ret{{.*}}, !dbg ![[RET]]
-  return x.x; // CHECK: ![[RET]] = !MDLocation(line: [[@LINE]],
+  return x.x; // CHECK: ![[RET]] = !DILocation(line: [[@LINE]],
 }
 

test/DebugInfo/returnlocation.swift

@@ -15,8 +15,8 @@ public func none(inout a: Int) {
   // CHECK_NONE: !dbg ![[NONE_INIT:.*]]
   a -= 2;
   // CHECK_NONE: ret {{.*}}, !dbg ![[NONE_RET:.*]]
-  // CHECK_NONE: ![[NONE_INIT]] = !MDLocation(line: [[@LINE-2]], column:
-  // CHECK_NONE: ![[NONE_RET]] = !MDLocation(line: [[@LINE+1]], column: 1,
+  // CHECK_NONE: ![[NONE_INIT]] = !DILocation(line: [[@LINE-2]], column:
+  // CHECK_NONE: ![[NONE_RET]] = !DILocation(line: [[@LINE+1]], column: 1,
 }
 
 // RUN: FileCheck %s --check-prefix=CHECK_EMPTY < %t.ll
@@ -24,16 +24,16 @@ public func none(inout a: Int) {
 public func empty(inout a: Int) {
   if a > 24 {
       // CHECK-DAG_EMPTY: br {{.*}}, !dbg ![[EMPTY_RET1:.*]]
-      // CHECK-DAG_EMPTY_RET1: ![[EMPTY_RET1]] = !MDLocation(line: [[@LINE+1]], column: 6,
+      // CHECK-DAG_EMPTY_RET1: ![[EMPTY_RET1]] = !DILocation(line: [[@LINE+1]], column: 6,
       return
   }
 
   a -= 2;
   // CHECK-DAG_EMPTY: br {{.*}}, !dbg ![[EMPTY_RET2:.*]]
-  // CHECK-DAG_EMPTY_RET2: ![[EMPTY_RET]] = !MDLocation(line: [[@LINE+1]], column: 3,
+  // CHECK-DAG_EMPTY_RET2: ![[EMPTY_RET]] = !DILocation(line: [[@LINE+1]], column: 3,
   return
   // CHECK-DAG_EMPTY: ret {{.*}}, !dbg ![[EMPTY_RET:.*]]
-  // CHECK-DAG_EMPTY: ![[EMPTY_RET]] = !MDLocation(line: [[@LINE+1]], column: 1,
+  // CHECK-DAG_EMPTY: ![[EMPTY_RET]] = !DILocation(line: [[@LINE+1]], column: 1,
 }
 
 // RUN: FileCheck %s --check-prefix=CHECK_EMPTY_NONE < %t.ll
@@ -45,7 +45,7 @@ public func empty_none(inout a: Int) {
 
   a -= 2;
   // CHECK_EMPTY_NONE: ret {{.*}}, !dbg ![[EMPTY_NONE_RET:.*]]
-  // CHECK_EMPTY_NONE: ![[EMPTY_NONE_RET]] = !MDLocation(line: [[@LINE+1]], column: 1,
+  // CHECK_EMPTY_NONE: ![[EMPTY_NONE_RET]] = !DILocation(line: [[@LINE+1]], column: 1,
 }
 
 // RUN: FileCheck %s --check-prefix=CHECK_SIMPLE_RET < %t.ll
@@ -56,7 +56,7 @@ public func simple(a: Int) -> Int {
   }
   return 1
   // CHECK_SIMPLE_RET: ret i{{.*}}, !dbg ![[SIMPLE_RET:.*]]
-  // CHECK_SIMPLE_RET: ![[SIMPLE_RET]] = !MDLocation(line: [[@LINE+1]], column: 1,
+  // CHECK_SIMPLE_RET: ![[SIMPLE_RET]] = !DILocation(line: [[@LINE+1]], column: 1,
 }
 
 // RUN: FileCheck %s --check-prefix=CHECK_COMPLEX_RET < %t.ll
@@ -67,7 +67,7 @@ public func complex(a: Int) -> Int {
   }
   return a/2
   // CHECK_COMPLEX_RET: ret i{{.*}}, !dbg ![[COMPLEX_RET:.*]]
-  // CHECK_COMPLEX_RET: ![[COMPLEX_RET]] = !MDLocation(line: [[@LINE+1]], column: 1,
+  // CHECK_COMPLEX_RET: ![[COMPLEX_RET]] = !DILocation(line: [[@LINE+1]], column: 1,
 }
 
 // RUN: FileCheck %s --check-prefix=CHECK_COMPLEX_SIMPLE < %t.ll
@@ -78,7 +78,7 @@ public func complex_simple(a: Int) -> Int {
   }
   return 2
   // CHECK_COMPLEX_SIMPLE: ret i{{.*}}, !dbg ![[COMPLEX_SIMPLE_RET:.*]]
-  // CHECK_COMPLEX_SIMPLE: ![[COMPLEX_SIMPLE_RET]] = !MDLocation(line: [[@LINE+1]], column: 1,
+  // CHECK_COMPLEX_SIMPLE: ![[COMPLEX_SIMPLE_RET]] = !DILocation(line: [[@LINE+1]], column: 1,
 }
 
 // RUN: FileCheck %s --check-prefix=CHECK_SIMPLE_COMPLEX < %t.ll
@@ -89,7 +89,7 @@ public func simple_complex(a: Int) -> Int {
   }
   return 2
   // CHECK_SIMPLE_COMPLEX: ret {{.*}}, !dbg ![[SIMPLE_COMPLEX_RET:.*]]
-  // CHECK_SIMPLE_COMPLEX: ![[SIMPLE_COMPLEX_RET]] = !MDLocation(line: [[@LINE+1]], column: 1,
+  // CHECK_SIMPLE_COMPLEX: ![[SIMPLE_COMPLEX_RET]] = !DILocation(line: [[@LINE+1]], column: 1,
 }
 
 
@@ -101,7 +101,7 @@ public func simple_complex(a: Int) -> Int {
 public func cleanup_none(inout a: NSString) {
   a = "empty"
   // CHECK_CLEANUP_NONE: ret void, !dbg ![[CLEANUP_NONE_RET:.*]]
-  // CHECK_CLEANUP_NONE: ![[CLEANUP_NONE_RET]] = !MDLocation(line: [[@LINE+1]], column: 1,
+  // CHECK_CLEANUP_NONE: ![[CLEANUP_NONE_RET]] = !DILocation(line: [[@LINE+1]], column: 1,
 }
 
 // RUN: FileCheck %s --check-prefix=CHECK_CLEANUP_EMPTY < %t.ll
@@ -114,7 +114,7 @@ public func cleanup_empty(inout a: NSString) {
   a = "empty"
   return
   // CHECK_CLEANUP_EMPTY: ret void, !dbg ![[CLEANUP_EMPTY_RET:.*]]
-  // CHECK_CLEANUP_EMPTY: ![[CLEANUP_EMPTY_RET]] = !MDLocation(line: [[@LINE+1]], column: 1,
+  // CHECK_CLEANUP_EMPTY: ![[CLEANUP_EMPTY_RET]] = !DILocation(line: [[@LINE+1]], column: 1,
 }
 
 // RUN: FileCheck %s --check-prefix=CHECK_CLEANUP_EMPTY_NONE < %t.ll
@@ -126,7 +126,7 @@ public func cleanup_empty_none(inout a: NSString) {
 
   a = "empty"
   // CHECK_CLEANUP_EMPTY_NONE: ret {{.*}}, !dbg ![[CLEANUP_EMPTY_NONE_RET:.*]]
-  // CHECK_CLEANUP_EMPTY_NONE: ![[CLEANUP_EMPTY_NONE_RET]] = !MDLocation(line: [[@LINE+1]], column: 1,
+  // CHECK_CLEANUP_EMPTY_NONE: ![[CLEANUP_EMPTY_NONE_RET]] = !DILocation(line: [[@LINE+1]], column: 1,
 }
 
 // RUN: FileCheck %s --check-prefix=CHECK_CLEANUP_SIMPLE_RET < %t.ll
@@ -138,7 +138,7 @@ public func cleanup_simple(a: NSString) -> Int {
 
   return 1
   // CHECK_CLEANUP_SIMPLE_RET: ret {{.*}}, !dbg ![[CLEANUP_SIMPLE_RET:.*]]
-  // CHECK_CLEANUP_SIMPLE_RET: ![[CLEANUP_SIMPLE_RET]] = !MDLocation(line: [[@LINE+1]], column: 1,
+  // CHECK_CLEANUP_SIMPLE_RET: ![[CLEANUP_SIMPLE_RET]] = !DILocation(line: [[@LINE+1]], column: 1,
 }
 
 // RUN: FileCheck %s --check-prefix=CHECK_CLEANUP_COMPLEX < %t.ll
@@ -150,7 +150,7 @@ public func cleanup_complex(a: NSString) -> Int {
 
   return a.length/2
   // CHECK_CLEANUP_COMPLEX: ret i{{.*}}, !dbg ![[CLEANUP_COMPLEX_RET:.*]]
-  // CHECK_CLEANUP_COMPLEX: ![[CLEANUP_COMPLEX_RET]] = !MDLocation(line: [[@LINE+1]], column: 1,
+  // CHECK_CLEANUP_COMPLEX: ![[CLEANUP_COMPLEX_RET]] = !DILocation(line: [[@LINE+1]], column: 1,
 }
 
 // RUN: FileCheck %s --check-prefix=CHECK_CLEANUP_COMPLEX_SIMPLE < %t.ll
@@ -162,7 +162,7 @@ public func cleanup_complex_simple(a: NSString) -> Int {
 
   return 2
   // CHECK_CLEANUP_COMPLEX_SIMPLE: ret {{.*}}, !dbg ![[CLEANUP_COMPLEX_SIMPLE_RET:.*]]
-  // CHECK_CLEANUP_COMPLEX_SIMPLE: ![[CLEANUP_COMPLEX_SIMPLE_RET]] = !MDLocation(line: [[@LINE+1]], column: 1,
+  // CHECK_CLEANUP_COMPLEX_SIMPLE: ![[CLEANUP_COMPLEX_SIMPLE_RET]] = !DILocation(line: [[@LINE+1]], column: 1,
 }
 
 // RUN: FileCheck %s --check-prefix=CHECK_CLEANUP_SIMPLE_COMPLEX < %t.ll
@@ -173,7 +173,7 @@ public func cleanup_simple_complex(a: NSString) -> Int {
   }
   return 2
   // CHECK_CLEANUP_SIMPLE_COMPLEX: ret {{.*}}, !dbg ![[CLEANUP_SIMPLE_COMPLEX_RET:.*]]
-  // CHECK_CLEANUP_SIMPLE_COMPLEX: ![[CLEANUP_SIMPLE_COMPLEX_RET]] = !MDLocation(line: [[@LINE+1]], column: 1,
+  // CHECK_CLEANUP_SIMPLE_COMPLEX: ![[CLEANUP_SIMPLE_COMPLEX_RET]] = !DILocation(line: [[@LINE+1]], column: 1,
 }
 
 // ---------------------------------------------------------------------

test/DebugInfo/scopes.swift

@@ -15,13 +15,13 @@ class AppDelegate {
   var window: UIWindow?
 
   func application() -> Bool {
-    // CHECK-DAG: !MDLexicalBlock({{.*}}line: [[@LINE+1]], column: 13
+    // CHECK-DAG: !DILexicalBlock({{.*}}line: [[@LINE+1]], column: 13
     if true {
       // Verify that all debug line table entries for the expression
       // below are in the same scope.
       //
-      // CHECK-DAG: !{{.*}} = !MDLocation(line: [[@LINE+2]], column: 46, scope: ![[S:.*]])
-      // CHECK-DAG: !{{.*}} = !MDLocation(line: [[@LINE+1]], column: 11, scope: ![[S]])
+      // CHECK-DAG: !{{.*}} = !DILocation(line: [[@LINE+2]], column: 46, scope: ![[S:.*]])
+      // CHECK-DAG: !{{.*}} = !DILocation(line: [[@LINE+1]], column: 11, scope: ![[S]])
       let splitViewController = self.window!.rootViewController as! UISplitViewController
     }
     return true

test/DebugInfo/sdk.swift

@@ -1,11 +1,11 @@
 // Check that the sdk and resource dirs end up in the debug info.
 // RUN: %target-swiftc_driver %s -emit-ir -g -o - | FileCheck %s
 // RUN: %target-swiftc_driver %s -emit-ir -sdk "/Weird Location/SDK" -g -o - | FileCheck --check-prefix CHECK-EXPLICIT %s
-// CHECK:          !MDCompileUnit({{.*}}producer: "{{(Apple )?Swift version [^"]+}}"
+// CHECK:          !DICompileUnit({{.*}}producer: "{{(Apple )?Swift version [^"]+}}"
 // CHECK-SAME:                    flags: "
 // CHECK-NOT:                     "
 // CHECK-SAME:                    -resource-dir 
-// CHECK-EXPLICIT: !MDCompileUnit({{.*}}producer: "{{(Apple )?Swift version [^"]+}}"
+// CHECK-EXPLICIT: !DICompileUnit({{.*}}producer: "{{(Apple )?Swift version [^"]+}}"
 // CHECK-EXPLICIT-SAME:           flags: "
 // CHECK-EXPLICIT-NOT:            "
 // CHECK-EXPLICIT-SAME:           -sdk \22/Weird Location/SDK\22

test/DebugInfo/self.swift

@@ -17,7 +17,7 @@ public func f() {
 // CHECK-NEXT: entry:
 // CHECK-NEXT: %[[ALLOCA:.*]] = alloca %V4self11stuffStruct, align {{(4|8)}}
 // CHECK: call void @llvm.dbg.declare(metadata %V4self11stuffStruct* %[[ALLOCA]], metadata ![[SELF:.*]], metadata !{{[0-9]+}}), !dbg
-// CHECK: !MDCompositeType(tag: DW_TAG_structure_type, name: "stuffStruct",
+// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "stuffStruct",
 // CHECK-SAME:             identifier: [[STUFFSTRUCT:"[^"]+"]]
-// CHECK: ![[SELF]] = !MDLocalVariable(tag: DW_TAG_auto_variable, name: "self",{{.*}} type: ![[STUFFSTRUCT]]
+// CHECK: ![[SELF]] = !DILocalVariable(tag: DW_TAG_auto_variable, name: "self",{{.*}} type: ![[STUFFSTRUCT]]
 

test/DebugInfo/simple.sil

@@ -17,7 +17,7 @@ bb0(%0 : $Int32):
   cond_fail %8 : $Builtin.Int1                    // id: %9
   %10 = struct $Int32 (%7 : $Builtin.Int32)          // user: %11
   // CHECK: ret i32 %{{.*}}, !dbg ![[LOC:.*]]
-  // CHECK: ![[LOC]] = !MDLocation(line: [[@LINE+1]],
+  // CHECK: ![[LOC]] = !DILocation(line: [[@LINE+1]],
   return %10 : $Int32                               // id: %11
 }
 

test/DebugInfo/structs.swift

@@ -10,7 +10,7 @@ func test(var x : A) {}
 // CHECK:    define hidden void @_TF7structs4test
 // CHECK:      [[X:%.*]] = alloca [[A:%.*]], align {{(4|8)}}
 // CHECK-NEXT: call void @llvm.dbg.declare(metadata [[A]]* [[X]], metadata [[X_DBG:!.*]], metadata !{{[0-9]+}})
-// CHECK: !MDCompositeType(tag: DW_TAG_structure_type, name: "A"
+// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "A"
 // CHECK-SAME:             identifier: [[A_DI:"[^"]+"]]
-// CHECK: [[X_DBG]] = !MDLocalVariable(tag: DW_TAG_arg_variable, name: "x",
+// CHECK: [[X_DBG]] = !DILocalVariable(tag: DW_TAG_arg_variable, name: "x",
 // CHECK-SAME:             type: ![[A_DI]]

test/DebugInfo/test-foundation.swift

@@ -22,10 +22,10 @@
 
 // Sanity check for the regex above.
 // SANITY: {{^ *ret }}
-// SANITY: !MDCompileUnit(
+// SANITY: !DICompileUnit(
 
 // CHECK-HIDDEN: @[[HIDDEN_GV:_TWVVSC.*]] = linkonce_odr hidden
-// CHECK-HIDDEN-NOT: !MDGlobalVariable({{.*}}[[HIDDEN_GV]]
+// CHECK-HIDDEN-NOT: !DIGlobalVariable({{.*}}[[HIDDEN_GV]]
 
 import ObjectiveC
 import Foundation
@@ -40,17 +40,17 @@ class MyObject : NSObject {
 // IMPORT-CHECK: %Si = type <{ i[[PTRSIZE:[0-9]+]] }>
 // IMPORT-CHECK: filename: "test-foundation.swift"
 // IMPORT-CHECK: !MDModule(name: "ObjectiveC"
-// IMPORT-CHECK: !MDCompositeType(tag: DW_TAG_structure_type, name: "NSArray", scope: ![[FOUNDATION:[0-9]+]]
+// IMPORT-CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "NSArray", scope: ![[FOUNDATION:[0-9]+]]
 // IMPORT-CHECK-SAME:             identifier: [[NSARRAY:"[^"]+"]]
 // IMPORT-CHECK: [[FOUNDATION]] = !MDModule(name: "Foundation",{{.*}} file: ![[FOUNDATION_FILE:[0-9]+]]
-// IMPORT-CHECK: ![[FOUNDATION_FILE]] = !MDFile(filename: "Foundation-{{.*}}.pcm"
-// IMPORT-CHECK: !MDDerivedType(tag: DW_TAG_member, name: "MyArr",
+// IMPORT-CHECK: ![[FOUNDATION_FILE]] = !DIFile(filename: "Foundation-{{.*}}.pcm"
+// IMPORT-CHECK: !DIDerivedType(tag: DW_TAG_member, name: "MyArr",
 // IMPORT-CHECK-NOT:            line:
 // IMPORT-CHECK-SAME:           baseType: ![[NSARRAY]]
 // IMPORT-CHECK-SAME:           size: [[PTRSIZE]], align: [[PTRSIZE]]
 // IMPORT-CHECK-NOT:            offset: 0
 // IMPORT-CHECK-SAME:           ){{$}}
-// IMPORT-CHECK: !MDImportedEntity(tag: DW_TAG_imported_module,{{.*}} entity: ![[FOUNDATION]]
+// IMPORT-CHECK: !DIImportedEntity(tag: DW_TAG_imported_module,{{.*}} entity: ![[FOUNDATION]]
 
 
   // Force the use of Int.
@@ -62,15 +62,15 @@ class MyObject : NSObject {
 }
 
 // FIXME (LLVM-branch): The [local] attribute means ObjectiveC-CC.
-// SANITY-DAG: !MDSubprogram(name: "blah",{{.*}} line: [[@LINE+2]],{{.*}} isDefinition: true
+// SANITY-DAG: !DISubprogram(name: "blah",{{.*}} line: [[@LINE+2]],{{.*}} isDefinition: true
 extension MyObject {
   func blah() {
     println("blah blah blah")
   }
 }
 
-// SANITY-DAG: !MDCompositeType(tag: DW_TAG_structure_type, name: "NSObject",{{.*}} identifier: "_TtCSo8NSObject"
-// SANITY-DAG: !MDGlobalVariable(name: "NsObj",{{.*}} line: [[@LINE+1]],{{.*}} type: !"_TtCSo8NSObject",{{.*}} isDefinition: true
+// SANITY-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "NSObject",{{.*}} identifier: "_TtCSo8NSObject"
+// SANITY-DAG: !DIGlobalVariable(name: "NsObj",{{.*}} line: [[@LINE+1]],{{.*}} type: !"_TtCSo8NSObject",{{.*}} isDefinition: true
 var NsObj: NSObject
 NsObj = MyObject()
 var MyObj: MyObject
@@ -96,10 +96,10 @@ public func date() {
   d2.dateFormat = "mm dd yyyy" // LOC-CHECK: call{{.*}}objc_msgSend{{.*}}, !dbg ![[L4]]
 }
 
-// LOC-CHECK: ![[THUNK:.*]] = !MDSubprogram({{.*}}linkageName: "_TToFC4main8MyObjectg5MyArrCSo7NSArray"
+// LOC-CHECK: ![[THUNK:.*]] = !DISubprogram({{.*}}linkageName: "_TToFC4main8MyObjectg5MyArrCSo7NSArray"
 // LOC-CHECK-NOT:                           line:
 // LOC-CHECK-SAME:                          isDefinition: true
-// LOC-CHECK: ![[DBG]] = !MDLocation(line: 0, scope: ![[THUNK]])
+// LOC-CHECK: ![[DBG]] = !DILocation(line: 0, scope: ![[THUNK]])
 
 // These debug locations should all be in ordered by increasing line number.
 // LOC-CHECK: ![[L1]] =

test/DebugInfo/test_ints.swift

@@ -1,16 +1,16 @@
 // RUN: %target-swift-frontend %s -emit-ir -g -o - | FileCheck %s
 
 // These two should not have the same type.
-// CHECK: !MDCompositeType(tag: DW_TAG_structure_type, name: "Int64"
+// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "Int64"
 // CHECK-SAME:             size: 64, align: 64
 // CHECK-NOT:              offset: 0
 // CHECK-NOT:              DIFlagFwdDecl
 // CHECK-SAME:             identifier: "_TtVSs5Int64"
-// CHECK: !MDGlobalVariable(name: "a",{{.*}} line: [[@LINE+2]]
+// CHECK: !DIGlobalVariable(name: "a",{{.*}} line: [[@LINE+2]]
 // CHECK-SAME:              type: !"_TtVSs5Int64"
 var a : Int64 = 2
 
-// CHECK: !MDGlobalVariable(name: "b",{{.*}} line: [[@LINE+2]]
+// CHECK: !DIGlobalVariable(name: "b",{{.*}} line: [[@LINE+2]]
 // CHECK-SAME:              type: !"_TtSi"
 var b = 2
 

test/DebugInfo/thunks.swift

@@ -16,10 +16,10 @@ let i = foo.foo(-, x: y)
 // CHECK: define {{.*}}@_TTRXFdCb_dSi_dSi_XFo_dSi_dSi_
 // CHECK-NOT: ret
 // CHECK: call {{.*}}, !dbg ![[LOC:.*]]
-// CHECK: ![[THUNK:.*]] = !MDSubprogram(name: "_TTRXFdCb_dSi_dSi_XFo_dSi_dSi_"
+// CHECK: ![[THUNK:.*]] = !DISubprogram(name: "_TTRXFdCb_dSi_dSi_XFo_dSi_dSi_"
 // CHECK-NOT:                           line:
 // CHECK-SAME:                          ){{$}}
-// CHECK: ![[LOC]] = !MDLocation(line: 0, scope: ![[THUNK]])
+// CHECK: ![[LOC]] = !DILocation(line: 0, scope: ![[THUNK]])
 
 // SIL-CHECK: sil shared {{.*}}@_TTRXFo_dSi_dSi_XFdCb_dSi_dSi_
 // SIL-CHECK-NOT: return

test/DebugInfo/top_level_var.swift

@@ -4,8 +4,8 @@ var a = 1
 println(a)
 // Verify that global variables are emitted once in main, once as
 // global variable.
-// CHECK: ![[MAIN:.*]] = !MDSubprogram(name: "main",{{.*}} line: 1
+// CHECK: ![[MAIN:.*]] = !DISubprogram(name: "main",{{.*}} line: 1
 // CHECK: ![[MOD:.*]] = !MDModule(name: "top_level_var"
-// CHECK: !MDGlobalVariable(name: "a",
+// CHECK: !DIGlobalVariable(name: "a",
 // CHECK-SAME:              scope: ![[MOD]]
 // CHECK-SAME:              isDefinition: true

test/DebugInfo/trap-optimized.swift

@@ -3,9 +3,9 @@
 // CHECK-LABEL: define{{.*}}2fn
 func fn() {
   println("two")
-// CHECK-DAG: ![[LOC:.*]] = !MDLocation(line: [[@LINE+1]], column: 13,
+// CHECK-DAG: ![[LOC:.*]] = !DILocation(line: [[@LINE+1]], column: 13,
   println(0 - UInt(Process.arguments.count))
-// CHECK-DAG: ![[LOC2:.*]] = !MDLocation(line: [[@LINE+1]], column: 13,
+// CHECK-DAG: ![[LOC2:.*]] = !DILocation(line: [[@LINE+1]], column: 13,
   println(1 - UInt(Process.arguments.count))
   println("three")
 }

test/DebugInfo/trap.swift

@@ -5,11 +5,11 @@ import Swift
 func f(x : Int) -> Int {
   if x < 23 {
     // CHECK-DAG: call void @llvm.trap(), !dbg ![[LOC1:.*]]
-    // CHECK-DAG: ![[LOC1]] = !MDLocation(line: [[@LINE+1]],
+    // CHECK-DAG: ![[LOC1]] = !DILocation(line: [[@LINE+1]],
     Builtin.int_trap()
   }
   if x > 42 {
-    // CHECK-DAG: ![[LOC2:.*]] = !MDLocation(line: [[@LINE+1]],
+    // CHECK-DAG: ![[LOC2:.*]] = !DILocation(line: [[@LINE+1]],
     Builtin.int_trap()
     // CHECK-DAG: call void @llvm.trap(), !dbg ![[LOC2]]
   }

test/DebugInfo/tuple.swift

@@ -1,5 +1,5 @@
 // RUN: %target-swift-frontend -primary-file %s -emit-ir -g -o - | FileCheck %s
 // Don't emit a line number for tuple types. They are unnamed
 // and have no declaration, so the line number is nonsensical.
-// CHECK: !MDCompositeType(tag: DW_TAG_structure_type, name: "_TtTSiSf_"
+// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "_TtTSiSf_"
 let tuple : (Int, Float) = (1, 2.89)

test/DebugInfo/typealias.swift

@@ -2,15 +2,15 @@
 
 class DWARF
 {
-// CHECK-DAG: ![[DIEOFFSET:.*]] = !MDDerivedType(tag: DW_TAG_typedef, name: "_TtaC9typealias5DWARF9DIEOffset",{{.*}} line: [[@LINE+1]], baseType: !"_TtVSs6UInt32")
+// CHECK-DAG: ![[DIEOFFSET:.*]] = !DIDerivedType(tag: DW_TAG_typedef, name: "_TtaC9typealias5DWARF9DIEOffset",{{.*}} line: [[@LINE+1]], baseType: !"_TtVSs6UInt32")
     typealias DIEOffset = UInt32
 }
 
 func main () {
-  // CHECK-DAG: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "a",{{.*}} type: ![[DIEOFFSET]]
+  // CHECK-DAG: !DILocalVariable(tag: DW_TAG_auto_variable, name: "a",{{.*}} type: ![[DIEOFFSET]]
     var a : DWARF.DIEOffset = 123
     println("a is \(a)")
-  // CHECK-DAG: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "b",{{.*}} type: ![[DIEOFFSET]]
+  // CHECK-DAG: !DILocalVariable(tag: DW_TAG_auto_variable, name: "b",{{.*}} type: ![[DIEOFFSET]]
     var b = DWARF.DIEOffset(456) as DWARF.DIEOffset
     println("b is \(b)")
 }

test/DebugInfo/typearg.swift

@@ -9,11 +9,11 @@ class AClass : AProtocol {
 
 // CHECK: define hidden void @{{.*}}aFunction
 // CHECK:  call void @llvm.dbg.declare(metadata %swift.type** %{{.*}}, metadata ![[TYPEARG:.*]], metadata !{{[0-9]+}}),
-// CHECK: ![[VOIDPTR:[0-9]+]] = !MDDerivedType(tag: DW_TAG_pointer_type, name: "_TtBp", baseType: null
-// CHECK: ![[TYPEARG]] = !MDLocalVariable(tag: DW_TAG_auto_variable, name: "$swift.type.T"
+// CHECK: ![[VOIDPTR:[0-9]+]] = !DIDerivedType(tag: DW_TAG_pointer_type, name: "_TtBp", baseType: null
+// CHECK: ![[TYPEARG]] = !DILocalVariable(tag: DW_TAG_auto_variable, name: "$swift.type.T"
 // CHECK-SAME:                            type: ![[SWIFTMETATYPE:[^,)]+]]
 // CHECK-SAME:                            flags: DIFlagArtificial
-// CHECK: ![[SWIFTMETATYPE]] = !MDDerivedType(tag: DW_TAG_typedef, name: "$swift.type",
+// CHECK: ![[SWIFTMETATYPE]] = !DIDerivedType(tag: DW_TAG_typedef, name: "$swift.type",
 // CHECK-SAME:                                baseType: ![[VOIDPTR]]
 func aFunction<T : AProtocol>(x: T) {
     println("I am in aFunction: \(x.f())")
@@ -27,8 +27,8 @@ class Foo<Bar> {
       }
 
       func two<Baz>(x: Baz) {
-    // CHECK: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "$swift.type.Bar"
-    // CHECK: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "$swift.type.Baz"
+    // CHECK: !DILocalVariable(tag: DW_TAG_auto_variable, name: "$swift.type.Bar"
+    // CHECK: !DILocalVariable(tag: DW_TAG_auto_variable, name: "$swift.type.Baz"
       }
 }
 

test/DebugInfo/unowned-capture.swift

@@ -7,9 +7,9 @@ class Foo
     // Verify that we only emit the implicit argument,
     // and not the unowned local copy of self.
     //
-    // CHECK-NOT: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "self"
-    // CHECK: !MDLocalVariable(tag: DW_TAG_arg_variable, name: "self"
-    // CHECK-NOT: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "self"
+    // CHECK-NOT: !DILocalVariable(tag: DW_TAG_auto_variable, name: "self"
+    // CHECK: !DILocalVariable(tag: DW_TAG_arg_variable, name: "self"
+    // CHECK-NOT: !DILocalVariable(tag: DW_TAG_auto_variable, name: "self"
     return { [unowned self] in
              var tmp_string = a_string
              return tmp_string

test/DebugInfo/variables.swift

@@ -12,21 +12,21 @@
 
 // Global variables.
 var glob_i8:   Int8 = 8;
-// CHECK-DAG: !MDGlobalVariable(name: "glob_i8",{{.*}} scope: ![[TLC]],{{.*}} line: [[@LINE-1]],{{.*}} type: ![[I8:[^,]+]]
+// CHECK-DAG: !DIGlobalVariable(name: "glob_i8",{{.*}} scope: ![[TLC]],{{.*}} line: [[@LINE-1]],{{.*}} type: ![[I8:[^,]+]]
 var glob_i16:  Int16 = 16;
-// CHECK-DAG: !MDGlobalVariable(name: "glob_i16",{{.*}} scope: ![[TLC]],{{.*}} line: [[@LINE-1]],{{.*}} type: ![[I16:[^,]+]]
+// CHECK-DAG: !DIGlobalVariable(name: "glob_i16",{{.*}} scope: ![[TLC]],{{.*}} line: [[@LINE-1]],{{.*}} type: ![[I16:[^,]+]]
 var glob_i32:  Int32 = 32;
-// CHECK-DAG: !MDGlobalVariable(name: "glob_i32",{{.*}} scope: ![[TLC]],{{.*}} line: [[@LINE-1]],{{.*}} type: ![[I32:[^,]+]]
+// CHECK-DAG: !DIGlobalVariable(name: "glob_i32",{{.*}} scope: ![[TLC]],{{.*}} line: [[@LINE-1]],{{.*}} type: ![[I32:[^,]+]]
 var glob_i64:  Int64 = 64;
-// CHECK-DAG: !MDGlobalVariable(name: "glob_i64",{{.*}} scope: ![[TLC]],{{.*}} line: [[@LINE-1]],{{.*}} type: ![[I64:[^,]+]]
+// CHECK-DAG: !DIGlobalVariable(name: "glob_i64",{{.*}} scope: ![[TLC]],{{.*}} line: [[@LINE-1]],{{.*}} type: ![[I64:[^,]+]]
 var glob_f:    Float = 2.89;
-// CHECK-DAG: !MDGlobalVariable(name: "glob_f",{{.*}} scope: ![[TLC]],{{.*}} line: [[@LINE-1]],{{.*}} type: ![[F:[^,]+]]
+// CHECK-DAG: !DIGlobalVariable(name: "glob_f",{{.*}} scope: ![[TLC]],{{.*}} line: [[@LINE-1]],{{.*}} type: ![[F:[^,]+]]
 var glob_d:    Double = 3.14;
-// CHECK-DAG: !MDGlobalVariable(name: "glob_d",{{.*}} scope: ![[TLC]],{{.*}} line: [[@LINE-1]],{{.*}} type: ![[D:[^,]+]]
+// CHECK-DAG: !DIGlobalVariable(name: "glob_d",{{.*}} scope: ![[TLC]],{{.*}} line: [[@LINE-1]],{{.*}} type: ![[D:[^,]+]]
 var glob_b:    Bool = true
-// CHECK-DAG: !MDGlobalVariable(name: "glob_b",{{.*}} scope: ![[TLC]],{{.*}} line: [[@LINE-1]],{{.*}} type: ![[B:[^,]+]]
+// CHECK-DAG: !DIGlobalVariable(name: "glob_b",{{.*}} scope: ![[TLC]],{{.*}} line: [[@LINE-1]],{{.*}} type: ![[B:[^,]+]]
 var glob_s:    String = "😄"
-// CHECK-DAG: !MDGlobalVariable(name: "glob_s",{{.*}} scope: ![[TLC]],{{.*}} line: [[@LINE-1]],{{.*}} type: ![[S:[^,]+]]
+// CHECK-DAG: !DIGlobalVariable(name: "glob_s",{{.*}} scope: ![[TLC]],{{.*}} line: [[@LINE-1]],{{.*}} type: ![[S:[^,]+]]
 // FIXME: Dreadful type-checker performance prevents this from being this single
 // print expression:
 //   print("\(glob_v), \(glob_i8), \(glob_i16), \(glob_i32), \(glob_i64), \(glob_f), \(glob_d), \(glob_b), \(glob_s)")
@@ -46,9 +46,9 @@ var unused: Int32 = -1
 // Stack variables.
 func foo(dt: Float) -> Float {
   // CHECK-DAG: call void @llvm.dbg.declare
-  // CHECK-DAG: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "f"
+  // CHECK-DAG: !DILocalVariable(tag: DW_TAG_auto_variable, name: "f"
   var f: Float = 9.78;
-  // CHECK-DAG: !MDLocalVariable(tag: DW_TAG_auto_variable, name: "r"
+  // CHECK-DAG: !DILocalVariable(tag: DW_TAG_auto_variable, name: "r"
   var r: Float = f*dt;
   return r;
 }
@@ -57,11 +57,11 @@ var g = foo(1.0);
 
 // Tuple types.
 var tuple: (Int, Bool) = (1, true)
-// CHECK-DAG: !MDGlobalVariable(name: "tuple", linkageName: "_Tv{{9variables|4main}}5tupleTSiSb_",{{.*}} type: ![[TUPTY:[^,)]+]]
-// CHECK-DAG: !MDCompositeType(tag: DW_TAG_structure_type,{{.*}} elements: ![[ELEMS:[0-9]+]],{{.*}} identifier: [[TUPTY]]
+// CHECK-DAG: !DIGlobalVariable(name: "tuple", linkageName: "_Tv{{9variables|4main}}5tupleTSiSb_",{{.*}} type: ![[TUPTY:[^,)]+]]
+// CHECK-DAG: !DICompositeType(tag: DW_TAG_structure_type,{{.*}} elements: ![[ELEMS:[0-9]+]],{{.*}} identifier: [[TUPTY]]
 // CHECK-DAG: ![[ELEMS]] = !{![[MI64:[0-9]+]], ![[MB:[0-9]+]]}
-// CHECK-DAG: ![[MI64]] = !MDDerivedType(tag: DW_TAG_member,{{.*}} baseType: !"_TtSi"
-// CHECK-DAG: ![[MB]] = !MDDerivedType(tag: DW_TAG_member,{{.*}} baseType: ![[B]]
+// CHECK-DAG: ![[MI64]] = !DIDerivedType(tag: DW_TAG_member,{{.*}} baseType: !"_TtSi"
+// CHECK-DAG: ![[MB]] = !DIDerivedType(tag: DW_TAG_member,{{.*}} baseType: ![[B]]
 func println(p: (i: Int, b: Bool)) {
      println("\(p.i) -> \(p.b)")
 }
@@ -71,8 +71,8 @@ func println(p: (i: Int, b: Bool)) {
 println(tuple)
 
 // Arrays are represented as an instantiation of Array.
-// CHECK-DAG: !MDCompositeType(tag: DW_TAG_structure_type, name: "Array",{{.*}} identifier: [[Array:"[^"]+"]]
-// CHECK-DAG: !MDGlobalVariable(name: "array_of_tuples",{{.*}} type: ![[Array]]
+// CHECK-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "Array",{{.*}} identifier: [[Array:"[^"]+"]]
+// CHECK-DAG: !DIGlobalVariable(name: "array_of_tuples",{{.*}} type: ![[Array]]
 var array_of_tuples : [(a : Int, b : Int)] = [(1,2)]
 var twod : [[Int]] = [[1]]
 
@@ -80,9 +80,9 @@ func bar( x: [(a : Int, b : Int)], y: [[Int]] ) {
 }
 
 
-// CHECK-DAG: !MDGlobalVariable(name: "P",{{.*}} type: ![[PTY:[0-9]+]]
-// CHECK-DAG: !MDCompositeType(tag: DW_TAG_structure_type, name: "_TtT1xSd1ySd1zSd_",{{.*}} identifier: [[PTUP:[^,)]+]]
-// CHECK-DAG: ![[PTY]] = !MDDerivedType(tag: DW_TAG_typedef, name: "_Tta{{9variables|4main}}5Point",{{.*}} baseType: ![[PTUP]]
+// CHECK-DAG: !DIGlobalVariable(name: "P",{{.*}} type: ![[PTY:[0-9]+]]
+// CHECK-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "_TtT1xSd1ySd1zSd_",{{.*}} identifier: [[PTUP:[^,)]+]]
+// CHECK-DAG: ![[PTY]] = !DIDerivedType(tag: DW_TAG_typedef, name: "_Tta{{9variables|4main}}5Point",{{.*}} baseType: ![[PTUP]]
 typealias Point = (x: Double, y: Double, z: Double)
 var P:Point = (1, 2, 3)
 func println(p: (x: Double, y: Double, z: Double)) {
@@ -90,8 +90,8 @@ func println(p: (x: Double, y: Double, z: Double)) {
 }
 println(P)
 
-// CHECK-DAG: !MDGlobalVariable(name: "P2",{{.*}} type: ![[APTY:[0-9]+]]
-// CHECK-DAG: ![[APTY]] = !MDDerivedType(tag: DW_TAG_typedef, name: "_Tta{{9variables|4main}}13AliasForPoint",{{.*}} baseType: ![[PTY:[0-9]+]]
+// CHECK-DAG: !DIGlobalVariable(name: "P2",{{.*}} type: ![[APTY:[0-9]+]]
+// CHECK-DAG: ![[APTY]] = !DIDerivedType(tag: DW_TAG_typedef, name: "_Tta{{9variables|4main}}13AliasForPoint",{{.*}} baseType: ![[PTY:[0-9]+]]
 typealias AliasForPoint = Point
 var P2:AliasForPoint = (4, 5, 6)
 println(P2)
@@ -102,8 +102,8 @@ enum TriValue {
   case true_
   case top
 }
-// CHECK-DAG: !MDGlobalVariable(name: "unknown",{{.*}} type: !"_TtO{{9variables|4main}}8TriValue"
-// CHECK-DAG: !MDCompositeType(tag: DW_TAG_union_type, name: "TriValue", {{.*}}identifier: "_TtO{{9variables|4main}}8TriValue"
+// CHECK-DAG: !DIGlobalVariable(name: "unknown",{{.*}} type: !"_TtO{{9variables|4main}}8TriValue"
+// CHECK-DAG: !DICompositeType(tag: DW_TAG_union_type, name: "TriValue", {{.*}}identifier: "_TtO{{9variables|4main}}8TriValue"
 var unknown = TriValue.top
 func println(value: TriValue) {
      switch value {
@@ -114,4 +114,4 @@ func println(value: TriValue) {
 }
 println(unknown)
 
-// CHECK-DAG: !MDFile(filename: "variables.swift"
+// CHECK-DAG: !DIFile(filename: "variables.swift"

test/SILPasses/dead_inlined_func.swift

@@ -8,7 +8,7 @@
 // CHECK-IR-NOT: define {{.*}}to_be_inlined
 
 // But: we want debug info for it.
-// CHECK-IR: !MDSubprogram(name: "to_be_inlined"
+// CHECK-IR: !DISubprogram(name: "to_be_inlined"
 
 private func to_be_inlined(x: Int) -> Int {
 	return x + 1