[DEBUGINFO] Add -no-dwarf-debug-ranges option.

[ABataev]

Summary

Added option -no-dwarf-debug-ranges option to disable emission of
.debug_ranges section.

[ABataev]

Test checks updated

[dblaikie]

(& the same question as the other change, about whether this should be a per-CU flag)

test/DebugInfo/X86/no_debug_ranges.ll

4–8 ↗

(On Diff #138013)

Probably worth testing what the range of this CU is rendered as, given that there are several functions in several sections, yet ranges cannot be used.

What do existing tools operating under this constraint do? (should the DWARF perhaps only describe code in the first section - rather than having (I assume this is what LLVM will produce with this patch) descriptions of several functions in several sections, but with a CU range that only covers one of those contiguous section ranges? (this might be invalid DWARF? Inaccurate ranges))

10–44 ↗

(On Diff #138013)

What's interesting about these 4 sections/6 functions, more than having two sections/functions? (trying to understand what nuances are being tested here - perhaps a comment in the test case would be helpful to explain the motivation)

[ABataev]

test/DebugInfo/X86/no_debug_ranges.ll

10–44 ↗

(On Diff #138013)

Nothing special, I just copied an existing test that definitely produces ranges by default. Test just checks that with the flag -no-dwarf-ranges-section no .debug_ranges section is emitted. But I agree that it would be good to test how the addresses are emitted

[dblaikie]

If you could simplify the test down to the smallest example that produces
ranges, that'd be good - which should be achievable with two functions in
distinct sections ('a' and 'b' for example).

[ABataev]

Updated test checks.

[dblaikie]

test/DebugInfo/X86/no_debug_ranges.ll

1–2 ↗

(On Diff #138070)

Usually debug info is tested through llvm-dwarfdump, but given the need to test for specific sections being named, testing the assembly directly's probably fine here.

4 ↗

(On Diff #138070)

probably check for only .debug_ranges here? (since it's outside the debug_info section, so any mention of DW_AT_ranges wouldn't be too relevant (short of the abbrev section, but no need to check for that when you're checking for the contents of debug_info anyway, I think))

6 ↗

(On Diff #138070)

probably replace ".debug_ranges" with ".section" here? (ie: make sure the low/high pc you're checking for is in the debug_info section, and make sure that section doesn't include a DW_AT_ranges)

[ABataev]

test/DebugInfo/X86/no_debug_ranges.ll

4 ↗

(On Diff #138070)

There can be .debug_abbrev section with DW_AT_ranges, we need to be sure that no ranges info is generated

6 ↗

(On Diff #138070)

Ok

[ABataev]

Updated test checks

[echristo]

In D44384#1035072, @dblaikie wrote:

(& the same question as the other change, about whether this should be a per-CU flag)

Right now the idea is that we're going to want to turn off certain kinds of sections for nvptx based assembly (same as the other patch). I think we can possibly come up with dwarf/elf ways to encode this data, but in the short term let's get asm printer (and use a flag to set it up piece by piece testable) and then we can try to figure out ways to actually get the data out in the long term.

I'll let the rest of the review go as it is since it's in progress. Thanks Dave :)

-eric

[ABataev]

Dave, some more comments?

[ABataev]

Updated to latest version

[dblaikie]

Seems OK.

Still not sure what the "right" behavior is when this is disabled, but ranges are necessary to describe the entity (like this is going to produce some odd debug info if two functions are in different sections, as shown in the test - but also cases of scopes, etc inside a function).

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

addSectionLabel(ScopeDIE, dwarf::DW_AT_ranges, List.getSym(),
                     RangeSectionSym);
 
   // 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) {
-  if (Ranges.size() == 1) {
-    const auto &single = Ranges.front();
-    attachLowHighPC(Die, single.getStart(), single.getEnd());
+  if (Ranges.size() == 1 || !DD->useRangesSection()) {
+    const RangeSpan &Front = Ranges.front();
+    const RangeSpan &Back = Ranges.back();
+    attachLowHighPC(Die, Front.getStart(), Back.getEnd());
   } else
     addScopeRangeList(Die, std::move(Ranges));
 }
 
 void DwarfCompileUnit::attachRangesOrLowHighPC(
     DIE &Die, const SmallVectorImpl<InsnRange> &Ranges) {
   SmallVector<RangeSpan, 2> List;
   List.reserve(Ranges.size());

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfDebug.h

class DwarfDebug : public DebugHandlerBase {
   bool UseAllLinkageNames;
 
   /// Use inlined strings.
   bool UseInlineStrings = false;
 
   /// Whether to emit DWARF pub sections or not.
   bool UsePubSections = true;
 
+  /// Allow emission of .debug_ranges section.
+  bool UseRangesSection = true;
+
   /// DWARF5 Experimental Options
   /// @{
   bool HasDwarfAccelTables;
   bool HasAppleExtensionAttributes;
   bool HasSplitDwarf;
 
   /// Whether to generate the DWARF v5 string offsets table.
   /// It consists of a series of contributions, each preceded by a header.
public:
   bool useDWARF2Bitfields() const { return UseDWARF2Bitfields; }
 
   /// Returns whether to use inline strings.
   bool useInlineStrings() const { return UseInlineStrings; }
 
   /// Returns whether GNU oub sections should be emitted.
   bool usePubSections() const { return UsePubSections; }
 
+  /// Returns whether ranges section should be emitted.
+  bool useRangesSection() const { return UseRangesSection; }
+
   // Experimental DWARF5 features.
 
   /// Returns whether or not to emit tables that dwarf consumers can
   /// use to accelerate lookup.
   bool useDwarfAccelTables() const { return HasDwarfAccelTables; }
 
   bool useAppleExtensionAttributes() const {
     return HasAppleExtensionAttributes;

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

DwarfInlinedStrings("dwarf-inlined-strings", cl::Hidden,
                             clEnumVal(Disable, "Disabled")),
                  cl::init(Default));
 
 static cl::opt<bool>
     NoDwarfPubSections("no-dwarf-pub-sections", cl::Hidden,
                        cl::desc("Disable emission of DWARF pub sections."),
                        cl::init(false));
 
+static cl::opt<bool>
+    NoDwarfRangesSection("no-dwarf-ranges-section", cl::Hidden,
+                         cl::desc("Disable emission .debug_ranges section."),
+                         cl::init(false));
+
 enum LinkageNameOption {
   DefaultLinkageNames,
   AllLinkageNames,
   AbstractLinkageNames
 };
 
 static cl::opt<LinkageNameOption>
     DwarfLinkageNames("dwarf-linkage-names", cl::Hidden,
DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
 
   unsigned DwarfVersionNumber = Asm->TM.Options.MCOptions.DwarfVersion;
   unsigned DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
                                     : MMI->getModule()->getDwarfVersion();
   // Use dwarf 4 by default if nothing is requested.
   DwarfVersion = DwarfVersion ? DwarfVersion : dwarf::DWARF_VERSION;
 
   UsePubSections = !NoDwarfPubSections;
+  UseRangesSection = !NoDwarfRangesSection;
 
   // Work around a GDB bug. GDB doesn't support the standard opcode;
   // SCE doesn't support GNU's; LLDB prefers the standard opcode, which
   // is defined as of DWARF 3.
   // See GDB bug 11616 - DW_OP_form_tls_address is unimplemented
   // https://sourceware.org/bugzilla/show_bug.cgi?id=11616
   UseGNUTLSOpcode = tuneForGDB() || DwarfVersion < 3;
 
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)
+      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());
void DwarfDebug::emitDebugARanges() {
   }
 }
 
 /// Emit address ranges into a debug ranges 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.");
+    return;
+  }
+
   // Start the dwarf ranges section.
   Asm->OutStreamer->SwitchSection(
       Asm->getObjFileLowering().getDwarfRangesSection());
 
   // Size for our labels.
   unsigned char Size = Asm->MAI->getCodePointerSize();
 
   // Grab the specific ranges for the compile units in the module.

llvm/trunk/test/DebugInfo/X86/no_debug_ranges.ll

+; RUN: llc -filetype=asm -mtriple=x86_64-pc-linux-gnu < %s -o - -dwarf-version=2 -no-dwarf-ranges-section | FileCheck %s --check-prefix=DISABLED
+; RUN: llc -filetype=asm -mtriple=x86_64-pc-linux-gnu < %s -o - -dwarf-version=2 | FileCheck %s
+
+; DISABLED-NOT:  {{DW_AT_ranges|.debug_ranges}}
+; DISABLED:      .section .debug_info
+; DISABLED-NOT:  {{DW_AT_ranges|.section}}
+; DISABLED:      .quad .Lfunc_begin0 # DW_AT_low_pc
+; DISABLED-NEXT: .quad .Lfunc_end1   # DW_AT_high_pc
+; DISABLED-NOT:  {{DW_AT_ranges|.debug_ranges}}
+
+; .debug_ranges section must be emitted by default
+; CHECK: .section .debug_info
+; CHECK: quad 0 # DW_AT_low_pc
+; CHECK-NEXT: long [[RANGE0:[.]Ldebug_ranges[0-9]+]] # DW_AT_ranges
+; CHECK: .debug_ranges
+; CHECK-NEXT: [[RANGE0]]:
+; CHECK-NEXT: .quad .Lfunc_begin0
+; CHECK-NEXT: .quad .Lfunc_end0
+; CHECK-NEXT: .quad .Lfunc_begin1
+; CHECK-NEXT: .quad .Lfunc_end1
+; CHECK-NEXT: .quad 0
+; CHECK-NEXT: .quad 0
+
+; Function Attrs: noinline nounwind optnone uwtable
+define void @_Z2f1v() #0 section "a" !dbg !7 {
+entry:
+  ret void, !dbg !10
+}
+
+; Function Attrs: noinline nounwind optnone uwtable
+define void @_Z2f2v() #0 section "b" !dbg !11 {
+entry:
+  ret void, !dbg !12
+}
+
+attributes #0 = { noinline nounwind optnone uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+
+!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 6.0.0 (trunk 309523) (llvm/trunk 309526)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
+!1 = !DIFile(filename: "funcs.cpp", directory: "/usr/local/google/home/blaikie/dev/scratch")
+!2 = !{}
+!3 = !{i32 2, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 6.0.0 (trunk 309523) (llvm/trunk 309526)"}
+!7 = distinct !DISubprogram(name: "f1", linkageName: "_Z2f1v", scope: !1, file: !1, line: 1, type: !8, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: false, unit: !0, variables: !2)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null}
+!10 = !DILocation(line: 1, column: 42, scope: !7)
+!11 = 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, variables: !2)
+!12 = !DILocation(line: 2, column: 42, scope: !11)