[DebugInfo] Place static variable DIEs under the correct parent

[ellis]

Summary

If a static variable (which is also a global variable) is defined in a function that is inlined and removed, then the concrete DIE of the function will not be created and the variable's DIE won't have the correct parent. Instead, delay the construction of static variable DIEs until finalizeModuleInfo() so that the abstract origin SP DIEs are available. This depends on https://reviews.llvm.org/D110294 because getOrCreateGlobalVariableDIE() should look for an abstract origin SP DIE in this case.

This fixes https://bugs.llvm.org/show_bug.cgi?id=30637

Some of this work was inspired by @krisb's work in https://reviews.llvm.org/D109703.

[dblaikie]

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

100

Rather than creating then deferring them - would it work if the whole creation were deferred until needed? (ie: move this loop:

DenseSet<DIGlobalVariable *> Processed;
for (auto *GVE : CUNode->getGlobalVariables()) {
  DIGlobalVariable *GV = GVE->getVariable();
  if (Processed.insert(GV).second)
    CU.getOrCreateGlobalVariableDIE(GV, sortGlobalExprs(GVMap[GV]));
}

from beginModule to finalizeModuleInfo?

[ellis]

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

100

The issue is getOrCreateGlobalVariableDIE() is call in constructImportedEntityDIE() before finalizeModuleInfo(). That's why I made sure to include DIImportedEntity() in the test case.

[dblaikie]

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

100

& we can't move the imported entity creation to the end of the module because they're needed for lexical scopes?

[ellis]

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

100

Yeah I guess so. IMO it seems like it's simpler to just give a special case to static globals instead of deferring all globals, imported entities, and their dependencies.

[dblaikie]

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

138–143

Be good to address these else-after-return issues as flagged by the linter.

154–161

I worry about creating DIEs without parents for extended periods of time within the DWARF emission - as they may confuse/break certain assumptions about parentage that are made when trying to determine when to use cross-unit references: https://github.com/llvm/llvm-project/blob/d8d84c9df82fc114f2b22a533a8183065ca1a2e0/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp#L380

Perhaps you could do some testing around whether this is an issue/comes up for this case? (and/or maybe add an expensive assertion that checks somewhere in that code that the DIE being queried for its unit is not in the UnfinishedStaticVariables list)

155

This condition doesn't cover all/only the cases where a global variable is local to a function. It misses the case of local static variables in inline functions (these are not "local to unit", unlike a local static in a non-inline function definition) and it incorrectly classifies a file-scoped static variable as needing deferred initialization, when it doesn't.

156–157

I'd probably flesh out this comment a bit more - it's not immediately obvious how the first part relates to the last part. Maybe something like:

Defer adding static variables to their parent DIE until all subprograms have been found/created - until then (without a second pass) it's not possible to know whether there will be a separate abstract origin DIE (which should be the parent for local static 'global' variables) or only one out of line subprogram (which would be the parent in that case).

Maybe? I'm not sure.

491

Unrelated formatting should be removed or committed separately.

1026–1027

This can/should probably be committed separately - feel free to commit without review. (maybe flesh out the comment a bit to explain what's missing here - I assume/think the bug this comment is alluding to is that static local variables currently always go in the root of the subprogram, rather than in their appropriate lexical scope?)

llvm/test/CodeGen/ARM/2011-01-19-MergedGlobalDbg.ll

14 ↗

(On Diff #367916)

Just removing these lines is probably not ideal - it means the DW_TAG_variable that's being checked is potentially (likely) unrelated to the attributes being checked. So perhaps the right answer is to leave the CHECK-NOT in, but add a few extra "CHECK: DW_TAG_variable"s before the first one, to skip over whatever extra variables there are in these test cases?)

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

18–31 ↗

(On Diff #367916)

Could you explain more about what this test was testing for and what changed? Looks like the original code was checking for two different DIEs but didn't check either DW_TAG? So maybe adding the DW_TAG checking would make the test more legible, to make it clear which things are being checked for rather than it sort of looking like a weird collection of attributes we wouldn't expect to see on a single DIE (ie: wouldn't expect noreturn and location on the same DIE - one is for functions, the other is for variables)

[ellis]

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

154–161

Yes, you are right. In fact, in this function we add attributes to this DIE which calls addDIEEntry() and triggers that assertion. I'll have to see if I can somehow defer the creation of all global variable DIEs until after the module has been processed like you mentioned earlier.

155

I'm now checking the scope to see if it's a DILocalScope, which I assume means it is a static variable. Let me know if there is another case to consider.

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

18–31 ↗

(On Diff #367916)

I guess fixing which globals get deferred made this test pass without any changes

[ellis]

Rebase and resolve comments

[dblaikie]

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

154–161

Did this issue get resolved? Looks like this code is still creating VariableDIE and not immediately giving it a parent.

155

Not sure - Yeah, looks like DILexicalBlockScope and DISubprogram are both kinds of DILocalScope, so what you've got here should probably cover the necessary cases I can think of.

[ellis]

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

154–161

No I still need to fix this. I just pushed the work I had done so far.

[krisb]

@ellis, @dblaikie I'm working on a patch that aims to fix a similar issue with static locals reported at https://bugs.llvm.org/show_bug.cgi?id=44695, just published the review at https://reviews.llvm.org/D109703. It should fix the issue with inlined scopes as well. Could you please take a look if you have a chance?

[ellis]

Update

[ellis]

Add comment

[ellis]

Remove dependency on D110294 by checking for abstract SPs in getOrCreateGlobalVariableDIE() when appropriate.

[ellis]

Moved to https://reviews.llvm.org/D112337

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

 class GlobalVariable;
 class MCExpr;
 class MCSymbol;
 class MDNode;
 
 enum class UnitKind { Skeleton, Full };
 
 class DwarfCompileUnit final : public DwarfUnit {
+public:
+  /// A pair of GlobalVariable and DIExpression.
+  struct GlobalExpr {
+    const GlobalVariable *Var;
+    const DIExpression *Expr;
+  };
+
+private:
   /// A numeric ID unique among all CUs in the module
   unsigned UniqueID;
   bool HasRangeLists = false;
 
   /// The start of the unit line section, this is also
   /// reused in appyStmtList.
   MCSymbol *LineTableStartSym;
 
private:
 
   // The base address of this unit, if any. Used for relative references in
   // ranges/locs.
   const MCSymbol *BaseAddress = nullptr;
 
   DenseMap<const MDNode *, DIE *> AbstractSPDies;
   DenseMap<const DINode *, std::unique_ptr<DbgEntity>> AbstractEntities;
 
+  /// Static variables defined within the CU.
+  DenseMap<const DIGlobalVariable *, SmallVector<GlobalExpr, 1>>
+      DeferredStaticVariables;
+
   /// DWO ID for correlating skeleton and split units.
   uint64_t DWOId = 0;
 
   /// Construct a DIE for the given DbgVariable without initializing the
   /// DbgVariable's DIE reference.
   DIE *constructVariableDIEImpl(const DbgVariable &DV, bool Abstract);
 
   bool isDwoUnit() const override;
 
   DenseMap<const MDNode *, DIE *> &getAbstractSPDies() {
     if (isDwoUnit() && !DD->shareAcrossDWOCUs())
public:
   void initStmtList();
 
   /// Apply the DW_AT_stmt_list from this compile unit to the specified DIE.
   void applyStmtList(DIE &D);
 
   /// Get line table start symbol for this unit.
   MCSymbol *getLineTableStartSym() const { return LineTableStartSym; }
 
-  /// A pair of GlobalVariable and DIExpression.
-  struct GlobalExpr {
-    const GlobalVariable *Var;
-    const DIExpression *Expr;
-  };
-
   struct BaseTypeRef {
     BaseTypeRef(unsigned BitSize, dwarf::TypeKind Encoding) :
       BitSize(BitSize), Encoding(Encoding) {}
     unsigned BitSize;
     dwarf::TypeKind Encoding;
     DIE *Die = nullptr;
   };
 
   std::vector<BaseTypeRef> ExprRefedBaseTypes;
 
   /// Get or create global variable DIE.
   DIE *
   getOrCreateGlobalVariableDIE(const DIGlobalVariable *GV,
                                ArrayRef<GlobalExpr> GlobalExprs);
 
+  /// Defer the construction of a static variable DIE until its scope DIE has
+  /// been created.
+  void deferStaticVariable(const DIGlobalVariable *GV,
+                           ArrayRef<GlobalExpr> GlobalExprs) {
+    SmallVector<GlobalExpr> GEs(GlobalExprs.begin(), GlobalExprs.end());
+    DeferredStaticVariables.insert(std::make_pair(GV, GEs));
+  }
+
   DIE *getOrCreateCommonBlock(const DICommonBlock *CB,
                               ArrayRef<GlobalExpr> GlobalExprs);
 
   void addLocationAttribute(DIE *ToDIE, const DIGlobalVariable *GV,
                             ArrayRef<GlobalExpr> GlobalExprs);
 
   /// addLabelAddress - Add a dwarf label attribute data and value using
   /// either DW_FORM_addr or DW_FORM_GNU_addr_index.
public:
   void constructCallSiteParmEntryDIEs(DIE &CallSiteDIE,
                                       SmallVector<DbgCallSiteParam, 4> &Params);
 
   /// Construct import_module DIE.
   DIE *constructImportedEntityDIE(const DIImportedEntity *Module);
 
   void finishSubprogramDefinition(const DISubprogram *SP);
   void finishEntityDefinition(const DbgEntity *Entity);
+  void finishDeferredStaticVariableDIEs();
 
   /// Find abstract variable associated with Var.
   using InlinedEntity = DbgValueHistoryMap::InlinedEntity;
   DbgEntity *getExistingAbstractEntity(const DINode *Node);
   void createAbstractEntity(const DINode *Node, LexicalScope *Scope);
 
   /// Set the skeleton unit associated with this unit.
   void setSkeleton(DwarfCompileUnit &Skel) { Skeleton = &Skel; }

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

unsigned DwarfCompileUnit::getOrCreateSourceID(const DIFile *File) {
   if (!File)
     return Asm->OutStreamer->emitDwarfFileDirective(0, "", "", None, None,
                                                     CUID);
   return Asm->OutStreamer->emitDwarfFileDirective(
       0, File->getDirectory(), File->getFilename(), DD->getMD5AsBytes(File),
       File->getSource(), CUID);
 }
 
+void DwarfCompileUnit::finishDeferredStaticVariableDIEs() {
+  for (auto &Var : DeferredStaticVariables)
+    getOrCreateGlobalVariableDIE(Var.first, Var.second);
+  DeferredStaticVariables.clear();
+}
+
 DIE *DwarfCompileUnit::getOrCreateGlobalVariableDIE(
     const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) {
   // Check for pre-existence.
   if (DIE *Die = getDIE(GV))
     return Die;
 
   assert(GV);
 
   auto *GVContext = GV->getScope();
   const DIType *GTy = GV->getType();
 
   // Construct the context before querying for the existence of the DIE in
   // case such construction creates the DIE.
-  auto *CB = GVContext ? dyn_cast<DICommonBlock>(GVContext) : nullptr;
-  DIE *ContextDIE = CB ? getOrCreateCommonBlock(CB, GlobalExprs)
-    : getOrCreateContextDIE(GVContext);
+  DIE *ContextDIE = nullptr;
+  if (auto *CB = dyn_cast_or_null<DICommonBlock>(GVContext))
+    ContextDIE = getOrCreateCommonBlock(CB, GlobalExprs);
+  else if (auto *LS = dyn_cast_or_null<DILocalScope>(GVContext))
+    ContextDIE = getAbstractSPDies().lookup(LS->getSubprogram());
+
+  if (!ContextDIE)
+    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());
case TargetFrameLowering::DwarfFrameBase::WasmFrameBase: {
         addSInt(*Loc, dwarf::DW_FORM_sdata, TI_GLOBAL_RELOC);
         if (!isDwoUnit()) {
           addLabel(*Loc, dwarf::DW_FORM_data4, SPSym);
           DD->addArangeLabel(SymbolCU(this, SPSym));
         } else {
           // FIXME: when writing dwo, we need to avoid relocations. Probably
           // the "right" solution is to treat globals the way func and data
           // symbols are (with entries in .debug_addr).
           // For now, since we only ever use index 0, this should work as-is.       
           addUInt(*Loc, dwarf::DW_FORM_data4, FrameBase.Location.WasmLoc.Index);
         }
         addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
         addBlock(*SPDie, dwarf::DW_AT_frame_base, Loc);
       } else {
         DIELoc *Loc = new (DIEValueAllocator) DIELoc;
         DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
         DIExpressionCursor Cursor({});
DIE *DwarfCompileUnit::createScopeChildrenDIE(LexicalScope *Scope,
   for (auto &DV : Vars.Args)
     Children.push_back(constructVariableDIE(*DV.second, *Scope, ObjectPointer));
 
   // Emit local variables.
   auto Locals = sortLocalVars(Vars.Locals);
   for (DbgVariable *DV : Locals)
     Children.push_back(constructVariableDIE(*DV, *Scope, ObjectPointer));
 
   // Skip imported directives in gmlt-like data.
   if (!includeMinimalInlineScopes()) {
     // There is no need to emit empty lexical block DIE.
     for (const auto *IE : ImportedEntities[Scope->getScopeNode()])
       Children.push_back(
           constructImportedEntityDIE(cast<DIImportedEntity>(IE)));
   }
 
   if (HasNonScopeChildren)
     *HasNonScopeChildren = !Children.empty();

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

for (auto *GVE : CUNode->getGlobalVariables()) {
       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]));
+      if (Processed.insert(GV).second) {
+        auto &GEs = sortGlobalExprs(GVMap[GV]);
+        if (isa_and_nonnull<DILocalScope>(GV->getScope())) {
+          // If a DIGlobalVariable's scope is a DILocalScope, it is a
+          // function-local static global variable. At this point it is not
+          // possible to know whether the parent will be a separate abstract
+          // origin DIE or an out-of-line subprogram DIE. Defer creating these
+          // DIEs until all subprograms have been found and created.
+          CU.deferStaticVariable(GV, GEs);
+          continue;
+        }
+        CU.getOrCreateGlobalVariableDIE(GV, GEs);
+      }
     }
 
     for (auto *Ty : CUNode->getEnumTypes()) {
       // The enum types array by design contains pointers to
       // MDNodes rather than DIRefs. Unique them here.
       CU.getOrCreateTypeDIE(cast<DIType>(Ty));
     }
     for (auto *Ty : CUNode->getRetainedTypes()) {
void DwarfDebug::finishSubprogramDefinitions() {
   }
 }
 
 void DwarfDebug::finalizeModuleInfo() {
   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
 
   finishSubprogramDefinitions();
 
+  for (const auto &P : CUMap)
+    P.second->finishDeferredStaticVariableDIEs();
+
   finishEntityDefinitions();
 
   // Include the DWO file name in the hash if there's more than one CU.
   // This handles ThinLTO's situation where imported CUs may very easily be
   // duplicate with the same CU partially imported into another ThinLTO unit.
   StringRef DWOName;
   if (CUMap.size() > 1)
     DWOName = Asm->TM.Options.MCOptions.SplitDwarfFile;

llvm/test/DebugInfo/Generic/inlined-static-var.ll

+; RUN: %llc_dwarf -O0 -filetype=obj < %s | llvm-dwarfdump -debug-info - | FileCheck --implicit-check-not "{{DW_TAG|NULL}}" %s
+
+; inline __attribute__((always_inline))
+; int foo() {
+;   static int global;
+;   return global;
+; }
+; int bar() { return foo(); }
+
+; Ensure that global variables reference the correct subprograms even if
+; those subprograms are inlined.
+
+; CHECK: DW_TAG_compile_unit
+; CHECK: [[FOO:0x.*]]:  DW_TAG_subprogram
+; CHECK:     DW_AT_name       ("foo")
+; CHECK:     DW_AT_inline     (DW_INL_inlined)
+; CHECK:     DW_TAG_variable
+; CHECK:       DW_AT_name     ("global")
+; CHECK:     NULL
+; CHECK:   DW_TAG_base_type
+; CHECK:   DW_TAG_subprogram
+; CHECK:     DW_AT_name       ("bar")
+; CHECK:     DW_TAG_inlined_subroutine
+; CHECK:       DW_AT_abstract_origin ([[FOO]] "_Z3foov")
+; CHECK:     NULL
+; CHECK:   NULL
+
+@_ZZ3foovE6global = linkonce_odr dso_local global i32 0, align 4, !dbg !0
+
+define dso_local i32 @_Z3barv() !dbg !21 {
+  %1 = load i32, i32* @_ZZ3foovE6global, align 4, !dbg !22
+  ret i32 %1, !dbg !24
+}
+
+!llvm.dbg.cu = !{!7}
+!llvm.module.flags = !{!11, !12, !13, !14, !15, !16, !17, !18, !19}
+!llvm.ident = !{!20}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "global", scope: !2, file: !3, line: 3, type: !6, isLocal: false, isDefinition: true)
+!2 = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov", scope: !3, file: !3, line: 2, type: !4, scopeLine: 2, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !7, retainedNodes: !10)
+!3 = !DIFile(filename: "static-var-inlined.cpp", directory: "")
+!4 = !DISubroutineType(types: !5)
+!5 = !{!6}
+!6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!7 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !8, producer: "clang version 14.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !9, splitDebugInlining: false, nameTableKind: None)
+!8 = !DIFile(filename: "static-var-inlined.cpp", directory: "")
+!9 = !{!0}
+!10 = !{}
+!11 = !{i32 7, !"Dwarf Version", i32 4}
+!12 = !{i32 2, !"Debug Info Version", i32 3}
+!13 = !{i32 1, !"wchar_size", i32 4}
+!14 = !{i32 1, !"branch-target-enforcement", i32 0}
+!15 = !{i32 1, !"sign-return-address", i32 0}
+!16 = !{i32 1, !"sign-return-address-all", i32 0}
+!17 = !{i32 1, !"sign-return-address-with-bkey", i32 0}
+!18 = !{i32 7, !"uwtable", i32 1}
+!19 = !{i32 7, !"frame-pointer", i32 1}
+!20 = !{!"clang version 14.0.0"}
+!21 = distinct !DISubprogram(name: "bar", linkageName: "_Z3barv", scope: !3, file: !3, line: 7, type: !4, scopeLine: 7, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !7, retainedNodes: !10)
+!22 = !DILocation(line: 4, column: 10, scope: !2, inlinedAt: !23)
+!23 = distinct !DILocation(line: 7, column: 20, scope: !21)
+!24 = !DILocation(line: 7, column: 13, scope: !21)

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

 ; CHECK: DW_AT_name {{.*}} "D"
 
 ; CHECK: [[GLOB_NS_FUNC:0x[0-9a-f]+]]: DW_TAG_subprogram
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK: DW_AT_linkage_name
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK: DW_AT_name {{.*}} "global_namespace_function"
 
-; CHECK: DW_TAG_subprogram
-; CHECK-NOT: {{DW_TAG|NULL}}
-; CHECK:   DW_AT_name {{.*}} "f3"
-; CHECK-NOT: {{DW_TAG|NULL}}
-; CHECK: [[F3_Z:.*]]:   DW_TAG_variable
-; CHECK-NOT: DW_TAG
-; CHECK:     DW_AT_name {{.*}} "z"
-; CHECK-NOT: {{DW_TAG|NULL}}
-; CHECK:     DW_AT_location
-; CHECK-NOT: {{DW_TAG|NULL}}
-; CHECK:   NULL
-; CHECK-NOT: {{DW_TAG|NULL}}
-
 ; CHECK: [[ANON:.*]]: DW_TAG_namespace
 ; CHECK-NOT:   DW_AT_name
 ; CHECK: [[ANON_I:.*]]: DW_TAG_variable
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:     DW_AT_name {{.*}} "i"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK: [[ANON_INNER:.*]]:  DW_TAG_namespace
 ; CHECK-NOT: DW_TAG

 ; CHECK: DW_AT_specification {{.*}} "_ZN1C22static_member_functionEv"
 
 ; CHECK: [[GLOBAL_FUNC:0x[0-9a-f]+]]: DW_TAG_subprogram
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK: DW_AT_linkage_name
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK: DW_AT_name {{.*}} "global_function"
 
+; CHECK: DW_TAG_subprogram
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:   DW_AT_name {{.*}} "f3"
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK: [[F3_Z:.*]]:   DW_TAG_variable
+; CHECK-NOT: DW_TAG
+; CHECK:     DW_AT_name {{.*}} "z"
+; CHECK-NOT: {{DW_TAG|NULL}}
+; CHECK:     DW_AT_location
+; CHECK-NOT: {{DW_TAG|NULL}}
+; 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"
 ; 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:  [[F3_Z]] STATIC VARIABLE "f3::z"
 ; 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"
 ; 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"

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
+; RUN: llc -O0 -mtriple=x86_64-unknown-linux-gnu %s -filetype=obj -o - | llvm-dwarfdump - | 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: DW_TAG_variable
+; CHECK:                          DW_AT_type  ({{0x.+}} "nml")
+; 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