[Verifier] definition subprograms cannot be nested within DICompositeType when enabling ODR.

[DianQK]

Summary

Resolve https://github.com/llvm/llvm-project/issues/61932. We should add the validation.

LLVM can't handle IR where subprogram definitions are nested within DICompositeType when doing LTO builds, because there's no good way to cross the CU boundary to insert a nested DISubprogram definition in one CU into a type defined in another CU.

The test cases cross-cu-inlining-2.ll and cross-cu-inlining-ranges.ll can be deleted. In the cross-cu-inlining-2.ll, the low pc and high pc of the CU are also incorrect.

[dblaikie]

Oh, sorry - I think I might've miscommunicated. My thinking was that this should be part of LLVM's IR verifier - not the DWARF binary verifier. This limitation is LLVM's, not DWARF's. (DWARF can describe member definitions inside type definitions, but LLVM can't handle IR that describes things that way when doing LTO builds because there's no good way to cross the CU boundary while preserving the context of where a given member was defined)

[DianQK]

This limitation is LLVM's, not DWARF's. (DWARF can describe member definitions inside type definitions, but LLVM can't handle IR that describes things that way when doing LTO builds because there's no good way to cross the CU boundary while preserving the context of where a given member was defined)

I did consider whether to put this verification in IR or DWARF, I just noticed that this type of verification is written in llvm-dwarfdump. Thank you for explaining, it's more appropriate to put it in IR. Could you explain the issues related to subroutines?

[dblaikie]

Could you explain the issues related to subroutines?

So the issue is that member functions might be defined in multiple CUs (and that might be important that they be defined in the correct CU - if, eg, that member function definition calls into a file-static function that's emitted into the suitable CU, so name lookup should find the CU-specific context like that) - but we can't simultaneously respect those two requirements in an LTO build, without duplicating the type into multiple CUs. Whereas the out of line member function definition can be in one CU, with the type definition (containing a member function declaration) can be in another CU and a cross-CU reference can be used to reference the member function declaration from the member funciton definition.

We /could/ do this by emitting a type /declaration/ into the CU with the other member function definition in an LTO build, but that seems a bit ugly, then requiring debuggers to stitch together these various descriptions of the type.

Also, I'm not sure what this metadata would do to DWARF type units (the type description would no longer be canonical, and we'd end up trying to emit a definition into the type in the type unit, which wouldn't be right).

[DianQK]

What I would like to ask is about the checks related to inlined subroutines in the issue. How are they different from the checks for definition subprograms? Based on your previous explanation and my current understanding, it seems that checking DISubprogram should be sufficient.

In the current context, I think I can understand that "subroutine" and "subprogram" are the same term/semantics.

[DianQK]

Rebase.

[dblaikie]

In D152095#4413788, @DianQK wrote:

What I would like to ask is about the checks related to inlined subroutines in the issue. How are they different from the checks for definition subprograms? Based on your previous explanation and my current understanding, it seems that checking DISubprogram should be sufficient.

In the current context, I think I can understand that "subroutine" and "subprogram" are the same term/semantics.

Ah, sorry - yeah, I might've used "subroutine" and "subprogram" somewhat casually/interchangeably in my descriptions. It's weird those things are named differently in the DWARF spec anyway, but...

The basic idea is that if a member function is defined inside the type, we can't properly reflect that if the type is in another CU - so for cross-CU/LTO purposes, all member functions need to be indirected through a declaration in the type and otherwise scoped to something that can appear outside the type definition - like to the root or to a namespace, that can be duplicated/produced in whatever CU is required for the definition of the function.

[dblaikie]

This has LLVM changes in it? What's the purpose of those changes?

llvm/test/DebugInfo/Generic/cross-cu-inlining-ranges.ll

50

This looks a bit confused - it's claiming to be a definition, but it's not referenced by any llvm Function - and then it's referencing a declaration? Perhaps these functions should not have the definition flag?

@aprantl @JDevlieghere what's the Swift IR look like today? Does it put subprogram definitions within composite types? That's not ideal/bit likely to break under LTO builds & would you be amenable to changing that to indirect through a definition that's outside the composite type to a declaration in the composite type?

[DianQK]

The modifications made this time still involve manually adding declaration references. I just wanted to demonstrate that these test cases work after removing the previous code and adding the declaration. I can remove these two test cases in the next commit or remove them in this current commit.

llvm/test/DebugInfo/Generic/cross-cu-inlining-ranges.ll

50

I deleted this piece of code earlier in order to create the smallest possible test cases.

In the https://swift.godbolt.org/z/7Yoqa7qnx, the init method does exist.
From the provided link, the swiftc still puts subprogram definitions within composite types.

[dblaikie]

In D152095#4452275, @DianQK wrote:

The modifications made this time still involve manually adding declaration references. I just wanted to demonstrate that these test cases work after removing the previous code and adding the declaration. I can remove these two test cases in the next commit or remove them in this current commit.

Not sure I follow - I guess regardless they probably shouldn't be in this change.

I'd expect this change to add the verifier check, and add an example IR that doesn't pass verification/demonstrates the new verifier check correctly catches the intended case(s).

@aprantl @JDevlieghere Sounds like this verifier check might fail for Swift debug info IR? You folks have any thoughts on that/how to address it/if anything needs to be done before we enable this check? (and how Swift is working with LTO if it generates IR like this... ?)

[DianQK]

In D152095#4457017, @dblaikie wrote:

Not sure I follow - I guess regardless they probably shouldn't be in this change.

I want to remove these two IRs from this change. Since these violate the current convention, these don't make sense anymore.

I'd expect this change to add the verifier check, and add an example IR that doesn't pass verification/demonstrates the new verifier check correctly catches the intended case(s).

This should be llvm/test/Verifier/disubprogram-declaration-within-struct.ll?

[DianQK]

I tried adding a patch to Swift based on the Rust implementation. I don't know if the condition for determining whether a function is a method is reasonable, but everything seems to be working fine.
Thanks very much for @cuviper's implementation.

[dblaikie]

In D152095#4459678, @DianQK wrote:

In D152095#4457017, @dblaikie wrote:

Not sure I follow - I guess regardless they probably shouldn't be in this change.

I want to remove these two IRs from this change. Since these violate the current convention, these don't make sense anymore.

I'm still not quite following why this patch has changes to llvm/lib/CodeGen/AsmPrinter? Is the point that those changes can be removed once this invariant is introduced? If so, those changes should probably be in a follow-up after this one, rather than at the same time.

I'd expect this change to add the verifier check, and add an example IR that doesn't pass verification/demonstrates the new verifier check correctly catches the intended case(s).

This should be llvm/test/Verifier/disubprogram-declaration-within-struct.ll?

Yep, that looks OK. Though I don't understand the phrasing "when enabling ODR" - what does that refer to? (is there some feature to "enable/disable ODR" that's relevant here?)

[DianQK]

Remove changes that are not directly related to this patch.
Improve the description and handling of the ODR.

[DianQK]

In D152095#4474741, @dblaikie wrote:

I'm still not quite following why this patch has changes to llvm/lib/CodeGen/AsmPrinter? Is the point that those changes can be removed once this invariant is introduced? If so, those changes should probably be in a follow-up after this one, rather than at the same time.

I have removed these changes. I could push these changes directly after the current patch. If a review is still required, please let me know.

I'd expect this change to add the verifier check, and add an example IR that doesn't pass verification/demonstrates the new verifier check correctly catches the intended case(s).

This should be llvm/test/Verifier/disubprogram-declaration-within-struct.ll?

Yep, that looks OK. Though I don't understand the phrasing "when enabling ODR" - what does that refer to? (is there some feature to "enable/disable ODR" that's relevant here?)

We can disable ODR with disableDebugTypeODRUniquing, or with the command line parameter --disable-debug-info-type-map.
When ODR is disabled or DICompositeType without an identifier, llvm-link will create two DICompositeType in different CU. In this case, LTO works fine.

The explanation I found from ODR in LangRef is the One Definition Rule.

[dblaikie]

In D152095#4480908, @DianQK wrote:

In D152095#4474741, @dblaikie wrote:

I'm still not quite following why this patch has changes to llvm/lib/CodeGen/AsmPrinter? Is the point that those changes can be removed once this invariant is introduced? If so, those changes should probably be in a follow-up after this one, rather than at the same time.

I have removed these changes. I could push these changes directly after the current patch. If a review is still required, please let me know.

OK, sounds good! Yeah, if those revert previous patches that are no longer required after this invariant is introduced, no need for further review - if you can mark them as reverts of the patches that introduced them (even if the revert doesn't apply perfectly cleanly/requires some cleanup to apply) it'll help keep track of everything - be good to mention the original commits D*** numbers in this review and/or mention this review in the reverts, etc, so we can piece the whole story together.

I'd expect this change to add the verifier check, and add an example IR that doesn't pass verification/demonstrates the new verifier check correctly catches the intended case(s).

This should be llvm/test/Verifier/disubprogram-declaration-within-struct.ll?

Yep, that looks OK. Though I don't understand the phrasing "when enabling ODR" - what does that refer to? (is there some feature to "enable/disable ODR" that's relevant here?)

We can disable ODR with disableDebugTypeODRUniquing, or with the command line parameter --disable-debug-info-type-map.
When ODR is disabled or DICompositeType without an identifier, llvm-link will create two DICompositeType in different CU. In this case, LTO works fine.

Ah, good to know.

SGTM.

llvm/lib/IR/Verifier.cpp

1415–1416 ↗

(On Diff #538139)

Perhaps "there's no good way to cross the CU boundary to insert a nested DISubprogram definition in one CU into a type defined in another CU"?

[DianQK]

Update code comments.

[DianQK]

Thank you for your help and review.
Subsequent commits are https://github.com/llvm/llvm-project/commit/30f2170a78e7c67a9d870ba9615d0c4c472cedbf and https://github.com/llvm/llvm-project/commit/f2d307c4ede0c55b28bd366511907bda29703994.
I did not remove the code changes to D135114, which should make sense.

[dblaikie]

Awesome - thanks!

llvm/include/llvm/DebugInfo/DWARF/DWARFVerifier.h

private:
   /// \returns The number of errors that occurred during verification.
   unsigned verifyUnitSection(const DWARFSection &S);
   unsigned verifyUnits(const DWARFUnitVector &Units);
 
   unsigned verifyIndexes(const DWARFObject &DObj);
   unsigned verifyIndex(StringRef Name, DWARFSectionKind SectionKind,
                        StringRef Index);
 
+  /// Verifies that definition subprograms cannot be nested within structures
+  /// such as classes and structs.
+  ///
+  /// \returns Number of errors that occurred during verification.
+  unsigned verifyDebugInfoSubprogram(const DWARFDie &Die);
+
   /// Verifies that a call site entry is nested within a subprogram with a
   /// DW_AT_call attribute.
   ///
   /// \returns Number of errors that occurred during verification.
   unsigned verifyDebugInfoCallSite(const DWARFDie &Die);
 
   /// Verify that all Die ranges are valid.
   ///

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

public:
 
   void attachLowHighPC(DIE &D, const MCSymbol *Begin, const MCSymbol *End);
 
   /// Find DIE for the given subprogram and attach appropriate
   /// DW_AT_low_pc and DW_AT_high_pc attributes. If there are global
   /// variables in this scope then create and insert DIEs for these
   /// variables.
   DIE &updateSubprogramScopeDIE(const DISubprogram *SP);
-  DIE &updateSubprogramScopeDIEImpl(const DISubprogram *SP, DIE *SPDie);
 
   void constructScopeDIE(LexicalScope *Scope, DIE &ParentScopeDIE);
 
   /// A helper function to construct a RangeSpanList for a given
   /// lexical scope.
   void addScopeRangeList(DIE &ScopeDIE, SmallVector<RangeSpan, 2> Range);
 
   void attachRangesOrLowHighPC(DIE &D, SmallVector<RangeSpan, 2> Ranges);

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

void DwarfCompileUnit::attachLowHighPC(DIE &D, const MCSymbol *Begin,
 
   addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
   if (DD->getDwarfVersion() < 4)
     addLabelAddress(D, dwarf::DW_AT_high_pc, End);
   else
     addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);
 }
 
-// Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
-// and DW_AT_high_pc attributes. If there are global variables in this
-// scope then create and insert DIEs for these variables.
-DIE &DwarfCompileUnit::updateSubprogramScopeDIE(const DISubprogram *SP) {
-  DIE *SPDie = getOrCreateSubprogramDIE(SP, includeMinimalInlineScopes());
-  auto *ContextCU = static_cast<DwarfCompileUnit *>(SPDie->getUnit());
-  return ContextCU->updateSubprogramScopeDIEImpl(SP, SPDie);
-}
-
 // Add info for Wasm-global-based relocation.
 // 'GlobalIndex' is used for split dwarf, which currently relies on a few
 // assumptions that are not guaranteed in a formal way but work in practice.
 void DwarfCompileUnit::addWasmRelocBaseGlobal(DIELoc *Loc, StringRef GlobalName,
                                               uint64_t GlobalIndex) {
   // FIXME: duplicated from Target/WebAssembly/WebAssembly.h
   // don't want to depend on target specific headers in this code?
   const unsigned TI_GLOBAL_RELOC = 3;
if (!isDwoUnit()) {
     // symbols are (with entries in .debug_addr).
     // For now we hardcode the indices in the callsites. Global indices are not
     // fixed, but in practice a few are fixed; for example, __stack_pointer is
     // always index 0.
     addUInt(*Loc, dwarf::DW_FORM_data4, GlobalIndex);
   }
 }
 
-DIE &DwarfCompileUnit::updateSubprogramScopeDIEImpl(const DISubprogram *SP,
-                                                    DIE *SPDie) {
+// Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
+// and DW_AT_high_pc attributes. If there are global variables in this
+// scope then create and insert DIEs for these variables.
+DIE &DwarfCompileUnit::updateSubprogramScopeDIE(const DISubprogram *SP) {
   SmallVector<RangeSpan, 2> BB_List;
+  DIE *SPDie = getOrCreateSubprogramDIE(SP, includeMinimalInlineScopes());
   // If basic block sections are on, ranges for each basic block section has
   // to be emitted separately.
   for (const auto &R : Asm->MBBSectionRanges)
     BB_List.push_back({R.second.BeginLabel, R.second.EndLabel});
 
   attachRangesOrLowHighPC(*SPDie, BB_List);
 
   if (DD->useAppleExtensionAttributes() &&
while (!WorkList.empty()) {
     }
   }
   return Result;
 }
 
 DIE &DwarfCompileUnit::constructSubprogramScopeDIE(const DISubprogram *Sub,
                                                    LexicalScope *Scope) {
   DIE &ScopeDIE = updateSubprogramScopeDIE(Sub);
-  auto *ContextCU = static_cast<DwarfCompileUnit *>(ScopeDIE.getUnit());
 
   if (Scope) {
     assert(!Scope->getInlinedAt());
     assert(!Scope->isAbstractScope());
     // Collect lexical scope children first.
     // ObjectPointer might be a local (non-argument) local variable if it's a
     // block's synthetic this pointer.
-    if (DIE *ObjectPointer =
-            ContextCU->createAndAddScopeChildren(Scope, ScopeDIE))
-      ContextCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
-                             *ObjectPointer);
+    if (DIE *ObjectPointer = createAndAddScopeChildren(Scope, ScopeDIE))
+      addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer);
   }
 
   // If this is a variadic function, add an unspecified parameter.
   DITypeRefArray FnArgs = Sub->getType()->getTypeArray();
 
   // If we have a single element of null, it is a function that returns void.
   // If we have more than one elements and the last one is null, it is a
   // variadic function.

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

if (Die.hasChildren()) {
       if (Die.getFirstChild().isValid() &&
           Die.getFirstChild().getTag() == DW_TAG_null) {
         warn() << dwarf::TagString(Die.getTag())
                << " has DW_CHILDREN_yes but DIE has no children: ";
         Die.dump(OS);
       }
     }
 
+    NumUnitErrors += verifyDebugInfoSubprogram(Die);
     NumUnitErrors += verifyDebugInfoCallSite(Die);
   }
 
   DWARFDie Die = Unit.getUnitDIE(/* ExtractUnitDIEOnly = */ false);
   if (!Die) {
     error() << "Compilation unit without DIE.\n";
     NumUnitErrors++;
     return NumUnitErrors;
unsigned DWARFVerifier::verifyUnitContents(DWARFUnit &Unit,
   }
 
   DieRangeInfo RI;
   NumUnitErrors += verifyDieRanges(Die, RI);
 
   return NumUnitErrors;
 }
 
+unsigned DWARFVerifier::verifyDebugInfoSubprogram(const DWARFDie &Die) {
+  if (!Die.isSubprogramDIE() || Die.find(DW_AT_declaration))
+    return 0;
+
+  // Typically, we nest defined subprograms within modules, namespaces,
+  // subprograms, or similar entries.
+  DWARFDie Parent = Die.getParent();
+  switch (Parent.getTag()) {
+  case DW_TAG_array_type:
+  case DW_TAG_class_type:
+  case DW_TAG_enumeration_type:
+  case DW_TAG_string_type:
+  case DW_TAG_structure_type:
+  case DW_TAG_union_type:
+  case DW_TAG_set_type:
+  case DW_TAG_subrange_type:
+    error() << "Definition subprograms cannot be nested within "
+            << TagString(Parent.getTag()) << ":";
+    Die.dump(OS);
+    return 1;
+  default:
+    return 0;
+  }
+}
+
 unsigned DWARFVerifier::verifyDebugInfoCallSite(const DWARFDie &Die) {
   if (Die.getTag() != DW_TAG_call_site && Die.getTag() != DW_TAG_GNU_call_site)
     return 0;
 
   DWARFDie Curr = Die.getParent();
   for (; Curr.isValid() && !Curr.isSubprogramDIE(); Curr = Die.getParent()) {
     if (Curr.getTag() == DW_TAG_inlined_subroutine) {
       error() << "Call site entry nested within inlined subroutine:";

llvm/test/DebugInfo/Generic/cross-cu-inlining-2.ll

 !llvm.dbg.cu = !{!0, !3}
 !llvm.module.flags = !{!10, !11}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_Swift, file: !1, isOptimized: true, runtimeVersion: 5, emissionKind: FullDebug, globals: !2, imports: !2)
 !1 = !DIFile(filename: "A.swift", directory: "")
 !2 = !{}
 !3 = distinct !DICompileUnit(language: DW_LANG_Swift, file: !4, isOptimized: true, runtimeVersion: 5, emissionKind: FullDebug, imports: !2)
 !4 = !DIFile(filename: "B.swift", directory: "")
+!5 = !DISubprogram(name: "foo", scope: !25, file: !1, line: 116, type: !27, scopeLine: 116, flags: DIFlagPrototyped, spFlags: 0)
+!6 = !DISubprogram(name: "init", scope: !31, file: !30, type: !27, flags: DIFlagPrototyped, spFlags: 0)
+!7 = !DISubprogram(name: "bar", scope: !31, file: !4, line: 21, type: !27, scopeLine: 21, flags: DIFlagPrototyped, spFlags: 0)
 !10 = !{i32 7, !"Dwarf Version", i32 4}
 !11 = !{i32 2, !"Debug Info Version", i32 3}
-!24 = distinct !DISubprogram(name: "foo", scope: !25, file: !1, line: 116, type: !27, scopeLine: 116, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
+!24 = distinct !DISubprogram(name: "foo", scope: !25, file: !1, line: 116, type: !27, scopeLine: 116, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2, declaration: !5)
 !25 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "FooTy", scope: !26, file: !1, size: 64, elements: !2)
 !26 = !DIModule(scope: null, name: "Mod")
 !27 = !DISubroutineType(types: !2)
 !28 = !DILocation(line: 0, scope: !29, inlinedAt: !32)
-!29 = distinct !DISubprogram(name: "init", scope: !31, file: !30, type: !27, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
+!29 = distinct !DISubprogram(name: "init", scope: !31, file: !30, type: !27, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2, declaration: !6)
 !30 = !DIFile(filename: "<compiler-generated>", directory: "")
 !31 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "ModController", scope: !26, file: !4, size: 64, elements: !2, runtimeLang: DW_LANG_Swift)
 !32 = !DILocation(line: 117, column: 29, scope: !33)
 !33 = distinct !DILexicalBlock(scope: !24, file: !1, line: 116, column: 68)
-!34 = distinct !DISubprogram(name: "bar", scope: !31, file: !4, line: 21, type: !27, scopeLine: 21, unit: !3, retainedNodes: !2)
+!34 = distinct !DISubprogram(name: "bar", scope: !31, file: !4, line: 21, type: !27, scopeLine: 21, unit: !3, retainedNodes: !2, declaration: !7)
 !35 = !DILocation(line: 0, scope: !36, inlinedAt: !37)
 !36 = distinct !DISubprogram(name: "goo", scope: !26, file: !30, type: !27, unit: !3, retainedNodes: !2)
 !37 = !DILocation(line: 21, column: 26, scope: !34)
 
 ; CHECK: DW_TAG_compile_unit
 ; CHECK:   DW_TAG_module
 ; CHECK:     DW_TAG_structure_type
-; CHECK: [[INIT:0x.*]]: DW_TAG_subprogram
+; CHECK:       DW_TAG_subprogram
 ; CHECK;         DW_AT_name [DW_FORM_strp]  ({{.*}} = "init")
+; CHECK:         DW_AT_declaration [DW_FORM_flag_present] (true)
+; CHECK: 0x[[BAR_REF_ADDR:.*]]: DW_TAG_subprogram
+; CHECK:         DW_AT_name [DW_FORM_strp]  ({{.*}} = "bar")
+; CHECK:         DW_AT_declaration [DW_FORM_flag_present] (true)
+; CHECK:       NULL
+; CHECK:     DW_TAG_structure_type
 ; CHECK:       DW_TAG_subprogram
-; CHECK;         DW_AT_name [DW_FORM_strp]  ({{.*}} = "bar")
-; CHECK:         DW_TAG_inlined_subroutine
-; CHECK:           DW_AT_abstract_origin [DW_FORM_ref_addr] (0x00000000[[GOO:.*]] "goo")
-; CHECK:         NULL
-; CHECK:       NULL
-; CHECK:     DW_TAG_structure_type
-; CHECK:       DW_TAG_subprogram
-; CHECK;         DW_AT_name [DW_FORM_strp]  ({{.*}} = "foo")
-; CHECK:         DW_TAG_inlined_subroutine
-; CHECK:           DW_AT_abstract_origin [DW_FORM_ref4]  ({{.*}} => {[[INIT]]} "init")
-; CHECK:         NULL
-; CHECK:       NULL
-; CHECK:     NULL
-; CHECK:   NULL
+; CHECK;         DW_AT_name [DW_FORM_strp]  ({{.*}} = "foo")
+; CHECK:         DW_AT_declaration [DW_FORM_flag_present] (true)
+; CHECK:       NULL
+; CHECK:     NULL
+; CHECK: [[INIT:0x.*]]: DW_TAG_subprogram
+; CHECK;     DW_AT_name [DW_FORM_strp]  ({{.*}} = "init")
+; CHECK:   DW_TAG_subprogram
+; CHECK;     DW_AT_name [DW_FORM_strp]  ({{.*}} = "foo")
+; CHECK:     DW_TAG_inlined_subroutine
+; CHECK:       DW_AT_abstract_origin [DW_FORM_ref4]  ({{.*}} => {[[INIT]]} "init")
+; CHECK:     NULL
+; CHECK:   NULL
 ; CHECK: DW_TAG_compile_unit
+; CHECK:   DW_AT_low_pc [DW_FORM_addr]  ([[LOW_PC:0x.*]] ".text")
+; CHECK:   DW_AT_high_pc [DW_FORM_data4]  ([[HIGH_PC:0x.*]])
 ; CHECK:   DW_TAG_module
-; CHECK: 0x[[GOO]]: DW_TAG_subprogram
-; CHECK;       DW_AT_name [DW_FORM_strp]  ({{.*}} = "goo")
+; CHECK: [[GOO:0x.*]]: DW_TAG_subprogram
+; CHECK:       DW_AT_name [DW_FORM_strp]  ({{.*}} = "goo")
+; CHECK:     NULL
+; CHECK:   DW_TAG_subprogram
+; CHECK:     DW_AT_specification [DW_FORM_ref_addr]  (0x00000000[[BAR_REF_ADDR]] "bar")
+; CHECK:     DW_TAG_inlined_subroutine
+; CHECK:       DW_AT_abstract_origin [DW_FORM_ref4] (cu + 0x{{.*}} => {[[GOO]]} "goo")
+; CHECK:       DW_AT_low_pc [DW_FORM_addr]  ([[LOW_PC]] ".text")
+; CHECK:       DW_AT_high_pc [DW_FORM_data4]  ([[HIGH_PC]])
 ; CHECK:     NULL
 ; CHECK:   NULL

llvm/test/DebugInfo/Generic/cross-cu-inlining-ranges.ll

 !2 = distinct !DICompileUnit(language: DW_LANG_Swift, file: !3, isOptimized: true, runtimeVersion: 5, emissionKind: FullDebug)
 !3 = !DIFile(filename: "bar.swift", directory: "")
 !4 = !{i32 7, !"Dwarf Version", i32 4}
 !5 = !{i32 2, !"Debug Info Version", i32 3}
 !6 = distinct !DISubprogram(name: "foo", scope: !0, type: !7, spFlags: DISPFlagDefinition, unit: !0)
 !7 = !DISubroutineType(types: !8)
 !8 = !{}
 !9 = !DILocation(line: 0, scope: !10, inlinedAt: !13)
-!10 = distinct !DISubprogram(name: "init", scope: !12, file: !11, type: !7, spFlags: DISPFlagDefinition, unit: !0)
+!10 = distinct !DISubprogram(name: "init", scope: !12, file: !11, type: !7, spFlags: DISPFlagDefinition, unit: !0, declaration: !22)
 !11 = !DIFile(filename: "<compiler-generated>", directory: "")
 !12 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Type", file: !3, runtimeLang: DW_LANG_Swift, identifier: "Type")
 !13 = !DILocation(line: 0, scope: !14)
 !14 = distinct !DILexicalBlock(scope: !6, file: !1)
-!15 = distinct !DISubprogram(name: "bar", scope: !12, type: !7, spFlags: DISPFlagDefinition, unit: !2)
+!15 = distinct !DISubprogram(name: "bar", scope: !12, type: !7, spFlags: DISPFlagDefinition, unit: !2, declaration: !23)
 !16 = !DILocation(line: 0, scope: !17, inlinedAt: !19)
 !17 = distinct !DILexicalBlock(scope: !18, file: !3)
-!18 = distinct !DISubprogram(name: "inlined_baz", scope: !12, file: !3, type: !7, spFlags: DISPFlagDefinition, unit: !2)
+!18 = distinct !DISubprogram(name: "inlined_baz", scope: !12, file: !3, type: !7, spFlags: DISPFlagDefinition, unit: !2, declaration: !24)
 !19 = !DILocation(line: 0, scope: !20)
 !20 = distinct !DILexicalBlock(scope: !15, file: !3)
 !21 = !DILocation(line: 0, scope: !15)
+!22 = !DISubprogram(name: "init", scope: !12, file: !11, type: !7, flags: DIFlagPrototyped, spFlags: 0)
+!23 = !DISubprogram(name: "bar", scope: !12, type: !7, flags: DIFlagPrototyped, spFlags: 0)
+!24 = !DISubprogram(name: "inlined_baz", scope: !12, file: !3, type: !7, flags: DIFlagPrototyped, spFlags: 0)

llvm/test/tools/llvm-dwarfdump/X86/debug_info_subprogram.s

+# RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj -o %t.o
+# RUN: not llvm-dwarfdump -verify %t.o 2>&1 | FileCheck %s
+
+# CHECK: Definition subprograms cannot be nested within DW_TAG_structure_type:
+# CHECK: DW_TAG_subprogram
+# CHECK:   DW_AT_low_pc
+# CHECK:   DW_AT_name ("bar")
+# CHECK: Errors detected.
+
+# The Rust source:
+# pub struct Foo;
+# impl Foo {
+#    pub fn bar() {}
+# }
+
+# The IR source:
+# ; ModuleID = 'foo.7e668e4a-cgu.0'
+# source_filename = "foo.7e668e4a-cgu.0"
+# 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"
+#
+# ; foo::Foo::bar
+# ; Function Attrs: nonlazybind uwtable
+# define void @_ZN3foo3Foo3bar17h32d65c44145019c8E() unnamed_addr #0 !dbg !6 {
+# start:
+#   ret void, !dbg !14
+# }
+#
+# attributes #0 = { nonlazybind uwtable "probe-stack"="__rust_probestack" "target-cpu"="x86-64" }
+#
+# !llvm.module.flags = !{!0, !1, !2, !3}
+# !llvm.dbg.cu = !{!4}
+#
+# !0 = !{i32 7, !"PIC Level", i32 2}
+# !1 = !{i32 2, !"RtLibUseGOT", i32 1}
+# !2 = !{i32 2, !"Dwarf Version", i32 4}
+# !3 = !{i32 2, !"Debug Info Version", i32 3}
+# !4 = distinct !DICompileUnit(language: DW_LANG_Rust, file: !5, producer: "clang LLVM (rustc version 1.69.0 (84c898d65 2023-04-16))", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false)
+# !5 = !DIFile(filename: "foo.rs/@/foo.7e668e4a-cgu.0", directory: "/tmp")
+# !6 = distinct !DISubprogram(name: "bar", linkageName: "_ZN3foo3Foo3bar17h32d65c44145019c8E", scope: !8, file: !7, line: 4, type: !12, scopeLine: 4, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !4, templateParams: !11, retainedNodes: !11)
+# !7 = !DIFile(filename: "foo.rs", directory: "/tmp", checksumkind: CSK_MD5, checksum: "427d9b572596c2f310b6185a1781f222")
+# !8 = !DICompositeType(tag: DW_TAG_structure_type, name: "Foo", scope: !10, file: !9, align: 8, elements: !11, identifier: "a8fd67db4e906c9c4aceea39cb8b0f61")
+# !9 = !DIFile(filename: "<unknown>", directory: "")
+# !10 = !DINamespace(name: "foo", scope: null)
+# !11 = !{}
+# !12 = !DISubroutineType(types: !13)
+# !13 = !{null}
+# !14 = !DILocation(line: 6, column: 6, scope: !6)
+
+  .text
+  .file "foo.7e668e4a-cgu.0"
+  .section  .text._ZN3foo3Foo3bar17h32d65c44145019c8E,"ax",@progbits
+  .globl  _ZN3foo3Foo3bar17h32d65c44145019c8E
+  .p2align  4, 0x90
+  .type _ZN3foo3Foo3bar17h32d65c44145019c8E,@function
+_ZN3foo3Foo3bar17h32d65c44145019c8E:
+.Lfunc_begin0:
+  .file 1 "/tmp" "foo.rs"
+  .loc  1 4 0
+  .cfi_startproc
+  .loc  1 6 6 prologue_end
+  retq
+.Ltmp0:
+.Lfunc_end0:
+  .size _ZN3foo3Foo3bar17h32d65c44145019c8E, .Lfunc_end0-_ZN3foo3Foo3bar17h32d65c44145019c8E
+  .cfi_endproc
+
+  .section  .debug_abbrev,"",@progbits
+  .byte 1
+  .byte 17
+  .byte 1
+  .byte 37
+  .byte 14
+  .byte 19
+  .byte 5
+  .byte 3
+  .byte 14
+  .byte 16
+  .byte 23
+  .byte 27
+  .byte 14
+  .ascii  "\264B"
+  .byte 25
+  .byte 17
+  .byte 1
+  .byte 18
+  .byte 6
+  .byte 0
+  .byte 0
+  .byte 2
+  .byte 57
+  .byte 1
+  .byte 3
+  .byte 14
+  .byte 0
+  .byte 0
+  .byte 3
+  .byte 19
+  .byte 1
+  .byte 3
+  .byte 14
+  .byte 11
+  .byte 11
+  .ascii  "\210\001"
+  .byte 15
+  .byte 0
+  .byte 0
+  .byte 4
+  .byte 46
+  .byte 0
+  .byte 17
+  .byte 1
+  .byte 18
+  .byte 6
+  .byte 64
+  .byte 24
+  .byte 110
+  .byte 14
+  .byte 3
+  .byte 14
+  .byte 58
+  .byte 11
+  .byte 59
+  .byte 11
+  .byte 63
+  .byte 25
+  .byte 0
+  .byte 0
+  .byte 0
+  .section  .debug_info,"",@progbits
+.Lcu_begin0:
+  .long .Ldebug_info_end0-.Ldebug_info_start0
+.Ldebug_info_start0:
+  .short  4
+  .long .debug_abbrev
+  .byte 8
+  .byte 1
+  .long .Linfo_string0
+  .short  28
+  .long .Linfo_string1
+  .long .Lline_table_start0
+  .long .Linfo_string2
+
+  .quad .Lfunc_begin0
+  .long .Lfunc_end0-.Lfunc_begin0
+  .byte 2
+  .long .Linfo_string3
+  .byte 3
+  .long .Linfo_string4
+  .byte 0
+  .byte 1
+  .byte 4
+  .quad .Lfunc_begin0
+  .long .Lfunc_end0-.Lfunc_begin0
+  .byte 1
+  .byte 87
+  .long .Linfo_string5
+  .long .Linfo_string6
+  .byte 1
+  .byte 4
+
+  .byte 0
+  .byte 0
+  .byte 0
+.Ldebug_info_end0:
+  .section  .text._ZN3foo3Foo3bar17h32d65c44145019c8E,"ax",@progbits
+.Lsec_end0:
+  .section  .debug_aranges,"",@progbits
+  .long 44
+  .short  2
+  .long .Lcu_begin0
+  .byte 8
+  .byte 0
+  .zero 4,255
+  .quad .Lfunc_begin0
+  .quad .Lsec_end0-.Lfunc_begin0
+  .quad 0
+  .quad 0
+  .section  .debug_str,"MS",@progbits,1
+.Linfo_string0:
+  .asciz  "clang LLVM (rustc version 1.69.0 (84c898d65 2023-04-16))"
+.Linfo_string1:
+  .asciz  "foo.rs/@/foo.7e668e4a-cgu.0"
+.Linfo_string2:
+  .asciz  "/tmp"
+.Linfo_string3:
+  .asciz  "foo"
+.Linfo_string4:
+  .asciz  "Foo"
+.Linfo_string5:
+  .asciz  "_ZN3foo3Foo3bar17h32d65c44145019c8E"
+.Linfo_string6:
+  .asciz  "bar"
+  .section  .debug_pubnames,"",@progbits
+  .long .LpubNames_end0-.LpubNames_start0
+.LpubNames_start0:
+  .short  2
+  .long .Lcu_begin0
+  .long 82
+  .long 42
+  .asciz  "foo"
+  .long 54
+  .asciz  "bar"
+  .long 0
+.LpubNames_end0:
+  .section  .debug_pubtypes,"",@progbits
+  .long .LpubTypes_end0-.LpubTypes_start0
+.LpubTypes_start0:
+  .short  2
+  .long .Lcu_begin0
+  .long 82
+  .long 47
+  .asciz  "Foo"
+  .long 0
+.LpubTypes_end0:
+  .section  ".note.GNU-stack","",@progbits
+  .section  .debug_line,"",@progbits
+.Lline_table_start0: