[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.

159–171

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)

160

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.

161–162

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.

499

Unrelated formatting should be removed or committed separately.

1034–1035

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

159–171

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.

160

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

159–171

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

160

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

159–171

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;
 
+  /// A global variable whose DIE does not yet have a parent.
+  struct DeferredGlobalVariable {
+    const DIGlobalVariable *GV;
+    DIE *Die;
+    ArrayRef<GlobalExpr> Exprs;
+  };
+  SmallVector<DeferredGlobalVariable, 1> DeferredGlobalVariables;
+
   /// 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;
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 the parent DIE of the global variable.
+  DIE *getOrCreateGlobalVariableParentDIE(const DIGlobalVariable *GV,
+                                          ArrayRef<GlobalExpr> GlobalExprs);
   /// Get or create global variable DIE.
   DIE *
   getOrCreateGlobalVariableDIE(const DIGlobalVariable *GV,
                                ArrayRef<GlobalExpr> GlobalExprs);
 
   DIE *getOrCreateCommonBlock(const DICommonBlock *CB,
                               ArrayRef<GlobalExpr> GlobalExprs);
 
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);
+  /// Move static variable DIEs to the appropriate parent DIE.
+  void finishStaticVariableDIEs();
 
   /// 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);
 }
 
+DIE *DwarfCompileUnit::getOrCreateGlobalVariableParentDIE(
+    const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) {
+  auto *Scope = GV->getScope();
+  if (auto *ParentDie = getAbstractSPDies()[Scope])
+    return ParentDie;
+  if (auto *CB = Scope ? dyn_cast<DICommonBlock>(Scope) : nullptr)
+    return getOrCreateCommonBlock(CB, GlobalExprs);
+  return getOrCreateContextDIE(Scope);
+}
+
+void DwarfCompileUnit::finishStaticVariableDIEs() {
+  for (auto &Var : DeferredGlobalVariables)
+    getOrCreateGlobalVariableParentDIE(Var.GV, Var.Exprs)->addChild(Var.Die);
+}
+
 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 *VariableDIE = DIE::get(DIEValueAllocator, GV->getTag());
+  const auto *Scope = GV->getScope();
+  if (Scope && isa<DILocalScope>(Scope)) {
+    // 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 adding these DIEs to their parent DIE until all
+    // subprograms have been found and created.
+    DeferredGlobalVariables.push_back({GV, VariableDIE, GlobalExprs});
+  } else {
+    getOrCreateGlobalVariableParentDIE(GV, GlobalExprs)->addChild(VariableDIE);
+  }
+  insertDIE(GV, VariableDIE);
 
-  // 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());
     // We need the declaration DIE that is in the static member's class.
     DIE *VariableSpecDIE = getOrCreateStaticMemberDIE(SDMDecl);
     addDIEEntry(*VariableDIE, dwarf::DW_AT_specification, *VariableSpecDIE);
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

if (CUMap.size() > 1)
     DWOName = Asm->TM.Options.MCOptions.SplitDwarfFile;
 
   // Handle anything that needs to be done on a per-unit basis after
   // all other generation.
   for (const auto &P : CUMap) {
     auto &TheCU = *P.second;
     if (TheCU.getCUNode()->isDebugDirectivesOnly())
       continue;
+    TheCU.finishStaticVariableDIEs();
     // Emit DW_AT_containing_type attribute to connect types with their
     // vtable holding type.
     TheCU.constructContainingTypeDIEs();
 
     // Add CU specific attributes if we need to add any.
     // If we're splitting the dwarf out now that we've got the entire
     // CU then add the dwo id to it.
     auto *SkCU = TheCU.getSkeleton();

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

void DwarfUnit::addDIETypeSignature(DIE &Die, uint64_t Signature) {
   addAttribute(Die, dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
                DIEInteger(Signature));
 }
 
 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
                             DIEEntry Entry) {
   const DIEUnit *CU = Die.getUnit();
   const DIEUnit *EntryCU = Entry.getEntry().getUnit();
-  if (!CU)
+  if (!CU) {
     // We assume that Die belongs to this CU, if it is not linked to any CU yet.
     CU = getUnitDie().getUnit();
+    // for (auto &DGV : ((const DwarfCompileUnit *)CU)->DeferredGlobalVariables)
+    //   assert(DGV.Die != &Die);
+  }
   if (!EntryCU)
     EntryCU = getUnitDie().getUnit();
   addAttribute(Die, Attribute,
                EntryCU == CU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
                Entry);
 }
 
 DIE &DwarfUnit::createAndAddDIE(dwarf::Tag Tag, DIE &Parent, const DINode *N) {

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

+; RUN: %llc_dwarf -O0 -filetype=obj < %s | llvm-dwarfdump -v -debug-info - | FileCheck --implicit-check-not "{{DW_TAG|NULL}}" %s
+
+; CHECK: DW_TAG_compile_unit
+; CHECK:   DW_TAG_base_type
+; CHECK:   DW_TAG_imported_declaration
+; CHECK:   DW_TAG_subprogram
+; CHECK:     DW_AT_name {{.*}} "foo"
+; CHECK:     DW_AT_inline [DW_FORM_data1]    (DW_INL_inlined)
+; CHECK:     DW_TAG_variable
+; CHECK:       DW_AT_name {{.*}} "local_var"
+; CHECK:     DW_TAG_variable
+; CHECK:       DW_AT_name {{.*}} "static_var"
+; CHECK:     DW_TAG_variable
+; CHECK:       DW_AT_name {{.*}} "imported_static_var"
+; CHECK:     NULL
+; CHECK:   DW_TAG_subprogram
+; CHECK:     DW_AT_name {{.*}} "main"
+; CHECK:     DW_TAG_inlined_subroutine
+; CHECK:       DW_AT_abstract_origin {{.*}} "foo"
+; CHECK:       DW_TAG_variable
+; CHECK:         DW_AT_abstract_origin {{.*}} "local_var"
+; CHECK:     NULL
+; CHECK:   NULL
+; CHECK: NULL
+
+@static_var = internal global i32 4, align 4, !dbg !0
+
+define i32 @main() !dbg !7 {
+  store i32 0, i32* @static_var, align 4, !dbg !15
+  %local_var = alloca i32, align 4
+  call void @llvm.dbg.declare(metadata i32* %local_var, metadata !2, metadata !DIExpression()), !dbg !15
+  store i32 0, i32* %local_var, align 4, !dbg !15
+  ret i32 0
+}
+
+declare void @llvm.dbg.declare(metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!4}
+!llvm.module.flags = !{!11, !12, !13}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = !DIGlobalVariable(name: "static_var", scope: !6, file: !5, line: 3, type: !10, isLocal: false, isDefinition: true)
+!2 = !DILocalVariable(name: "local_var", scope: !6, file: !5, line: 4, type: !10)
+!3 = !DISubroutineType(types: !8)
+!4 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !5, emissionKind: FullDebug, globals: !9, splitDebugInlining: false, imports: !17)
+!5 = !DIFile(filename: "test.cpp", directory: "/")
+!6 = distinct !DISubprogram(name: "foo", scope: !5, file: !5, line: 2, type: !3, scopeLine: 2, unit: !4)
+!7 = distinct !DISubprogram(name: "main", scope: !5, file: !5, line: 7, type: !3, scopeLine: 7, unit: !4)
+!8 = !{}
+!9 = !{!0}
+!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!11 = !{i32 7, !"Dwarf Version", i32 4}
+!12 = !{i32 2, !"Debug Info Version", i32 3}
+!13 = !{i32 1, !"wchar_size", i32 4}
+!15 = !DILocation(line: 4, column: 7, scope: !6, inlinedAt: !16)
+!16 = !DILocation(line: 9, column: 3, scope: !7)
+!17 = !{!18}
+!18 = !DIImportedEntity(tag: DW_TAG_imported_declaration, scope: !4, entity: !19, line: 122)
+!19 = !DIGlobalVariable(name: "imported_static_var", scope: !6, file: !5, line: 3, type: !10, isLocal: false, isDefinition: true)

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"