[CodeGen][Dwarf] Generate global variable DIEs after all subprogram (and their abstract origin) DIEs

[jmmartinez]

Summary

In the case of static local variables, the associated DW_TAG_variable
child should be added in subprogram's DW_AT_abstract_origin in case
one exists.

To highlight the difference, compile and debug the following example with:

$ clang -g test.c -o a.out
$ gdb -ex "break g" -ex "run" -ex "print x" --args a.out

int __attribute__((always_inline)) g(int n) {
  static int x[10];
  int y = 1;
  return x[n] + y;
}
int f(int n) { return g(n); }
int main(int argc, char *argv[]) {
  return f(argc);
}

If the DIE for x is inserted as a child of the the DIE (with the tag DW_TAG_subprogram) associated to g,
then, when iterating over the inlined instructions of g we won't be
able to refer to x.

Annoyingly, this patch changes the order in which the dwarf info is
generated (which breaks way too many tests).

[jmmartinez]

I'm sorry about the huge diff. Changing the order in which the DIEs where generated changed the order in which they appear in the output, which breaks a lot of tests.

I'll pick up any advice into how to deal with this problem.

• I'm considered submitting an hybrid approach to reduce the size of the diff (but I'm not sure it's worth it). I could split the generation of the DIEs for globals in two, to avoid introducing a change in the order of so many tests:
  1. first for DIGlobalVariables whose scope is not a DISubprogram,
  2. then for globals whose scope is a DISubprogram.

• I introduced a test based on the C code I showed in the commit message (DebugInfo/X86/static-local-var.ll).

• There are still 6 remaining tests to fix...

[dblaikie]

This might have some overlap with all the work to scope non-instanced local entities (local statics and local types) that were reverted in 62a6b9e9ab3eb778111e90a34fee1e6a7c64db8a ?

Could we move the variable construction in one patch, then fix the functionality in a separate patch? will make it easier to review the mechanical changes separately from the semantic ones.

[jmmartinez]

In D141679#4052278, @dblaikie wrote:

This might have some overlap with all the work to scope non-instanced local entities (local statics and local types) that were reverted in 62a6b9e9ab3eb778111e90a34fee1e6a7c64db8a ?

Could we move the variable construction in one patch, then fix the functionality in a separate patch? will make it easier to review the mechanical changes separately from the semantic ones.

Thanks for pointing me to that patch. I took a quick look and it seems that the patch in https://reviews.llvm.org/D125693 does a much better job at addressing the issue.

I'm closing this patch.

[dblaikie]

In D141679#4056029, @jmmartinez wrote:

In D141679#4052278, @dblaikie wrote:

This might have some overlap with all the work to scope non-instanced local entities (local statics and local types) that were reverted in 62a6b9e9ab3eb778111e90a34fee1e6a7c64db8a ?

Could we move the variable construction in one patch, then fix the functionality in a separate patch? will make it easier to review the mechanical changes separately from the semantic ones.

Thanks for pointing me to that patch. I took a quick look and it seems that the patch in https://reviews.llvm.org/D125693 does a much better job at addressing the issue.

I'm closing this patch.

I will note that that patch series has stalled out - so if you're interested in this functionality, perhaps you'd be interested in trying to resurrect (either by getting the interest of the previous contributors, or commandeering the work/taking it on yourself) it.

[krisb]

@jmmartinez Just FYI, I'm going to resurrect/update the whole patchset related to D125693 in a week or two, and will appreciate any help in reviewing the patches.

[jmmartinez]

In D141679#4079682, @krisb wrote:

@jmmartinez Just FYI, I'm going to resurrect/update the whole patchset related to D125693 in a week or two, and will appreciate any help in reviewing the patches.

Sounds good to me. Please add me to the reviewers when you do that, I'd like to help.

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

DIE *DwarfCompileUnit::getOrCreateGlobalVariableDIE(
   if (DIE *Die = getDIE(GV))
     return Die;
 
   assert(GV);
 
   auto *GVContext = GV->getScope();
   const DIType *GTy = GV->getType();
 
-  auto *CB = GVContext ? dyn_cast<DICommonBlock>(GVContext) : nullptr;
-  DIE *ContextDIE = CB ? getOrCreateCommonBlock(CB, GlobalExprs)
-    : getOrCreateContextDIE(GVContext);
+  DIE *ContextDIE;
+  if (auto *CB = dyn_cast_or_null<DICommonBlock>(GVContext)) {
+    ContextDIE = getOrCreateCommonBlock(CB, GlobalExprs);
+  } else if (DIE *AbstractSP = getAbstractSPDies().lookup(GVContext)) {
+    ContextDIE = AbstractSP;
+  } else {
+    ContextDIE = getOrCreateContextDIE(GVContext);
+  }
 
   // Add to map.
   DIE *VariableDIE = &createAndAddDIE(GV->getTag(), *ContextDIE, GV);
   DIScope *DeclContext;
   if (auto *SDMDecl = GV->getStaticDataMemberDeclaration()) {
     DeclContext = SDMDecl->getScope();
     assert(SDMDecl->isStaticMember() && "Expected static member decl");
     assert(GV->isDefinition());

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h

class DwarfDebug : public DebugHandlerBase {
   DebugLocStream DebugLocs;
 
   /// This is a collection of subprogram MDNodes that are processed to
   /// create DIEs.
   SetVector<const DISubprogram *, SmallVector<const DISubprogram *, 16>,
             SmallPtrSet<const DISubprogram *, 16>>
       ProcessedSPNodes;
 
+  /// If nonnull, stores the current module we're processing.
+  const Module *CurModule = nullptr;
+
   /// If nonnull, stores the current machine function we're processing.
   const MachineFunction *CurFn = nullptr;
 
   /// If nonnull, stores the CU in which the previous subprogram was contained.
   const DwarfCompileUnit *PrevCU = nullptr;
 
   /// As an optimization, there is no need to emit an entry in the directory
   /// table for the same directory as DW_AT_comp_dir.
private:
   template <typename DataT>
   void addAccelNameImpl(const DICompileUnit &CU, AccelTable<DataT> &AppleAccel,
                         StringRef Name, const DIE &Die);
 
   void finishEntityDefinitions();
 
   void finishSubprogramDefinitions();
 
+  void createGlobalVariableDefinitions();
+
   /// Finish off debug information after all functions have been
   /// processed.
   void finalizeModuleInfo();
 
   /// Emit the debug info section.
   void emitDebugInfo();
 
   /// Emit the abbreviation section.

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

 // global DIEs and emit initial debug info sections. This is invoked by
 // the target AsmPrinter.
 void DwarfDebug::beginModule(Module *M) {
   DebugHandlerBase::beginModule(M);
 
   if (!Asm || !MMI->hasDebugInfo())
     return;
 
+  assert(!CurModule);
+  CurModule = M;
+
   unsigned NumDebugCUs = std::distance(M->debug_compile_units_begin(),
                                        M->debug_compile_units_end());
   assert(NumDebugCUs > 0 && "Asm unexpectedly initialized");
   assert(MMI->hasDebugInfo() &&
          "DebugInfoAvailabilty unexpectedly not initialized");
   SingleCU = NumDebugCUs == 1;
-  DenseMap<DIGlobalVariable *, SmallVector<DwarfCompileUnit::GlobalExpr, 1>>
-      GVMap;
-  for (const GlobalVariable &Global : M->globals()) {
-    SmallVector<DIGlobalVariableExpression *, 1> GVs;
-    Global.getDebugInfo(GVs);
-    for (auto *GVE : GVs)
-      GVMap[GVE->getVariable()].push_back({&Global, GVE->getExpression()});
-  }
 
   // Create the symbol that designates the start of the unit's contribution
   // to the string offsets table. In a split DWARF scenario, only the skeleton
   // unit has the DW_AT_str_offsets_base attribute (and hence needs the symbol).
   if (useSegmentedStringOffsetsTable())
     (useSplitDwarf() ? SkeletonHolder : InfoHolder)
         .setStringOffsetsStartSym(Asm->createTempSymbol("str_offsets_base"));
 
for (DICompileUnit *CUNode : M->debug_compile_units()) {
     // subprogram, then this search won't be needed and a
     // getImportedEntities().empty() test should go below with the rest.
     bool HasNonLocalImportedEntities = llvm::any_of(
         CUNode->getImportedEntities(), [](const DIImportedEntity *IE) {
           return !isa<DILocalScope>(IE->getScope());
         });
 
     if (!HasNonLocalImportedEntities && CUNode->getEnumTypes().empty() &&
-        CUNode->getRetainedTypes().empty() &&
-        CUNode->getGlobalVariables().empty() && CUNode->getMacros().empty())
+        CUNode->getRetainedTypes().empty() && CUNode->getMacros().empty())
       continue;
 
     DwarfCompileUnit &CU = getOrCreateDwarfCompileUnit(CUNode);
 
-    // Global Variables.
-    for (auto *GVE : CUNode->getGlobalVariables()) {
-      // Don't bother adding DIGlobalVariableExpressions listed in the CU if we
-      // already know about the variable and it isn't adding a constant
-      // expression.
-      auto &GVMapEntry = GVMap[GVE->getVariable()];
-      auto *Expr = GVE->getExpression();
-      if (!GVMapEntry.size() || (Expr && Expr->isConstant()))
-        GVMapEntry.push_back({nullptr, Expr});
-    }
-
-    DenseSet<DIGlobalVariable *> Processed;
-    for (auto *GVE : CUNode->getGlobalVariables()) {
-      DIGlobalVariable *GV = GVE->getVariable();
-      if (Processed.insert(GV).second)
-        CU.getOrCreateGlobalVariableDIE(GV, sortGlobalExprs(GVMap[GV]));
-    }
-
     for (auto *Ty : CUNode->getEnumTypes())
       CU.getOrCreateTypeDIE(cast<DIType>(Ty));
 
     for (auto *Ty : CUNode->getRetainedTypes()) {
       // The retained types array by design contains pointers to
       // MDNodes rather than DIRefs. Unique them here.
       if (DIType *RT = dyn_cast<DIType>(Ty))
         // There is no point in force-emitting a forward declaration.
void DwarfDebug::finishSubprogramDefinitions() {
   for (const DISubprogram *SP : ProcessedSPNodes) {
     assert(SP->getUnit()->getEmissionKind() != DICompileUnit::NoDebug);
     forBothCUs(
         getOrCreateDwarfCompileUnit(SP->getUnit()),
         [&](DwarfCompileUnit &CU) { CU.finishSubprogramDefinition(SP); });
   }
 }
 
+void DwarfDebug::createGlobalVariableDefinitions() {
+  // This function creates definitions for global variables, which may originate
+  // from static local variables in the source code. For static local variables,
+  // this step be done before finishing the subprogram definitions (as static
+  // locals may add a DW_TAG_variable child to the subprogram); and after all
+  // the subprograms abstract definitions have been created (in this case, the
+  // DW_TAG_variable child is added to the abstract definition and not to the
+  // subprogram's DIE).
+
+  if (!Asm || !MMI->hasDebugInfo())
+    return;
+
+  DenseMap<DIGlobalVariable *, SmallVector<DwarfCompileUnit::GlobalExpr, 1>>
+      GVMap;
+  for (const GlobalVariable &Global : CurModule->globals()) {
+    SmallVector<DIGlobalVariableExpression *, 1> GVs;
+    Global.getDebugInfo(GVs);
+    for (auto *GVE : GVs)
+      GVMap[GVE->getVariable()].push_back({&Global, GVE->getExpression()});
+  }
+
+  for (DICompileUnit *CUNode : CurModule->debug_compile_units()) {
+    if (CUNode->getGlobalVariables().empty())
+      continue;
+
+    DwarfCompileUnit &CU = getOrCreateDwarfCompileUnit(CUNode);
+    for (auto *GVE : CUNode->getGlobalVariables()) {
+      // Don't bother adding DIGlobalVariableExpressions listed in the CU if we
+      // already know about the variable and it isn't adding a constant
+      // expression.
+      auto &GVMapEntry = GVMap[GVE->getVariable()];
+      auto *Expr = GVE->getExpression();
+      if (!GVMapEntry.size() || (Expr && Expr->isConstant()))
+        GVMapEntry.push_back({nullptr, Expr});
+    }
+
+    DenseSet<DIGlobalVariable *> Processed;
+    for (auto *GVE : CUNode->getGlobalVariables()) {
+      DIGlobalVariable *GV = GVE->getVariable();
+      if (Processed.insert(GV).second)
+        CU.getOrCreateGlobalVariableDIE(GV, sortGlobalExprs(GVMap[GV]));
+    }
+  }
+}
+
 void DwarfDebug::finalizeModuleInfo() {
   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
 
   finishSubprogramDefinitions();
 
   finishEntityDefinitions();
 
   // Include the DWO file name in the hash if there's more than one CU.

 void DwarfDebug::endModule() {
   // Terminate the pending line table.
   if (PrevCU)
     terminateLineTable(PrevCU);
   PrevCU = nullptr;
   assert(CurFn == nullptr);
   assert(CurMI == nullptr);
 
+  createGlobalVariableDefinitions();
+
   for (const auto &P : CUMap) {
     auto &CU = *P.second;
     CU.createBaseTypeDIEs();
   }
 
   // If we aren't actually generating debug info (check beginModule -
   // conditionalized on the presence of the llvm.dbg.cu metadata node)
   if (!Asm || !MMI->hasDebugInfo())
void DwarfDebug::endModule() {
   case AccelTableKind::Default:
     llvm_unreachable("Default should have already been resolved.");
   }
 
   // Emit the pubnames and pubtypes sections if requested.
   emitDebugPubSections();
 
   // clean up.
+  CurModule = nullptr;
   // FIXME: AbstractVariables.clear();
 }
 
 void DwarfDebug::ensureAbstractEntityIsCreated(DwarfCompileUnit &CU,
                                                const DINode *Node,
                                                const MDNode *ScopeNode) {
   if (CU.getExistingAbstractEntity(Node))
     return;

llvm/test/DebugInfo/AMDGPU/variable-locations.ll

 ; RUN: llc -O0 -mtriple=amdgcn-amd-amdhsa -mcpu=fiji -verify-machineinstrs -filetype=obj < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ; LLVM IR generated with the following command and OpenCL source:
 ;
 ; $clang -cl-std=CL2.0 -g -O0 -target amdgcn-amd-amdhsa -S -emit-llvm <path-to-file>
 ;
 ; global int GlobA;
 ; global int GlobB;
 ;
 ; kernel void kernel1(unsigned int ArgN, global int  addrspace(5)*ArgA, global int  addrspace(5)*ArgB) {
 ;   ArgA[ArgN] += ArgB[ArgN];
 ; }
 
 declare void @llvm.dbg.declare(metadata, metadata, metadata)
 
-; CHECK: {{.*}}DW_TAG_variable
-; CHECK-NEXT: DW_AT_name {{.*}}"GlobA"
-; CHECK-NEXT: DW_AT_type
-; CHECK-NEXT: DW_AT_external
-; CHECK-NEXT: DW_AT_decl_file
-; CHECK-NEXT: DW_AT_decl_line
-; CHECK-NEXT: DW_AT_location [DW_FORM_block1] (DW_OP_addr 0x0)
 @GlobA = common addrspace(1) global i32 0, align 4, !dbg !0
 
-; CHECK: {{.*}}DW_TAG_variable
-; CHECK-NEXT: DW_AT_name {{.*}}"GlobB"
-; CHECK-NEXT: DW_AT_type
-; CHECK-NEXT: DW_AT_external
-; CHECK-NEXT: DW_AT_decl_file
-; CHECK-NEXT: DW_AT_decl_line
-; CHECK-NEXT: DW_AT_location [DW_FORM_block1] (DW_OP_addr 0x0)
 @GlobB = common addrspace(1) global i32 0, align 4, !dbg !6
 
 ; CHECK: {{.*}}DW_TAG_subprogram
 ; CHECK-NOT: DW_AT_frame_base
 
 define amdgpu_kernel void @kernel1(
 ; CHECK: {{.*}}DW_TAG_formal_parameter
 ; CHECK-NEXT: DW_AT_location [DW_FORM_block1] (DW_OP_fbreg +4, DW_OP_lit1, DW_OP_swap, DW_OP_xderef)
entry:
   %idxprom1 = zext i32 %4 to i64, !dbg !31
   %arrayidx2 = getelementptr inbounds i32, ptr addrspace(1) %3, i64 %idxprom1, !dbg !31
   %5 = load i32, ptr addrspace(1) %arrayidx2, align 4, !dbg !33
   %add = add nsw i32 %5, %2, !dbg !33
   store i32 %add, ptr addrspace(1) %arrayidx2, align 4, !dbg !33
   ret void, !dbg !34
 }
 
+; CHECK: {{.*}}DW_TAG_variable
+; CHECK-NEXT: DW_AT_name {{.*}}"GlobA"
+; CHECK-NEXT: DW_AT_type
+; CHECK-NEXT: DW_AT_external
+; CHECK-NEXT: DW_AT_decl_file
+; CHECK-NEXT: DW_AT_decl_line
+; CHECK-NEXT: DW_AT_location [DW_FORM_block1] (DW_OP_addr 0x0)
+
+; CHECK: {{.*}}DW_TAG_variable
+; CHECK-NEXT: DW_AT_name {{.*}}"GlobB"
+; CHECK-NEXT: DW_AT_type
+; CHECK-NEXT: DW_AT_external
+; CHECK-NEXT: DW_AT_decl_file
+; CHECK-NEXT: DW_AT_decl_line
+; CHECK-NEXT: DW_AT_location [DW_FORM_block1] (DW_OP_addr 0x0)
+
 !llvm.dbg.cu = !{!2}
 !opencl.ocl.version = !{!9}
 !llvm.module.flags = !{!10, !11}
 !llvm.ident = !{!12}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "GlobA", scope: !2, file: !3, line: 1, type: !8, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 5.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)

llvm/test/DebugInfo/BPF/extern-void.ll

entry:
   ret ptr @bla2, !dbg !28
 }
 
 ; CHECK:        .quad bla1
 ; CHECK-NEXT:   DW_TAG_variable
 ;
 ; CHECK:        .quad   bla2
 ; CHECK-NEXT:   DW_TAG_const_type
-; CHECK-NEXT:   DW_TAG_subprogram
 
 ; Function Attrs: nounwind readnone speculatable willreturn
 declare void @llvm.dbg.value(metadata, metadata, metadata) #1
 
 attributes #0 = { norecurse nounwind readnone "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 attributes #1 = { nounwind readnone speculatable willreturn }
 
 !llvm.dbg.cu = !{!2}

llvm/test/DebugInfo/Generic/cross-cu-linkonce-distinct.ll

 ; inline int func(int i) {
 ;   return i * 2;
 ; }
 ; int (*y)(int) = &func;
 
 ; The DISubprogram should show up in compile unit a.
 ; CHECK: DW_TAG_compile_unit
 ; CHECK-NOT: DW_TAG
-; CHECK:    DW_AT_name ("b.cpp")
-; CHECK-NOT: DW_TAG_subprogram
+; CHECK:     DW_AT_name ("a.cpp")
+; CHECK:     DW_AT_name ("func")
 
 ; CHECK: DW_TAG_compile_unit
 ; CHECK-NOT: DW_TAG
-; CHECK:     DW_AT_name ("a.cpp")
-; CHECK:     DW_AT_name ("func")
+; CHECK:    DW_AT_name ("b.cpp")
+; CHECK-NOT: DW_TAG_subprogram
 
 source_filename = "test/DebugInfo/Generic/cross-cu-linkonce-distinct.ll"
 
 @x = global ptr @_Z4funci, align 8, !dbg !0
 @y = global ptr @_Z4funci, align 8, !dbg !7
 
 ; Function Attrs: inlinehint nounwind uwtable
 define linkonce_odr i32 @_Z4funci(i32 %i) #0 !dbg !18 {

llvm/test/DebugInfo/Generic/debug-names-linkage-name.ll

 ; XFAIL: target={{.*}}-aix{{.*}}
 ; Generate one file with all linkage names, and another with only abstract ones.
 ; Then test both.
 ; RUN: %llc_dwarf -accel-tables=Dwarf -dwarf-linkage-names=All -filetype=obj -o %t.All < %s
 ; RUN: %llc_dwarf -accel-tables=Dwarf -dwarf-linkage-names=Abstract -filetype=obj -o %t.Abstract < %s
 ; RUN: llvm-dwarfdump -debug-info -debug-names %t.All | FileCheck %s --check-prefix=ALL
 ; RUN: llvm-dwarfdump -debug-info -debug-names %t.Abstract \
 ; RUN:   | FileCheck %s --check-prefix=ABSTRACT --implicit-check-not=_Z1gi --implicit-check-not=_ZN1n1vE 
 ; RUN: llvm-dwarfdump -debug-names -verify %t.All | FileCheck --check-prefix=VERIFY %s
 ; RUN: llvm-dwarfdump -debug-names -verify %t.Abstract | FileCheck --check-prefix=VERIFY %s
 
 ; We should have all three linkage names in the .debug_info and .debug_names
 ; ALL: .debug_info contents:
-; ALL: DW_AT_linkage_name ("_ZN1n1vE")
 ; ALL: DW_AT_linkage_name ("_Z1fi")
 ; ALL: DW_AT_linkage_name ("_Z1gi")
+; ALL: DW_AT_linkage_name ("_ZN1n1vE")
 ; ALL: .debug_names contents:
 ; ALL: String: {{.*}} "_Z1fi"
 ; ALL: String: {{.*}} "_Z1gi"
 ; ALL: String: {{.*}} "_ZN1n1vE"
 
 ; Only _Z1fi should be present in both sections
 ; ABSTRACT: .debug_info contents:
 ; ABSTRACT: DW_AT_linkage_name  ("_Z1fi")

llvm/test/DebugInfo/Generic/namespace.ll

 ; RUN: %llc_dwarf -O0 -filetype=obj -dwarf-linkage-names=All < %s | llvm-dwarfdump - | FileCheck %s --implicit-check-not "{{DW_TAG|NULL}}"
 
 ; CHECK: debug_info contents
 ; CHECK:DW_TAG_compile_unit
 
 ; CHECK: [[NS1:0x[0-9a-f]*]]:{{ *}}DW_TAG_namespace
 ; CHECK:   DW_AT_name ("A")
 ; CHECK-NOT: DW_AT_decl_file
 ; CHECK-NOT: DW_AT_decl_line
 
 ; CHECK: [[NS2:0x[0-9a-f]*]]:{{ *}}DW_TAG_namespace
 ; CHECK:   DW_AT_name ("B")
 ; CHECK-NOT: DW_AT_decl_file
 ; CHECK-NOT: DW_AT_decl_line
 
-; CHECK: [[I:0x[0-9a-f]*]]:{{ *}}DW_TAG_variable
-; CHECK:   DW_AT_name ("i")
-; CHECK: [[VAR_FWD:0x[0-9a-f]*]]:{{ *}}DW_TAG_variable
-; CHECK:   DW_AT_name ("var_fwd")
-
 ; CHECK: [[FOO:0x[0-9a-f]*]]:{{ *}}DW_TAG_structure_type
 ; CHECK:   DW_AT_name ("foo")
 ; CHECK:   DW_AT_declaration
 ; CHECK: [[BAR:0x[0-9a-f]*]]:{{ *}}DW_TAG_structure_type
 ; CHECK:   DW_AT_name ("bar")
+; CHECK: [[I:0x[0-9a-f]*]]:{{ *}}DW_TAG_variable
+; CHECK:   DW_AT_name ("i")
 
 ; CHECK: DW_TAG_subprogram
 ; CHECK:   DW_AT_MIPS_linkage_name
 ; CHECK:   DW_AT_name ("f1")
 ; CHECK: [[FUNC1:.*]]: DW_TAG_subprogram
 ; CHECK:   DW_AT_MIPS_linkage_name
 ; CHECK:   DW_AT_name ("f1")
 ; CHECK:   DW_TAG_formal_parameter
 ; CHECK:   NULL
 
 ; CHECK: [[BAZ:0x[0-9a-f]*]]:{{.*}}DW_TAG_typedef
 ; CHECK:   DW_AT_name ("baz")
 
 ; CHECK: [[VAR_DECL:0x[0-9a-f]*]]:{{.*}}DW_TAG_variable
 ; CHECK:   DW_AT_name ("var_decl")
 ; CHECK:   DW_AT_declaration
 
 ; CHECK: [[FUNC_DECL:0x[0-9a-f]*]]:{{.*}}DW_TAG_subprogram
 ; CHECK:   DW_AT_name ("func_decl")
 ; CHECK:   DW_AT_declaration
 
+; CHECK: [[VAR_FWD:0x[0-9a-f]*]]:{{ *}}DW_TAG_variable
+; CHECK:   DW_AT_name ("var_fwd")
+
 ; CHECK: [[FUNC_FWD:0x[0-9a-f]*]]:{{.*}}DW_TAG_subprogram
 ; CHECK:   DW_AT_name ("func_fwd")
 ; CHECK-NOT: DW_AT_declaration
 ; CHECK: NULL
 
 ; CHECK: DW_TAG_imported_module
 ; CHECK:   DW_AT_decl_file ([[F2:.*]])
 ; CHECK:   DW_AT_decl_line (15)
 ; CHECK:   DW_AT_import ([[NS2]])
 ; CHECK: DW_TAG_imported_declaration
 ; CHECK: NULL
 
-; CHECK: DW_TAG_base_type
 ; CHECK: DW_TAG_imported_module
 ; CHECK:   DW_AT_decl_file ([[F2:.*]])
 ; CHECK:   DW_AT_decl_line (18)
 ; CHECK:   DW_AT_import ([[NS1]])
 ; CHECK: DW_TAG_imported_declaration
 
+; CHECK: DW_TAG_base_type
+
 ; CHECK: DW_TAG_subprogram
 ; CHECK: DW_TAG_subprogram
 ; CHECK:   DW_AT_MIPS_linkage_name
 ; CHECK:   DW_AT_name ("func")
 ; CHECK:   DW_TAG_formal_parameter
 ; CHECK:   DW_TAG_imported_module
 ; CHECK:     DW_AT_decl_file ([[F2:.*]])
 ; CHECK:     DW_AT_decl_line (26)

llvm/test/DebugInfo/NVPTX/debug-addr-class.ll

 !34 = !DILocation(line: 7, column: 3, scope: !17)
 !35 = !DILocation(line: 7, column: 5, scope: !17)
 !36 = !DILocation(line: 7, column: 8, scope: !17)
 !37 = !DILocation(line: 8, column: 10, scope: !17)
 !38 = !DILocation(line: 9, column: 10, scope: !17)
 !39 = !DILocation(line: 10, column: 1, scope: !17)
 !40 = !{!22, !24, !26, !28}
 
-; CHECK:        .section        .debug_abbrev
+; CHECK:        .section   .debug_abbrev
 ; CHECK-NEXT:        {
 ; CHECK-NEXT:.b8 1                                   // Abbreviation Code
 ; CHECK-NEXT:.b8 17                                  // DW_TAG_compile_unit
 ; CHECK-NEXT:.b8 1                                   // DW_CHILDREN_yes
 ; CHECK-NEXT:.b8 37                                  // DW_AT_producer
 ; CHECK-NEXT:.b8 8                                   // DW_FORM_string
 ; CHECK-NEXT:.b8 19                                  // DW_AT_language
 ; CHECK-NEXT:.b8 5                                   // DW_FORM_data2
 ; CHECK-NEXT:.b8 3                                   // DW_AT_name
 ; CHECK-NEXT:.b8 8                                   // DW_FORM_string
 ; CHECK-NEXT:.b8 16                                  // DW_AT_stmt_list
 ; CHECK-NEXT:.b8 6                                   // DW_FORM_data4
 ; CHECK-NEXT:.b8 27                                  // DW_AT_comp_dir
 ; CHECK-NEXT:.b8 8                                   // DW_FORM_string
 ; CHECK-NEXT:.b8 17                                  // DW_AT_low_pc
 ; CHECK-NEXT:.b8 1                                   // DW_FORM_addr
 ; CHECK-NEXT:.b8 18                                  // DW_AT_high_pc
 ; CHECK-NEXT:.b8 1                                   // DW_FORM_addr
 ; CHECK-NEXT:.b8 0                                   // EOM(1)
 ; CHECK-NEXT:.b8 0                                   // EOM(2)
 ; CHECK-NEXT:.b8 2                                   // Abbreviation Code
-; CHECK-NEXT:.b8 52                                  // DW_TAG_variable
-; CHECK-NEXT:.b8 0                                   // DW_CHILDREN_no
-; CHECK-NEXT:.b8 3                                   // DW_AT_name
-; CHECK-NEXT:.b8 8                                   // DW_FORM_string
-; CHECK-NEXT:.b8 73                                  // DW_AT_type
-; CHECK-NEXT:.b8 19                                  // DW_FORM_ref4
-; CHECK-NEXT:.b8 63                                  // DW_AT_external
-; CHECK-NEXT:.b8 12                                  // DW_FORM_flag
-; CHECK-NEXT:.b8 58                                  // DW_AT_decl_file
-; CHECK-NEXT:.b8 11                                  // DW_FORM_data1
-; CHECK-NEXT:.b8 59                                  // DW_AT_decl_line
-; CHECK-NEXT:.b8 11                                  // DW_FORM_data1
-; CHECK-NEXT:.b8 51                                  // DW_AT_address_class
-; CHECK-NEXT:.b8 11                                  // DW_FORM_data1
-; CHECK-NEXT:.b8 2                                   // DW_AT_location
-; CHECK-NEXT:.b8 10                                  // DW_FORM_block1
-; CHECK-NEXT:.b8 0                                   // EOM(1)
-; CHECK-NEXT:.b8 0                                   // EOM(2)
-; CHECK-NEXT:.b8 3                                   // Abbreviation Code
-; CHECK-NEXT:.b8 36                                  // DW_TAG_base_type
-; CHECK-NEXT:.b8 0                                   // DW_CHILDREN_no
-; CHECK-NEXT:.b8 3                                   // DW_AT_name
-; CHECK-NEXT:.b8 8                                   // DW_FORM_string
-; CHECK-NEXT:.b8 62                                  // DW_AT_encoding
-; CHECK-NEXT:.b8 11                                  // DW_FORM_data1
-; CHECK-NEXT:.b8 11                                  // DW_AT_byte_size
-; CHECK-NEXT:.b8 11                                  // DW_FORM_data1
-; CHECK-NEXT:.b8 0                                   // EOM(1)
-; CHECK-NEXT:.b8 0                                   // EOM(2)
-; CHECK-NEXT:.b8 4                                   // Abbreviation Code
 ; CHECK-NEXT:.b8 46                                  // DW_TAG_subprogram
 ; CHECK-NEXT:.b8 1                                   // DW_CHILDREN_yes
 ; CHECK-NEXT:.b8 17                                  // DW_AT_low_pc
 ; CHECK-NEXT:.b8 1                                   // DW_FORM_addr
 ; CHECK-NEXT:.b8 18                                  // DW_AT_high_pc
 ; CHECK-NEXT:.b8 1                                   // DW_FORM_addr
 ; CHECK-NEXT:.b8 64                                  // DW_AT_frame_base
 ; CHECK-NEXT:.b8 10                                  // DW_FORM_block1
 ; CHECK-NEXT:.b8 135                                 // DW_AT_MIPS_linkage_name
 ; CHECK-NEXT:.b8 64
 ; CHECK-NEXT:.b8 8                                   // DW_FORM_string
 ; CHECK-NEXT:.b8 3                                   // DW_AT_name
 ; CHECK-NEXT:.b8 8                                   // DW_FORM_string
 ; CHECK-NEXT:.b8 58                                  // DW_AT_decl_file
 ; CHECK-NEXT:.b8 11                                  // DW_FORM_data1
 ; CHECK-NEXT:.b8 59                                  // DW_AT_decl_line
 ; CHECK-NEXT:.b8 11                                  // DW_FORM_data1
 ; CHECK-NEXT:.b8 63                                  // DW_AT_external
 ; CHECK-NEXT:.b8 12                                  // DW_FORM_flag
 ; CHECK-NEXT:.b8 0                                   // EOM(1)
 ; CHECK-NEXT:.b8 0                                   // EOM(2)
-; CHECK-NEXT:.b8 5                                   // Abbreviation Code
+; CHECK-NEXT:.b8 3                                   // Abbreviation Code
 ; CHECK-NEXT:.b8 5                                   // DW_TAG_formal_parameter
 ; CHECK-NEXT:.b8 0                                   // DW_CHILDREN_no
 ; CHECK-NEXT:.b8 3                                   // DW_AT_name
 ; CHECK-NEXT:.b8 8                                   // DW_FORM_string
 ; CHECK-NEXT:.b8 58                                  // DW_AT_decl_file
 ; CHECK-NEXT:.b8 11                                  // DW_FORM_data1
 ; CHECK-NEXT:.b8 59                                  // DW_AT_decl_line
 ; CHECK-NEXT:.b8 11                                  // DW_FORM_data1
 ; CHECK-NEXT:.b8 73                                  // DW_AT_type
 ; CHECK-NEXT:.b8 19                                  // DW_FORM_ref4
 ; CHECK-NEXT:.b8 0                                   // EOM(1)
 ; CHECK-NEXT:.b8 0                                   // EOM(2)
+; CHECK-NEXT:.b8 4                                   // Abbreviation Code
+; CHECK-NEXT:.b8 52                                  // DW_TAG_variable
+; CHECK-NEXT:.b8 0                                   // DW_CHILDREN_no
+; CHECK-NEXT:.b8 3                                   // DW_AT_name
+; CHECK-NEXT:.b8 8                                   // DW_FORM_string
+; CHECK-NEXT:.b8 73                                  // DW_AT_type
+; CHECK-NEXT:.b8 19                                  // DW_FORM_ref4
+; CHECK-NEXT:.b8 63                                  // DW_AT_external
+; CHECK-NEXT:.b8 12                                  // DW_FORM_flag
+; CHECK-NEXT:.b8 58                                  // DW_AT_decl_file
+; CHECK-NEXT:.b8 11                                  // DW_FORM_data1
+; CHECK-NEXT:.b8 59                                  // DW_AT_decl_line
+; CHECK-NEXT:.b8 11                                  // DW_FORM_data1
+; CHECK-NEXT:.b8 51                                  // DW_AT_address_class
+; CHECK-NEXT:.b8 11                                  // DW_FORM_data1
+; CHECK-NEXT:.b8 2                                   // DW_AT_location
+; CHECK-NEXT:.b8 10                                  // DW_FORM_block1
+; CHECK-NEXT:.b8 0                                   // EOM(1)
+; CHECK-NEXT:.b8 0                                   // EOM(2)
+; CHECK-NEXT:.b8 5                                   // Abbreviation Code
+; CHECK-NEXT:.b8 36                                  // DW_TAG_base_type
+; CHECK-NEXT:.b8 0                                   // DW_CHILDREN_no
+; CHECK-NEXT:.b8 3                                   // DW_AT_name
+; CHECK-NEXT:.b8 8                                   // DW_FORM_string
+; CHECK-NEXT:.b8 62                                  // DW_AT_encoding
+; CHECK-NEXT:.b8 11                                  // DW_FORM_data1
+; CHECK-NEXT:.b8 11                                  // DW_AT_byte_size
+; CHECK-NEXT:.b8 11                                  // DW_FORM_data1
+; CHECK-NEXT:.b8 0                                   // EOM(1)
+; CHECK-NEXT:.b8 0                                   // EOM(2)
 ; CHECK-NEXT:.b8 6                                   // Abbreviation Code
 ; CHECK-NEXT:.b8 15                                  // DW_TAG_pointer_type
 ; CHECK-NEXT:.b8 0                                   // DW_CHILDREN_no
 ; CHECK-NEXT:.b8 73                                  // DW_AT_type
 ; CHECK-NEXT:.b8 19                                  // DW_FORM_ref4
 ; CHECK-NEXT:.b8 0                                   // EOM(1)
 ; CHECK-NEXT:.b8 0                                   // EOM(2)
 ; CHECK-NEXT:.b8 0                                   // EOM(3)
-; CHECK-NEXT:        }
-; CHECK-NEXT:        .section        .debug_info
-; CHECK-NEXT:        {
+; CHECK-NEXT: }
+; CHECK-NEXT: .section  .debug_info
+; CHECK-NEXT: {
 ; CHECK-NEXT:.b32 240                                // Length of Unit
 ; CHECK-NEXT:.b8 2                                   // DWARF version number
 ; CHECK-NEXT:.b8 0
 ; CHECK-NEXT:.b32 .debug_abbrev                      // Offset Into Abbrev. Section
 ; CHECK-NEXT:.b8 8                                   // Address Size (in bytes)
 ; CHECK-NEXT:.b8 1                                   // Abbrev [1] 0xb:0xe9 DW_TAG_compile_unit
 ; CHECK-NEXT:.b8 99                                  // DW_AT_producer
 ; CHECK-NEXT:.b8 108

 ; CHECK-NEXT:.b32 .debug_line                        // DW_AT_stmt_list
 ; CHECK-NEXT:.b8 47                                  // DW_AT_comp_dir
 ; CHECK-NEXT:.b8 116
 ; CHECK-NEXT:.b8 109
 ; CHECK-NEXT:.b8 112
 ; CHECK-NEXT:.b8 0
 ; CHECK-NEXT:.b64 $L__func_begin0                    // DW_AT_low_pc
 ; CHECK-NEXT:.b64 $L__func_end0                      // DW_AT_high_pc
-; CHECK-NEXT:.b8 2                                   // Abbrev [2] 0x65:0x1a DW_TAG_variable
-; CHECK-NEXT:.b8 71                                  // DW_AT_name
-; CHECK-NEXT:.b8 76
-; CHECK-NEXT:.b8 79
-; CHECK-NEXT:.b8 66
-; CHECK-NEXT:.b8 65
-; CHECK-NEXT:.b8 76
-; CHECK-NEXT:.b8 0
-; CHECK-NEXT:.b32 127                                // DW_AT_type
-; CHECK-NEXT:.b8 1                                   // DW_AT_external
-; CHECK-NEXT:.b8 1                                   // DW_AT_decl_file
-; CHECK-NEXT:.b8 3                                   // DW_AT_decl_line
-; CHECK-NEXT:.b8 5                                   // DW_AT_address_class
-; CHECK-NEXT:.b8 9                                   // DW_AT_location
-; CHECK-NEXT:.b8 3
-; CHECK-NEXT:.b64 GLOBAL
-; CHECK-NEXT:.b8 3                                   // Abbrev [3] 0x7f:0x7 DW_TAG_base_type
-; CHECK-NEXT:.b8 105                                 // DW_AT_name
-; CHECK-NEXT:.b8 110
-; CHECK-NEXT:.b8 116
-; CHECK-NEXT:.b8 0
-; CHECK-NEXT:.b8 5                                   // DW_AT_encoding
-; CHECK-NEXT:.b8 4                                   // DW_AT_byte_size
-; CHECK-NEXT:.b8 2                                   // Abbrev [2] 0x86:0x1a DW_TAG_variable
-; CHECK-NEXT:.b8 83                                  // DW_AT_name
-; CHECK-NEXT:.b8 72
-; CHECK-NEXT:.b8 65
-; CHECK-NEXT:.b8 82
-; CHECK-NEXT:.b8 69
-; CHECK-NEXT:.b8 68
-; CHECK-NEXT:.b8 0
-; CHECK-NEXT:.b32 127                                // DW_AT_type
-; CHECK-NEXT:.b8 1                                   // DW_AT_external
-; CHECK-NEXT:.b8 1                                   // DW_AT_decl_file
-; CHECK-NEXT:.b8 4                                   // DW_AT_decl_line
-; CHECK-NEXT:.b8 8                                   // DW_AT_address_class
-; CHECK-NEXT:.b8 9                                   // DW_AT_location
-; CHECK-NEXT:.b8 3
-; CHECK-NEXT:.b64 SHARED
-; CHECK-NEXT:.b8 4                                   // Abbrev [4] 0xa0:0x45 DW_TAG_subprogram
+; CHECK-NEXT:.b8 2                                   // Abbrev [2] 0x65:0x45 DW_TAG_subprogram
 ; CHECK-NEXT:.b64 $L__func_begin0                    // DW_AT_low_pc
 ; CHECK-NEXT:.b64 $L__func_end0                      // DW_AT_high_pc
 ; CHECK-NEXT:.b8 1                                   // DW_AT_frame_base
 ; CHECK-NEXT:.b8 156
 ; CHECK-NEXT:.b8 116                                 // DW_AT_MIPS_linkage_name
 ; CHECK-NEXT:.b8 101
 ; CHECK-NEXT:.b8 115
 ; CHECK-NEXT:.b8 116
 ; CHECK-NEXT:.b8 0
 ; CHECK-NEXT:.b8 116                                 // DW_AT_name
 ; CHECK-NEXT:.b8 101
 ; CHECK-NEXT:.b8 115
 ; CHECK-NEXT:.b8 116
 ; CHECK-NEXT:.b8 0
 ; CHECK-NEXT:.b8 1                                   // DW_AT_decl_file
 ; CHECK-NEXT:.b8 6                                   // DW_AT_decl_line
 ; CHECK-NEXT:.b8 1                                   // DW_AT_external
-; CHECK-NEXT:.b8 5                                   // Abbrev [5] 0xc0:0x9 DW_TAG_formal_parameter
+; CHECK-NEXT:.b8 3                                   // Abbrev [3] 0x85:0x9 DW_TAG_formal_parameter
 ; CHECK-NEXT:.b8 97                                  // DW_AT_name
 ; CHECK-NEXT:.b8 0
 ; CHECK-NEXT:.b8 1                                   // DW_AT_decl_file
 ; CHECK-NEXT:.b8 6                                   // DW_AT_decl_line
 ; CHECK-NEXT:.b32 229                                // DW_AT_type
-; CHECK-NEXT:.b8 5                                   // Abbrev [5] 0xc9:0x9 DW_TAG_formal_parameter
+; CHECK-NEXT:.b8 3                                   // Abbrev [3] 0x8e:0x9 DW_TAG_formal_parameter
 ; CHECK-NEXT:.b8 120                                 // DW_AT_name
 ; CHECK-NEXT:.b8 0
 ; CHECK-NEXT:.b8 1                                   // DW_AT_decl_file
 ; CHECK-NEXT:.b8 6                                   // DW_AT_decl_line
 ; CHECK-NEXT:.b32 238                                // DW_AT_type
-; CHECK-NEXT:.b8 5                                   // Abbrev [5] 0xd2:0x9 DW_TAG_formal_parameter
+; CHECK-NEXT:.b8 3                                   // Abbrev [3] 0x97:0x9 DW_TAG_formal_parameter
 ; CHECK-NEXT:.b8 121                                 // DW_AT_name
 ; CHECK-NEXT:.b8 0
 ; CHECK-NEXT:.b8 1                                   // DW_AT_decl_file
 ; CHECK-NEXT:.b8 6                                   // DW_AT_decl_line
 ; CHECK-NEXT:.b32 238                                // DW_AT_type
-; CHECK-NEXT:.b8 5                                   // Abbrev [5] 0xdb:0x9 DW_TAG_formal_parameter
+; CHECK-NEXT:.b8 3                                   // Abbrev [3] 0xa0:0x9 DW_TAG_formal_parameter
 ; CHECK-NEXT:.b8 105                                 // DW_AT_name
 ; CHECK-NEXT:.b8 0
 ; CHECK-NEXT:.b8 1                                   // DW_AT_decl_file
 ; CHECK-NEXT:.b8 6                                   // DW_AT_decl_line
-; CHECK-NEXT:.b32 127                                // DW_AT_type
+; CHECK-NEXT:.b32 196                                // DW_AT_type
 ; CHECK-NEXT:.b8 0                                   // End Of Children Mark
-; CHECK-NEXT:.b8 3                                   // Abbrev [3] 0xe5:0x9 DW_TAG_base_type
+; CHECK-NEXT:.b8 4                                   // Abbrev [4] 0xaa:0x1a DW_TAG_variable
+; CHECK-NEXT:.b8 71                                  // DW_AT_name
+; CHECK-NEXT:.b8 76
+; CHECK-NEXT:.b8 79
+; CHECK-NEXT:.b8 66
+; CHECK-NEXT:.b8 65
+; CHECK-NEXT:.b8 76
+; CHECK-NEXT:.b8 0
+; CHECK-NEXT:.b32 196                                // DW_AT_type
+; CHECK-NEXT:.b8 1                                   // DW_AT_external
+; CHECK-NEXT:.b8 1                                   // DW_AT_decl_file
+; CHECK-NEXT:.b8 3                                   // DW_AT_decl_line
+; CHECK-NEXT:.b8 5                                   // DW_AT_address_class
+; CHECK-NEXT:.b8 9                                   // DW_AT_location
+; CHECK-NEXT:.b8 3
+; CHECK-NEXT:.b64 GLOBAL
+; CHECK-NEXT:.b8 5                                   // Abbrev [5] 0xc4:0x7 DW_TAG_base_type
+; CHECK-NEXT:.b8 105                                 // DW_AT_name
+; CHECK-NEXT:.b8 110
+; CHECK-NEXT:.b8 116
+; CHECK-NEXT:.b8 0
+; CHECK-NEXT:.b8 5                                   // DW_AT_encoding
+; CHECK-NEXT:.b8 4                                   // DW_AT_byte_size
+; CHECK-NEXT:.b8 4                                   // Abbrev [4] 0xcb:0x1a DW_TAG_variable
+; CHECK-NEXT:.b8 83                                  // DW_AT_name
+; CHECK-NEXT:.b8 72
+; CHECK-NEXT:.b8 65
+; CHECK-NEXT:.b8 82
+; CHECK-NEXT:.b8 69
+; CHECK-NEXT:.b8 68
+; CHECK-NEXT:.b8 0
+; CHECK-NEXT:.b32 196                                // DW_AT_type
+; CHECK-NEXT:.b8 1                                   // DW_AT_external
+; CHECK-NEXT:.b8 1                                   // DW_AT_decl_file
+; CHECK-NEXT:.b8 4                                   // DW_AT_decl_line
+; CHECK-NEXT:.b8 8                                   // DW_AT_address_class
+; CHECK-NEXT:.b8 9                                   // DW_AT_location
+; CHECK-NEXT:.b8 3
+; CHECK-NEXT:.b64 SHARED
+; CHECK-NEXT:.b8 5                                   // Abbrev [5] 0xe5:0x9 DW_TAG_base_type
 ; CHECK-NEXT:.b8 102                                 // DW_AT_name
 ; CHECK-NEXT:.b8 108
 ; CHECK-NEXT:.b8 111
 ; CHECK-NEXT:.b8 97
 ; CHECK-NEXT:.b8 116
 ; CHECK-NEXT:.b8 0
 ; CHECK-NEXT:.b8 4                                   // DW_AT_encoding
 ; CHECK-NEXT:.b8 4                                   // DW_AT_byte_size
 ; CHECK-NEXT:.b8 6                                   // Abbrev [6] 0xee:0x5 DW_TAG_pointer_type
 ; CHECK-NEXT:.b32 229                                // DW_AT_type
 ; CHECK-NEXT:.b8 0                                   // End Of Children Mark
 ; CHECK-NEXT:        }
-; CHECK-NEXT:         .section        .debug_loc      {       }
-; CHECK-NOT: debug_
+; CHECK-NEXT:         .section        .debug_loc      {         }
+; CHECK-NOT: debug_
 No newline at end of file

llvm/test/DebugInfo/PowerPC/strict-dwarf.ll

 ; is also right for attribute 0.
 ; For this case, the location attribute adding is for global variable @_ZL3var
 ; and the call chain to addUInt() is:
 ; 1: DwarfCompileUnit::addLocationAttribute()
 ; 2: DwarfUnit::addOpAddress()
 ; 3: DwarfUnit::addUInt()
 ; 4: addUInt(Block, (dwarf::Attribute)0, Form, Integer);
 
+; CHECK: DW_TAG_subprogram
+; CHECK-NOT: DW_TAG_
+; CHECK: DW_AT_name      ("f")
+; CHECK: DW_AT_noreturn
+;
+; CHECK: DW_TAG_variable
 ; CHECK: DW_AT_name      ("var")
 ; CHECK-NOT: DW_TAG_
 ; CHECK: DW_AT_alignment
 ; CHECK: DW_AT_location  (DW_OP_addr 0x0)
-; CHECK: DW_AT_noreturn
+
+; STRICT: DW_TAG_subprogram
+; STRICT-NOT: DW_TAG_
+; STRICT: DW_AT_name      ("f")
+; STRICT-NOT: DW_AT_noreturn
 ;
 ; STRICT: DW_AT_name      ("var")
 ; STRICT-NOT: DW_AT_alignment
 ; STRICT-NOT: DW_TAG_
 ; STRICT: DW_AT_location  (DW_OP_addr 0x0)
+;
 ; STRICT-NOT: DW_AT_noreturn
 
 @_ZL3var = internal global i32 0, align 16, !dbg !0
 
 ; Function Attrs: noinline noreturn optnone uwtable mustprogress
 define dso_local void @_Z1fv() #0 !dbg !12 {
 entry:
   call void @_Z4exitv(), !dbg !15

llvm/test/DebugInfo/X86/2011-09-26-GlobalVarContext.ll

 !12 = distinct !DILexicalBlock(scope: !8, file: !2, line: 3, column: 9)
 !13 = !DIExpression()
 !14 = !DILocation(line: 4, column: 9, scope: !12)
 !15 = !DILocation(line: 4, column: 23, scope: !12)
 !16 = !DILocation(line: 5, column: 5, scope: !12)
 
 ; CHECK: DW_TAG_variable
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_name [DW_FORM_strp]       ( .debug_str[0x{{[0-9a-f]*}}] = "GLB")
+; CHECK: DW_AT_name [DW_FORM_strp]   ( .debug_str[0x{{[0-9a-f]*}}] = "LOC")
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_decl_file [DW_FORM_data1] ("/work/llvm/vanilla/test/DebugInfo{{[/\\]}}test.c")
+; CHECK: DW_AT_decl_file [DW_FORM_data1]     ("/work/llvm/vanilla/test/DebugInfo{{[/\\]}}test.c")
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_decl_line [DW_FORM_data1] (1)
+; CHECK: DW_AT_decl_line [DW_FORM_data1]     (4)
 
 ; CHECK: DW_TAG_variable
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_name [DW_FORM_strp]   ( .debug_str[0x{{[0-9a-f]*}}] = "LOC")
+; CHECK: DW_AT_name [DW_FORM_strp]       ( .debug_str[0x{{[0-9a-f]*}}] = "GLB")
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_decl_file [DW_FORM_data1]     ("/work/llvm/vanilla/test/DebugInfo{{[/\\]}}test.c")
+; CHECK: DW_AT_decl_file [DW_FORM_data1] ("/work/llvm/vanilla/test/DebugInfo{{[/\\]}}test.c")
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_decl_line [DW_FORM_data1]     (4)
-
+; CHECK: DW_AT_decl_line [DW_FORM_data1] (1)

llvm/test/DebugInfo/X86/DW_AT_calling-convention.ll

 ; CHECK: .debug_abbrev contents:
 
 ; CHECK: [[subroutine_abbrev:\[[0-9]+\]]] DW_TAG_subroutine_type      DW_CHILDREN_yes
 ; CHECK-NEXT:         DW_AT_type      DW_FORM_ref4
 ; CHECK-NEXT:         DW_AT_calling_convention        DW_FORM_data1
 
 ; CHECK: .debug_info contents:
 
-; CHECK:  DW_TAG_subroutine_type [[subroutine_abbrev]] *
-; CHECK-NEXT:         DW_AT_type [DW_FORM_ref4]       {{.*}}
-; CHECK-NEXT:         DW_AT_calling_convention [DW_FORM_data1]        (DW_CC_BORLAND_msfastcall)
-
 ; CHECK: DW_TAG_subprogram [{{.*}}] *
 ; CHECK:                 DW_AT_low_pc
 ; CHECK:                 DW_AT_high_pc
 ; CHECK:                 DW_AT_frame_base
 ; CHECK:                 DW_AT_linkage_name
 ; CHECK:                 DW_AT_name
 ; CHECK:                 DW_AT_decl_file
 ; CHECK:                 DW_AT_decl_line
 ; CHECK:                 DW_AT_calling_convention [DW_FORM_data1]        (DW_CC_BORLAND_msfastcall)
 ; CHECK:                 DW_AT_type
 ; CHECK:                 DW_AT_external
 
+; CHECK:  DW_TAG_subroutine_type [[subroutine_abbrev]] *
+; CHECK-NEXT:         DW_AT_type [DW_FORM_ref4]       {{.*}}
+; CHECK-NEXT:         DW_AT_calling_convention [DW_FORM_data1]        (DW_CC_BORLAND_msfastcall)
+
 ; ModuleID = 't.cpp'
 source_filename = "t.cpp"
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
 target triple = "i386-pc-windows-msvc19.0.23918"
 
 @"\01?fptr@@3P6IHHH@ZA" = global i32 (i32, i32)* @"\01?f@@YIHHH@Z", align 4, !dbg !0
 
 ; Function Attrs: nounwind readnone

llvm/test/DebugInfo/X86/align_cpp11.ll

 ; {
 ;     S ss;
 ;     E e;
 ;     C1 c1;
 ;     alignas(32) int i = 42;
 ;     auto Lambda = [i](){};
 ; }
 
-; CHECK:   DW_TAG_class_type
-; CHECK:     DW_AT_name{{.*}}"C0"
-; CHECK:     DW_AT_alignment{{.*}}64
-
-; CHECK:   DW_TAG_variable
-; CHECK:     DW_AT_name{{.*}}"s"
-; CHECK:     DW_AT_alignment{{.*}}2048
-
-; CHECK:   DW_TAG_structure_type
-; CHECK:     DW_TAG_member
-; CHECK:     DW_TAG_member
-; CHECK:       DW_AT_name{{.*}}"xx"
-; CHECK:       DW_AT_alignment{{.*}}128
-
 ; CHECK:   DW_TAG_enumeration_type
 ; CHECK:     DW_AT_alignment{{.*}}16
 ; CHECK:       DW_TAG_enumerator
 ; CHECK:       DW_TAG_enumerator
 ; CHECK:       DW_TAG_enumerator
 
 ; CHECK:   DW_TAG_subprogram
 ; CHECK:     DW_TAG_variable
 ; CHECK:     DW_TAG_variable
 ; CHECK:     DW_TAG_variable
 ; CHECK:     DW_TAG_variable
 ; CHECK:       DW_AT_name{{.*}}"i"
 ; CHECK:       DW_AT_alignment{{.*}}32
 ; CHECK:     DW_TAG_variable
 ; CHECK:     DW_TAG_class_type
 ; CHECK:       DW_TAG_member
 ; CHECK:         DW_AT_name{{.*}}"i"
 ; CHECK:         DW_AT_alignment{{.*}}32
 ; CHECK:       DW_TAG_subprogram
 ; CHECK:         DW_TAG_formal_parameter
 
 ; CHECK:   DW_TAG_class_type
+; CHECK:     DW_AT_name{{.*}}"C0"
+; CHECK:     DW_AT_alignment{{.*}}64
+
+; CHECK:   DW_TAG_variable
+; CHECK:     DW_AT_name{{.*}}"s"
+; CHECK:     DW_AT_alignment{{.*}}2048
+
+; CHECK:   DW_TAG_structure_type
+; CHECK:     DW_TAG_member
+; CHECK:     DW_TAG_member
+; CHECK:       DW_AT_name{{.*}}"xx"
+; CHECK:       DW_AT_alignment{{.*}}128
+
+; CHECK:   DW_TAG_class_type
 ; CHECK:     DW_AT_name{{.*}}"C1"
 ; CHECK:     DW_TAG_member
 ; CHECK:       DW_AT_name{{.*}}"p"
 ; CHECK:       DW_AT_alignment{{.*}}64
 
 ; ModuleID = 'test.cpp'
 source_filename = "test.cpp"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"

llvm/test/DebugInfo/X86/align_objc.ll

 ; S0 s0;
 ;
 ; void f() {
 ;   S1 s1;
 ;   __attribute__((aligned (32))) int i;
 ; }
 
 ; CHECK: DW_TAG_compile_unit
+
+; CHECK:   DW_TAG_subprogram
+; CHECK:     DW_TAG_variable
+; CHECK:     DW_TAG_variable
+; CHECK:       DW_AT_name{{.*}}"i"
+; CHECK:       DW_AT_alignment{{.*}}32
+
 ; CHECK:   DW_TAG_variable
 ; CHECK:   DW_TAG_typedef
 ; CHECK:     DW_AT_name{{.*}}"S0"
 
 ; CHECK:   DW_TAG_structure_type
 ; CHECK:     DW_AT_alignment{{.*}}128
 ; CHECK:     DW_TAG_member
 ; CHECK:   DW_TAG_base_type
 
-; CHECK:   DW_TAG_subprogram
-; CHECK:     DW_TAG_variable
-; CHECK:     DW_TAG_variable
-; CHECK:       DW_AT_name{{.*}}"i"
-; CHECK:       DW_AT_alignment{{.*}}32
-
 ; CHECK:   DW_TAG_typedef
 ; CHECK:     DW_AT_name{{.*}}"S1"
 ; CHECK:   DW_TAG_structure_type
 ; CHECK:     DW_TAG_member
 ; CHECK:       DW_AT_name{{.*}}"c"
 ; CHECK:       DW_AT_alignment{{.*}}64
 ; CHECK:   DW_TAG_base_type
 

llvm/test/DebugInfo/X86/arange-and-stub.ll

 ; RUN: llc -generate-arange-section -relocation-model=pic < %s | FileCheck %s
 
 ; CHECK:   .data
 ; CHECK-NOT: .section
 ; CHECK: .L_ZTId.DW.stub:
 
 ; CHECK:  .data
-; CHECK-NEXT: .Lsec_end0:
+; CHECK-NEXT: .Lsec_end1:
 
 source_filename = "test/DebugInfo/X86/arange-and-stub.ll"
 target triple = "x86_64-linux-gnu"
 
 @_ZTId = external constant ptr
 @zed = global [1 x ptr] [ptr @bar], !dbg !0
 
 define void @foo() !dbg !17 {

llvm/test/DebugInfo/X86/containing-type-extension-rust.ll

 ; RUN: llc -O0 -filetype=obj < %s > %t
 ; RUN: llvm-dwarfdump -v -debug-info %t | FileCheck %s
 
 ; Check that any type can have a vtable holder.
+; CHECK: DW_TAG_structure_type
 ; CHECK: [[SP:.*]]: DW_TAG_structure_type
 ; CHECK-NOT: TAG
 ; CHECK: DW_AT_containing_type [DW_FORM_ref4] ({{.*}} "f64")
 ; CHECK: DW_AT_name [DW_FORM_strp] {{.*}}= "vtable")
 
 ; This was compiled using
 ; rustc -g --emit=llvm-ir t2.rs
 ; ... and then edited by hand, because rustc is using a somewhat older llvm.

llvm/test/DebugInfo/X86/debug-info-access.ll

 ;
 ;   U u;
 ;   A a;
 ;   B b;
 ;   C c;
 ;   F f;
 ;   H h;
 
+; CHECK: DW_TAG_subprogram
+; CHECK:     DW_AT_name {{.*}}"free")
+; CHECK-NOT: DW_AT_accessibility
+
 ; CHECK: DW_TAG_member
 ; CHECK:     DW_AT_name {{.*}}"union_priv")
 ; CHECK-NOT: DW_TAG
 ; CHECK:     DW_AT_accessibility {{.*}}(DW_ACCESS_private)
 
 ; CHECK: DW_TAG_subprogram
 ; CHECK:     DW_AT_name {{.*}}"union_pub_default")
 ; CHECK-NOT: DW_AT_accessibility

 ; CHECK: DW_TAG_union_type
 ; CHECK:     DW_AT_name ("G")
 ; CHECK:     DW_AT_accessibility (DW_ACCESS_private)
 
 ; CHECK: DW_TAG_class_type
 ; CHECK:     DW_AT_name ("I")
 ; CHECK:     DW_AT_accessibility (DW_ACCESS_private)
 
-; CHECK: DW_TAG_subprogram
-; CHECK:     DW_AT_name {{.*}}"free")
-; CHECK-NOT: DW_AT_accessibility
-
 %union.U = type { i32 }
 %struct.A = type { i8 }
 %class.B = type { i32 }
 %class.C = type { %"struct.C::D", %"union.C::E", %"struct.C::J" }
 %"struct.C::D" = type { i8 }
 %"union.C::E" = type { i8 }
 %"struct.C::J" = type { i8 }
 %struct.F = type { %"union.F::G" }

llvm/test/DebugInfo/X86/debug-info-static-member.ll

 !32 = !DILocation(line: 21, scope: !26)
 !33 = !DILocation(line: 22, scope: !26)
 
 ; PRESENT verifies that static member declarations have these attributes:
 ; external, declaration, accessibility, and either DW_AT_linkage_name
 ; (for variables) or DW_AT_const_value (for constants).
 ;
 ; PRESENT:      .debug_info contents:
+; PRESENT:      NULL
 ; PRESENT:      DW_TAG_variable
 ; PRESENT-NEXT: DW_AT_specification {{.*}} "a"
 ; PRESENT-NEXT: DW_AT_location
 ; PRESENT-NEXT: DW_AT_linkage_name {{.*}} "_ZN1C1aE"
 ; PRESENT:      DW_TAG_class_type
 ; PRESENT-NEXT: DW_AT_name {{.*}} "C"
 ; PRESENT:      DW_TAG_member
 ; PRESENT-NEXT: DW_AT_name {{.*}} "a"

 ; PRESENT-NEXT: DW_AT_linkage_name {{.*}} "_ZN1C1bE"
 ; PRESENT:      DW_TAG_variable
 ; PRESENT-NEXT: DW_AT_specification {{.*}} "c"
 ; PRESENT-NEXT: DW_AT_location
 ; PRESENT-NEXT: DW_AT_linkage_name {{.*}} "_ZN1C1cE"
 
 ; For Darwin gdb:
 ; DARWINP:      .debug_info contents:
+; DARWINP:      NULL
 ; DARWINP:      DW_TAG_variable
 ; DARWINP-NEXT: DW_AT_specification {{.*}} "a"
 ; DARWINP-NEXT: DW_AT_location
 ; DARWINP-NEXT: DW_AT_linkage_name {{.*}} "_ZN1C1aE"
 ; DARWINP:      DW_TAG_class_type
 ; DARWINP-NEXT: DW_AT_name {{.*}} "C"
 ; DARWINP:      DW_TAG_member
 ; DARWINP-NEXT: DW_AT_name {{.*}} "a"

llvm/test/DebugInfo/X86/dwarf-aranges.ll

 ; RUN: llc -generate-arange-section < %s | FileCheck %s
 
 ; -- header --
 ; CHECK: .short 2 # DWARF Arange version number
 ; CHECK-NEXT: .long .Lcu_begin0
 ; CHECK-NEXT: .byte 8 # Address Size (in bytes)
 ; CHECK-NEXT: .byte 0 # Segment Size (in bytes)
 ; -- alignment --
 ; CHECK-NEXT: .zero 4,255
 
+; <text section> - it should have made one span covering all functions in this CU.
+; CHECK-NEXT: .quad .Lfunc_begin0
+; CHECK-NEXT: .quad .Lsec_end0-.Lfunc_begin0
+
 ; <data section> - it should have made one span covering all vars in this CU.
 ; CHECK-NEXT: .quad some_data
-; CHECK-NEXT: .quad .Lsec_end0-some_data
+; CHECK-NEXT: .quad .Lsec_end1-some_data
 
 ; <other sections> - it should have made one span covering all vars in this CU.
 ; CHECK-NEXT: .quad some_other
-; CHECK-NEXT: .quad .Lsec_end1-some_other
+; CHECK-NEXT: .quad .Lsec_end2-some_other
 
 ; <common symbols> - it should have made one span for each symbol.
 ; CHECK-NEXT: .quad some_bss
 ; CHECK-NEXT: .quad 4
 
-; <text section> - it should have made one span covering all functions in this CU.
-; CHECK-NEXT: .quad .Lfunc_begin0
-; CHECK-NEXT: .quad .Lsec_end2-.Lfunc_begin0
-
 ; -- finish --
 ; CHECK-NEXT: # ARange terminator
 
 ; -- source code --
 ; Generated from: "clang -c -g -emit-llvm"
 ;
 ; int some_data = 4;
 ; int some_bss;

llvm/test/DebugInfo/X86/dwarf-linkage-names.ll

 ;  int bar() { return global_var; }
 ;};
 
 ; With linkage names, we get an attribute for the declaration (first) entry
 ; for the global variable, and one for the function.
 
 ; This assumes the variable will appear before the function.
 ; LINKAGE1: .section .debug_info
-; LINKAGE1: DW_TAG_variable
+; LINKAGE1: DW_TAG_subprogram
 ; LINKAGE1-NOT: DW_TAG
 ; LINKAGE1: {{DW_AT_(MIPS_)?linkage_name}}
-; LINKAGE1: DW_TAG_subprogram
+; LINKAGE1: DW_TAG_variable
 ; LINKAGE1-NOT: DW_TAG
 ; LINKAGE1: {{DW_AT_(MIPS_)?linkage_name}}
 ; LINKAGE1: .section
 
 ; Also verify we see the mangled names. We do this as a separate pass to
 ; avoid depending on the order of .debug_info and .debug_str sections.
 
 ; LINKAGE2-DAG: .asciz   "_ZN4test10global_varE"

llvm/test/DebugInfo/X86/dwarfdump-DIImportedEntity_elements.ll

 ;; This test checks processing of DIImportedEntity with elements field.
 ; REQUIRES: x86_64-linux
 
 ; RUN: llc %s -filetype=obj -o - | llvm-dwarfdump - | FileCheck %s
 
-; CHECK: [[MYMOD:0x[0-9a-f]+]]: DW_TAG_module
-; CHECK:   DW_AT_name      ("mymod")
-; CHECK:   [[VAR1:0x[0-9a-f]+]]: DW_TAG_variable
-; CHECK:     DW_AT_name    ("var1")
-
 ; CHECK: DW_TAG_subprogram
 ; CHECK:   DW_AT_name      ("main")
 ; CHECK:   DW_TAG_subprogram
 ; CHECK:     DW_AT_name      ("use_renamed")
 ; CHECK:     DW_TAG_imported_module
-; CHECK:       DW_AT_import ([[MYMOD]])
+; CHECK:       DW_AT_import ([[MYMOD:0x[0-9a-f]+]])
 ; CHECK:       DW_TAG_imported_declaration
-; CHECK:         DW_AT_import ([[VAR1]])
+; CHECK:         DW_AT_import ([[VAR1:0x[0-9a-f]+]])
 ; CHECK:         DW_AT_name        ("var4")
 
+; CHECK: [[MYMOD]]: DW_TAG_module
+; CHECK:   DW_AT_name      ("mymod")
+; CHECK:   [[VAR1]]: DW_TAG_variable
+; CHECK:     DW_AT_name    ("var1")
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;This test case is generated from
 ;;module mymod
 ;;  integer :: var1 = 11
 ;;  integer :: var2 = 12
 ;;  integer :: var3 = 13
 ;;end module mymod
 ;;

llvm/test/DebugInfo/X86/generate-odr-hash.ll

 ;   } a_b;
 ; };
 
 ; wombat wom;
 
 ; SINGLE-LABEL: .debug_info contents:
 ; FISSION-LABEL: .debug_info.dwo contents:
 ; CHECK: Compile Unit: length = [[CU_SIZE:[0-9a-f]+]]
+; CHECK: [[CU_NAME:^0x........]]: DW_TAG_compile_unit
 
-; CHECK: [[BAR:^0x........]]: DW_TAG_structure_type
+; CHECK: [[BAR:^0x........]]: DW_TAG_structure_type [{{[0-9]+}}]   ([[CU_NAME]])
 ; CHECK-NEXT: DW_AT_declaration
 ; CHECK-NEXT: DW_AT_signature {{.*}} (0x1d02f3be30cc5688)
 ; CHECK: [[FLUFFY:^0x........]]: DW_TAG_class_type
 ; CHECK-NEXT: DW_AT_declaration
 ; CHECK-NEXT: DW_AT_signature {{.*}} (0xb04af47397402e77)
 
+; CHECK: [[WOMBAT:^0x........]]: DW_TAG_structure_type [{{[0-9]+}}] * ([[CU_NAME]])
+; CHECK-NEXT: DW_AT_declaration
+; CHECK-NEXT: DW_AT_signature {{.*}} (0xfd756cee88f8a118)
+
 ; Ensure the CU-local type 'walrus' is not placed in a type unit.
-; CHECK: [[WALRUS:^0x........]]: DW_TAG_structure_type
+; CHECK: [[WALRUS_NAMESPACE:^0x........]]: DW_TAG_namespace [{{[0-9]+}}] * ([[CU_NAME]])
+; CHECK: [[WALRUS:^0x........]]: DW_TAG_structure_type [{{[0-9]+}}] * ([[WALRUS_NAMESPACE]])
 ; CHECK-NEXT: DW_AT_name{{.*}}"walrus"
 ; CHECK-NEXT: DW_AT_byte_size
 ; CHECK-NEXT: DW_AT_decl_file
 ; CHECK-NEXT: DW_AT_decl_line
 
-; CHECK: [[WOMBAT:^0x........]]: DW_TAG_structure_type
-; CHECK-NEXT: DW_AT_declaration
-; CHECK-NEXT: DW_AT_signature {{.*}} (0xfd756cee88f8a118)
-
 ; SINGLE-LABEL: .debug_types contents:
 ; FISSION: .debug_types.dwo contents:
 
 ; Check that we generate a hash for bar and the value.
 ; CHECK-NOT: type_signature
 ; CHECK-LABEL: type_signature = 0x1d02f3be30cc5688
 ; CHECK: DW_TAG_structure_type
 ; FISSION-NEXT: DW_AT_name {{.*}} (indexed {{.*}} "bar"

llvm/test/DebugInfo/X86/gnu-public-names.ll

 ; ASM: .byte   16                      # Attributes: TYPE, EXTERNAL
 ; ASM-NEXT: .asciz  "C"                     # External Name
 
 ; CHECK: .debug_info contents:
 ; CHECK: DW_TAG_compile_unit
 ; CHECK:   DW_AT_GNU_pubnames (true)
 ; CHECK-NOT: DW_AT_GNU_pubtypes [
 
-; CHECK:   [[STATIC_MEM_VAR:0x[0-9a-f]+]]: DW_TAG_variable
-; CHECK:     DW_AT_specification {{.*}} "static_member_variable"
+; CHECK:   DW_TAG_enumeration
+; CHECK:     [[UNNAMED_ENUM_ENUMERATOR:0x[0-9a-f]+]]:  DW_TAG_enumerator
+; CHECK:       DW_AT_name ("unnamed_enum_enumerator")
+; CHECK:     NULL
 
-; CHECK:   [[C:0x[0-9a-f]+]]: DW_TAG_structure_type
-; CHECK:     DW_AT_name ("C")
-; CHECK:     DW_TAG_member
-; CHECK:       DW_AT_name ("static_member_variable")
-; CHECK:     DW_TAG_subprogram
-; CHECK:       DW_AT_linkage_name
-; CHECK:       DW_AT_name ("member_function")
-; CHECK:       DW_TAG_formal_parameter
-; CHECK:       NULL
-; CHECK:     DW_TAG_subprogram
-; CHECK:       DW_AT_linkage_name
-; CHECK:       DW_AT_name ("static_member_function")
+; CHECK:   [[UNSIGNED_INT:0x[0-9a-f]+]]: DW_TAG_base_type
+; CHECK:     DW_AT_name ("unsigned int")
+
+; CHECK:   [[NAMED_ENUM:0x[0-9a-f]+]]: DW_TAG_enumeration
+; CHECK:     DW_AT_name ("named_enum")
+; CHECK:     [[NAMED_ENUM_ENUMERATOR:0x[0-9a-f]+]]:  DW_TAG_enumerator
+; CHECK:       DW_AT_name ("named_enum_enumerator")
+; CHECK:     NULL
+
+; CHECK:   [[NAMED_ENUM_CLASS:0x[0-9a-f]+]]: DW_TAG_enumeration
+; CHECK:     DW_AT_name ("named_enum_class")
+; CHECK:     [[NAMED_ENUM_CLASS_ENUMERATOR:0x[0-9a-f]+]]:  DW_TAG_enumerator
+; CHECK:       DW_AT_name ("named_enum_class_enumerator")
 ; CHECK:     NULL
 
 ; CHECK:   [[INT:0x[0-9a-f]+]]: DW_TAG_base_type
 ; CHECK:     DW_AT_name ("int")
-; CHECK:   DW_TAG_pointer_type
-
-; CHECK:   [[GLOB_VAR:0x[0-9a-f]+]]: DW_TAG_variable
-; CHECK:     DW_AT_name ("global_variable")
 
 ; CHECK:   [[NS:0x[0-9a-f]+]]: DW_TAG_namespace
 ; CHECK:     DW_AT_name ("ns")
+; CHECK:     DW_TAG_variable
+; CHECK:     DW_AT_name ("global_namespace_variable_decl")
+; CHECK:     [[GLOB_NS_FUNC:0x[0-9a-f]+]]: DW_TAG_subprogram
+; CHECK:       DW_AT_linkage_name
+; CHECK:       DW_AT_name ("global_namespace_function")
 ; CHECK:     [[GLOB_NS_VAR:0x[0-9a-f]+]]: DW_TAG_variable
 ; CHECK:       DW_AT_name ("global_namespace_variable")
 ; CHECK-NOT:   DW_AT_specification
 ; CHECK:       DW_AT_location
 ; CHECK-NOT:   DW_AT_specification
 ; CHECK:     [[D_VAR:0x[0-9a-f]+]]: DW_TAG_variable
 ; CHECK:       DW_AT_name ("d")
 ; CHECK-NOT:   DW_AT_specification
 ; CHECK:       DW_AT_location
 ; CHECK-NOT:   DW_AT_specification
 ; CHECK:     [[D:0x[0-9a-f]+]]: DW_TAG_structure_type
 ; CHECK:       DW_AT_name ("D")
 ; CHECK:       DW_TAG_member
 ; CHECK:       NULL
-; CHECK:     DW_TAG_variable
-; CHECK:     [[GLOB_NS_FUNC:0x[0-9a-f]+]]: DW_TAG_subprogram
+; CHECK:     NULL
+
+; CHECK:   DW_TAG_imported_declaration
+
+; CHECK:   [[C:0x[0-9a-f]+]]: DW_TAG_structure_type
+; CHECK:     DW_AT_name ("C")
+; CHECK:     DW_TAG_member
+; CHECK:       DW_AT_name ("static_member_variable")
+; CHECK:     DW_TAG_subprogram
 ; CHECK:       DW_AT_linkage_name
-; CHECK:       DW_AT_name ("global_namespace_function")
+; CHECK:       DW_AT_name ("member_function")
+; CHECK:       DW_TAG_formal_parameter
+; CHECK:       NULL
+; CHECK:     DW_TAG_subprogram
+; CHECK:       DW_AT_linkage_name
+; CHECK:       DW_AT_name ("static_member_function")
+; CHECK:     NULL
+
+; CHECK:   DW_TAG_pointer_type
+
+; CHECK:   [[MEM_FUNC:0x[0-9a-f]+]]: DW_TAG_subprogram
+; CHECK:     DW_AT_specification {{.*}} "_ZN1C15member_functionEv"
+; CHECK:     DW_TAG_formal_parameter
 ; CHECK:     NULL
 
+; CHECK:   [[STATIC_MEM_FUNC:0x[0-9a-f]+]]: DW_TAG_subprogram
+; CHECK:     DW_AT_specification {{.*}} "_ZN1C22static_member_functionEv"
+
+; CHECK:   [[GLOBAL_FUNC:0x[0-9a-f]+]]: DW_TAG_subprogram
+; CHECK:     DW_AT_linkage_name
+; CHECK:     DW_AT_name ("global_function")
+
 ; CHECK:   DW_TAG_subprogram
 ; CHECK:     DW_AT_name ("f3")
 ; CHECK:     [[F3_Z:.*]]: DW_TAG_variable
 ; CHECK:       DW_AT_name ("z")
 ; CHECK:       DW_AT_location
 ; CHECK:     NULL
 
+; CHECK:   DW_TAG_subprogram
+; CHECK:     DW_AT_name ("f7")
+
+; CHECK:   [[STATIC_MEM_VAR:0x[0-9a-f]+]]: DW_TAG_variable
+; CHECK:     DW_AT_specification {{.*}} "static_member_variable"
+
+; CHECK:   [[GLOB_VAR:0x[0-9a-f]+]]: DW_TAG_variable
+; CHECK:     DW_AT_name ("global_variable")
+
 ; CHECK:   [[ANON:.*]]: DW_TAG_namespace
 ; CHECK-NOT: DW_AT_name
 ; CHECK:     [[ANON_I:.*]]: DW_TAG_variable
 ; CHECK:       DW_AT_name ("i")
 ; CHECK:       [[ANON_INNER:.*]]:  DW_TAG_namespace
 ; CHECK:         DW_AT_name ("inner")
 ; CHECK:         [[ANON_INNER_B:.*]]: DW_TAG_variable
 ; CHECK:           DW_AT_name ("b")
 ; CHECK:         NULL
 ; CHECK:     NULL
 
 ; CHECK:   [[OUTER:.*]]: DW_TAG_namespace
 ; CHECK:     DW_AT_name ("outer")
 ; CHECK:     [[OUTER_ANON:.*]]:  DW_TAG_namespace
 ; CHECK-NOT:   DW_AT_name
 ; CHECK:       [[OUTER_ANON_C:.*]]: DW_TAG_variable
 ; CHECK:         DW_AT_name ("c")
 ; CHECK:       NULL
 ; CHECK:     NULL
 
-; CHECK:   DW_TAG_enumeration
-; CHECK:     [[UNNAMED_ENUM_ENUMERATOR:0x[0-9a-f]+]]:  DW_TAG_enumerator
-; CHECK:       DW_AT_name ("unnamed_enum_enumerator")
-; CHECK:     NULL
-
-; CHECK:   [[UNSIGNED_INT:0x[0-9a-f]+]]: DW_TAG_base_type
-; CHECK:     DW_AT_name ("unsigned int")
-
-; CHECK:   [[NAMED_ENUM:0x[0-9a-f]+]]: DW_TAG_enumeration
-; CHECK:     DW_AT_name ("named_enum")
-; CHECK:     [[NAMED_ENUM_ENUMERATOR:0x[0-9a-f]+]]:  DW_TAG_enumerator
-; CHECK:       DW_AT_name ("named_enum_enumerator")
-; CHECK:     NULL
-
-; CHECK:   [[NAMED_ENUM_CLASS:0x[0-9a-f]+]]: DW_TAG_enumeration
-; CHECK:     DW_AT_name ("named_enum_class")
-; CHECK:     [[NAMED_ENUM_CLASS_ENUMERATOR:0x[0-9a-f]+]]:  DW_TAG_enumerator
-; CHECK:       DW_AT_name ("named_enum_class_enumerator")
-; CHECK:     NULL
-
-; CHECK:   DW_TAG_imported_declaration
-
-; CHECK:   [[MEM_FUNC:0x[0-9a-f]+]]: DW_TAG_subprogram
-; CHECK:     DW_AT_specification {{.*}} "_ZN1C15member_functionEv"
-; CHECK:     DW_TAG_formal_parameter
-; CHECK:     NULL
-
-; CHECK:   [[STATIC_MEM_FUNC:0x[0-9a-f]+]]: DW_TAG_subprogram
-; CHECK:     DW_AT_specification {{.*}} "_ZN1C22static_member_functionEv"
-
-; CHECK:   [[GLOBAL_FUNC:0x[0-9a-f]+]]: DW_TAG_subprogram
-; CHECK:     DW_AT_linkage_name
-; CHECK:     DW_AT_name ("global_function")
-
-; CHECK:   DW_TAG_subprogram
 ; CHECK:   DW_TAG_pointer_type
 ; CHECK:   DW_TAG_pointer_type
 ; CHECK:   NULL
 
 ; CHECK-LABEL: .debug_gnu_pubnames contents:
 ; CHECK-NEXT: length = {{.*}}, version = 0x0002, unit_offset = 0x00000000, unit_size = {{.*}}
 ; CHECK-NEXT: Offset     Linkage  Kind     Name
-; CHECK-NEXT:  [[GLOBAL_FUNC]] EXTERNAL FUNCTION "global_function"
-; CHECK-NEXT:  [[NS]] EXTERNAL TYPE     "ns"
-; CHECK-NEXT:  [[OUTER_ANON_C]] STATIC VARIABLE "outer::(anonymous namespace)::c"
-; CHECK-NEXT:  [[ANON_I]] STATIC VARIABLE "(anonymous namespace)::i"
-; CHECK-NEXT:  [[GLOB_NS_FUNC]] EXTERNAL FUNCTION "ns::global_namespace_function"
+; CHECK-DAG:  [[GLOBAL_FUNC]] EXTERNAL FUNCTION "global_function"
+; CHECK-DAG:  [[NS]] EXTERNAL TYPE     "ns"
+; CHECK-DAG:  [[OUTER_ANON_C]] STATIC VARIABLE "outer::(anonymous namespace)::c"
+; CHECK-DAG:  [[ANON_I]] STATIC VARIABLE "(anonymous namespace)::i"
+; CHECK-DAG:  [[GLOB_NS_FUNC]] EXTERNAL FUNCTION "ns::global_namespace_function"
 ; GCC Doesn't put local statics in pubnames, but it seems not unreasonable and
 ; comes out naturally from LLVM's implementation, so I'm OK with it for now. If
 ; it's demonstrated that this is a major size concern or degrades debug info
 ; consumer behavior, feel free to change it.
-; CHECK-NEXT:  [[F3_Z]] STATIC VARIABLE "f3::z"
-; CHECK-NEXT:  [[ANON]] EXTERNAL TYPE "(anonymous namespace)"
-; CHECK-NEXT:  [[OUTER_ANON]] EXTERNAL TYPE "outer::(anonymous namespace)"
-; CHECK-NEXT:  [[ANON_INNER_B]] STATIC VARIABLE "(anonymous namespace)::inner::b"
-; CHECK-NEXT:  [[OUTER]] EXTERNAL TYPE "outer"
+; CHECK-DAG:  [[F3_Z]] STATIC VARIABLE "f3::z"
+; CHECK-DAG:  [[ANON]] EXTERNAL TYPE "(anonymous namespace)"
+; CHECK-DAG:  [[OUTER_ANON]] EXTERNAL TYPE "outer::(anonymous namespace)"
+; CHECK-DAG:  [[ANON_INNER_B]] STATIC VARIABLE "(anonymous namespace)::inner::b"
+; CHECK-DAG:  [[OUTER]] EXTERNAL TYPE "outer"
 ; FIXME: GCC produces enumerators as EXTERNAL, not STATIC
-; CHECK-NEXT:  [[NAMED_ENUM_CLASS_ENUMERATOR]] STATIC VARIABLE  "named_enum_class_enumerator"
-; CHECK-NEXT:  [[MEM_FUNC]] EXTERNAL FUNCTION "C::member_function"
-; CHECK-NEXT:  [[GLOB_VAR]] EXTERNAL VARIABLE "global_variable"
-; CHECK-NEXT:  [[GLOB_NS_VAR]] EXTERNAL VARIABLE "ns::global_namespace_variable"
-; CHECK-NEXT:  [[ANON_INNER]] EXTERNAL TYPE "(anonymous namespace)::inner"
-; CHECK-NEXT:  [[D_VAR]] EXTERNAL VARIABLE "ns::d"
-; CHECK-NEXT:  [[NAMED_ENUM_ENUMERATOR]] STATIC VARIABLE  "named_enum_enumerator"
-; CHECK-NEXT:  [[STATIC_MEM_VAR]] EXTERNAL VARIABLE "C::static_member_variable"
-; CHECK-NEXT:  [[STATIC_MEM_FUNC]] EXTERNAL FUNCTION "C::static_member_function"
-; CHECK-NEXT:  [[UNNAMED_ENUM_ENUMERATOR]] STATIC VARIABLE  "unnamed_enum_enumerator"
+; CHECK-DAG:  [[NAMED_ENUM_CLASS_ENUMERATOR]] STATIC VARIABLE  "named_enum_class_enumerator"
+; CHECK-DAG:  [[MEM_FUNC]] EXTERNAL FUNCTION "C::member_function"
+; CHECK-DAG:  [[GLOB_VAR]] EXTERNAL VARIABLE "global_variable"
+; CHECK-DAG:  [[GLOB_NS_VAR]] EXTERNAL VARIABLE "ns::global_namespace_variable"
+; CHECK-DAG:  [[ANON_INNER]] EXTERNAL TYPE "(anonymous namespace)::inner"
+; CHECK-DAG:  [[D_VAR]] EXTERNAL VARIABLE "ns::d"
+; CHECK-DAG:  [[NAMED_ENUM_ENUMERATOR]] STATIC VARIABLE  "named_enum_enumerator"
+; CHECK-DAG:  [[STATIC_MEM_VAR]] EXTERNAL VARIABLE "C::static_member_variable"
+; CHECK-DAG:  [[STATIC_MEM_FUNC]] EXTERNAL FUNCTION "C::static_member_function"
+; CHECK-DAG:  [[UNNAMED_ENUM_ENUMERATOR]] STATIC VARIABLE  "unnamed_enum_enumerator"
 
 ; CHECK-LABEL: debug_gnu_pubtypes contents:
 ; CHECK: Offset     Linkage  Kind     Name
-; CHECK-NEXT:  [[C]] EXTERNAL TYPE     "C"
-; CHECK-NEXT:  [[UNSIGNED_INT]] STATIC   TYPE     "unsigned int"
-; CHECK-NEXT:  [[D]] EXTERNAL TYPE     "ns::D"
-; CHECK-NEXT:  [[NAMED_ENUM]] EXTERNAL TYPE     "named_enum"
-; CHECK-NEXT:  [[INT]] STATIC   TYPE     "int"
-; CHECK-NEXT:  [[NAMED_ENUM_CLASS]] EXTERNAL TYPE     "named_enum_class"
+; CHECK-DAG:  [[C]] EXTERNAL TYPE     "C"
+; CHECK-DAG:  [[UNSIGNED_INT]] STATIC   TYPE     "unsigned int"
+; CHECK-DAG:  [[D]] EXTERNAL TYPE     "ns::D"
+; CHECK-DAG:  [[NAMED_ENUM]] EXTERNAL TYPE     "named_enum"
+; CHECK-DAG:  [[INT]] STATIC   TYPE     "int"
+; CHECK-DAG:  [[NAMED_ENUM_CLASS]] EXTERNAL TYPE     "named_enum_class"
 
 %struct.C = type { i8 }
 %"struct.ns::D" = type { i32 }
 
 @_ZN1C22static_member_variableE = dso_local global i32 0, align 4, !dbg !0
 @global_variable = dso_local global %struct.C zeroinitializer, align 1, !dbg !18
 @_ZN2ns25global_namespace_variableE = dso_local global i32 1, align 4, !dbg !29
 @_ZN2ns1dE = dso_local global %"struct.ns::D" zeroinitializer, align 4, !dbg !32

llvm/test/DebugInfo/X86/linkage-name.ll

 ; RUN: llc -mtriple=x86_64-macosx %s -o %t -filetype=obj
 ; RUN: llvm-dwarfdump -v -debug-info %t | FileCheck %s
 
-; CHECK: DW_TAG_subprogram [9] *
+; CHECK: DW_TAG_subprogram [8] *
 ; CHECK-NOT: DW_AT_{{(MIPS_)?}}linkage_name
 ; CHECK: DW_AT_specification
 
 source_filename = "test/DebugInfo/X86/linkage-name.ll"
 
 %class.A = type { i8 }
 
 @a = global %class.A zeroinitializer, align 1, !dbg !0

llvm/test/DebugInfo/X86/namelist1.ll

 ; Namelist is a fortran feature, this test checks whether DW_TAG_namelist and
 ; DW_TAG_namelist_item attributes are emitted correctly.
 ;
 ; RUN: llc -O0 -mtriple=x86_64-unknown-linux-gnu %s -filetype=obj -o %t.o
 ; RUN: llvm-dwarfdump %t.o | FileCheck %s
 ;
-; CHECK: [[ITEM1:0x.+]]:       DW_TAG_variable
-; CHECK:                          DW_AT_name  ("a")
 ; CHECK: [[ITEM2:0x.+]]:       DW_TAG_variable
 ; CHECK:                          DW_AT_name  ("b")
+; CHECK: {{0x.+}}:             DW_TAG_variable
+; CHECK:                          DW_AT_const_value
+; CHECK: [[ITEM1:0x.+]]:       DW_TAG_variable
+; CHECK:                          DW_AT_name  ("a")
 ; CHECK: DW_TAG_namelist
 ; CHECK:    DW_AT_name  ("nml")
 ; CHECK: DW_TAG_namelist_item
 ; CHECK:    DW_AT_namelist_item ([[ITEM1]])
 ; CHECK: DW_TAG_namelist_item
 ; CHECK:    DW_AT_namelist_item ([[ITEM2]])
 ;
 ; generated from

llvm/test/DebugInfo/X86/prototyped.ll

 ; RUN: sed -e "s/LANG_C/LANG_ObjC/" %s > %t/test.ll
 ; RUN: llc -mtriple=x86_64-pc-linux-gnu -filetype=obj -o %t/test.o < %t/test.ll
 ; RUN: llvm-dwarfdump -debug-info %t/test.o | FileCheck %s
 
 ; Generated from this simple example, compiled as C code:
 ; void (*x)(void);
 ; void y(void) { }
 
-; CHECK: DW_TAG_subroutine_type
+; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:   DW_AT_prototyped (true)
 
-; CHECK: DW_TAG_subprogram
+; CHECK: DW_TAG_subroutine_type
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:   DW_AT_prototyped (true)
 
 @x = dso_local global ptr null, align 8, !dbg !0
 
 ; Function Attrs: noinline nounwind optnone uwtable
 define dso_local void @y() #0 !dbg !16 {
 entry:

llvm/test/DebugInfo/X86/ref_addr_relocation.ll

 ; #include "hdr.h"
 ; foo f;
 ; cat tu2.cpp
 ; #include "hdr.h"
 ; foo g;
 
 ; Make sure we use relocation for ref_addr on non-darwin platforms.
 ; CHECK: DW_TAG_compile_unit
+; CHECK: DW_TAG_structure_type
 ; CHECK: DW_TAG_variable
 ; ELF-ASM: .long [[TYPE:.*]] # DW_AT_type
 ; DARWIN-ASM2: .long [[TYPE:.*]] ## DW_AT_type
 ; DARWIN-ASM4: .long [[TYPE:.*]] ## DW_AT_type
 ; COFF-ASM: .long [[TYPE:.*]] # DW_AT_type
-; CHECK: DW_TAG_structure_type
 ; CHECK: cu_begin1
 ; CHECK: DW_TAG_compile_unit
 ; CHECK-NOT: DW_TAG_structure_type
 ; This variable's type is in the 1st CU.
 ; CHECK: DW_TAG_variable
 ; Make sure this is relocatable.
 ; and test that we don't create the labels to emit a correct COFF relocation
 ; ELF-ASM: .quad .debug_info+[[TYPE]] # DW_AT_type
 ; COFF-ASM: .secrel32 .Lsection_info+[[TYPE]] # DW_AT_type
 ; DARWIN-ASM2: .quad [[TYPE]] ## DW_AT_type
 ; DARWIN-ASM4: .long [[TYPE]] ## DW_AT_type
 ; CHECK-NOT: DW_TAG_structure_type
 ; CHECK: .section
 
 ; CHECK-DWARF: DW_TAG_compile_unit
 ; CHECK-DWARF: 0x[[ADDR:.*]]: DW_TAG_structure_type
 ; CHECK-DWARF: DW_TAG_compile_unit
 ; CHECK-DWARF: DW_TAG_variable
 ; CHECK-DWARF: DW_AT_type [DW_FORM_ref_addr] {{.*}}[[ADDR]]
 
 ; CHECK-DWARF2: DW_TAG_compile_unit
+; CHECK-DWARF2: [[ADDR:.*]]: DW_TAG_structure_type
 ; CHECK-DWARF2: DW_TAG_variable
-; CHECK-DWARF2: DW_AT_type [DW_FORM_ref4] {{.*}} => {[[ADDR:.*]]}
-; CHECK-DWARF2: [[ADDR]]: DW_TAG_structure_type
+; CHECK-DWARF2: DW_AT_type [DW_FORM_ref4] {{.*}} => {[[ADDR]]}
 
 source_filename = "test/DebugInfo/X86/ref_addr_relocation.ll"
 
 %struct.foo = type { i8 }
 
 @f = global %struct.foo zeroinitializer, align 1, !dbg !0
 @g = global %struct.foo zeroinitializer, align 1, !dbg !6
 

llvm/test/DebugInfo/X86/static-local-var.ll

+; RUN: llc -O0 -mtriple=x86_64-unknown-linux-gnu %s -filetype=obj -o - | llvm-dwarfdump - | FileCheck %s "--implicit-check-not={{NULL|DW_TAG}}" 
+; 
+; Test case generated from:
+; 
+; int __attribute__((always_inline)) g(int n) {
+;   static int x[10];
+;   int y = 1;
+;   return x[n] + y;
+; }
+; int f(int n) { return g(n); }
+;
+; Check that the DW_TAG_varaible for `x` is defined only once in the abstract definition of `g`
+;
+; CHECK: DW_TAG_compile_unit
+;
+; Definition of `g`
+; CHECK: DW_TAG_subprogram
+; CHECK:   DW_AT_abstract_origin   ([[G_ABSTRACT:0x[0-9]+]] "g")
+; CHECK:   DW_TAG_formal_parameter
+; CHECK:     DW_AT_abstract_origin ([[N_ABSTRACT:0x[0-9]+]] "n")
+; CHECK:   DW_TAG_variable
+; CHECK:     DW_AT_abstract_origin ([[Y_ABSTRACT:0x[0-9]+]] "y")
+; CHECK: NULL
+; 
+; Abstract definition of `g`
+; CHECK: [[G_ABSTRACT]]:   DW_TAG_subprogram
+; CHECK:   DW_AT_name      ("g")
+; CHECK: [[N_ABSTRACT]]:     DW_TAG_formal_parameter
+; CHECK:   DW_AT_name      ("n")
+; CHECK: [[Y_ABSTRACT]]:     DW_TAG_variable
+; CHECK:   DW_AT_name      ("y")
+; CHECK: DW_TAG_variable
+; CHECK:   DW_AT_name      ("x")
+; CHECK: NULL
+;
+; CHECK: DW_TAG_base_type
+;
+; Definition of `f`
+; CHECK: DW_TAG_subprogram
+; CHECK:   DW_AT_name      ("f")
+; CHECK:   DW_TAG_formal_parameter
+; Inlined definition of `g`
+; CHECK:   DW_TAG_inlined_subroutine
+; CHECK:     DW_AT_abstract_origin ([[G_ABSTRACT]] "g")
+; CHECK:       DW_TAG_formal_parameter
+; CHECK:         DW_AT_abstract_origin ([[N_ABSTRACT:0x[0-9]+]] "n")
+; CHECK:       DW_TAG_variable
+; CHECK:         DW_AT_abstract_origin ([[Y_ABSTRACT:0x[0-9]+]] "y")
+; CHECK: NULL
+; CHECK: NULL
+
+; CHECK: DW_TAG_array_type
+; CHECK: DW_TAG_subrange_type
+; CHECK: NULL
+; CHECK: DW_TAG_base_type
+; CHECK: NULL
+
+@g.x = internal global [10 x i32] zeroinitializer, align 16, !dbg !0
+
+define dso_local i32 @g(i32 %n) #0 !dbg !2 {
+entry:
+  %n.addr = alloca i32, align 4
+  %y = alloca i32, align 4
+  store i32 %n, ptr %n.addr, align 4
+  call void @llvm.dbg.declare(metadata ptr %n.addr, metadata !21, metadata !DIExpression()), !dbg !22
+  call void @llvm.dbg.declare(metadata ptr %y, metadata !23, metadata !DIExpression()), !dbg !24
+  store i32 1, ptr %y, align 4, !dbg !24
+  %i = load i32, ptr %n.addr, align 4, !dbg !25
+  %idxprom = sext i32 %i to i64, !dbg !26
+  %arrayidx = getelementptr inbounds [10 x i32], ptr @g.x, i64 0, i64 %idxprom, !dbg !26
+  %i1 = load i32, ptr %arrayidx, align 4, !dbg !26
+  %i2 = load i32, ptr %y, align 4, !dbg !27
+  %add = add nsw i32 %i1, %i2, !dbg !28
+  ret i32 %add, !dbg !29
+}
+
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+define dso_local i32 @f(i32 %n) #2 !dbg !30 {
+entry:
+  %n.addr.i = alloca i32, align 4
+  %y.i = alloca i32, align 4
+  %n.addr = alloca i32, align 4
+  store i32 %n, ptr %n.addr, align 4
+  call void @llvm.dbg.declare(metadata ptr %n.addr, metadata !31, metadata !DIExpression()), !dbg !32
+  %0 = load i32, ptr %n.addr, align 4, !dbg !33
+  store i32 %0, ptr %n.addr.i, align 4
+  call void @llvm.dbg.declare(metadata ptr %n.addr.i, metadata !21, metadata !DIExpression()), !dbg !34
+  call void @llvm.dbg.declare(metadata ptr %y.i, metadata !23, metadata !DIExpression()), !dbg !36
+  store i32 1, ptr %y.i, align 4, !dbg !36
+  %1 = load i32, ptr %n.addr.i, align 4, !dbg !37
+  %idxprom.i = sext i32 %1 to i64, !dbg !38
+  %arrayidx.i = getelementptr inbounds [10 x i32], ptr @g.x, i64 0, i64 %idxprom.i, !dbg !38
+  %2 = load i32, ptr %arrayidx.i, align 4, !dbg !38
+  %3 = load i32, ptr %y.i, align 4, !dbg !39
+  %add.i = add nsw i32 %2, %3, !dbg !40
+  ret i32 %add.i, !dbg !41
+}
+
+attributes #0 = { alwaysinline nounwind uwtable "frame-pointer"="all" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
+attributes #1 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
+attributes #2 = { noinline nounwind optnone uwtable "frame-pointer"="all" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
+
+!llvm.dbg.cu = !{!7}
+!llvm.module.flags = !{!13, !14, !15, !16, !17, !18, !19}
+!llvm.ident = !{!20}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "x", scope: !2, file: !3, line: 2, type: !10, isLocal: true, isDefinition: true)
+!2 = distinct !DISubprogram(name: "g", scope: !3, file: !3, line: 1, type: !4, scopeLine: 1, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !7, retainedNodes: !9)
+!3 = !DIFile(filename: "test.c", directory: "/_build", checksumkind: CSK_MD5, checksum: "b0f3c9d2dcba025ece076268b66296cc")
+!4 = !DISubroutineType(types: !5)
+!5 = !{!6, !6}
+!6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!7 = distinct !DICompileUnit(language: DW_LANG_C11, file: !3, producer: "clang version 16.0.0 (ssh://[e-mail]/llvm/llvm-project.git 911b73bed0eb651a0cee6acc4eff45c275c6c86c)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !8, splitDebugInlining: false, nameTableKind: None)
+!8 = !{!0}
+!9 = !{}
+!10 = !DICompositeType(tag: DW_TAG_array_type, baseType: !6, size: 320, elements: !11)
+!11 = !{!12}
+!12 = !DISubrange(count: 10)
+!13 = !{i32 7, !"Dwarf Version", i32 5}
+!14 = !{i32 2, !"Debug Info Version", i32 3}
+!15 = !{i32 1, !"wchar_size", i32 4}
+!16 = !{i32 8, !"PIC Level", i32 2}
+!17 = !{i32 7, !"PIE Level", i32 2}
+!18 = !{i32 7, !"uwtable", i32 2}
+!19 = !{i32 7, !"frame-pointer", i32 2}
+!20 = !{!"clang version 16.0.0 (ssh://[e-mail]/llvm/llvm-project.git 911b73bed0eb651a0cee6acc4eff45c275c6c86c)"}
+!21 = !DILocalVariable(name: "n", arg: 1, scope: !2, file: !3, line: 1, type: !6)
+!22 = !DILocation(line: 1, column: 42, scope: !2)
+!23 = !DILocalVariable(name: "y", scope: !2, file: !3, line: 3, type: !6)
+!24 = !DILocation(line: 3, column: 5, scope: !2)
+!25 = !DILocation(line: 4, column: 10, scope: !2)
+!26 = !DILocation(line: 4, column: 8, scope: !2)
+!27 = !DILocation(line: 4, column: 15, scope: !2)
+!28 = !DILocation(line: 4, column: 13, scope: !2)
+!29 = !DILocation(line: 4, column: 1, scope: !2)
+!30 = distinct !DISubprogram(name: "f", scope: !3, file: !3, line: 6, type: !4, scopeLine: 6, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !7, retainedNodes: !9)
+!31 = !DILocalVariable(name: "n", arg: 1, scope: !30, file: !3, line: 6, type: !6)
+!32 = !DILocation(line: 6, column: 11, scope: !30)
+!33 = !DILocation(line: 6, column: 25, scope: !30)
+!34 = !DILocation(line: 1, column: 42, scope: !2, inlinedAt: !35)
+!35 = distinct !DILocation(line: 6, column: 23, scope: !30)
+!36 = !DILocation(line: 3, column: 5, scope: !2, inlinedAt: !35)
+!37 = !DILocation(line: 4, column: 10, scope: !2, inlinedAt: !35)
+!38 = !DILocation(line: 4, column: 8, scope: !2, inlinedAt: !35)
+!39 = !DILocation(line: 4, column: 15, scope: !2, inlinedAt: !35)
+!40 = !DILocation(line: 4, column: 13, scope: !2, inlinedAt: !35)
+!41 = !DILocation(line: 6, column: 16, scope: !30)
 No newline at end of file

llvm/test/DebugInfo/X86/string-offsets-multiple-cus.ll

 ; TYPEUNITS:      DW_TAG_type_unit
 ; TYPEUNITS-NOT:  {{DW_TAG|NULL}}
 ; TYPEUNITS:      DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x[[CU1_STROFF:[0-9a-f]+]])
 ; TYPEUNITS-NOT:  NULL
 ; TYPEUNITS:      DW_TAG_enumerator
 ; TYPEUNITS-NOT:  NULL
 ; TYPEUNITS:      DW_TAG_enumerator
 ; TYPEUNITS-NOT:  {{DW_TAG|NULL}}
-; TYPEUNITS:      DW_AT_name [DW_FORM_strx1] (indexed (00000005) string = "b")
+; TYPEUNITS:      DW_AT_name [DW_FORM_strx1] (indexed (00000004) string = "b")
 ; TYPEUNITS-NOT:  contents:
 ; TYPEUNITS:      DW_TAG_type_unit
 ; TYPEUNITS-NOT:  {{DW_TAG|NULL}}
 ; TYPEUNITS:      DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x[[CU1_STROFF]])
 ; TYPEUNITS-NOT:  NULL
 ; TYPEUNITS:      DW_TAG_enumeration_type
-; TYPEUNITS:      DW_AT_name [DW_FORM_strx1] (indexed (0000000d) string = "E2")
+; TYPEUNITS:      DW_AT_name [DW_FORM_strx1] (indexed (0000000b) string = "E2")
 ; TYPEUNITS-NOT:  contents:
 ; TYPEUNITS:      DW_TAG_type_unit
 ; TYPEUNITS-NOT:  {{DW_TAG|NULL}}
 ; TYPEUNITS:      DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x[[CU1_STROFF]])
 ; TYPEUNITS-NOT:  NULL
 ; TYPEUNITS:      DW_TAG_enumeration_type
-; TYPEUNITS:      DW_AT_name [DW_FORM_strx1] (indexed (00000013) string = "E3")
+; TYPEUNITS:      DW_AT_name [DW_FORM_strx1] (indexed (00000010) string = "E3")
 
 ; CU 1
 ; BOTH-NOT:    .contents:
 ; BOTH:        DW_TAG_compile_unit
 ; BOTH-NOT:    {{DW_TAG|NULL}}
 ; DEFAULT:     DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x[[CU1_STROFF:[0-9a-f]+]])
 ; TYPEUNITS:   DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x[[CU1_STROFF]])
 ;
 ; CU 2
 ; BOTH-NOT:    contents:
 ; BOTH:        DW_TAG_compile_unit
 ; BOTH-NOT:    {{DW_TAG|NULL}}
 ; BOTH:        DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x[[CU1_STROFF]])
 ; BOTH-NOT:    NULL
+; BOTH:        DW_TAG_enumeration_type
 ; BOTH:        DW_TAG_variable
 ; BOTH-NOT:    {{DW_TAG|NULL}}
-; BOTH:        DW_AT_name [DW_FORM_strx1] (indexed (00000009) string = "glob2")
+; BOTH:        DW_AT_name [DW_FORM_strx1] (indexed (00000012) string = "glob2")
 ;
 ; CU 3
 ; BOTH-NOT:    contents:
 ; BOTH:        DW_TAG_compile_unit
 ; BOTH-NOT:    {{DW_TAG|NULL}}
 ; BOTH:        DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x[[CU1_STROFF]])
 ; BOTH-NOT:    NULL
+; BOTH:        DW_TAG_enumeration_type
 ; BOTH:        DW_TAG_variable
 ; BOTH-NOT:    {{DW_TAG|NULL}}
-; BOTH:        DW_AT_name [DW_FORM_strx1] (indexed (0000000f) string = "glob3")
+; BOTH:        DW_AT_name [DW_FORM_strx1] (indexed (00000013) string = "glob3")
 ;
 ; Extract the offset of a string to verify that it is referenced in the string
 ; offsets section.
 ; BOTH:           .debug_str contents:
 ; BOTH-NOT:       contents:
 ; BOTH:           0x[[GLOB2OFF:[0-9a-f]+]]: "glob2"
 ;
 ; Check the .debug_str_offsets section header and make sure the referenced string
 ; has the correct offset.
 ; BOTH:           .debug_str_offsets contents:
 ; BOTH-NEXT:      0x00000000: Contribution size = 84, Format = DWARF32, Version = 5
 ; BOTH-NEXT:      0x[[CU1_STROFF]]:
 ; BOTH-NEXT:      {{.*:}}
 ; BOTH-NEXT:      {{.*:}}
 ; BOTH-NEXT:      {{.*:}}
 ; BOTH-NEXT:      {{.*:}}
 ; BOTH-NEXT:      {{.*:}}
 ; BOTH-NEXT:      {{.*:}}
 ; BOTH-NEXT:      {{.*:}}
 ; BOTH-NEXT:      {{.*:}}
-; The string with index 9 should be "glob2"
+; BOTH-NEXT:      {{.*:}}
+; BOTH-NEXT:      {{.*:}}
+; BOTH-NEXT:      {{.*:}}
+; BOTH-NEXT:      {{.*:}}
+; BOTH-NEXT:      {{.*:}}
+; BOTH-NEXT:      {{.*:}}
+; BOTH-NEXT:      {{.*:}}
+; BOTH-NEXT:      {{.*:}}
+; BOTH-NEXT:      {{.*:}}
+; The string with index 0x12 should be "glob2"
 ; BOTH-NEXT:      {{.*:}} [[GLOB2OFF]]
 ;
 ; ModuleID = 'test.bc'
 source_filename = "llvm-link"
 
 @glob1 = global i32 0, align 4, !dbg !0
 @glob2 = global i32 0, align 4, !dbg !11
 @glob3 = global i32 0, align 4, !dbg !22

llvm/test/DebugInfo/X86/string-offsets-table.ll

 ; SPLIT-NOT:  contents:
 ; SPLIT:      DW_TAG_compile_unit
 ;
 ; Check that a couple of indexed strings are displayed correctly and that
 ; they have the right format (DW_FORM_strx1).
 ; SPLIT-NOT:  contents:
 ; SPLIT:      DW_TAG_enumerator
 ; SPLIT-NOT:  {{DW_TAG|NULL}}
-; SPLIT:      DW_AT_name [DW_FORM_strx1]    (indexed (00000001) string = "a")
+; SPLIT:      DW_AT_name [DW_FORM_strx1]    (indexed ({{[0-9]+}}) string = "a")
 ; SPLIT-NOT:  contents:
 ; SPLIT:      DW_TAG_enumerator
 ; SPLIT-NOT:  {{DW_TAG|NULL}}
-; SPLIT:      DW_AT_name [DW_FORM_strx1]    (indexed (00000002) string = "b")
+; SPLIT:      DW_AT_name [DW_FORM_strx1]    (indexed ({{[0-9]+}}) string = "b")
 ;
 ; Extract the string offsets referenced in the main file by the skeleton unit.
 ; SPLIT:      .debug_str contents:
 ; SPLIT-NEXT: 0x[[STRHOMETESTSPLIT:[0-9a-f]*]]: "/home/test"
 ; SPLIT-NEXT: 0x[[STRESPLIT:[0-9a-f]*]]: "E"
 ; SPLIT-NEXT: 0x[[STRGLOBSPLIT:[0-9a-f]*]]: "glob"
 ; SPLIT-NEXT: 0x[[STRFOODWOSPLIT:[0-9a-f]*]]: "foo.dwo"
 ;

llvm/test/DebugInfo/X86/subprogram-across-cus.ll

 ; via the struct local type, and "main" is created in the CU for 1.cpp, which
 ; is incorrect.
 ;
 ; See PR48790 for more discussion and original compile commands.
 ;
 ; Check that there are no verifier failures, and that the SP for "main" appears
 ; in the correct CU.
 ; CHECK-LABEL:      DW_TAG_compile_unit
-; CHECK:              DW_AT_name ("1.cpp")
-; CHECK-NOT:          DW_AT_name ("main")
-; CHECK-LABEL:      DW_TAG_compile_unit
 ; CHECK:              DW_AT_name ("2.cpp")
 ; CHECK:            DW_TAG_subprogram
 ; CHECK:              DW_AT_name ("main")
+; CHECK-LABEL:      DW_TAG_compile_unit
+; CHECK:              DW_AT_name ("1.cpp")
+; CHECK-NOT:          DW_AT_name ("main")
 
 source_filename = "ld-temp.o"
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Function Attrs: noinline norecurse nounwind optnone uwtable mustprogress
 define internal fastcc void @_Z2f1v() unnamed_addr {
 entry:

llvm/test/DebugInfo/X86/template.ll

 ;  return var<int>;
 ; }
 ; template<typename> struct y_impl { struct nested { }; };
 ; int glbl = func<3, &glbl, y_impl, nullptr, E, 1, 2>();
 ; y_impl<int>::nested n;
 
 ; VERIFY-NOT: error:
 
-; CHECK: [[INT:0x[0-9a-f]*]]:{{ *}}DW_TAG_base_type
-; CHECK-NEXT: DW_AT_name{{.*}} = "int"
-
-; CHECK: DW_TAG_structure_type
-; CHECK: DW_AT_name{{.*}}"y_impl<int>"
-; CHECK-NOT: {{TAG|NULL}}
-; CHECK: DW_TAG_template_type_parameter
-
-; CHECK: DW_TAG_variable
-; CHECK-NEXT: DW_AT_name{{.*}}"var"
-; CHECK-NOT: NULL
-; CHECK: DW_TAG_template_type_parameter
-; CHECK-NEXT: DW_AT_type{{.*}}=> {[[INT]]}
-; CHECK-NEXT: DW_AT_name{{.*}}= "T"
-
-
 ; CHECK: DW_AT_name{{.*}}"func<3, &glbl, y_impl, nullptr, E, 1, 2>"
 ; CHECK-NOT: NULL
 ; CHECK: DW_TAG_template_value_parameter
-; CHECK-NEXT: DW_AT_type{{.*}}=> {[[INT]]}
+; CHECK-NEXT: DW_AT_type{{.*}}=> {[[INT:0x[0-9a-f]*]]}
 ; CHECK-NEXT: DW_AT_name{{.*}}= "x"
 ; CHECK-NEXT: DW_AT_const_value [DW_FORM_sdata]{{.*}}(3)
 
 ; CHECK: DW_TAG_template_value_parameter
 ; CHECK-NEXT: DW_AT_type{{.*}}=> {[[INTPTR:0x[0-9a-f]*]]}
-
 ; The address of the global 'glbl', followed by DW_OP_stack_value (9f), to use
 ; the value immediately, rather than indirecting through the address.
-
 ; CHECK-NEXT: DW_AT_location [DW_FORM_exprloc]{{ *}}(DW_OP_addr 0x0, DW_OP_stack_value)
 ; CHECK-NOT: NULL
 
 ; CHECK: DW_TAG_GNU_template_template_param
 ; CHECK-NEXT: DW_AT_name{{.*}}= "y"
 ; CHECK-NEXT: DW_AT_GNU_template_name{{.*}}= "y_impl"
 ; CHECK-NOT: NULL
 

 ; CHECK: DW_TAG_template_value_parameter
 ; CHECK-NEXT: DW_AT_type{{.*}}=> {[[INT]]}
 ; CHECK-NEXT: DW_AT_const_value  [DW_FORM_sdata]{{.*}}(1)
 ; CHECK-NOT: NULL
 ; CHECK: DW_TAG_template_value_parameter
 ; CHECK-NEXT: DW_AT_type{{.*}}=> {[[INT]]}
 ; CHECK-NEXT: DW_AT_const_value  [DW_FORM_sdata]{{.*}}(2)
 
+; CHECK: [[INT]]:{{ *}}DW_TAG_base_type
+; CHECK-NEXT: DW_AT_name{{.*}} = "int"
+
+; CHECK: DW_TAG_structure_type
+; CHECK: DW_AT_name{{.*}}"y_impl<int>"
+; CHECK-NOT: {{TAG|NULL}}
+; CHECK: DW_TAG_template_type_parameter
+
+; CHECK: DW_TAG_variable
+; CHECK-NEXT: DW_AT_name{{.*}}"var"
+; CHECK-NOT: NULL
+; CHECK: DW_TAG_template_type_parameter
+; CHECK-NEXT: DW_AT_type{{.*}}=> {[[INT]]}
+; CHECK-NEXT: DW_AT_name{{.*}}= "T"
+
 ; CHECK: [[INTPTR]]:{{ *}}DW_TAG_pointer_type
 ; CHECK-NEXT: DW_AT_type{{.*}} => {[[INT]]}
 
 ; CHECK: [[NULLPTR]]:{{ *}}DW_TAG_unspecified_type
 ; CHECK-NEXT: DW_AT_name{{.*}}= "decltype(nullptr)"
 
 source_filename = "test.cpp"
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"

llvm/test/DebugInfo/X86/tls.ll

 ; TODO: Add expected output for -emulated-tls tests.
 ; EMUSINGLE-32: {{^}}
 ; EMUSINGLE-64: {{^}}
 
 ; FIXME: add relocation and DWARF expression support to llvm-dwarfdump & use
 ; that here instead of raw assembly printing
 
 ; FISSION: .section    .debug_info.dwo,
+; SINGLE: .section     .debug_info,
+; DARWIN: .section     {{.*}}debug_info,
+
+; FISSION: DW_TAG_subprogram
+; SINGLE: DW_TAG_subprogram
+; DARWIN: DW_TAG_subprogram
+
+; FISSION: DW_TAG_template_value_parameter
+; FISSION: .byte 3 # DW_AT_location
+; DW_OP_GNU_addr_index
+; FISSION-NEXT: .byte 251
+; FISSION-NEXT: .byte 2
+; DW_OP_stack_value
+; FISSION-NEXT: .byte 159
+
+; FISSION: DW_TAG_variable
+; SINGLE: DW_TAG_variable
+; DARWIN: DW_TAG_variable
+
 ; 3 bytes of data in this DW_FORM_exprloc representation of the location of 'tls'
 ; FISSION: .byte 3{{ *}}# DW_AT_location
 ; DW_OP_GNU_const_index (0xfx == 252) to refer to the debug_addr table
 ; FISSION-NEXT: .byte 252
-; an index of zero into the debug_addr table
-; FISSION-NEXT: .byte 0
-
-; SINGLE: .section     .debug_info,
-; DARWIN: .section     {{.*}}debug_info,
+; an index of one into the debug_addr table
+; FISSION-NEXT: .byte 1
 
 ; 10 bytes of data in this DW_FORM_exprloc representation of the location of 'tls'
 ; SINGLE-64: .byte     10 # DW_AT_location
 ; DW_OP_const8u (0x0e == 14) of address
 ; SINGLE-64-NEXT: .byte        14
 ; SINGLE-64-NEXT: .quad tls@DTPOFF
 
 ; DARWIN: .byte     10 ## DW_AT_location

 ; GNUOP-NEXT: .byte 224
 ; DW_OP_form_tls_address
 ; STDOP-NEXT: .byte 155
 
 ; FISSION: DW_TAG_variable
 ; FISSION: .byte 2 # DW_AT_location
 ; DW_OP_GNU_addr_index
 ; FISSION-NEXT: .byte 251
-; FISSION-NEXT: .byte 1
-
-; FISSION: DW_TAG_template_value_parameter
-; FISSION: .byte 3 # DW_AT_location
-; DW_OP_GNU_addr_index
-; FISSION-NEXT: .byte 251
-; FISSION-NEXT: .byte 1
-; DW_OP_stack_value
-; FISSION-NEXT: .byte 159
+; FISSION-NEXT: .byte 2
 
-; check that the expected TLS address description is the first thing in the debug_addr section
+; check that the expected TLS address description is the second thing in the debug_addr section
 ; FISSION: .section    .debug_addr
 ; FISSION-NEXT: .Laddr_table_base0:
-; FISSION-NEXT: .quad  tls@DTPOFF
-; FISSION-NEXT: .quad  glbl
-; FISSION-NOT: .quad  glbl
+; FISSION-NEXT: .quad .Lfunc_begin0
+; FISSION-NEXT: .quad tls@DTPOFF
+; FISSION-NEXT: .quad glbl
+; FISSION-NOT: .quad glbl
 
 ; Generated from:
 
 ; __thread int tls;
 ; int glbl;
 ;
 ; template <int *I>
 ; int func() {

llvm/test/DebugInfo/X86/tu-to-non-tu.ll

 ; };
 ; void templ_non_tu<bool>::f1() {}
 ; struct ref_templ_non_tu_mangled {
 ;   templ_non_tu<bool> v1;
 ; };
 ; ref_templ_non_tu_mangled v4;
 
 
-
-
 ; CHECK-LABEL: Type Unit:
+
 ; CHECK: DW_TAG_class_type
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name {{.*}}"ref_from_ref_internal_template"
 
-
 ; CHECK-LABEL: Compile Unit:
 
 ; CHECK: DW_TAG_structure_type
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_name {{.*}}"tu_ref_non_tu"
+; CHECK: DW_AT_name {{.*}}"non_tu"
+; CHECK: NULL
 
 ; CHECK: DW_TAG_structure_type
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_name {{.*}}"non_tu"
+; CHECK: DW_AT_name {{.*}}"_STN|templ_non_tu|<int>"
+
+; CHECK: DW_TAG_structure_type
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_name      ("templ_non_tu")
+; CHECK-NOT: DW_TAG
+; CHECK: DW_TAG_template_type_parameter
+; CHECK-NEXT: DW_AT_type    {{.*}}"long"
+
+; CHECK: DW_TAG_structure_type
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_name      ("_STN|templ_non_tu|<bool>")
+; CHECK-NOT: DW_TAG
+; CHECK: DW_TAG_template_type_parameter
+; CHECK-NEXT: DW_AT_type    {{.*}}"bool"
+
+; CHECK: DW_TAG_structure_type
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_name {{.*}}"tu_ref_non_tu"
 
 ; CHECK: DW_TAG_structure_type
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name {{.*}}"ref_internal"
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_byte_size
 
 ; CHECK: DW_TAG_namespace
 ; CHECK-NOT: {{DW_TAG|DW_AT}}
 ; CHECK: DW_TAG_structure_type
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name {{.*}}"internal"
 
 ; CHECK: DW_TAG_structure_type
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name {{.*}}"internal_template<ref_from_ref_internal_template>"
 
 ; CHECK: DW_TAG_structure_type
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name {{.*}}"ref_templ_non_tu"
-; CHECK: DW_TAG_structure_type
-; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_name {{.*}}"_STN|templ_non_tu|<int>"
 
 ; CHECK: DW_TAG_structure_type
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name {{.*}}"ref_templ_non_tu_simple"
-; CHECK: DW_TAG_structure_type
-; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_name      ("templ_non_tu")
-; CHECK-NOT: DW_TAG
-; CHECK: DW_TAG_template_type_parameter
-; CHECK-NEXT: DW_AT_type    {{.*}}"long"
 
 ; CHECK: DW_TAG_structure_type
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name {{.*}}"ref_templ_non_tu_mangled"
-; CHECK: DW_TAG_structure_type
-; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_name      ("_STN|templ_non_tu|<bool>")
-; CHECK-NOT: DW_TAG
-; CHECK: DW_TAG_template_type_parameter
-; CHECK-NEXT: DW_AT_type    {{.*}}"bool"
+
 ; CHECK: DW_TAG_class_type
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name {{.*}}"ref_internal_template"
 ; CHECK: DW_TAG_class_type
 ; CHECK-NEXT:   DW_AT_declaration       (true)
 ; CHECK-NEXT:   DW_AT_signature (0x30c4e2370930c7ad)
 
 %struct.ref_internal = type { %"struct.(anonymous namespace)::internal" }

llvm/test/DebugInfo/X86/vla-global.ll

 ; RUN: llc -mtriple=x86_64-apple-darwin %s -o - -filetype=obj | llvm-dwarfdump - | FileCheck %s
+; CHECK: NULL
+; CHECK-EMPTY:
 ; CHECK: 0x00000[[G:.*]]:     DW_TAG_variable
 ; CHECK-NEXT:                DW_AT_name ("g")
 ; CHECK: DW_TAG_array_type
 ; CHECK-NEXT:  DW_AT_type ({{.*}} "int")
 ; CHECK-NOT: DW_TAG
 ; CHECK:       DW_TAG_subrange_type
 ; CHECK-NEXT:     DW_AT_type  ({{.*}} "__ARRAY_SIZE_TYPE__")
 ; CHECK-NEXT:      DW_AT_count  (0x00000[[G]])

llvm/test/DebugInfo/attr-btf_tag.ll

 
 attributes #0 = { noinline nounwind optnone uwtable "frame-pointer"="all" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
 attributes #1 = { nofree nosync nounwind readnone speculatable willreturn }
 
 !llvm.dbg.cu = !{!2}
 !llvm.module.flags = !{!10, !11, !12, !13, !14}
 !llvm.ident = !{!15}
 
-!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
-!1 = distinct !DIGlobalVariable(name: "g1", scope: !2, file: !3, line: 8, type: !6, isLocal: false, isDefinition: true, annotations: !7)
-
-; CHECK:       DW_TAG_variable
-; CHECK-NEXT:     DW_AT_name      ("g1")
-; CHECK:          DW_TAG_LLVM_annotation
-; CHECK-NEXT:       DW_AT_name    ("btf_decl_tag")
-; CHECK-NEXT:       DW_AT_const_value     ("tag1")
-; CHECK-EMPTY:
-; CHECK-NEXT:     DW_TAG_LLVM_annotation
-; CHECK-NEXT:       DW_AT_name    ("btf_decl_tag")
-; CHECK-NEXT:       DW_AT_const_value     ("tag2")
-; CHECK-EMPTY:
-; CHECK-NEXT:     NULL
-
 !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 13.0.0 (https://github.com/llvm/llvm-project.git 305231a4f71b68945b4dd92925c76ff49e377c86)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, splitDebugInlining: false, nameTableKind: None)
 !3 = !DIFile(filename: "t.c", directory: "/tmp/home/yhs/work/tests/llvm/btf_tag")
 !4 = !{}
 !5 = !{!0}
 !6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !7 = !{!8, !9}
 !8 = !{!"btf_decl_tag", !"tag1"}
 !9 = !{!"btf_decl_tag", !"tag2"}

 ; CHECK-NEXT:     DW_AT_const_value     ("tag1")
 ; CHECK-EMPTY:
 ; CHECK-NEXT:   DW_TAG_LLVM_annotation
 ; CHECK-NEXT:     DW_AT_name    ("btf_decl_tag")
 ; CHECK-NEXT:     DW_AT_const_value     ("tag2")
 ; CHECK-EMPTY:
 ; CHECK-NEXT:   NULL
 
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "g1", scope: !2, file: !3, line: 8, type: !6, isLocal: false, isDefinition: true, annotations: !7)
+; CHECK:       DW_TAG_variable
+; CHECK-NEXT:     DW_AT_name      ("g1")
+; CHECK:          DW_TAG_LLVM_annotation
+; CHECK-NEXT:       DW_AT_name    ("btf_decl_tag")
+; CHECK-NEXT:       DW_AT_const_value     ("tag1")
+; CHECK-EMPTY:
+; CHECK-NEXT:     DW_TAG_LLVM_annotation
+; CHECK-NEXT:       DW_AT_name    ("btf_decl_tag")
+; CHECK-NEXT:       DW_AT_const_value     ("tag2")
+; CHECK-EMPTY:
+; CHECK-NEXT:     NULL
+
 !17 = !DISubroutineType(types: !18)
 !18 = !{!6, !19}
 !19 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !20, size: 64)
 !20 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "t1", file: !3, line: 4, size: 32, elements: !21, annotations: !7)
 !21 = !{!22}
 !22 = !DIDerivedType(tag: DW_TAG_member, name: "a", scope: !20, file: !3, line: 5, baseType: !6, size: 32, annotations: !7)
 
 ; CHECK:      DW_TAG_structure_type