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.

lldb/trunk/packages/Python/lldbsuite/test/python_api/symbol-context/two-files/TestSymbolContextTwoFiles.py

def test_lookup_by_address(self):
             self.assertTrue(1, sc_list.GetSize())
             symbol_address = sc_list.GetContextAtIndex(
                 0).GetSymbol().GetStartAddress()
             self.assertTrue(symbol_address.IsValid())
             sc_by_address = module.ResolveSymbolContextForAddress(
                 symbol_address, lldb.eSymbolContextFunction)
             self.assertEqual(symbol_name,
                              sc_by_address.GetFunction().GetName())
+
+    @add_test_categories(['pyapi'])
+    def test_ranges_in_multiple_compile_unit(self):
+        """This test verifies that we correctly handle the case when multiple
+        compile unit contains DW_AT_ranges and DW_AT_ranges_base attributes."""
+        self.build()
+        exe = os.path.join(os.getcwd(), "a.out")
+
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target, VALID_TARGET)
+
+        source1 = "file1.cpp"
+        line1 = line_number(source1, '// Break1')
+        breakpoint1 = target.BreakpointCreateByLocation(source1, line1)
+        self.assertIsNotNone(breakpoint1)
+        self.assertTrue(breakpoint1.IsValid())
+
+        source2 = "file2.cpp"
+        line2 = line_number(source2, '// Break2')
+        breakpoint2 = target.BreakpointCreateByLocation(source2, line2)
+        self.assertIsNotNone(breakpoint2)
+        self.assertTrue(breakpoint2.IsValid())
+
+        process = target.LaunchSimple(None, None, os.getcwd())
+        self.assertIsNotNone(process, PROCESS_IS_VALID)
+
+        threads = lldbutil.get_threads_stopped_at_breakpoint(
+            process, breakpoint2)
+        self.assertEqual(len(threads), 1)
+        frame = threads[0].GetFrameAtIndex(0)
+        value = frame.FindVariable("x")
+        self.assertTrue(value.IsValid())
+
+        process.Continue()
+
+        threads = lldbutil.get_threads_stopped_at_breakpoint(
+            process, breakpoint1)
+        self.assertEqual(len(threads), 1)
+        frame = threads[0].GetFrameAtIndex(0)
+        value = frame.FindVariable("x")
+        self.assertTrue(value.IsValid())
+
+        process.Continue()

lldb/trunk/packages/Python/lldbsuite/test/python_api/symbol-context/two-files/decls.h

-struct struct1
-{
-    static void
-    f();
+struct struct1 {
+  ~struct1();
+  static void f();
 };
 
-struct struct2
-{
-    static void
-    f();
+struct struct2 {
+  ~struct2();
+  static void f();
 };
+
+int g();

lldb/trunk/packages/Python/lldbsuite/test/python_api/symbol-context/two-files/file1.cpp

 #include "decls.h"
 
-void
-struct1::f()
-{
+int g() {
+  return 1;
 }
 
-int main()
-{
-    struct1::f();
-    struct2::f();
-    return 0;
+struct1::~struct1() {
+  int x = g(); // Break1
+}
+
+void struct1::f() {}
+
+int main() {
+
+  struct1 s1;
+  struct2 s2;
+
 }

lldb/trunk/packages/Python/lldbsuite/test/python_api/symbol-context/two-files/file2.cpp

 #include "decls.h"
 
-void
-struct2::f()
-{
+struct2::~struct2() {
+  int x = g(); // Break2
 }
+
+void struct2::f() {}

lldb/trunk/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,

lldb/trunk/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();
 }

lldb/trunk/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) {

lldb/trunk/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_

lldb/trunk/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;
 }

lldb/trunk/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 =