[DWARF v5] Don't emit duplicate DW_AT_rnglists_base and address review comments from previous review

[wolfgangp]

Summary

This is a follow-on to https://reviews.llvm.org/D49214, which received some additional review comments after closing.

Addresses the following:

1. Fixing a bug with duplicate emission of DW_AT_rnglists_base with test case.
2. Fixing a somewhat stale comment to constructSkeletonCU() and moving it to the header.
3. Refactor DwarfDebug::emitDebugRanges() to handle both v5 and prior.
4. Some minor grammatical tweaks.

Dave already handled the base address specifier issues mentioned in the other review, as well as some test coverage additions in a different revision. Thanks!

[JDevlieghere]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2093–2096

Can we simplify this by returning a MCSymbol* instead?

[wolfgangp]

Review comments: Have emitRnglistsTableHeader() return the end symbol instead of setting it as a reference parameter.

Found a problem with the fix to duplite emission of DW_AT_rnglists_base and corrected it. Apologies.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2093–2096

Yes, I was a bit hesitant to return something from a function called 'emit' but it's simpler that way.

[dblaikie]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

811

This doesn't look like the right place to add the rnglists_base - it's possible for there to be ranges without the CU itself having ranges. (eg: a CU could have one function containing one scope - the CU would have a low/high pc (not ranges) but would still need rnglists_base so the scope could use rnglistx), I think?

So it probably can be pulled out of this conditional (& a test case added to cover/demonstrate this situation)

2127–2130

Probably drop the extra () around the return expression?

2164–2165

Rather than testing the dwarf version and then asserting table end, maybe just use TableEnd as the test:

if (TableEnd)
  Asm->OutStreamer->EmitLabel(TableEnd);

test/DebugInfo/X86/rnglists_base_attr.ll

10

total side note: (& I stumbled across the same code sample as you did here while making some range tests) this code probably shoudln't produce a DW_AT_ranges at -O0. For some reason the bool initialization is done inside the new/nested scope (which seems good/proper/correct) but the boolean test is not (which seems a bit weird/bogus)...

Fine for this test case (though I'd tend to err on the side of something a bit more intentional, though it's more work - like introducing a scope & then manually reordering some instructions to introduce a "hole" & force ranges to be used) because even if clang is fixed, the IR here will remain as-is.

[wolfgangp]

Addressed review comments wrt correctly adding DW_AT_rnglists_base and associated test cases. More details inline.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

811

Right. All CU ranges are added to the range list vector by attachRangesOrLowHighPC() (unless the CU just uses low/high so we can use the size of the vector to decide whether to add the attribute.

There seem to be 3 distinct cases:

• at least one scope range: requires a range list table (and hence the attribute), even if there is only one CU range. This is covered by fission-ranges.ll
• otherwise, if there is more than one CU range, we need a table & attribute. The new test case rnglists_curanges.ll covers this.
• if there is only one CU range, no list or attribute is needed. This is covered by a mod to cu-ranges.ll

test/DebugInfo/X86/rnglists_base_attr.ll

10

I modified the test like you suggested. Not that much work, really.

[dblaikie]

Is this still missing test coverage for the case where the CU has low/high_pc, but also needs a ranges_base because a function has ranges for a local scope? Looks like the bug got fixed, but test coverage is still missing?

test/DebugInfo/X86/rnglists_base_attr.ll

5

Maybe expound on this a bit more:

"... in the CU DIE when more than one range list is emitted."

To help explain why the source example code looks the way it does - maybe include some comment about "force a non-contiguous local-scope DIEs for f1 and a non-contiguous CU by having functions in different sections" or the like.

(I know I'm really bad at commenting test cases & explaining why they're constructed the way they are - so this is more a "do as I say, not as I do" - but also please do poke me about doing this myself when I'm a bit opaque in my test cases!)

5–6

I'd probably introduce a separate f1/f2 - so that it doesn't look like the recursion is an integral part of the test:

void f1();
void f2() {
  f1(); //reorder the IR for this call between the two below to produce ranges
  {
    bool b; // force a DW_AT_lexical_scope to be created
    f1();
    f1();
  }
}

[wolfgangp]

In D49522#1172894, @dblaikie wrote:

Is this still missing test coverage for the case where the CU has low/high_pc, but also needs a ranges_base because a function has ranges for a local scope? Looks like the bug got fixed, but test coverage is still missing?

This case is covered by the modified fission-range.ll in https://reviews.llvm.org/D49214. It's technically not a fission test case, but it was a convenient place to put it. I can pull it out if you like, or perhaps add a simpler test case.

[wolfgangp]

• Elaborated more on the rationale of the test case rnglists_base_attr.ll and used a simpler test case suggested by Dave.
• adjusted the spelling of some dump strings in a test.

[dblaikie]

Looks good! thanks for your patience!

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

void DwarfCompileUnit::addScopeRangeList(DIE &ScopeDIE,
   // (DW_RLE_startx_endx etc.).
   if (isDwoUnit()) {
     if (DD->getDwarfVersion() < 5)
       addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, List.getSym(),
                       RangeSectionSym);
   } else {
     addSectionLabel(ScopeDIE, dwarf::DW_AT_ranges, List.getSym(),
                     RangeSectionSym);
-    if (DD->getDwarfVersion() >= 5)
-      addRnglistsBase();
   }
 
   // Add the range list to the set of ranges to be emitted.
   (Skeleton ? Skeleton : this)->CURangeLists.push_back(std::move(List));
 }
 
 void DwarfCompileUnit::attachRangesOrLowHighPC(
     DIE &Die, SmallVector<RangeSpan, 2> Ranges) {

lib/CodeGen/AsmPrinter/DwarfDebug.h

class DwarfDebug : public DebugHandlerBase {
   void handleMacroNodes(DIMacroNodeArray Nodes, DwarfCompileUnit &U);
 
   /// DWARF 5 Experimental Split Dwarf Emitters
 
   /// Initialize common features of skeleton units.
   void initSkeletonUnit(const DwarfUnit &U, DIE &Die,
                         std::unique_ptr<DwarfCompileUnit> NewU);
 
-  /// Construct the split debug info compile unit for the debug info
-  /// section.
+  /// Construct the split debug info compile unit for the debug info section.
+  /// In DWARF v5, the skeleton unit DIE may have the following attributes:
+  /// DW_AT_addr_base, DW_AT_comp_dir, DW_AT_dwo_name, DW_AT_high_pc,
+  /// DW_AT_low_pc, DW_AT_ranges, DW_AT_stmt_list, and DW_AT_str_offsets_base.
+  /// Prior to DWARF v5 it may also have DW_AT_GNU_dwo_id. DW_AT_GNU_dwo_name
+  /// is used instead of DW_AT_dwo_name, Dw_AT_GNU_addr_base instead of
+  /// DW_AT_addr_base, and DW_AT_GNU_ranges_base instead of DW_AT_rnglists_base.
   DwarfCompileUnit &constructSkeletonCU(const DwarfCompileUnit &CU);
 
   /// Emit the debug info dwo section.
   void emitDebugInfoDWO();
 
   /// Emit the debug abbrev dwo section.
   void emitDebugAbbrevDWO();
 

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

for (const auto &P : CUMap) {
 
     // If we have code split among multiple sections or non-contiguous
     // ranges of code then emit a DW_AT_ranges attribute on the unit that will
     // remain in the .o file, otherwise add a DW_AT_low_pc.
     // FIXME: We should use ranges allow reordering of code ala
     // .subsections_via_symbols in mach-o. This would mean turning on
     // ranges for all subprogram DIEs for mach-o.
     DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
     if (unsigned NumRanges = TheCU.getRanges().size()) {
       if (NumRanges > 1 && useRangesSection())
         // A DW_AT_low_pc attribute may also be specified in combination with
         // DW_AT_ranges to specify the default base address for use in
         // location lists (see Section 2.6.2) and range lists (see Section
         // 2.17.3).
         U.addUInt(U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
       else
         U.setBaseAddress(TheCU.getRanges().front().getStart());
       U.attachRangesOrLowHighPC(U.getUnitDie(), TheCU.takeRanges());
     }
 
+    if (getDwarfVersion() >= 5 && !useSplitDwarf() &&
+        !U.getRangeLists().empty())
+      U.addRnglistsBase();
+
     auto *CUNode = cast<DICompileUnit>(P.first);
     // If compile Unit has macros, emit "DW_AT_macro_info" attribute.
     if (CUNode->getMacros())
       U.addSectionLabel(U.getUnitDie(), dwarf::DW_AT_macro_info,
                         U.getMacroLabelBegin(),
                         TLOF.getDwarfMacinfoSection()->getBeginSymbol());
   }
 
if (DwarfVersion >= 5) {
     Asm->OutStreamer->EmitIntValue(dwarf::DW_RLE_end_of_list, 1);
   } else {
     // Terminate the list with two 0 values.
     Asm->OutStreamer->EmitIntValue(0, Size);
     Asm->OutStreamer->EmitIntValue(0, Size);
   }
 }
 
-void DwarfDebug::emitDebugRnglists() {
-
-  // Don't emit a rangelist table if there are no ranges.
-  if (llvm::all_of(CUMap,
-                   [](const decltype(CUMap)::const_iterator::value_type &Pair) {
-                     DwarfCompileUnit *TheCU = Pair.second;
-                     if (auto *Skel = TheCU->getSkeleton())
-                       TheCU = Skel;
-                     return TheCU->getRangeLists().empty();
-                   }))
-    return;
-
-  assert(getDwarfVersion() >= 5 && "Dwarf version must be 5 or greater");
-  // FIXME: As long as we don't support DW_RLE_base_addrx, we cannot generate
-  // any tables in the .debug_rnglists.dwo section.
-  Asm->OutStreamer->SwitchSection(
-      Asm->getObjFileLowering().getDwarfRnglistsSection());
+// Emit the header of a DWARF 5 range list table. Returns the symbol that
+// designates the end of the table for the caller to emit when the table is
+// complete.
+static MCSymbol *emitRnglistsTableHeader(AsmPrinter *Asm, DwarfFile &Holder) {
   // The length is described by a starting label right after the length field
   // and an end label.
   MCSymbol *TableStart = Asm->createTempSymbol("debug_rnglist_table_start");
   MCSymbol *TableEnd = Asm->createTempSymbol("debug_rnglist_table_end");
   // Build the range table header, which starts with the length field.
   Asm->EmitLabelDifference(TableEnd, TableStart, 4);
   Asm->OutStreamer->EmitLabel(TableStart);
   // Version number (DWARF v5 and later).
-  Asm->emitInt16(getDwarfVersion());
+  Asm->emitInt16(Asm->OutStreamer->getContext().getDwarfVersion());
   // Address size.
   Asm->emitInt8(Asm->MAI->getCodePointerSize());
   // Segment selector size.
   Asm->emitInt8(0);
 
-  MCSymbol *RnglistTableBaseSym =
-      (useSplitDwarf() ? SkeletonHolder : InfoHolder).getRnglistsTableBaseSym();
+  MCSymbol *RnglistTableBaseSym = Holder.getRnglistsTableBaseSym();
 
   // FIXME: Generate the offsets table and use DW_FORM_rnglistx with the
   // DW_AT_ranges attribute. Until then set the number of offsets to 0.
   Asm->emitInt32(0);
   Asm->OutStreamer->EmitLabel(RnglistTableBaseSym);
-
-  // Emit the individual range lists.
-  for (const auto &I : CUMap) {
-    DwarfCompileUnit *TheCU = I.second;
-    if (auto *Skel = TheCU->getSkeleton())
-      TheCU = Skel;
-    for (const RangeSpanList &List : TheCU->getRangeLists())
-      emitRangeList(Asm, TheCU, List);
-  }
+  return TableEnd;
 
-  Asm->OutStreamer->EmitLabel(TableEnd);
-}
-
-/// Emit address ranges into the .debug_ranges section or DWARF v5 rangelists
-/// into the .debug_rnglists section.
+/// Emit address ranges into the .debug_ranges section or into the DWARF v5
+/// .debug_rnglists section.
 void DwarfDebug::emitDebugRanges() {
   if (CUMap.empty())
     return;
 
-  if (!useRangesSection()) {
-    assert(llvm::all_of(
-               CUMap,
-               [](const decltype(CUMap)::const_iterator::value_type &Pair) {
-                 return Pair.second->getRangeLists().empty();
-               }) &&
-           "No debug ranges expected.");
+  auto NoRangesPresent = [this]() {
+    return llvm::all_of(
+        CUMap, [](const decltype(CUMap)::const_iterator::value_type &Pair) {
+        });
+  };
+
+  if (!useRangesSection()) {
+    assert(NoRangesPresent() && "No debug ranges expected.");
     return;
   }
 
-  if (getDwarfVersion() >= 5) {
-    emitDebugRnglists();
+  if (NoRangesPresent())
     return;
-  }
 
   // Start the dwarf ranges section.
+  MCSymbol *TableEnd = nullptr;
+  if (getDwarfVersion() >= 5) {
+    Asm->OutStreamer->SwitchSection(
+        Asm->getObjFileLowering().getDwarfRnglistsSection());
+    TableEnd = emitRnglistsTableHeader(Asm, useSplitDwarf() ? SkeletonHolder
+                                                            : InfoHolder);
+  } else
     Asm->OutStreamer->SwitchSection(
         Asm->getObjFileLowering().getDwarfRangesSection());
 
   // Grab the specific ranges for the compile units in the module.
   for (const auto &I : CUMap) {
     DwarfCompileUnit *TheCU = I.second;
 
     if (auto *Skel = TheCU->getSkeleton())
       TheCU = Skel;
 
     // Iterate over the misc ranges for the compile units in the module.
     for (const RangeSpanList &List : TheCU->getRangeLists())
       emitRangeList(Asm, TheCU, List);
   }
+
+  if (TableEnd)
+    Asm->OutStreamer->EmitLabel(TableEnd);
 }
 
 void DwarfDebug::handleMacroNodes(DIMacroNodeArray Nodes, DwarfCompileUnit &U) {
   for (auto *MN : Nodes) {
     if (auto *M = dyn_cast<DIMacro>(MN))
       emitMacro(*M);
     else if (auto *F = dyn_cast<DIMacroFile>(MN))
       emitMacroFile(*F, U);
void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
   if (!CompilationDir.empty())
     NewU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
 
   addGnuPubAttributes(*NewU, Die);
 
   SkeletonHolder.addUnit(std::move(NewU));
 }
 
-// This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
-// DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
-// DW_AT_addr_base, DW_AT_ranges_base or DW_AT_rnglists_base.
 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
 
   auto OwnedUnit = llvm::make_unique<DwarfCompileUnit>(
       CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
   DwarfCompileUnit &NewCU = *OwnedUnit;
   NewCU.setSection(Asm->getObjFileLowering().getDwarfInfoSection());
 
   NewCU.initStmtList();

test/DebugInfo/X86/cu-ranges.ll

 ; RUN: llc -split-dwarf-file=foo.dwo -O0 %s -function-sections -mtriple=x86_64-unknown-linux-gnu -filetype=obj -o %t
 ; RUN: llvm-dwarfdump -debug-abbrev %t | FileCheck --check-prefix=FUNCTION-SECTIONS %s
 ; RUN: llvm-readobj --relocations %t | FileCheck --check-prefix=FUNCTION-SECTIONS-RELOCS %s
 
 ; RUN: llc -split-dwarf-file=foo.dwo -O0 %s -mtriple=x86_64-unknown-linux-gnu -filetype=obj -o %t
 ; RUN: llvm-dwarfdump -debug-abbrev %t | FileCheck --check-prefix=NO-FUNCTION-SECTIONS %s
 
+; RUN: llc -dwarf-version=5 -O0 %s -mtriple=x86_64-unknown-linux-gnu -filetype=obj -o %t
+; RUN: llvm-dwarfdump -v %t | FileCheck --check-prefix=DWARF5 %s
+
 ; From:
 ; int foo (int a) {
 ;   return a+1;
 ; }
 ; int bar (int b) {
 ;   return b+2;
 ; }
 
 ; With function sections enabled make sure that we have a DW_AT_ranges attribute.
 ; FUNCTION-SECTIONS: DW_AT_ranges
 
 ; Check that we have a relocation against the .debug_ranges section.
 ; FUNCTION-SECTIONS-RELOCS: R_X86_64_32 .debug_ranges 0x0
 
 ; Without function sections enabled make sure that we have no DW_AT_ranges attribute.
 ; NO-FUNCTION-SECTIONS-NOT: DW_AT_ranges
 ; NO-FUNCTION-SECTIONS: DW_AT_low_pc DW_FORM_addr
 ; NO-FUNCTION-SECTIONS-NOT: DW_AT_ranges
 
+; For Dwarf 5 check that we neither generate DW_AT_rnglists_base for the CU DIE nor 
+; a .debug_rnglists section. There is only 1 CU range with no scope ranges.
+;
+; DWARF5:     .debug_info contents:
+; DWARF5:     DW_TAG_compile_unit
+; DWARF5-NOT: DW_AT_rnglists_base [DW_FORM_sec_offset]   
+; DWARF5-NOT: .debug_rnglists contents:
+
 ; Function Attrs: nounwind uwtable
 define i32 @foo(i32 %a) #0 !dbg !4 {
 entry:
   %a.addr = alloca i32, align 4
   store i32 %a, i32* %a.addr, align 4
   call void @llvm.dbg.declare(metadata i32* %a.addr, metadata !13, metadata !DIExpression()), !dbg !14
   %0 = load i32, i32* %a.addr, align 4, !dbg !14
   %add = add nsw i32 %0, 1, !dbg !14

test/DebugInfo/X86/rnglists_base_attr.ll

+; RUN: llc -dwarf-version=5 -O0 %s -mtriple=x86_64-unknown-linux-gnu -filetype=obj -o %t
+; RUN: llvm-dwarfdump -v %t | FileCheck %s
+
+; Make sure we don't generate a duplicate DW_AT_rnglists_base attribute in the CU DIE
+; when more than one range list is emitted.
+; From the source:
+;
+; void f1();
+; void f2() {
+;   f1();
+;   {
+;     bool b;
+;     f1();
+;     f1();
+;   }
+; }
+; __attribute__((section(".text.foo"))) void f3() { }
+ 
+; Compile with clang -gwarf5 -S -emit-llvm
+; and change the resulting IR to move the first call to f1() to between
+; the second and the third call. This, along with the dbg.declare instruction
+; for the variable b, creates a gap in the code range for the nested lexical
+; scope that is b's immediate parent scope. A range list is emitted for that scope.
+;
+; In addition, the placement of f3() in a different section forces a 
+; rangelist to be emitted for the CU instead of simply using low/high pc 
+; attributes.
+
+; CHECK:      .debug_info contents:
+; CHECK:      DW_TAG_compile_unit
+; Make sure we have 2 CU ranges.
+; CHECK:      DW_AT_ranges
+; CHECK-NEXT: [0x{{[0-9a-f]+, 0x[0-9a-f]+}}) ".text"
+; CHECK-NEXT: [0x{{[0-9a-f]+, 0x[0-9a-f]+}}) ".text.foo"
+; We should not see any duplicate DW_AT_rnglists_base attributes.
+; CHECK:      DW_AT_rnglists_base [DW_FORM_sec_offset]                   (0x0000000c)
+; CHECK-NOT:  DW_AT_rnglists_base
+;
+; Make sure we see 2 ranges in the lexical block DIE.
+; CHECK:      DW_TAG_lexical_block
+; CHECK-NOT:  DW_TAG
+; CHECK:      DW_AT_ranges
+; CHECK-NEXT: [0x{{[0-9a-f]+, 0x[0-9a-f]+}}) ".text"
+; CHECK-NEXT: [0x{{[0-9a-f]+, 0x[0-9a-f]+}}) ".text"
+
+define dso_local void @_Z2f2v() !dbg !7 {
+entry:
+  %b = alloca i8, align 1
+  call void @llvm.dbg.declare(metadata i8* %b, metadata !11, metadata !DIExpression()), !dbg !14
+  call void @_Z2f1v(), !dbg !15
+  ; The following call has been moved here from right after the alloca
+  call void @_Z2f1v(), !dbg !10  
+  call void @_Z2f1v(), !dbg !16
+  ret void, !dbg !17
+}
+
+declare dso_local void @_Z2f1v()
+
+declare void @llvm.dbg.declare(metadata, metadata, metadata)
+
+define dso_local void @_Z2f3v() section ".text.foo" !dbg !18 {
+entry:
+  ret void, !dbg !19
+}
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 7.0.0 (trunk 337837)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
+!1 = !DIFile(filename: "t3.cpp", directory: "/home/test/rangelists", checksumkind: CSK_MD5, checksum: "1ba81b564a832caa8114cd008c199048")
+!2 = !{}
+!3 = !{i32 2, !"Dwarf Version", i32 5}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 7.0.0 (trunk 337837)"}
+!7 = distinct !DISubprogram(name: "f2", linkageName: "_Z2f2v", scope: !1, file: !1, line: 2, type: !8, isLocal: false, isDefinition: true, scopeLine: 2, flags: DIFlagPrototyped, isOptimized: false, unit: !0, retainedNodes: !2)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null}
+!10 = !DILocation(line: 3, column: 3, scope: !7)
+!11 = !DILocalVariable(name: "b", scope: !12, file: !1, line: 5, type: !13)
+!12 = distinct !DILexicalBlock(scope: !7, file: !1, line: 4, column: 3)
+!13 = !DIBasicType(name: "bool", size: 8, encoding: DW_ATE_boolean)
+!14 = !DILocation(line: 5, column: 10, scope: !12)
+!15 = !DILocation(line: 6, column: 5, scope: !12)
+!16 = !DILocation(line: 7, column: 5, scope: !12)
+!17 = !DILocation(line: 9, column: 1, scope: !7)
+!18 = distinct !DISubprogram(name: "f3", linkageName: "_Z2f3v", scope: !1, file: !1, line: 10, type: !8, isLocal: false, isDefinition: true, scopeLine: 10, flags: DIFlagPrototyped, isOptimized: false, unit: !0, retainedNodes: !2)
+!19 = !DILocation(line: 10, column: 51, scope: !18)

test/DebugInfo/X86/rnglists_curanges.ll

+; RUN: llc -dwarf-version=5 -O0 %s -mtriple=x86_64-unknown-linux-gnu -filetype=obj -o %t
+; RUN: llvm-dwarfdump -v %t | FileCheck %s
+;
+; Check that we generate DW_AT_rnglists_base in the CU die, as well as a range 
+; list table when we have more than 1 CU range and no scope range.
+;
+; Generated from:
+; 
+; __attribute__((section("text.foo"))) void f1() {}
+; __attribute__((section("text.bar"))) void f2() {}
+;
+; Compile with clangc -gdwarf-5 -O0 -S -emit-llvm
+;
+; CHECK:      .debug_info contents:
+; CHECK:      DW_TAG_compile_unit
+; CHECK-NOT:  DW_TAG
+; CHECK:      DW_AT_rnglists_base [DW_FORM_sec_offset]                   (0x0000000c)
+; CHECK:      .debug_rnglists contents:
+; CHECK:      0x00000000: range list header: length = 0x0000001d, version = 0x0005,
+; CHECK-SAME: addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+
+; Function Attrs: noinline nounwind optnone uwtable
+define dso_local void @f1() section "text.foo" !dbg !7 {
+entry:
+  ret void, !dbg !10
+}
+
+; Function Attrs: noinline nounwind optnone uwtable
+define dso_local void @f2() section "text.bar" !dbg !11 {
+entry:
+  ret void, !dbg !12
+}
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 7.0.0 (trunk 337470)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
+!1 = !DIFile(filename: "test3.c", directory: "/home/test/rangelists", checksumkind: CSK_MD5, checksum: "f3b46bc2e5bc55bdd511ae4ec29577b6")
+!2 = !{}
+!3 = !{i32 2, !"Dwarf Version", i32 5}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 7.0.0 (trunk 337470)"}
+!7 = distinct !DISubprogram(name: "f1", scope: !1, file: !1, line: 1, type: !8, isLocal: false, isDefinition: true, scopeLine: 1, isOptimized: false, unit: !0, retainedNodes: !2)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null}
+!10 = !DILocation(line: 1, column: 49, scope: !7)
+!11 = distinct !DISubprogram(name: "f2", scope: !1, file: !1, line: 2, type: !8, isLocal: false, isDefinition: true, scopeLine: 2, isOptimized: false, unit: !0, retainedNodes: !2)
+!12 = !DILocation(line: 2, column: 49, scope: !11)