[DebugInfo] Fix scope for local static variables

[krisb]

Summary

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

On clang side we need to place static locals defined within a bracketed
block into a correct scope. Since getContextDescriptor() does no access lexical
blocks, just pick the innermost lexical scope early.

On llvm side the patch proposes to delay emission of static locals until their
parent scopes are created (just like normal local variables).
In case of inlined function, static locals are created only for abstract
entities (as per suggestions from https://bugs.llvm.org/show_bug.cgi?id=30637).

[ellis]

Thanks for working on this! getOrCreateGlobalVariableDIE() is also called in constructImportedEntityDIE() which means that there could be some globals without DIE parents. In D108492 I've added this to the added test case.

!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)

But maybe we can fix this in another diff?

[krisb]

In D109703#2998155, @ellis wrote:

I've added this to the added test case.

!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)

Thank you for pointing to this! Just in case, do you have a C++ example, that reproduces the issue with imported static local declaration? I'm asking, cause in your example DW_TAG_imported_declaration has CU as a scope, while DIGlobalVariable is function-scoped. This looks a bit strange. I mean, constructImportedEntityDIE() called from DwarfDebug::beginModule() skips all local-scoped entities, and unless I'm missing something static locals shouldn't go here. Another call for constructImportedEntityDIE() is from DwarfCompileUnit::createScopeChildrenDIE where I'd not expect any issue with parents.

But it seems imported declarations are broken not just for static locals, but for all inlined entities, for example

namespace ns {
inline __attribute__((always_inline))
int foo() {
  int a = 42; 
  return a;
}
}

int main() {
  using ns::foo;
  return foo();
}

produces (with or w/o this patch) imported declaration for foo() that refers to an empty subprogram:

x0000002a:   DW_TAG_namespace
                DW_AT_name  ("ns")

0x0000002f:     DW_TAG_subprogram
                  DW_AT_name  ("foo")
                  DW_AT_inline  (DW_INL_inlined)

0x0000003f:       DW_TAG_variable
                    DW_AT_name  ("a")

0x0000004a:       NULL

0x0000004b:     DW_TAG_subprogram

0x0000004c:     NULL

0x00000054:   DW_TAG_subprogram
                DW_AT_name  ("main")

0x0000006d:     DW_TAG_imported_declaration
                  DW_AT_import  (0x0000004b)

while it should point to 0x0000002f.

[ellis]

In D109703#2998350, @krisb wrote:

In D109703#2998155, @ellis wrote:

I've added this to the added test case.

!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)

Thank you for pointing to this! Just in case, do you have a C++ example, that reproduces the issue with imported static local declaration? I'm asking, cause in your example DW_TAG_imported_declaration has CU as a scope, while DIGlobalVariable is function-scoped. This looks a bit strange. I mean, constructImportedEntityDIE() called from DwarfDebug::beginModule() skips all local-scoped entities, and unless I'm missing something static locals shouldn't go here. Another call for constructImportedEntityDIE() is from DwarfCompileUnit::createScopeChildrenDIE where I'd not expect any issue with parents.

No, I designed the test to hit that code path, but I should have found a C++ example to back it up. Thanks for looking into this!

[ellis]

In D109703#2998350, @krisb wrote:

But it seems imported declarations are broken not just for static locals, but for all inlined entities, for example

namespace ns {
inline __attribute__((always_inline))
int foo() {
  int a = 42; 
  return a;
}
}

int main() {
  using ns::foo;
  return foo();
}

produces (with or w/o this patch) imported declaration for foo() that refers to an empty subprogram:

x0000002a:   DW_TAG_namespace
                DW_AT_name  ("ns")

0x0000002f:     DW_TAG_subprogram
                  DW_AT_name  ("foo")
                  DW_AT_inline  (DW_INL_inlined)

0x0000003f:       DW_TAG_variable
                    DW_AT_name  ("a")

0x0000004a:       NULL

0x0000004b:     DW_TAG_subprogram

0x0000004c:     NULL

0x00000054:   DW_TAG_subprogram
                DW_AT_name  ("main")

0x0000006d:     DW_TAG_imported_declaration
                  DW_AT_import  (0x0000004b)

while it should point to 0x0000002f.

I've looked into this and realized that clang correctly emits a DW_TAG_inlined_subroutine for foo so the variables here are actually ok. The DW_TAG_imported_declaration tag is incorrect though, and I have a fix in https://reviews.llvm.org/D110294.

[dblaikie]

There have been a few different patches going around related to mis-scoped things - imported entities and types, maybe other things too? (static variables? Or has that already been fixed now) Perhaps some summary of the state of all these patches sent to llvm-dev/linked from the various reviews would be helpful? It'd be good to know if/how all these patches are hopefully aiming for some unified solution.

[krisb]

@dblaikie yeah, the problem(s) seemed easier and smaller :(

Basically, we have two issues with local scopes here:
(1) function-scoped entities like static variables, type definitions/typedefs, etc have incorrect (empty) parent DIE if the function containing them was inlined. We do not consider abstract SP as a possible parent DIE and try to create a new DIE for a function that doesn't exist. @ellis is working on this issue in [0] (for static vars) and [1] (for imported declarations).
(2) the same entities (static local vars, typedefs, etc) that should be scoped within a lexical block have a subprogram scope (in debug metadata) and parent DIE (in DWARF) instead. This is the issue I'm trying to fix in this patch, but for static variables only.

As a side effect, this patch fixes the issue with inlined functions for static vars (1) as well. But it seems the issues are not related and can be fixed separately.
And as now I've realized that static locals is not the only problem, this patch should implement a more generic solution to cover other entities. So, please, consider it as a WIP.

[0] https://reviews.llvm.org/D108492
[1] https://reviews.llvm.org/D110294

[ellis]

In D109703#3018935, @krisb wrote:

@dblaikie yeah, the problem(s) seemed easier and smaller :(

Basically, we have two issues with local scopes here:
(1) function-scoped entities like static variables, type definitions/typedefs, etc have incorrect (empty) parent DIE if the function containing them was inlined. We do not consider abstract SP as a possible parent DIE and try to create a new DIE for a function that doesn't exist. @ellis is working on this issue in [0] (for static vars) and [1] (for imported declarations).
(2) the same entities (static local vars, typedefs, etc) that should be scoped within a lexical block have a subprogram scope (in debug metadata) and parent DIE (in DWARF) instead. This is the issue I'm trying to fix in this patch, but for static variables only.

As a side effect, this patch fixes the issue with inlined functions for static vars (1) as well. But it seems the issues are not related and can be fixed separately.
And as now I've realized that static locals is not the only problem, this patch should implement a more generic solution to cover other entities. So, please, consider it as a WIP.

Hey @krisb I was under the impression that this patch would fix the static variable bug. Should I wait to see what this patch fixes before working on [0] and [1]?

[krisb]

@ellis I'd appreciate if you go ahead and fix the issues with inlined functions. Sorry for interrupting you in D108492.

[krisb]

Abandon in favor of https://reviews.llvm.org/D113741.

clang/lib/CodeGen/CGDebugInfo.cpp

void CGDebugInfo::collectVarDeclProps(const VarDecl *VD, llvm::DIFile *&Unit,
 
   if (isa<VarTemplateSpecializationDecl>(VD)) {
     llvm::DINodeArray parameterNodes = CollectVarTemplateParams(VD, &*Unit);
     TemplateParameters = parameterNodes.get();
   } else {
     TemplateParameters = nullptr;
   }
 
+  // For static locals just pick the lexical scope we are in (either a
+  // subprogram or a bracketed (lexical) block).
+  if (VD->isStaticLocal()) {
+    assert(!LexicalBlockStack.empty() &&
+           "Static local should have a local scope!");
+    VDContext = LexicalBlockStack.back();
+    return;
+  }
+
   // Since we emit declarations (DW_AT_members) for static members, place the
   // definition of those static members in the namespace they were declared in
   // in the source code (the lexical decl context).
   // FIXME: Generalize this for even non-member global variables where the
   // declaration and definition may have different lexical decl contexts, once
   // we have support for emitting declarations of (non-member) global variables.
   const DeclContext *DC = VD->isStaticDataMember() ? VD->getLexicalDeclContext()
                                                    : VD->getDeclContext();

clang/test/CodeGen/debug-info-static.c

 // RUN: %clang_cc1  -debug-info-kind=limited -emit-llvm -o - %s | FileCheck %s
 
 // CHECK: @f.xyzzy = internal global i32 0, align 4, !dbg [[XYZZY:![0-9]+]]
+// CHECK: @f.xyzzz = internal global i32 42, align 4, !dbg [[XYZZZ:![0-9]+]]
+
+// CHECK-DAG: [[XYZZY]] = !DIGlobalVariableExpression(var: [[VAR1:.*]], expr: !DIExpression())
+// CHECK-DAG: [[VAR1]] = distinct !DIGlobalVariable(name: "xyzzy", scope: [[SCOPE1:.*]], file
+// CHECK-DAG: [[SCOPE1]] = distinct !DISubprogram
+
+// Ensure that static local declared within a bracketed block has a DILexicalBlock scope.
+// CHECK-DAG: [[XYZZZ]] = !DIGlobalVariableExpression(var: [[VAR2:.*]], expr: !DIExpression())
+// CHECK-DAG: [[VAR2]] = distinct !DIGlobalVariable(name: "xyzzz", scope: [[SCOPE2:.*]], file
+// CHECK-DAG: [[SCOPE2]] = distinct !DILexicalBlock
 
-// CHECK: [[XYZZY]] = !DIGlobalVariableExpression(var: [[VAR:.*]], expr: !DIExpression())
-// CHECK: [[VAR]] = distinct !DIGlobalVariable
 void f(void)
 {
    static int xyzzy;
    xyzzy += 3;
+   if (xyzzy > 10) {
+     static int xyzzz = 42;
+     xyzzy += xyzzz;
+   }
 }

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

 //===- llvm/CodeGen/DwarfCompileUnit.h - Dwarf Compile Unit -----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains support for writing dwarf compile unit.

 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:
   DenseMap<const DINode *, std::unique_ptr<DbgEntity>> &getAbstractEntities() {
     if (isDwoUnit() && !DD->shareAcrossDWOCUs())
       return AbstractEntities;
     return DU->getAbstractEntities();
   }
 
   void finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) override;
 
+  /// Static local variables defined within the CU.
+  DenseMap<const DIGlobalVariable *, SmallVector<GlobalExpr, 1>>
+      StaticLocalVars;
+
+  /// Static local variables contained in a particular scope.
+  DenseMap<const DILocalScope *, SmallVector<const DIGlobalVariable *, 4>>
+      StaticLocalsInScope;
+
 public:
   DwarfCompileUnit(unsigned UID, const DICompileUnit *Node, AsmPrinter *A,
                    DwarfDebug *DW, DwarfFile *DWU,
                    UnitKind Kind = UnitKind::Full);
 
   bool hasRangeLists() const { return HasRangeLists; }
+
   unsigned getUniqueID() const { return UniqueID; }
 
   DwarfCompileUnit *getSkeleton() const {
     return Skeleton;
   }
 
   bool includeMinimalInlineScopes() const;
 
   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);
 
+  /// Get or create static local variable DIE.
+  DIE *
+  getOrCreateStaticLocalVariableDIE(const DIGlobalVariable *GV,
+                                    ArrayRef<GlobalExpr> GlobalExprs);
+
+  /// deferStaticLocal - Remember a static local to delay DIE construction
+  /// until its scope DIE is created.
+  void deferStaticLocal(const DIGlobalVariable *GV,
+                        SmallVector<GlobalExpr, 1> &GlobalExprs) {
+    const auto *Scope = cast<DILocalScope>(GV->getScope());
+    StaticLocalsInScope[Scope].push_back(GV);
+    StaticLocalVars.insert({GV, GlobalExprs});
+  }
+
+  /// getDeferredStaticLocalsInScope - Return a list of static local variables
+  /// for the given debug scope.
+  SmallVectorImpl<const DIGlobalVariable *> &
+  getDeferredStaticLocalsInScope(const DILocalScope *Scope) {
+    return StaticLocalsInScope[Scope];
+  }
+
   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.
   void addLabelAddress(DIE &Die, dwarf::Attribute Attribute,
                        const MCSymbol *Label);
 

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

while (!WorkList.empty()) {
     for (auto *Dependency : dependencies(Var)) {
       auto Dep = dyn_cast_or_null<const DILocalVariable>(Dependency);
       WorkList.push_back({DbgVar[Dep], 0});
     }
   }
   return Result;
 }
 
+DIE *DwarfCompileUnit::getOrCreateStaticLocalVariableDIE(
+    const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) {
+
+  // Check for pre-existence.
+  if (DIE *Die = getDIE(GV))
+    return Die;
+
+  // Define variable debug information entry.
+  auto VariableDIE = DIE::get(DIEValueAllocator, GV->getTag());
+  insertDIE(GV, VariableDIE);
+
+  // Add name and type.
+  addString(*VariableDIE, dwarf::DW_AT_name, GV->getDisplayName());
+
+  const DIType *GTy = GV->getType();
+  if (GTy)
+    addType(*VariableDIE, GTy);
+
+  // Add line number info.
+  addSourceLine(*VariableDIE, GV);
+
+  if (!GV->isDefinition())
+    addFlag(*VariableDIE, dwarf::DW_AT_declaration);
+  else
+    addGlobalName(GV->getName(), *VariableDIE, GV->getScope());
+
+  if (uint32_t AlignInBytes = GV->getAlignInBytes())
+    addUInt(*VariableDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
+            AlignInBytes);
+
+  if (MDTuple *TP = GV->getTemplateParams())
+    addTemplateParams(*VariableDIE, DINodeArray(TP));
+
+  // Add location.
+  addLocationAttribute(VariableDIE, GV, GlobalExprs);
+
+  return VariableDIE;
+}
+
 DIE *DwarfCompileUnit::createScopeChildrenDIE(LexicalScope *Scope,
                                               SmallVectorImpl<DIE *> &Children,
                                               bool *HasNonScopeChildren) {
   assert(Children.empty());
   DIE *ObjectPointer = nullptr;
 
+  // Emit static local variables.
+  auto *IA = Scope->getInlinedAt();
+  if (!IA) {
+    for (auto &GV : getDeferredStaticLocalsInScope(Scope->getScopeNode()))
+      Children.push_back(
+          getOrCreateStaticLocalVariableDIE(GV, StaticLocalVars[GV]));
+  }
+
   // Emit function arguments (order is significant).
   auto Vars = DU->getScopeVariables().lookup(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)

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

void DwarfDebug::constructAndAddImportedEntityDIE(DwarfCompileUnit &TheCU,
                                                   const DIImportedEntity *N) {
   if (isa<DILocalScope>(N->getScope()))
     return;
   if (DIE *D = TheCU.getOrCreateContextDIE(N->getScope()))
     D->addChild(TheCU.constructImportedEntityDIE(N));
 }
 
 /// Sort and unique GVEs by comparing their fragment offset.
-static SmallVectorImpl<DwarfCompileUnit::GlobalExpr> &
-sortGlobalExprs(SmallVectorImpl<DwarfCompileUnit::GlobalExpr> &GVEs) {
+static SmallVector<DwarfCompileUnit::GlobalExpr, 1> &
+sortGlobalExprs(SmallVector<DwarfCompileUnit::GlobalExpr, 1> &GVEs) {
   llvm::sort(
       GVEs, [](DwarfCompileUnit::GlobalExpr A, DwarfCompileUnit::GlobalExpr B) {
         // Sort order: first null exprs, then exprs without fragment
         // info, then sort by fragment offset in bits.
         // FIXME: Come up with a more comprehensive comparator so
         // the sorting isn't non-deterministic, and so the following
         // std::unique call works correctly.
         if (!A.Expr || !B.Expr)
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)
+      if (Processed.insert(GV).second) {
+        if (GV->getScope() && isa<DILocalScope>(GV->getScope())) {
+          CU.deferStaticLocal(GV, sortGlobalExprs(GVMap[GV]));
+          continue;
+        }
         CU.getOrCreateGlobalVariableDIE(GV, sortGlobalExprs(GVMap[GV]));
       }
+    }
 
     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()) {
       // The retained types array by design contains pointers to

llvm/test/DebugInfo/Generic/static-locals.ll

+; RUN: %llc_dwarf -O0 -filetype=obj < %s \
+; RUN:   | llvm-dwarfdump -debug-info -  \
+; RUN:   | FileCheck --implicit-check-not "{{DW_TAG|NULL}}" %s
+
+; Generated from:
+
+; static int global = 42;
+;
+; inline __attribute__((always_inline))
+; int inlined() {
+;   static int inlined_a = 1;
+;   if (global > 100) {
+;     static int inlined_b = 2;
+;     return inlined_b;
+;   }
+;   {
+;     static int inlined_c = 3;
+;     inlined_a = inlined_c;
+;   }
+;   return inlined_a;
+; }
+;
+; int foo() {
+;   static int a = 1;
+;   if (global < 100) {
+;     static int b = 2;
+;     return b;
+;   }
+;   {
+;     static int c = 3;
+;     a = c;
+;   }
+;   return a;
+; }
+;
+; int far() {
+;   return inlined();
+; }
+
+; CHECK: DW_TAG_compile_unit
+; CHECK: DW_TAG_variable
+; CHECK: DW_AT_name ("global")
+; CHECK: DW_TAG_base_type
+
+; foo().
+; CHECK: DW_TAG_subprogram
+; CHECK:   DW_AT_name ("foo")
+; CHECK:   DW_TAG_variable
+; CHECK:     DW_AT_name ("a")
+; CHECK:   DW_TAG_lexical_block
+; CHECK:     DW_TAG_variable
+; CHECK:       DW_AT_name ("b")
+; CHECK:     NULL
+; CHECK:   DW_TAG_lexical_block
+; CHECK:     DW_TAG_variable
+; CHECK:       DW_AT_name ("c")
+; CHECK:   NULL
+; CHECK: NULL
+
+; inlined().
+; CHECK: DW_TAG_subprogram
+; CHECK:   DW_AT_name  ("inlined")
+; CHECK:   DW_AT_inline  (DW_INL_inlined)
+; CHECK:   DW_TAG_variable
+; CHECK:     DW_AT_name ("inlined_a")
+; CHECK:   DW_TAG_lexical_block
+; CHECK:     DW_TAG_variable
+; CHECK:       DW_AT_name ("inlined_b")
+; CHECK:     NULL
+; CHECK:   DW_TAG_lexical_block
+; CHECK:     DW_TAG_variable
+; CHECK:       DW_AT_name ("inlined_c")
+; CHECK:   NULL
+; CHECK: NULL
+
+; far().
+; CHECK: DW_TAG_subprogram
+; CHECK:   DW_AT_name  ("far")
+; CHECK:   DW_TAG_inlined_subroutine
+; CHECK:     DW_AT_abstract_origin  (0x000000c3 "_Z7inlinedv")
+; CHECK:   NULL
+; CHECK: NULL
+
+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"
+
+@_ZZ3foovE1a = internal global i32 1, align 4, !dbg !0
+@_ZL6global = internal global i32 42, align 4, !dbg !17
+@_ZZ3foovE1b = internal global i32 2, align 4, !dbg !10
+@_ZZ3foovE1c = internal global i32 3, align 4, !dbg !14
+@_ZZ7inlinedvE9inlined_a = linkonce_odr dso_local global i32 1, align 4, !dbg !19
+@_ZZ7inlinedvE9inlined_b = linkonce_odr dso_local global i32 2, align 4, !dbg !22
+@_ZZ7inlinedvE9inlined_c = linkonce_odr dso_local global i32 3, align 4, !dbg !26
+
+define dso_local i32 @_Z3foov() !dbg !2 {
+entry:
+  %retval = alloca i32, align 4
+  %0 = load i32, i32* @_ZL6global, align 4, !dbg !35
+  %cmp = icmp slt i32 %0, 100, !dbg !36
+  br i1 %cmp, label %if.then, label %if.end, !dbg !37
+
+if.then:                                          ; preds = %entry
+  %1 = load i32, i32* @_ZZ3foovE1b, align 4, !dbg !38
+  store i32 %1, i32* %retval, align 4, !dbg !39
+  br label %return, !dbg !39
+
+if.end:                                           ; preds = %entry
+  %2 = load i32, i32* @_ZZ3foovE1c, align 4, !dbg !40
+  store i32 %2, i32* @_ZZ3foovE1a, align 4, !dbg !41
+  %3 = load i32, i32* @_ZZ3foovE1a, align 4, !dbg !42
+  store i32 %3, i32* %retval, align 4, !dbg !43
+  br label %return, !dbg !43
+
+return:                                           ; preds = %if.end, %if.then
+  %4 = load i32, i32* %retval, align 4, !dbg !44
+  ret i32 %4, !dbg !44
+}
+
+define dso_local i32 @_Z3farv() !dbg !45 {
+entry:
+  %retval.i = alloca i32, align 4
+  %0 = load i32, i32* @_ZL6global, align 4, !dbg !46
+  %cmp.i = icmp sgt i32 %0, 100, !dbg !48
+  br i1 %cmp.i, label %if.then.i, label %if.end.i, !dbg !49
+
+if.then.i:                                        ; preds = %entry
+  %1 = load i32, i32* @_ZZ7inlinedvE9inlined_b, align 4, !dbg !50
+  store i32 %1, i32* %retval.i, align 4, !dbg !51
+  br label %_Z7inlinedv.exit, !dbg !51
+
+if.end.i:                                         ; preds = %entry
+  %2 = load i32, i32* @_ZZ7inlinedvE9inlined_c, align 4, !dbg !52
+  store i32 %2, i32* @_ZZ7inlinedvE9inlined_a, align 4, !dbg !53
+  %3 = load i32, i32* @_ZZ7inlinedvE9inlined_a, align 4, !dbg !54
+  store i32 %3, i32* %retval.i, align 4, !dbg !55
+  br label %_Z7inlinedv.exit, !dbg !55
+
+_Z7inlinedv.exit:                                 ; preds = %if.then.i, %if.end.i
+  %4 = load i32, i32* %retval.i, align 4, !dbg !56
+  ret i32 %4, !dbg !57
+}
+
+!llvm.dbg.cu = !{!7}
+!llvm.module.flags = !{!29, !30, !31, !32, !33}
+!llvm.ident = !{!34}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "a", scope: !2, file: !3, line: 18, type: !6, isLocal: true, isDefinition: true)
+!2 = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov", scope: !3, file: !3, line: 17, type: !4, scopeLine: 17, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !7, retainedNodes: !8)
+!3 = !DIFile(filename: "test.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: !3, producer: "clang version 14.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !8, globals: !9, splitDebugInlining: false, nameTableKind: None)
+!8 = !{}
+!9 = !{!0, !10, !14, !17, !19, !22, !26}
+!10 = !DIGlobalVariableExpression(var: !11, expr: !DIExpression())
+!11 = distinct !DIGlobalVariable(name: "b", scope: !12, file: !3, line: 20, type: !6, isLocal: true, isDefinition: true)
+!12 = distinct !DILexicalBlock(scope: !13, file: !3, line: 19, column: 21)
+!13 = distinct !DILexicalBlock(scope: !2, file: !3, line: 19, column: 7)
+!14 = !DIGlobalVariableExpression(var: !15, expr: !DIExpression())
+!15 = distinct !DIGlobalVariable(name: "c", scope: !16, file: !3, line: 24, type: !6, isLocal: true, isDefinition: true)
+!16 = distinct !DILexicalBlock(scope: !2, file: !3, line: 23, column: 3)
+!17 = !DIGlobalVariableExpression(var: !18, expr: !DIExpression())
+!18 = distinct !DIGlobalVariable(name: "global", linkageName: "_ZL6global", scope: !7, file: !3, line: 1, type: !6, isLocal: true, isDefinition: true)
+!19 = !DIGlobalVariableExpression(var: !20, expr: !DIExpression())
+!20 = distinct !DIGlobalVariable(name: "inlined_a", scope: !21, file: !3, line: 5, type: !6, isLocal: false, isDefinition: true)
+!21 = distinct !DISubprogram(name: "inlined", linkageName: "_Z7inlinedv", scope: !3, file: !3, line: 4, type: !4, scopeLine: 4, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !7, retainedNodes: !8)
+!22 = !DIGlobalVariableExpression(var: !23, expr: !DIExpression())
+!23 = distinct !DIGlobalVariable(name: "inlined_b", scope: !24, file: !3, line: 7, type: !6, isLocal: false, isDefinition: true)
+!24 = distinct !DILexicalBlock(scope: !25, file: !3, line: 6, column: 21)
+!25 = distinct !DILexicalBlock(scope: !21, file: !3, line: 6, column: 7)
+!26 = !DIGlobalVariableExpression(var: !27, expr: !DIExpression())
+!27 = distinct !DIGlobalVariable(name: "inlined_c", scope: !28, file: !3, line: 11, type: !6, isLocal: false, isDefinition: true)
+!28 = distinct !DILexicalBlock(scope: !21, file: !3, line: 10, column: 3)
+!29 = !{i32 7, !"Dwarf Version", i32 4}
+!30 = !{i32 2, !"Debug Info Version", i32 3}
+!31 = !{i32 1, !"wchar_size", i32 4}
+!32 = !{i32 7, !"uwtable", i32 1}
+!33 = !{i32 7, !"frame-pointer", i32 2}
+!34 = !{!"clang version 14.0.0"}
+!35 = !DILocation(line: 19, column: 7, scope: !13)
+!36 = !DILocation(line: 19, column: 14, scope: !13)
+!37 = !DILocation(line: 19, column: 7, scope: !2)
+!38 = !DILocation(line: 21, column: 12, scope: !12)
+!39 = !DILocation(line: 21, column: 5, scope: !12)
+!40 = !DILocation(line: 25, column: 9, scope: !16)
+!41 = !DILocation(line: 25, column: 7, scope: !16)
+!42 = !DILocation(line: 27, column: 10, scope: !2)
+!43 = !DILocation(line: 27, column: 3, scope: !2)
+!44 = !DILocation(line: 28, column: 1, scope: !2)
+!45 = distinct !DISubprogram(name: "far", linkageName: "_Z3farv", scope: !3, file: !3, line: 30, type: !4, scopeLine: 30, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !7, retainedNodes: !8)
+!46 = !DILocation(line: 6, column: 7, scope: !25, inlinedAt: !47)
+!47 = distinct !DILocation(line: 31, column: 10, scope: !45)
+!48 = !DILocation(line: 6, column: 14, scope: !25, inlinedAt: !47)
+!49 = !DILocation(line: 6, column: 7, scope: !21, inlinedAt: !47)
+!50 = !DILocation(line: 8, column: 12, scope: !24, inlinedAt: !47)
+!51 = !DILocation(line: 8, column: 5, scope: !24, inlinedAt: !47)
+!52 = !DILocation(line: 12, column: 17, scope: !28, inlinedAt: !47)
+!53 = !DILocation(line: 12, column: 15, scope: !28, inlinedAt: !47)
+!54 = !DILocation(line: 14, column: 10, scope: !21, inlinedAt: !47)
+!55 = !DILocation(line: 14, column: 3, scope: !21, inlinedAt: !47)
+!56 = !DILocation(line: 15, column: 1, scope: !21, inlinedAt: !47)
+!57 = !DILocation(line: 31, column: 3, scope: !45)

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-NOT: {{DW_TAG|NULL}}
 ; 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-NOT: {{DW_TAG|NULL}}
+
+; 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"