Add support for DW_AT_ranges_base attribute

[tberghammer]

Summary

Add support for DW_AT_ranges_base attribute

It is a new attribute emitted by clang as a GNU extension and will
be part of Dwarf5. The purpose of the attribute is to specify a compile
unit level base value for all DW_AT_ranges to reduce the number of
relocation have to be done by the linker.

Fixes (at least partially): https://llvm.org/pr28826

[labath]

Looks straight-forward enough. However, it could use a test-case.

[tberghammer]

Adding a new test case

[labath]

Thanks for adding the test case. LGTM from my side.

[clayborg]

Looks good.

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h

public:
   uint16_t GetVersion() const { return m_version; }
   const DWARFAbbreviationDeclarationSet *GetAbbreviations() const {
     return m_abbrevs;
   }
   dw_offset_t GetAbbrevOffset() const;
   uint8_t GetAddressByteSize() const { return m_addr_size; }
   dw_addr_t GetBaseAddress() const { return m_base_addr; }
   dw_addr_t GetAddrBase() const { return m_addr_base; }
-  void SetAddrBase(dw_addr_t addr_base, dw_offset_t base_obj_offset);
+  dw_addr_t GetRangesBase() const { return m_ranges_base; }
+  void SetAddrBase(dw_addr_t addr_base, dw_addr_t ranges_base, dw_offset_t base_obj_offset);
   void ClearDIEs(bool keep_compile_unit_die);
   void BuildAddressRangeTable(SymbolFileDWARF *dwarf2Data,
                               DWARFDebugAranges *debug_aranges);
 
   lldb::ByteOrder GetByteOrder() const;
 
   lldb_private::TypeSystem *GetTypeSystem();
 
protected:
   uint8_t m_addr_size;
   Producer m_producer;
   uint32_t m_producer_version_major;
   uint32_t m_producer_version_minor;
   uint32_t m_producer_version_update;
   lldb::LanguageType m_language_type;
   bool m_is_dwarf64;
   lldb_private::LazyBool m_is_optimized;
-  dw_addr_t m_addr_base; // Value of DW_AT_addr_base
-  dw_offset_t
-      m_base_obj_offset; // If this is a dwo compile unit this is the offset of
-                         // the base compile unit in the main object file
+  dw_addr_t m_addr_base;         // Value of DW_AT_addr_base
+  dw_addr_t m_ranges_base;       // Value of DW_AT_ranges_base
+  dw_offset_t m_base_obj_offset; // If this is a dwo compile unit this is the
+                                 // offset of the base compile unit in the main
+                                 // object file
 
   void ParseProducerInfo();
 
   static void
   IndexPrivate(DWARFCompileUnit *dwarf_cu, const lldb::LanguageType cu_language,
                const DWARFFormValue::FixedFormSizes &fixed_form_sizes,
                const dw_offset_t cu_offset, NameToDIE &func_basenames,
                NameToDIE &func_fullnames, NameToDIE &func_methods,

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

DWARFCompileUnit::DWARFCompileUnit(SymbolFileDWARF *dwarf2Data)
     : m_dwarf2Data(dwarf2Data), m_abbrevs(NULL), m_user_data(NULL),
       m_die_array(), m_func_aranges_ap(), m_base_addr(0),
       m_offset(DW_INVALID_OFFSET), m_length(0), m_version(0),
       m_addr_size(DWARFCompileUnit::GetDefaultAddressSize()),
       m_producer(eProducerInvalid), m_producer_version_major(0),
       m_producer_version_minor(0), m_producer_version_update(0),
       m_language_type(eLanguageTypeUnknown), m_is_dwarf64(false),
       m_is_optimized(eLazyBoolCalculate), m_addr_base(0),
-      m_base_obj_offset(DW_INVALID_OFFSET) {}
+      m_ranges_base(0), m_base_obj_offset(DW_INVALID_OFFSET) {}
 
 DWARFCompileUnit::~DWARFCompileUnit() {}
 
 void DWARFCompileUnit::Clear() {
   m_offset = DW_INVALID_OFFSET;
   m_length = 0;
   m_version = 0;
   m_abbrevs = NULL;
void DWARFCompileUnit::AddCompileUnitDIE(DWARFDebugInfoEntry &die) {
   if (main_dwo_id != sub_dwo_id)
     return; // The 2 dwo ID isn't match. Don't use the dwo file as it belongs to
             // a differectn compilation.
 
   m_dwo_symbol_file = std::move(dwo_symbol_file);
 
   dw_addr_t addr_base = cu_die.GetAttributeValueAsUnsigned(
       m_dwarf2Data, this, DW_AT_GNU_addr_base, 0);
-  dwo_cu->SetAddrBase(addr_base, m_offset);
+  dw_addr_t ranges_base = cu_die.GetAttributeValueAsUnsigned(
+      m_dwarf2Data, this, DW_AT_GNU_ranges_base, 0);
+  dwo_cu->SetAddrBase(addr_base, ranges_base, m_offset);
 }
 
 dw_offset_t DWARFCompileUnit::GetAbbrevOffset() const {
   return m_abbrevs ? m_abbrevs->GetOffset() : DW_INVALID_OFFSET;
 }
 
 bool DWARFCompileUnit::Verify(Stream *s) const {
   const DWARFDataExtractor &debug_info = m_dwarf2Data->get_debug_info_data();

 
 void DWARFCompileUnit::SetUserData(void *d) {
   m_user_data = d;
   if (m_dwo_symbol_file)
     m_dwo_symbol_file->GetCompileUnit()->SetUserData(d);
 }
 
 void DWARFCompileUnit::SetAddrBase(dw_addr_t addr_base,
+                                   dw_addr_t ranges_base,
                                    dw_offset_t base_obj_offset) {
   m_addr_base = addr_base;
+  m_ranges_base = ranges_base;
   m_base_obj_offset = base_obj_offset;
 }
 
 lldb::ByteOrder DWARFCompileUnit::GetByteOrder() const {
   return m_dwarf2Data->GetObjectFile()->GetByteOrder();
 }

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

for (i = 0; i < numAttributes; ++i) {
               hi_pc += lo_pc; // DWARF 4 introduces <offset-from-lo-pc> to save
                               // on relocations
           }
           break;
 
         case DW_AT_ranges: {
           const DWARFDebugRanges *debug_ranges = dwarf2Data->DebugRanges();
           if (debug_ranges) {
-            debug_ranges->FindRanges(form_value.Unsigned(), ranges);
+            debug_ranges->FindRanges(cu->GetRangesBase(), form_value.Unsigned(), ranges);
             // All DW_AT_ranges are relative to the base address of the
             // compile unit. We add the compile unit base address to make
             // sure all the addresses are properly fixed up.
             ranges.Slide(cu->GetBaseAddress());
           } else {
             cu->GetSymbolFileDWARF()->GetObjectFile()->GetModule()->ReportError(
                 "{0x%8.8x}: DIE has DW_AT_ranges(0x%" PRIx64
                 ") attribute yet DWARF has no .debug_ranges, please file a bug "
size_t DWARFDebugInfoEntry::GetAttributeAddressRanges(
   ranges.Clear();
 
   dw_offset_t debug_ranges_offset = GetAttributeValueAsUnsigned(
       dwarf2Data, cu, DW_AT_ranges, DW_INVALID_OFFSET,
       check_specification_or_abstract_origin);
   if (debug_ranges_offset != DW_INVALID_OFFSET) {
     DWARFDebugRanges *debug_ranges = dwarf2Data->DebugRanges();
 
-    debug_ranges->FindRanges(debug_ranges_offset, ranges);
+    debug_ranges->FindRanges(cu->GetRangesBase(), debug_ranges_offset, ranges);
     ranges.Slide(cu->GetBaseAddress());
   } else if (check_hi_lo_pc) {
     dw_addr_t lo_pc = LLDB_INVALID_ADDRESS;
     dw_addr_t hi_pc = LLDB_INVALID_ADDRESS;
     if (GetAttributeAddressRange(dwarf2Data, cu, lo_pc, hi_pc,
                                  LLDB_INVALID_ADDRESS,
                                  check_specification_or_abstract_origin)) {
       if (lo_pc < hi_pc)
if (match_addr_range) {
                            ((function_die != NULL) || (block_die != NULL));
         }
       } else {
         dw_offset_t debug_ranges_offset = GetAttributeValueAsUnsigned(
             dwarf2Data, cu, DW_AT_ranges, DW_INVALID_OFFSET);
         if (debug_ranges_offset != DW_INVALID_OFFSET) {
           DWARFRangeList ranges;
           DWARFDebugRanges *debug_ranges = dwarf2Data->DebugRanges();
-          debug_ranges->FindRanges(debug_ranges_offset, ranges);
+          debug_ranges->FindRanges(cu->GetRangesBase(), debug_ranges_offset, ranges);
           // All DW_AT_ranges are relative to the base address of the
           // compile unit. We add the compile unit base address to make
           // sure all the addresses are properly fixed up.
           ranges.Slide(cu->GetBaseAddress());
           if (ranges.FindEntryThatContains(address)) {
             found_address = true;
             //  puts("***MATCH***");
             switch (m_tag) {

source/Plugins/SymbolFile/DWARF/DWARFDebugRanges.h

 class DWARFDebugRanges {
 public:
   DWARFDebugRanges();
   ~DWARFDebugRanges();
   void Extract(SymbolFileDWARF *dwarf2Data);
   static void Dump(lldb_private::Stream &s,
                    const lldb_private::DWARFDataExtractor &debug_ranges_data,
                    lldb::offset_t *offset_ptr, dw_addr_t cu_base_addr);
-  bool FindRanges(dw_offset_t debug_ranges_offset,
+  bool FindRanges(dw_addr_t debug_ranges_base,
+                  dw_offset_t debug_ranges_offset,
                   DWARFRangeList &range_list) const;
 
 protected:
   bool Extract(SymbolFileDWARF *dwarf2Data, lldb::offset_t *offset_ptr,
                DWARFRangeList &range_list);
 
   typedef std::map<dw_offset_t, DWARFRangeList> range_map;
   typedef range_map::iterator range_map_iterator;
   typedef range_map::const_iterator range_map_const_iterator;
   range_map m_range_map;
 };
 
 #endif // SymbolFileDWARF_DWARFDebugRanges_h_

source/Plugins/SymbolFile/DWARF/DWARFDebugRanges.cpp

if (begin == 0 && end == 0) {
       dw_addr_t end_addr = end + base_addr;
 
       s.AddressRange(begin_addr, end_addr, sizeof(dw_addr_t),
                      verbose ? " ==> addrs = " : NULL);
     }
   }
 }
 
-bool DWARFDebugRanges::FindRanges(dw_offset_t debug_ranges_offset,
+bool DWARFDebugRanges::FindRanges(dw_addr_t debug_ranges_base,
+                                  dw_offset_t debug_ranges_offset,
                                   DWARFRangeList &range_list) const {
-  range_map_const_iterator pos = m_range_map.find(debug_ranges_offset);
+  dw_addr_t debug_ranges_address = debug_ranges_base + debug_ranges_offset;
+  range_map_const_iterator pos = m_range_map.find(debug_ranges_address);
   if (pos != m_range_map.end()) {
     range_list = pos->second;
     return true;
   }
   return false;
 }

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if (num_attributes > 0) {
           } break;
           case DW_AT_specification:
             spec_die = GetDIE(DIERef(form_value));
             break;
           case DW_AT_start_scope: {
             if (form_value.Form() == DW_FORM_sec_offset) {
               DWARFRangeList dwarf_scope_ranges;
               const DWARFDebugRanges *debug_ranges = DebugRanges();
-              debug_ranges->FindRanges(form_value.Unsigned(),
+              debug_ranges->FindRanges(die.GetCU()->GetRangesBase(),
+                                       form_value.Unsigned(),
                                        dwarf_scope_ranges);
 
               // All DW_AT_start_scope are relative to the base address of the
               // compile unit. We add the compile unit base address to make
               // sure all the addresses are properly fixed up.
               for (size_t i = 0, count = dwarf_scope_ranges.GetSize();
                    i < count; ++i) {
                 const DWARFRangeList::Entry &range =