[LLDB] - Add support for DW_RLE_base_address and DW_RLE_offset_pair entries (.debug_rnglists)

[grimar]

Summary

The patch implements the support for DW_RLE_base_address and DW_RLE_offset_pair
.debug_rnglists entries

[clayborg]

See inlined comments.

source/Plugins/SymbolFile/DWARF/DWARFDebugRanges.cpp

150–151 ↗

(On Diff #169211)

Might be nice to not push a base address entry and store the base address locally and fixup any DW_RLE_offset_pair entries on the fly?

source/Plugins/SymbolFile/DWARF/DWARFDebugRanges.h

51–55 ↗

(On Diff #169211)

Do we really need to store all this? Can't we just convert to address ranges on the fly in DWARFDebugRngLists::Extract? With the current DW_RLE_base_address and DW_RLE_offset_pair stuff we can store the base address locally inside the DWARFDebugRngLists::Extract function and skip pushing an entry for it and then convert any DW_RLE_offset_pair stuff into addresses by adding the base address before pushing the range. Or will this be required to support other opcodes?

[grimar]

source/Plugins/SymbolFile/DWARF/DWARFDebugRanges.h

51–55 ↗

(On Diff #169211)

I think we can not do that in DWARFDebugRngLists::Extract because we should take
in account that we can have multiple CU with different address bases.

Example:
https://github.com/llvm-mirror/lldb/blob/master/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp#L1069
In this code dwarf2Data->DebugRanges() call Extract which extracts all ranges from .debug_range section.
But at the moment of extraction, it does not know the base address for a given CU and that is why code calls
range.Slide after that I believe.

Here is an example I have in mind for this patch. The executable below contains 2 CUs and 2 contibution in .debug_rnglists (one for each CU)

.debug_info contents:
0x00000000: Compile Unit: length = 0x000000ac version = 0x0005 unit_type = DW_UT_compile abbr_offset = 0x0000 addr_size = 0x08 (next unit at 0x000000b0)

0x0000000c: DW_TAG_compile_unit [1] *
...
              DW_AT_low_pc [DW_FORM_addr]	(0x0000000000400520)
              DW_AT_high_pc [DW_FORM_data4]	(0x00000034)
              DW_AT_rnglists_base [DW_FORM_sec_offset]	(0x0000000c)

...
0x000000b0: Compile Unit: length = 0x000000a1 version = 0x0005 unit_type = DW_UT_compile abbr_offset = 0x00ad addr_size = 0x08 (next unit at 0x00000155)

0x000000bc: DW_TAG_compile_unit [1] *
....
              DW_AT_low_pc [DW_FORM_addr]	(0x0000000000400560)
              DW_AT_high_pc [DW_FORM_data4]	(0x00000027)
              DW_AT_rnglists_base [DW_FORM_sec_offset]	(0x0000001f)

.debug_rnglists contents:
0x00000000: range list header: length = 0x0000000f, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
ranges:
0x0000000c: [DW_RLE_offset_pair]:  0x0000000000000005, 0x0000000000000012 => [0x0000000000000005, 0x0000000000000012)
0x0000000f: [DW_RLE_offset_pair]:  0x0000000000000017, 0x000000000000001d => [0x0000000000000017, 0x000000000000001d)
0x00000012: [DW_RLE_end_of_list]
0x00000013: range list header: length = 0x0000000f, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
ranges:
0x0000001f: [DW_RLE_offset_pair]:  0x0000000000000005, 0x0000000000000012 => [0x0000000000000005, 0x0000000000000012)
0x00000022: [DW_RLE_offset_pair]:  0x0000000000000017, 0x000000000000001d => [0x0000000000000017, 0x000000000000001d)
0x00000025: [DW_RLE_end_of_list]

With that, it seems we want to parse the .debug_rnglists section once, but for each CU we have different contribution offset (DW_AT_rnglists_base) and the different base address (DW_AT_low_pc), so I think should fix up the ranges parsed independently.
That is why I had to store RngListEntry list and doing the fixup in FindRanges.

As an improvement we might want to cache the result returned by FindRanges somehow I think, so for further calls of FindRanges
for a given CU we would not need to do a fixup and can just return the ranges list built earlier.

[grimar]

• Rebased, resolved conflicts.

[grimar]

Ping.

[aprantl]

It looks like this might have broken the bots, could you please take a look?

http://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/11671/consoleFull#434797663d489585b-5106-414a-ac11-3ff90657619c

******************** TEST 'lldb :: Breakpoint/debug_rnglist_rlestartend.test' FAILED ********************
Script:
--
: 'RUN: at line 1';   /Users/buildslave/jenkins/workspace/lldb-cmake/lldb-build/bin/yaml2obj /Users/buildslave/jenkins/workspace/lldb-cmake/llvm/tools/lldb/lit/Breakpoint/Inputs/debug_rnglist_rlestartend.yaml > /Users/buildslave/jenkins/workspace/lldb-cmake/lldb-build/tools/lldb/lit/Breakpoint/Output/debug_rnglist_rlestartend.test.tmptest
: 'RUN: at line 2';   /Users/buildslave/jenkins/workspace/lldb-cmake/lldb-build/bin/lldb-test breakpoints /Users/buildslave/jenkins/workspace/lldb-cmake/lldb-build/tools/lldb/lit/Breakpoint/Output/debug_rnglist_rlestartend.test.tmptest /Users/buildslave/jenkins/workspace/lldb-cmake/llvm/tools/lldb/lit/Breakpoint/debug_rnglist_rlestartend.test | /Users/buildslave/jenkins/workspace/lldb-cmake/lldb-build/bin/FileCheck /Users/buildslave/jenkins/workspace/lldb-cmake/llvm/tools/lldb/lit/Breakpoint/debug_rnglist_rlestartend.test
--
Exit Code: 2

Command Output (stderr):
--
unexpected encoding
UNREACHABLE executed at /Users/buildslave/jenkins/workspace/lldb-cmake/llvm/tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugRanges.cpp:202!
0  lldb-test                0x0000000105a27d65 llvm::sys::PrintStackTrace(llvm::raw_ostream&) + 37
1  lldb-test                0x0000000105a26c96 llvm::sys::RunSignalHandlers() + 198
2  lldb-test                0x0000000105a283c8 SignalHandler(int) + 264
3  libsystem_platform.dylib 0x00007fff78d08f5a _sigtramp + 26
4  libsystem_platform.dylib 0x00007ffeea2c9da8 _sigtramp + 1901858408
5  libsystem_c.dylib        0x00007fff78aa61ae abort + 127
6  lldb-test                0x000000010599797c llvm::llvm_unreachable_internal(char const*, char const*, unsigned int) + 540
7  lldb-test                0x0000000105eaeba9 DWARFDebugRngLists::FindRanges(DWARFUnit const*, unsigned int, lldb_private::RangeArray<unsigned long long, unsigned long long, 2u>&) const + 457
8  lldb-test                0x0000000105ea9dcc DWARFDebugInfoEntry::GetAttributeAddressRanges(SymbolFileDWARF*, DWARFUnit const*, lldb_private::RangeArray<unsigned long long, unsigned long long, 2u>&, bool, bool) const + 140
9  lldb-test                0x0000000105eb4114 DWARFUnit::BuildAddressRangeTable(SymbolFileDWARF*, DWARFDebugAranges*) + 116
10 lldb-test                0x0000000105ea6bd1 DWARFDebugInfo::GetCompileUnitAranges() + 1025
11 lldb-test                0x0000000105ec4c0f SymbolFileDWARF::ResolveSymbolContext(lldb_private::Address const&, unsigned int, lldb_private::SymbolContext&) + 255
12 lldb-test                0x0000000105ba76bf lldb_private::SymbolVendor::ResolveSymbolContext(lldb_private::Address const&, unsigned int, lldb_private::SymbolContext&) + 95
13 lldb-test                0x0000000105a8305b lldb_private::Module::ResolveSymbolContextForAddress(lldb_private::Address const&, unsigned int, lldb_private::SymbolContext&, bool) + 459
14 lldb-test                0x0000000105a49b3d lldb_private::Address::CalculateSymbolContext(lldb_private::SymbolContext*, unsigned int) const + 205
15 lldb-test                0x0000000105a33e67 lldb_private::BreakpointLocation::GetDescription(lldb_private::Stream*, lldb::DescriptionLevel) + 279
16 lldb-test                0x0000000105a2e591 lldb_private::Breakpoint::GetDescription(lldb_private::Stream*, lldb::DescriptionLevel, bool) + 849
17 lldb-test                0x000000010713ba1a CommandObjectBreakpointSet::DoExecute(lldb_private::Args&, lldb_private::CommandReturnObject&) + 3082
18 lldb-test                0x0000000105b2daa2 lldb_private::CommandObjectParsed::Execute(char const*, lldb_private::CommandReturnObject&) + 418
19 lldb-test                0x0000000105b26485 lldb_private::CommandInterpreter::HandleCommand(char const*, lldb_private::LazyBool, lldb_private::CommandReturnObject&, lldb_private::ExecutionContext*, bool, bool) + 2869
20 lldb-test                0x0000000105b2eb31 lldb_private::CommandObjectRegexCommand::DoExecute(llvm::StringRef, lldb_private::CommandReturnObject&) + 849
21 lldb-test                0x0000000105b2dcd6 lldb_private::CommandObjectRaw::Execute(char const*, lldb_private::CommandReturnObject&) + 470
22 lldb-test                0x0000000105b26485 lldb_private::CommandInterpreter::HandleCommand(char const*, lldb_private::LazyBool, lldb_private::CommandReturnObject&, lldb_private::ExecutionContext*, bool, bool) + 2869
23 lldb-test                0x000000010593c474 main + 1716
24 libdyld.dylib            0x00007fff789fa015 start + 1
25 libdyld.dylib            0x0000000000000004 start + 2271240176
Stack dump:
0.	Program arguments: /Users/buildslave/jenkins/workspace/lldb-cmake/lldb-build/bin/lldb-test breakpoints /Users/buildslave/jenkins/workspace/lldb-cmake/lldb-build/tools/lldb/lit/Breakpoint/Output/debug_rnglist_rlestartend.test.tmptest /Users/buildslave/jenkins/workspace/lldb-cmake/llvm/tools/lldb/lit/Breakpoint/debug_rnglist_rlestartend.test 
1.	HandleCommand(command = "b main")
2.	HandleCommand(command = "breakpoint set --name 'main'")
FileCheck error: '-' is empty.
FileCheck command line:  /Users/buildslave/jenkins/workspace/lldb-cmake/lldb-build/bin/FileCheck /Users/buildslave/jenkins/workspace/lldb-cmake/llvm/tools/lldb/lit/Breakpoint/debug_rnglist_rlestartend.test

--

lldb/trunk/lit/Breakpoint/Inputs/debug_rnglist_offset_pair.yaml

+--- !ELF
+FileHeader:      
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_EXEC
+  Machine:         EM_X86_64
+  Entry:           0x0000000000400440
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x0000000000400440
+    AddressAlign:    0x0000000000000010
+    Content:         31ED4989D15E4889E24883E4F0505449C7C0C005400048C7C15005400048C7C740054000E8B7FFFFFFF4660F1F44000055B820204000483D202040004889E57417B8000000004885C0740D5DBF20204000FFE00F1F4400005DC3660F1F440000BE20204000554881EE202040004889E548C1FE034889F048C1E83F4801C648D1FE7415B8000000004885C0740B5DBF20204000FFE00F1F005DC3660F1F440000803D391B0000007517554889E5E87EFFFFFFC605271B0000015DC30F1F440000F3C30F1F4000662E0F1F840000000000554889E55DEB89660F1F840000000000B9020000008B05F91A00000F1F44000021F883C1FF75F98905E71A0000C3669050BF01000000E8D5FFFFFF31C059C390415741564189FF415541544C8D25A618000055488D2DA6180000534989F64989D54C29E54883EC0848C1FD03E86FFEFFFF4885ED742031DB0F1F8400000000004C89EA4C89F64489FF41FF14DC4883C3014839EB75EA4883C4085B5D415C415D415E415FC390662E0F1F840000000000F3C3
+  - Name:            .debug_str_offsets
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x0000000000000001
+    Content:         300000000500000000000000230000002C0000004F00000051000000550000005D0000006100000066000000680000006A000000
+  - Name:            .debug_str
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_MERGE, SHF_STRINGS ]
+    AddressAlign:    0x0000000000000001
+    Content:         636C616E672076657273696F6E20382E302E3020287472756E6B203334343033352900746573742E637070002F686F6D652F756D622F74657374735F323031382F3130365F726E676C6973747332004300696E74005F5A33666F6F6900666F6F006D61696E00500049005700
+  - Name:            .debug_loc
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x0000000000000001
+    Content:         05000000000000001000000000000000030011009F00000000000000000000000000000000
+  - Name:            .debug_abbrev
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x0000000000000001
+    Content:         011101252513050325721710171B251101120674170000023400032549133F193A0B3B0B0218000003240003253E0B0B0B0000042E011101120640187A196E2503253A0B3B0B3F190000050500021803253A0B3B0B49130000060B01110112060000073400021703253A0B3B0B49130000080B015517000009340003253A0B3B0B491300000A2E011101120640187A1903253A0B3B0B49133F1900000B48007F137D0100000C0F004913000000
+  - Name:            .debug_info
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x0000000000000001
+    Content:         AC0000000500010800000000010004000108000000000000000220054000000000002F0000000C00000002033C000000010309032420400000000000030405040420054000000000001E0000000157050601040501550801043C0000000625054000000000001800000007000000000901063C000000080C000000090A0107AA0000000000000A40054000000000000F000000015707010E3C0000000B400000004B05400000000000000C3C00000000
+  - Name:            .debug_rnglists
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x0000000000000001
+    Content:         18000000050008000000000005200540000000000004051204171D00
+  - Name:            .debug_macinfo
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x0000000000000001
+    Content:         '00'
+  - Name:            .debug_line
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x0000000000000001
+    Content:         7F000000050008004C000000010101FB0E0D00010101010000000100000101011F010000000003011F020F051E0223000000003D8C80E874CE6D5F1FC4A6544BE9D5B323000000003D8C80E874CE6D5F1FC4A6544BE9D5B300090220054000000000001605080A5B0515C60503063C0508063005016805004105030A21A00204000101
+  - Name:            .debug_line_str
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_MERGE, SHF_STRINGS ]
+    AddressAlign:    0x0000000000000001
+    Content:         2F686F6D652F756D622F74657374735F323031382F3130365F726E676C697374733200746573742E63707000
+Symbols:         

lldb/trunk/lit/Breakpoint/debug_rnglist_offset_pair.test

+# RUN: yaml2obj %p/Inputs/debug_rnglist_offset_pair.yaml > %ttest
+# RUN: lldb-test breakpoints %ttest %s | FileCheck %s
+
+# The following code and invocation were used to produce asm file,
+# which was manually edited to add DW_RLE_base_address entry.
+# clang -S -g -gdwarf-5 -O1 test.cpp -o test.s
+# Then it was compiled and converted to yaml.
+#
+# int C = 0;
+# void foo(int P)
+# {
+#   for (int I = 0; I < 2; ++I) {
+#     int *W = &C; 
+#     *W &= P; 
+#   }
+# }
+# 
+# int main ()
+# {
+#   foo (1);
+#   return 0;
+# }
+#
+# clang and LLD versions were 8.0.0 (trunk 344035)
+#
+# Output file contains .debug_rnglists section with entries:
+# DW_RLE_offset_pair and DW_RLE_base_address.
+
+b foo
+# CHECK-LABEL: b foo
+# CHECK: Address: {{.*}}`foo(int) + 5 at test.cpp:8:8
+
+

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

for (uint32_t i = 0; i < numAttributes; ++i) {
               do_offset = hi_pc != LLDB_INVALID_ADDRESS;
             else
               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(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 {
+          const DWARFDebugRangesBase *debug_ranges = dwarf2Data->DebugRanges();
+          if (debug_ranges)
+            debug_ranges->FindRanges(cu, form_value.Unsigned(), ranges);
+          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 "
                 "and attach the file at the start of this error message",
                 m_offset, form_value.Unsigned());
-          }
         } break;
 
         case DW_AT_name:
           if (name == NULL)
             name = form_value.AsCString();
           break;
 
         case DW_AT_MIPS_linkage_name:
size_t DWARFDebugInfoEntry::GetAttributeAddressRanges(
     DWARFRangeList &ranges, bool check_hi_lo_pc,
     bool check_specification_or_abstract_origin) const {
   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) {
-    if (DWARFDebugRanges *debug_ranges = dwarf2Data->DebugRanges())
-      debug_ranges->FindRanges(cu->GetRangesBase(), debug_ranges_offset,
-                               ranges);
-    ranges.Slide(cu->GetBaseAddress());
+    if (DWARFDebugRangesBase *debug_ranges = dwarf2Data->DebugRanges())
+      debug_ranges->FindRanges(cu, debug_ranges_offset, ranges);
   } 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)
         ranges.Append(DWARFRangeList::Entry(lo_pc, hi_pc - lo_pc));
if (match_addr_range) {
                             m_tag == DW_TAG_partial_unit) &&
                            ((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(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());
+          DWARFDebugRangesBase *debug_ranges = dwarf2Data->DebugRanges();
+          debug_ranges->FindRanges(cu, debug_ranges_offset, ranges);
+
           if (ranges.FindEntryThatContains(address)) {
             found_address = true;
             //  puts("***MATCH***");
             switch (m_tag) {
             case DW_TAG_compile_unit: // File
             case DW_TAG_partial_unit: // File
               check_children = ((function_die != NULL) || (block_die != NULL));
               break;

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugRanges.h

 #ifndef SymbolFileDWARF_DWARFDebugRanges_h_
 #define SymbolFileDWARF_DWARFDebugRanges_h_
 
 #include "DWARFDIE.h"
 #include "SymbolFileDWARF.h"
 
 #include <map>
 
-class DWARFDebugRanges {
+class DWARFDebugRangesBase {
+public:
+  virtual ~DWARFDebugRangesBase(){};
+
+  virtual void Extract(SymbolFileDWARF *dwarf2Data) = 0;
+  virtual bool FindRanges(const DWARFUnit *cu, dw_offset_t debug_ranges_offset,
+                          DWARFRangeList &range_list) const = 0;
+};
+
+class DWARFDebugRanges final : public DWARFDebugRangesBase {
 public:
   DWARFDebugRanges();
-  virtual ~DWARFDebugRanges();
-  virtual void Extract(SymbolFileDWARF *dwarf2Data);
+
+  virtual void Extract(SymbolFileDWARF *dwarf2Data) override;
+  virtual bool FindRanges(const DWARFUnit *cu, dw_offset_t debug_ranges_offset,
+                          DWARFRangeList &range_list) const override;
 
   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_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;
 };
 
 // DWARF v5 .debug_rnglists section.
-class DWARFDebugRngLists : public DWARFDebugRanges {
+class DWARFDebugRngLists final : public DWARFDebugRangesBase {
+  struct RngListEntry {
+    uint8_t encoding;
+    uint64_t value0;
+    uint64_t value1;
+  };
+
 public:
   void Extract(SymbolFileDWARF *dwarf2Data) override;
+  bool FindRanges(const DWARFUnit *cu, dw_offset_t debug_ranges_offset,
+                  DWARFRangeList &range_list) const override;
 
 protected:
   bool ExtractRangeList(const lldb_private::DWARFDataExtractor &data,
                         uint8_t addrSize, lldb::offset_t *offset_ptr,
-                        DWARFRangeList &list);
+                        std::vector<RngListEntry> &list);
 
   std::vector<uint64_t> Offsets;
+  std::map<dw_offset_t, std::vector<RngListEntry>> m_range_map;
 };
 
 #endif // SymbolFileDWARF_DWARFDebugRanges_h_

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugRanges.cpp

 //===-- DWARFDebugRanges.cpp ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DWARFDebugRanges.h"
+#include "DWARFUnit.h"
 #include "SymbolFileDWARF.h"
 #include "lldb/Utility/Stream.h"
 #include <assert.h>
 
 using namespace lldb_private;
 using namespace std;
 
 static dw_addr_t GetBaseAddressMarker(uint32_t addr_size) {
   switch(addr_size) {
     case 2:
       return 0xffff;
     case 4:
       return 0xffffffff;
     case 8:
       return 0xffffffffffffffff;
   }
   llvm_unreachable("GetBaseAddressMarker unsupported address size.");
 }
 
 DWARFDebugRanges::DWARFDebugRanges() : m_range_map() {}
 
-DWARFDebugRanges::~DWARFDebugRanges() {}
-
 void DWARFDebugRanges::Extract(SymbolFileDWARF *dwarf2Data) {
   DWARFRangeList range_list;
   lldb::offset_t offset = 0;
   dw_offset_t debug_ranges_offset = offset;
   while (Extract(dwarf2Data, &offset, range_list)) {
     range_list.Sort();
     m_range_map[debug_ranges_offset] = range_list;
     debug_ranges_offset = offset;
if (begin == 0 && end == 0) {
       dw_addr_t begin_addr = begin + base_addr;
       dw_addr_t end_addr = end + base_addr;
 
       s.AddressRange(begin_addr, end_addr, sizeof(dw_addr_t), NULL);
     }
   }
 }
 
-bool DWARFDebugRanges::FindRanges(dw_addr_t debug_ranges_base,
+bool DWARFDebugRanges::FindRanges(const DWARFUnit *cu,
                                   dw_offset_t debug_ranges_offset,
                                   DWARFRangeList &range_list) const {
-  dw_addr_t debug_ranges_address = debug_ranges_base + debug_ranges_offset;
+  dw_addr_t debug_ranges_address = cu->GetRangesBase() + 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;
+
+    // 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.
+    range_list.Slide(cu->GetBaseAddress());
     return true;
   }
   return false;
 }
 
-bool DWARFDebugRngLists::ExtractRangeList(const DWARFDataExtractor &data,
-                                          uint8_t addrSize,
-                                          lldb::offset_t *offset_ptr,
-                                          DWARFRangeList &rangeList) {
-  rangeList.Clear();
+bool DWARFDebugRngLists::ExtractRangeList(
+    const DWARFDataExtractor &data, uint8_t addrSize,
+    lldb::offset_t *offset_ptr, std::vector<RngListEntry> &rangeList) {
+  rangeList.clear();
 
   bool error = false;
   while (!error) {
     switch (data.GetU8(offset_ptr)) {
     case DW_RLE_end_of_list:
       return true;
 
     case DW_RLE_start_length: {
       dw_addr_t begin = data.GetMaxU64(offset_ptr, addrSize);
       dw_addr_t len = data.GetULEB128(offset_ptr);
-      rangeList.Append(DWARFRangeList::Entry(begin, len));
+      rangeList.push_back({DW_RLE_start_length, begin, len});
       break;
     }
 
     case DW_RLE_start_end: {
       dw_addr_t begin = data.GetMaxU64(offset_ptr, addrSize);
       dw_addr_t end = data.GetMaxU64(offset_ptr, addrSize);
-      rangeList.Append(DWARFRangeList::Entry(begin, end - begin));
+      rangeList.push_back({DW_RLE_start_end, begin, end - begin});
+      break;
+    }
+
+    case DW_RLE_base_address: {
+      dw_addr_t base = data.GetMaxU64(offset_ptr, addrSize);
+      rangeList.push_back({DW_RLE_base_address, base, 0});
+      break;
+    }
+
+    case DW_RLE_offset_pair: {
+      dw_addr_t begin = data.GetULEB128(offset_ptr);
+      dw_addr_t end = data.GetULEB128(offset_ptr);
+      rangeList.push_back({DW_RLE_offset_pair, begin, end});
       break;
     }
 
     default:
       // Next encodings are not yet supported:
       // DW_RLE_base_addressx, DW_RLE_startx_endx, DW_RLE_startx_length,
       // DW_RLE_offset_pair, DW_RLE_base_address.
       lldbassert(0 && "unknown range list entry encoding");
       error = true;
     }
   }
 
   return false;
 }
 
+bool DWARFDebugRngLists::FindRanges(const DWARFUnit *cu,
+                                    dw_offset_t debug_ranges_offset,
+                                    DWARFRangeList &range_list) const {
+  range_list.Clear();
+  dw_addr_t debug_ranges_address = cu->GetRangesBase() + debug_ranges_offset;
+  auto pos = m_range_map.find(debug_ranges_address);
+  if (pos != m_range_map.end()) {
+    dw_addr_t BaseAddr = cu->GetBaseAddress();
+    for (const RngListEntry &E : pos->second) {
+      switch (E.encoding) {
+      case DW_RLE_start_length:
+        range_list.Append(DWARFRangeList::Entry(E.value0, E.value1));
+        break;
+      case DW_RLE_base_address:
+        BaseAddr = E.value0;
+        break;
+      case DW_RLE_offset_pair:
+        range_list.Append(
+            DWARFRangeList::Entry(BaseAddr + E.value0, E.value1 - E.value0));
+        break;
+      default:
+        llvm_unreachable("unexpected encoding");
+      }
+    }
+    return true;
+  }
+  return false;
+}
+
 void DWARFDebugRngLists::Extract(SymbolFileDWARF *dwarf2Data) {
   const DWARFDataExtractor &data = dwarf2Data->get_debug_rnglists_data();
   lldb::offset_t offset = 0;
 
   uint64_t length = data.GetU32(&offset);
   bool isDwarf64 = false;
   if (length == 0xffffffff) {
     length = data.GetU64(&offset);
if (data.GetU8(&offset) != 0) {
     return;
   }
 
   uint32_t offsetsAmount = data.GetU32(&offset);
   for (uint32_t i = 0; i < offsetsAmount; ++i)
     Offsets.push_back(data.GetPointer(&offset));
 
   lldb::offset_t listOffset = offset;
-  DWARFRangeList rangeList;
+  std::vector<RngListEntry> rangeList;
   while (offset < end && ExtractRangeList(data, addrSize, &offset, rangeList)) {
-    rangeList.Sort();
     m_range_map[listOffset] = rangeList;
     listOffset = offset;
   }
 }

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

 class DWARFAbbreviationDeclaration;
 class DWARFAbbreviationDeclarationSet;
 class DWARFileUnit;
 class DWARFDebugAbbrev;
 class DWARFDebugAranges;
 class DWARFDebugInfo;
 class DWARFDebugInfoEntry;
 class DWARFDebugLine;
-class DWARFDebugRanges;
-class DWARFDebugRngLists;
+class DWARFDebugRangesBase;
 class DWARFDeclContext;
 class DWARFDIECollection;
 class DWARFFormValue;
 class SymbolFileDWARFDebugMap;
 class SymbolFileDWARFDwo;
 class SymbolFileDWARFDwp;
 
 #define DIE_IS_BEING_PARSED ((lldb_private::Type *)1)
public:
   DWARFDebugAbbrev *DebugAbbrev();
 
   const DWARFDebugAbbrev *DebugAbbrev() const;
 
   DWARFDebugInfo *DebugInfo();
 
   const DWARFDebugInfo *DebugInfo() const;
 
-  DWARFDebugRanges *DebugRanges();
+  DWARFDebugRangesBase *DebugRanges();
 
-  const DWARFDebugRanges *DebugRanges() const;
+  const DWARFDebugRangesBase *DebugRanges() const;
 
   const lldb_private::DWARFDataExtractor &DebugLocData();
 
   static bool SupportedVersion(uint16_t version);
 
   DWARFDIE
   GetDeclContextDIEContainingDIE(const DWARFDIE &die);
 
protected:
   ExternalTypeModuleMap m_external_type_modules;
   std::unique_ptr<lldb_private::DWARFIndex> m_index;
   bool m_fetched_external_modules : 1;
   lldb_private::LazyBool m_supports_DW_AT_APPLE_objc_complete_type;
 
   typedef std::shared_ptr<std::set<DIERef>> DIERefSetSP;
   typedef std::unordered_map<std::string, DIERefSetSP> NameToOffsetMap;
   NameToOffsetMap m_function_scope_qualified_name_map;
-  std::unique_ptr<DWARFDebugRanges> m_ranges;
+  std::unique_ptr<DWARFDebugRangesBase> m_ranges;
   UniqueDWARFASTTypeMap m_unique_ast_type_map;
   DIEToTypePtr m_die_to_type;
   DIEToVariableSP m_die_to_variable_sp;
   DIEToClangType m_forward_decl_die_to_clang_type;
   ClangTypeToDIE m_forward_decl_clang_type_to_die;
 };
 
 #endif // SymbolFileDWARF_SymbolFileDWARF_h_

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

DWARFUnit *dwarf_cu =
         info->GetCompileUnit((dw_offset_t)comp_unit->GetID());
     if (dwarf_cu && dwarf_cu->GetUserData() == NULL)
       dwarf_cu->SetUserData(comp_unit);
     return dwarf_cu;
   }
   return NULL;
 }
 
-DWARFDebugRanges *SymbolFileDWARF::DebugRanges() {
+DWARFDebugRangesBase *SymbolFileDWARF::DebugRanges() {
   if (m_ranges.get() == NULL) {
     static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
     Timer scoped_timer(func_cat, "%s this = %p", LLVM_PRETTY_FUNCTION,
                        static_cast<void *>(this));
 
     if (get_debug_ranges_data().GetByteSize() > 0)
       m_ranges.reset(new DWARFDebugRanges());
     else if (get_debug_rnglists_data().GetByteSize() > 0)
       m_ranges.reset(new DWARFDebugRngLists());
 
     if (m_ranges.get())
       m_ranges->Extract(this);
   }
   return m_ranges.get();
 }
 
-const DWARFDebugRanges *SymbolFileDWARF::DebugRanges() const {
+const DWARFDebugRangesBase *SymbolFileDWARF::DebugRanges() const {
   return m_ranges.get();
 }
 
 lldb::CompUnitSP SymbolFileDWARF::ParseCompileUnit(DWARFUnit *dwarf_cu,
                                                    uint32_t cu_idx) {
   CompUnitSP cu_sp;
   if (dwarf_cu) {
     CompileUnit *comp_unit = (CompileUnit *)dwarf_cu->GetUserData();
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(die.GetCU()->GetRangesBase(),
+              const DWARFDebugRangesBase *debug_ranges = DebugRanges();
+              debug_ranges->FindRanges(die.GetCU(),
                                        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.
-              dwarf_scope_ranges.Slide(die.GetCU()->GetBaseAddress());
             } else {
               // TODO: Handle the case when DW_AT_start_scope have form
               // constant. The
               // dwarf spec is a bit ambiguous about what is the expected
               // behavior in case the enclosing block have a non coninious
               // address range and the DW_AT_start_scope entry have a form
               // constant.
               GetObjectFile()->GetModule()->ReportWarning(