[DWARFLinker] Rewrite CU DW_AT_low_pc/high_pc pairs into DW_AT_ranges

[JDevlieghere]

Summary

For small gapless programs, clang emits single-value DW_AT_low_pc/high_pc in the compile unit. For the debugger, parsing DW_AT_ranges is much faster than having to decode all the compile units. This patch makes the DWARF linker (dsymutil) rewrite DW_AT_low_pc/high_pc pairs into DW_AT_ranges for accelerated access.

rdar://56096523

[aprantl]

Nice. Should we do this in LLVM itsel, too when tuning for LLDB?

llvm/lib/DWARFLinker/DWARFLinker.cpp

1430

I think LLVM_FALLTHROUGH is more compatible.

[JDevlieghere]

• Use LLVM_FALLTHROUGH
• Document UINT64_MAX

[JDevlieghere]

In D141150#4032126, @aprantl wrote:

Should we do this in LLVM itsel, too when tuning for LLDB?

I think that would make sense. If we go that route, do we still want to perform the optimization in dsymutil or should we avoid the added complexity?

[avl]

llvm/lib/DWARFLinker/DWARFLinker.cpp

1428

probably it is better to do as general option?

i.e. so that it could be set/unset for the DWARFLinker?

[JDevlieghere]

After D68655 this doesn't provide an advantage anymore.

llvm/lib/DWARFLinker/DWARFLinker.cpp

if (OpenParens != StringRef::npos) {
                               SkipPubSection);
     }
   }
 }
 
 static bool
 shouldSkipAttribute(DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
                     uint16_t Tag, bool InDebugMap, bool SkipPC,
-                    bool InFunctionScope) {
+                    bool InFunctionScope, bool RewriteHighPC) {
   switch (AttrSpec.Attr) {
   default:
     return false;
-  case dwarf::DW_AT_low_pc:
   case dwarf::DW_AT_high_pc:
+    if (RewriteHighPC)
+      return true;
+    [[fallthrough]];
+  case dwarf::DW_AT_low_pc:
   case dwarf::DW_AT_ranges:
     return SkipPC;
   case dwarf::DW_AT_str_offsets_base:
     // FIXME: Use the string offset table with Dwarf 5.
     return true;
   case dwarf::DW_AT_location:
   case dwarf::DW_AT_frame_base:
     // FIXME: for some reason dsymutil-classic keeps the location attributes
     // when they are of block type (i.e. not location lists). This is totally
     // wrong for globals where we will keep a wrong address. It is mostly
     // harmless for locals, but there is no point in keeping these anyway when
     // the function wasn't linked.
     return (SkipPC || (!InFunctionScope && Tag == dwarf::DW_TAG_variable &&
                        !InDebugMap)) &&
            !DWARFFormValue(AttrSpec.Form).isFormClass(DWARFFormValue::FC_Block);
   }
 }
 
+static dwarf::Form getDwarfSectionOffsetForm(DWARFUnit &Unit) {
+  if (Unit.getVersion() >= 4)
+    return dwarf::Form::DW_FORM_sec_offset;
+  return Unit.getFormat() == dwarf::DWARF64 ? dwarf::Form::DW_FORM_data8
+                                            : dwarf::Form::DW_FORM_data4;
+}
+
 DIE *DWARFLinker::DIECloner::cloneDIE(const DWARFDie &InputDIE,
                                       const DWARFFile &File, CompileUnit &Unit,
                                       OffsetsStringPool &StringPool,
                                       int64_t PCOffset, uint32_t OutOffset,
                                       unsigned Flags, bool IsLittleEndian,
                                       DIE *Die) {
   DWARFUnit &U = Unit.getOrigUnit();
   unsigned Idx = U.getDIEIndex(InputDIE);
DIE *DWARFLinker::DIECloner::cloneDIE(const DWARFDie &InputDIE,
   const auto *Abbrev = InputDIE.getAbbreviationDeclarationPtr();
   Offset += getULEB128Size(Abbrev->getCode());
 
   // We are entering a subprogram. Get and propagate the PCOffset.
   if (Die->getTag() == dwarf::DW_TAG_subprogram)
     PCOffset = Info.AddrAdjust;
   AttrInfo.PCOffset = PCOffset;
 
+  bool RewriteHighPC = false;
+
   if (Abbrev->getTag() == dwarf::DW_TAG_subprogram) {
     Flags |= TF_InFunctionScope;
     if (!Info.InDebugMap && LLVM_LIKELY(!Update))
       Flags |= TF_SkipPC;
   } else if (Abbrev->getTag() == dwarf::DW_TAG_variable) {
     // Function-local globals could be in the debug map even when the function
     // is not, e.g., inlined functions.
     if ((Flags & TF_InFunctionScope) && Info.InDebugMap)
       Flags &= ~TF_SkipPC;
+  } else if (Abbrev->getTag() == dwarf::DW_TAG_compile_unit) {
+    // FIXME: Enable this optimization for DWARF 5 once we support
+    // .debug_rnglists.
+    RewriteHighPC = static_cast<bool>(InputDIE.find(dwarf::DW_AT_high_pc)) &&
+                    U.getVersion() <= 4;
   }
 
   for (const auto &AttrSpec : Abbrev->attributes()) {
     if (LLVM_LIKELY(!Update) &&
         shouldSkipAttribute(AttrSpec, Die->getTag(), Info.InDebugMap,
-                            Flags & TF_SkipPC, Flags & TF_InFunctionScope)) {
+                            Flags & TF_SkipPC, Flags & TF_InFunctionScope,
+                            RewriteHighPC)) {
       DWARFFormValue::skipValue(AttrSpec.Form, Data, &Offset,
                                 U.getFormParams());
       continue;
     }
 
     DWARFFormValue Val(AttrSpec.Form);
     uint64_t AttrSize = Offset;
     Val.extractValue(Data, &Offset, U.getFormParams(), &U);
     AttrSize = Offset - AttrSize;
 
     OutOffset += cloneAttribute(*Die, InputDIE, File, Unit, StringPool, Val,
                                 AttrSpec, AttrSize, AttrInfo, IsLittleEndian);
   }
 
+  if (RewriteHighPC) {
+    PatchLocation Patch =
+        Die->addValue(DIEAlloc, dwarf::DW_AT_ranges,
+                      getDwarfSectionOffsetForm(U), DIEInteger(UINT64_MAX));
+    Unit.noteRangeAttribute(*Die, Patch);
+    AttrInfo.HasRanges = true;
+    OutOffset += U.getDwarfOffsetByteSize();
+  }
+
   // Look for accelerator entries.
   uint16_t Tag = InputDIE.getTag();
   // FIXME: This is slightly wrong. An inline_subroutine without a
   // low_pc, but with AT_ranges might be interesting to get into the
   // accelerator tables too. For now stick with dsymutil's behavior.
   if ((Info.InDebugMap || AttrInfo.HasLowPc || AttrInfo.HasRanges) &&
       Tag != dwarf::DW_TAG_compile_unit &&
       getDIENames(InputDIE, AttrInfo, StringPool,
void DWARFLinker::patchRangesForUnit(const CompileUnit &Unit,
   // offset we need to apply to adapt to the new unit's low_pc.
   int64_t UnitPcOffset = 0;
   if (OrigLowPc != -1ULL)
     UnitPcOffset = int64_t(OrigLowPc) - Unit.getLowPc();
 
   for (const auto &RangeAttribute : Unit.getRangesAttributes()) {
     uint64_t Offset = RangeAttribute.get();
     RangeAttribute.set(TheDwarfEmitter->getRangesSectionSize());
+    if (Offset != UINT64_MAX) {
       if (Error E = RangeList.extract(RangeExtractor, &Offset)) {
         llvm::consumeError(std::move(E));
         reportWarning("invalid range list ignored.", File);
         RangeList.clear();
       }
+    }
     const auto &Entries = RangeList.getEntries();
     if (!Entries.empty()) {
       const DWARFDebugRangeList::RangeListEntry &First = Entries.front();
 
       if (!CurrRange ||
           !CurrRange->first.contains(First.StartAddress + OrigLowPc)) {
         CurrRange = FunctionRanges.getRangeValueThatContains(
             First.StartAddress + OrigLowPc);

llvm/test/tools/dsymutil/ARM/obfuscated.test

 CHECK:          length: 0x00000000
 CHECK: file_names[  1]:
 CHECK:            name: "six.c"
 CHECK:       dir_index: 0
 CHECK:        mod_time: 0x00000000
 CHECK:          length: 0x00000000
 
 PUB: .debug_pubnames contents:
-PUB: length = 0x00000017, format = DWARF32, version = 0x0002, unit_offset = 0x00000000, unit_size = 0x00000044
-PUB: 0x0000002e "main"
-PUB: length = 0x00000016, format = DWARF32, version = 0x0002, unit_offset = 0x00000044, unit_size = 0x00000044
-PUB: 0x0000002e "one"
-PUB: length = 0x00000016, format = DWARF32, version = 0x0002, unit_offset = 0x00000088, unit_size = 0x00000044
-PUB: 0x0000002e "two"
-PUB: length = 0x00000018, format = DWARF32, version = 0x0002, unit_offset = 0x000000cc, unit_size = 0x00000044
-PUB: 0x0000002e "three"
-PUB: length = 0x00000017, format = DWARF32, version = 0x0002, unit_offset = 0x00000110, unit_size = 0x00000044
-PUB: 0x0000002e "four"
-PUB: length = 0x00000017, format = DWARF32, version = 0x0002, unit_offset = 0x00000154, unit_size = 0x00000044
-PUB: 0x0000002e "five"
-PUB: length = 0x00000016, format = DWARF32, version = 0x0002, unit_offset = 0x00000198, unit_size = 0x00000044
-PUB: 0x0000002e "six"
+PUB: length = 0x00000017, format = DWARF32, version = 0x0002, unit_offset = 0x00000000, unit_size = 0x00000048
+PUB: 0x00000032 "main"
+PUB: length = 0x00000016, format = DWARF32, version = 0x0002, unit_offset = 0x00000048, unit_size = 0x00000048
+PUB: 0x00000032 "one"
+PUB: length = 0x00000016, format = DWARF32, version = 0x0002, unit_offset = 0x00000090, unit_size = 0x00000048
+PUB: 0x00000032 "two"
+PUB: length = 0x00000018, format = DWARF32, version = 0x0002, unit_offset = 0x000000d8, unit_size = 0x00000048
+PUB: 0x00000032 "three"
+PUB: length = 0x00000017, format = DWARF32, version = 0x0002, unit_offset = 0x00000120, unit_size = 0x00000048
+PUB: 0x00000032 "four"
+PUB: length = 0x00000017, format = DWARF32, version = 0x0002, unit_offset = 0x00000168, unit_size = 0x00000048
+PUB: 0x00000032 "five"
+PUB: length = 0x00000016, format = DWARF32, version = 0x0002, unit_offset = 0x000001b0, unit_size = 0x00000048
+PUB: 0x00000032 "six"
 
 CHECK: .apple_names contents:
 
 CHECK: String: 0x00000091 "five"
 CHECK-NEXT: Data 0 [
-CHECK-NEXT:   Atom[0]: 0x00000182
+CHECK-NEXT:   Atom[0]: 0x0000019a
 CHECK-NEXT: ]
 CHECK: String: 0x0000009c "six"
 CHECK-NEXT: Data 0 [
-CHECK-NEXT:   Atom[0]: 0x000001c6
+CHECK-NEXT:   Atom[0]: 0x000001e2
 CHECK-NEXT: ]
 CHECK: String: 0x00000078 "three"
 CHECK-NEXT: Data 0 [
-CHECK-NEXT:   Atom[0]: 0x000000fa
+CHECK-NEXT:   Atom[0]: 0x0000010a
 CHECK-NEXT: ]
 CHECK: String: 0x0000006c "two"
 CHECK-NEXT: Data 0 [
-CHECK-NEXT:   Atom[0]: 0x000000b6
+CHECK-NEXT:   Atom[0]: 0x000000c2
 CHECK-NEXT: ]
 CHECK: String: 0x00000057 "main"
 CHECK-NEXT: Data 0 [
-CHECK-NEXT:   Atom[0]: 0x0000002e
+CHECK-NEXT:   Atom[0]: 0x00000032
 CHECK-NEXT: ]
 CHECK: String: 0x00000085 "four"
 CHECK-NEXT: Data 0 [
-CHECK-NEXT:   Atom[0]: 0x0000013e
+CHECK-NEXT:   Atom[0]: 0x00000152
 CHECK-NEXT: ]
 CHECK: String: 0x00000062 "one"
 CHECK-NEXT: Data 0 [
-CHECK-NEXT:   Atom[0]: 0x00000072
+CHECK-NEXT:   Atom[0]: 0x0000007a
 CHECK-NEXT: ]

llvm/test/tools/dsymutil/X86/basic-lto-dw4-linking-x86.test

 RUN: dsymutil -f -o - -oso-prepend-path=%p/.. %p/../Inputs/basic-lto-dw4.macho.x86_64 | llvm-dwarfdump -a - | FileCheck %s
 
 CHECK: file format Mach-O 64-bit x86-64
 
 CHECK: debug_info contents
 
 CHECK:  Compile Unit: {{.*}} version = 0x0004
 CHECK:  DW_TAG_compile_unit
 CHECK:    DW_AT_producer ("clang version 3.7.0 ")
 CHECK:    DW_AT_language (DW_LANG_C99)
 CHECK:    DW_AT_name ("basic1.c")
 CHECK:    DW_AT_stmt_list (0x00000000)
 CHECK:    DW_AT_comp_dir ("/Inputs")
 CHECK:    DW_AT_low_pc (0x0000000100000f40)
-CHECK:    DW_AT_high_pc (0x0000000100000f4b)
+CHECK:    DW_AT_ranges      (0x00000030
+CHECK:      [0x0000000100000f40, 0x0000000100000f4b))
 CHECK:    DW_TAG_subprogram
 CHECK:      DW_AT_low_pc (0x0000000100000f40)
 CHECK:      DW_AT_high_pc (0x0000000100000f4b)
 CHECK:      DW_AT_frame_base (DW_OP_reg6 RBP)
 CHECK:      DW_AT_name ("main")
 CHECK:      DW_AT_decl_file ("/Inputs{{[/\\]}}basic1.c")
 CHECK:      DW_AT_prototyped (true)
 CHECK:      DW_AT_type (0x00000000000000a1

 CHECK:  Compile Unit:{{.*}} version = 0x0004
 
 CHECK:  DW_TAG_compile_unit
 CHECK:    DW_AT_producer ("clang version 3.7.0 ")
 CHECK:    DW_AT_language (DW_LANG_C99)
 CHECK:    DW_AT_name ("basic2.c")
 CHECK:    DW_AT_stmt_list (0x00000044)
 CHECK:    DW_AT_low_pc (0x0000000100000f50)
-CHECK:    DW_AT_high_pc (0x0000000100000f87)
+CHECK:    DW_AT_ranges      (0x00000050
+CHECK:      [0x0000000100000f50, 0x0000000100000f87))
 CHECK:    DW_TAG_base_type
 CHECK:      DW_AT_name ("int")
 CHECK:    DW_TAG_variable
 CHECK:      DW_AT_name ("baz")
 CHECK:      DW_AT_location (DW_OP_addr 0x100001000)
 CHECK:    DW_TAG_variable
 CHECK:      DW_AT_name ("private_int")
 CHECK:      DW_AT_decl_file ("/Inputs{{[/\\]}}basic2.c")

 
 CHECK:  Compile Unit: {{.*}} version = 0x0004
 
 CHECK:  DW_TAG_compile_unit
 CHECK:    DW_AT_producer ("clang version 3.7.0 ")
 CHECK:    DW_AT_name ("basic3.c")
 CHECK:    DW_AT_stmt_list (0x0000009a)
 CHECK:    DW_AT_low_pc (0x0000000100000f90)
-CHECK:    DW_AT_high_pc (0x0000000100000fb4)
+CHECK:    DW_AT_ranges      (0x00000070
+CHECK:      [0x0000000100000f90, 0x0000000100000fb4))
 CHECK:    DW_TAG_variable
 CHECK:      DW_AT_name ("val")
 CHECK:      DW_AT_decl_file ("/Inputs{{[/\\]}}basic3.c")
 CHECK:      DW_AT_location (DW_OP_addr 0x100001004)
 CHECK:    DW_TAG_volatile_type
 CHECK:    DW_TAG_subprogram
 CHECK:      DW_AT_name ("inc")
 CHECK:      DW_AT_inline (DW_INL_inlined)

llvm/test/tools/dsymutil/X86/dead-stripped.cpp

 // RUN: dsymutil -f -y %p/dummy-debug-map.map -oso-prepend-path %p/../Inputs/dead-stripped -o - | llvm-dwarfdump - --debug-info | FileCheck %s --implicit-check-not "{{DW_AT_low_pc|DW_AT_high_pc|DW_AT_location|DW_TAG|NULL}}"
 
 // The test was compiled with:
 // clang++ -O2 -g -c dead-strip.cpp -o 1.o
 
 // The goal of the test is to exercise dsymutil's behavior in presence of
 // functions/variables that have been dead-stripped by the linker but
 // that are still present in the linked debug info (in this case because
 // they have been DW_TAG_import'd in another namespace).
 
 // Everything in the N namespace below doesn't have a debug map entry, and
 // thus is considered dead (::foo() has a debug map entry, otherwise dsymutil
 // would just drop the CU altogether).
 
 // CHECK: DW_TAG_compile_unit
 // CHECK:   DW_AT_low_pc
-// CHECK:   DW_AT_high_pc
+// CHECK:   DW_AT_ranges
 // CHECK:   DW_TAG_namespace
 namespace N {
 int blah = 42;
 // This is actually a dsymutil-classic bug that we reproduced
 // CHECK: DW_TAG_variable
 // CHECK: DW_AT_location
 
 __attribute__((always_inline)) int foo() { return blah; }

llvm/test/tools/dsymutil/X86/inlined-static-variable.cpp

 }
 
 int foo() {
   return removed() + not_removed();
 }
 
 // CHECK: DW_TAG_compile_unit
 // CHECK:   DW_AT_low_pc
-// CHECK:   DW_AT_high_pc
+// CHECK:   DW_AT_ranges
 
 // CHECK:   DW_TAG_subprogram
 // CHECK:     DW_AT_name  ("removed")
 // CHECK:     DW_TAG_variable
 // CHECK:       DW_AT_name  ("a")
 // CHECK:       DW_AT_location
 // CHECK:     NULL