Add DWARF 5 support in gold.
authorCary Coutant <ccoutant@gmail.com>
Thu, 18 Mar 2021 04:31:15 +0000 (21:31 -0700)
committerCary Coutant <ccoutant@gmail.com>
Fri, 19 Mar 2021 20:55:35 +0000 (13:55 -0700)
elfcpp/
PR gold/27246
* dwarf.h (enum DW_LNCT): Add line number table content type codes.
(enum DW_LINE_OPS): Reformat.
(enum DW_LINE_EXTENDED_OPS): Reformat.
(enum DW_CHILDREN): Reformat.
(enum DW_RLE): Add range list entry types.
(enum DW_SECT): Update values for DWARF 5.

gold/
PR gold/27246
* dwarf_reader.cc (Dwarf_abbrev_table::do_get_abbrev): Handle
DW_FORM_implicit_const.
(Dwarf_ranges_table::read_ranges_table): Add version parameter;
Adjust all callers.  Look for .debug_rnglists section if DWARF 5.
(Dwarf_ranges_table::read_range_list_v5): New method.
(Dwarf_die::read_attributes): Handle new DWARF 5 DW_FORM codes.
(Dwarf_die::skip_attributes): Likewise.
(Dwarf_info_reader::do_parse): Support DWARF 5 unit header format.
(Dwarf_info_reader::read_3bytes_from_pointer): New method.
(Sized_dwarf_line_info::Sized_dwarf_line_info): Initialize
str_buffer_, str_buffer_start, reloc_map_, line_number_map_.
Look for .debug_line_str section.
(Sized_dwarf_line_info::read_header_prolog): Support DWARF 5 prolog.
(Sized_dwarf_line_info::read_header_tables): Rename to...
(Sized_dwarf_line_info::read_header_tables_v2): ... this.
(Sized_dwarf_line_info::read_header_tables_v5): New method.
(Sized_dwarf_line_info::process_one_opcode): Insert missing "this->".
Change advance_line to signed int64_t.
(Sized_dwarf_line_info::read_lines): Add endptr parameter; adjust
callers.  Insert missing "this->".
(Sized_dwarf_line_info::read_line_mappings): Support DWARF 5.
(Sized_dwarf_line_info::do_addr2line): Add debug code.
* dwarf_reader.h (Dwarf_abbrev_table::Attribute): Add implicit_const
field. Adjust constructor.
(Dwarf_abbrev_table::add_sttribute): Add implicit_const parameter.
(Dwarf_ranges_table::read_ranges_table): Add version parameter.
(Dwarf_ranges_table::read_range_list_v5): New method.
(Dwarf_die): Remove unused attr_off field.
(Dwarf_info_reader::Dwarf_info_reader): Initialize unit_type_ field.
(Dwarf_info_reader::is_type_unit): New method.
(Dwarf_info_reader::read_3bytes_from_pointer): New method.
(Dwarf_info_reader::read_range_list): Call read_range_list_v5 for
DWARF 5 range lists.
(Dwarf_info_reader::is_type_unit_): Remove.
(Dwarf_info_reader::unit_type_): New field.
(Sized_dwarf_line_info::~Sized_dwarf_line_info): Delete
str_buffer_start_.
(Sized_dwarf_line_info::read_header_tables): Rename to...
(Sized_dwarf_line_info::read_header_tables_v2): ... this.
(Sized_dwarf_line_info::read_header_tables_v5): New method.
(Sized_dwarf_line_info::read_lines): Add endptr parameter.
(Sized_dwarf_line_info::Dwarf_line_infoHeader): Add address_size field.
(Sized_dwarf_line_info::str_buffer_): New field.
(Sized_dwarf_line_info::str_buffer_end_): New field.
(Sized_dwarf_line_info::str_buffer_start_): New field.
(Sized_dwarf_line_info::end_of_header_length_): New field.
(Sized_dwarf_line_info::end_of_unit_): New field.

elfcpp/ChangeLog
elfcpp/dwarf.h
gold/ChangeLog
gold/dwarf_reader.cc
gold/dwarf_reader.h

index 069b7dcbbbb6031471202790239cc47f8b4ed957..afc32c9b065b28ed90e76bd5eef057cb519dabde 100644 (file)
@@ -1,3 +1,13 @@
+2021-03-19  Cary Coutant  <ccoutant@gmail.com>
+
+       PR gold/27246
+       * dwarf.h (enum DW_LNCT): Add line number table content type codes.
+       (enum DW_LINE_OPS): Reformat.
+       (enum DW_LINE_EXTENDED_OPS): Reformat.
+       (enum DW_CHILDREN): Reformat.
+       (enum DW_RLE): Add range list entry types.
+       (enum DW_SECT): Update values for DWARF 5.
+
 2021-01-09  Nick Clifton  <nickc@redhat.com>
 
        * 2.36 release branch crated.
index e24347f8481bd4eb7e1057a87e23d3e8b2b145a7..c9a9e02369cef636aa3fb354be89d6eea73d9635 100644 (file)
@@ -152,35 +152,48 @@ enum DW_EH_PE
   DW_EH_PE_indirect = 0x80
 };
 
+// Line number table content type codes.
+
+enum DW_LNCT
+{
+  DW_LNCT_path            = 0x1,
+  DW_LNCT_directory_index = 0x2,
+  DW_LNCT_timestamp       = 0x3,
+  DW_LNCT_size            = 0x4,
+  DW_LNCT_MD5             = 0x5,
+  DW_LNCT_lo_user         = 0x2000,
+  DW_LNCT_hi_user         = 0x3fff
+};
+
 // Line number opcodes.
 
 enum DW_LINE_OPS
 {
-  DW_LNS_extended_op 0,
-  DW_LNS_copy 1,
-  DW_LNS_advance_pc 2,
-  DW_LNS_advance_line 3,
-  DW_LNS_set_file 4,
-  DW_LNS_set_column 5,
-  DW_LNS_negate_stmt 6,
-  DW_LNS_set_basic_block 7,
-  DW_LNS_const_add_pc 8,
-  DW_LNS_fixed_advance_pc 9,
+  DW_LNS_extended_op        = 0x00,
+  DW_LNS_copy               = 0x01,
+  DW_LNS_advance_pc         = 0x02,
+  DW_LNS_advance_line       = 0x03,
+  DW_LNS_set_file           = 0x04,
+  DW_LNS_set_column         = 0x05,
+  DW_LNS_negate_stmt        = 0x06,
+  DW_LNS_set_basic_block    = 0x07,
+  DW_LNS_const_add_pc       = 0x08,
+  DW_LNS_fixed_advance_pc   = 0x09,
   // DWARF 3.
-  DW_LNS_set_prologue_end = 10,
-  DW_LNS_set_epilogue_begin = 11,
-  DW_LNS_set_isa = 12
+  DW_LNS_set_prologue_end   = 0x0a,
+  DW_LNS_set_epilogue_begin = 0x0b,
+  DW_LNS_set_isa            = 0x0c
 };
 
 // Line number extended opcodes.
 
 enum DW_LINE_EXTENDED_OPS
 {
-  DW_LNE_end_sequence 1,
-  DW_LNE_set_address 2,
-  DW_LNE_define_file 3,
+  DW_LNE_end_sequence                = 0x01,
+  DW_LNE_set_address                 = 0x02,
+  DW_LNE_define_file                 = 0x03,
   // DWARF4.
-  DW_LNE_set_discriminator 4,
+  DW_LNE_set_discriminator           = 0x04,
   // HP extensions.
   DW_LNE_HP_negate_is_UV_update      = 0x11,
   DW_LNE_HP_push_context             = 0x12,
@@ -191,13 +204,15 @@ enum DW_LINE_EXTENDED_OPS
   DW_LNE_HP_negate_post_semantics    = 0x17,
   DW_LNE_HP_negate_function_exit     = 0x18,
   DW_LNE_HP_negate_front_end_logical = 0x19,
-  DW_LNE_HP_define_proc              = 0x20
+  DW_LNE_HP_define_proc              = 0x20,
+  DW_LNE_lo_user                     = 0x80,
+  DW_LNE_hi_user                     = 0xff
 };
 
 enum DW_CHILDREN
 {
-  DW_CHILDREN_no                    =0x00,
-  DW_CHILDREN_yes                   =0x01
+  DW_CHILDREN_no  0,
+  DW_CHILDREN_yes 1
 };
 
 // Source language names and codes.
@@ -247,20 +262,38 @@ enum DW_LANG
   DW_LANG_HP_Assembler = 0x8007
 };
 
+// Range list entry kinds in .debug_rnglists* section.
+
+enum DW_RLE
+{
+  DW_RLE_end_of_list   = 0x00,
+  DW_RLE_base_addressx = 0x01,
+  DW_RLE_startx_endx   = 0x02,
+  DW_RLE_startx_length = 0x03,
+  DW_RLE_offset_pair   = 0x04,
+  DW_RLE_base_address  = 0x05,
+  DW_RLE_start_end     = 0x06,
+  DW_RLE_start_length  = 0x07
+};
+
 // DWARF section identifiers used in the package format.
 // Extensions for Fission.  See http://gcc.gnu.org/wiki/DebugFissionDWP.
+// Added (with changes) in DWARF 5.
 
 enum DW_SECT
 {
-  DW_SECT_INFO = 1,
-  DW_SECT_TYPES = 2,
-  DW_SECT_ABBREV = 3,
-  DW_SECT_LINE = 4,
-  DW_SECT_LOC = 5,
+  DW_SECT_INFO        = 1,
+  DW_SECT_ABBREV      = 3,
+  DW_SECT_LINE        = 4,
+  DW_SECT_LOCLISTS    = 5,
   DW_SECT_STR_OFFSETS = 6,
-  DW_SECT_MACINFO = 7,
-  DW_SECT_MACRO = 8,
-  DW_SECT_MAX = DW_SECT_MACRO,
+  DW_SECT_MACINFO     = 7,
+  DW_SECT_RNGLISTS    = 8,
+  DW_SECT_MAX = DW_SECT_RNGLISTS,
+  // These were used only for the experimental Fission support in DWARF 4.
+  DW_SECT_TYPES       = 2,
+  DW_SECT_LOC         = 5,
+  DW_SECT_MACRO       = 8
 };
 
 } // End namespace elfcpp.
index 5180c02f26090d2bda563e1a75d218a1ca8dc143..09e1fc505acc05a036837062a89c37e2dcf54f5c 100644 (file)
@@ -1,3 +1,54 @@
+2021-03-19  Cary Coutant  <ccoutant@gmail.com>
+
+       PR gold/27246
+       * dwarf_reader.cc (Dwarf_abbrev_table::do_get_abbrev): Handle
+       DW_FORM_implicit_const.
+       (Dwarf_ranges_table::read_ranges_table): Add version parameter;
+       Adjust all callers.  Look for .debug_rnglists section if DWARF 5.
+       (Dwarf_ranges_table::read_range_list_v5): New method.
+       (Dwarf_die::read_attributes): Handle new DWARF 5 DW_FORM codes.
+       (Dwarf_die::skip_attributes): Likewise.
+       (Dwarf_info_reader::do_parse): Support DWARF 5 unit header format.
+       (Dwarf_info_reader::read_3bytes_from_pointer): New method.
+       (Sized_dwarf_line_info::Sized_dwarf_line_info): Initialize
+       str_buffer_, str_buffer_start, reloc_map_, line_number_map_.
+       Look for .debug_line_str section.
+       (Sized_dwarf_line_info::read_header_prolog): Support DWARF 5 prolog.
+       (Sized_dwarf_line_info::read_header_tables): Rename to...
+       (Sized_dwarf_line_info::read_header_tables_v2): ... this.
+       (Sized_dwarf_line_info::read_header_tables_v5): New method.
+       (Sized_dwarf_line_info::process_one_opcode): Insert missing "this->".
+       Change advance_line to signed int64_t.
+       (Sized_dwarf_line_info::read_lines): Add endptr parameter; adjust
+       callers.  Insert missing "this->".
+       (Sized_dwarf_line_info::read_line_mappings): Support DWARF 5.
+       (Sized_dwarf_line_info::do_addr2line): Add debug code.
+       * dwarf_reader.h (Dwarf_abbrev_table::Attribute): Add implicit_const
+       field. Adjust constructor.
+       (Dwarf_abbrev_table::add_sttribute): Add implicit_const parameter.
+       (Dwarf_ranges_table::read_ranges_table): Add version parameter.
+       (Dwarf_ranges_table::read_range_list_v5): New method.
+       (Dwarf_die): Remove unused attr_off field.
+       (Dwarf_info_reader::Dwarf_info_reader): Initialize unit_type_ field.
+       (Dwarf_info_reader::is_type_unit): New method.
+       (Dwarf_info_reader::read_3bytes_from_pointer): New method.
+       (Dwarf_info_reader::read_range_list): Call read_range_list_v5 for
+       DWARF 5 range lists.
+       (Dwarf_info_reader::is_type_unit_): Remove.
+       (Dwarf_info_reader::unit_type_): New field.
+       (Sized_dwarf_line_info::~Sized_dwarf_line_info): Delete
+       str_buffer_start_.
+       (Sized_dwarf_line_info::read_header_tables): Rename to...
+       (Sized_dwarf_line_info::read_header_tables_v2): ... this.
+       (Sized_dwarf_line_info::read_header_tables_v5): New method.
+       (Sized_dwarf_line_info::read_lines): Add endptr parameter.
+       (Sized_dwarf_line_info::Dwarf_line_infoHeader): Add address_size field.
+       (Sized_dwarf_line_info::str_buffer_): New field.
+       (Sized_dwarf_line_info::str_buffer_end_): New field.
+       (Sized_dwarf_line_info::str_buffer_start_): New field.
+       (Sized_dwarf_line_info::end_of_header_length_): New field.
+       (Sized_dwarf_line_info::end_of_unit_): New field.
+
 2021-01-28  H.J. Lu  <hongjiu.lu@intel.com>
 
        PR gold/27246
index f0e6b89bde2fb791bcd6479e07d6d142f9397380..83a0114ed39f7077250050c19157d04c9a8fd4cb 100644 (file)
@@ -26,6 +26,7 @@
 #include <utility>
 #include <vector>
 
+#include "debug.h"
 #include "elfcpp_swap.h"
 #include "dwarf.h"
 #include "object.h"
@@ -275,6 +276,14 @@ Dwarf_abbrev_table::do_get_abbrev(unsigned int code)
          uint64_t form = read_unsigned_LEB_128(this->buffer_pos_, &len);
          this->buffer_pos_ += len;
 
+         // For DW_FORM_implicit_const, read the constant.
+         int64_t implicit_const = 0;
+         if (form == elfcpp::DW_FORM_implicit_const)
+           {
+             implicit_const = read_signed_LEB_128(this->buffer_pos_, &len);
+             this->buffer_pos_ += len;
+           }
+
          // A (0,0) pair terminates the list.
          if (attr == 0 && form == 0)
            break;
@@ -282,7 +291,7 @@ Dwarf_abbrev_table::do_get_abbrev(unsigned int code)
          if (attr == elfcpp::DW_AT_sibling)
            entry->has_sibling_attribute = true;
 
-         entry->add_attribute(attr, form);
+         entry->add_attribute(attr, form, implicit_const);
        }
 
       this->store_abbrev(nextcode, entry);
@@ -302,8 +311,16 @@ Dwarf_ranges_table::read_ranges_table(
     Relobj* object,
     const unsigned char* symtab,
     off_t symtab_size,
-    unsigned int ranges_shndx)
+    unsigned int ranges_shndx,
+    unsigned int version)
 {
+  const std::string section_name(version < 5
+                                ? ".debug_ranges"
+                                : ".debug_rnglists");
+  const std::string compressed_section_name(version < 5
+                                           ? ".zdebug_ranges"
+                                           : ".zdebug_rnglists");
+
   // If we've already read this abbrev table, return immediately.
   if (this->ranges_shndx_ > 0
       && this->ranges_shndx_ == ranges_shndx)
@@ -318,7 +335,7 @@ Dwarf_ranges_table::read_ranges_table(
       for (unsigned int i = 1; i < object->shnum(); ++i)
        {
          std::string name = object->section_name(i);
-         if (name == ".debug_ranges" || name == ".zdebug_ranges")
+         if (name == section_name || name == compressed_section_name)
            {
              ranges_shndx = i;
              this->output_section_offset_ = object->output_section_offset(i);
@@ -393,7 +410,7 @@ Dwarf_ranges_table::read_range_list(
 {
   Dwarf_range_list* ranges;
 
-  if (!this->read_ranges_table(object, symtab, symtab_size, ranges_shndx))
+  if (!this->read_ranges_table(object, symtab, symtab_size, ranges_shndx, 4))
     return NULL;
 
   // Correct the offset.  For incremental update links, we have a
@@ -459,6 +476,125 @@ Dwarf_ranges_table::read_range_list(
   return ranges;
 }
 
+// Read a DWARF 5 range list from section RANGES_SHNDX at offset RANGES_OFFSET.
+
+Dwarf_range_list*
+Dwarf_ranges_table::read_range_list_v5(
+    Relobj* object,
+    const unsigned char* symtab,
+    off_t symtab_size,
+    unsigned int addr_size,
+    unsigned int ranges_shndx,
+    off_t offset)
+{
+  Dwarf_range_list* ranges;
+
+  if (!this->read_ranges_table(object, symtab, symtab_size, ranges_shndx, 5))
+    return NULL;
+
+  ranges = new Dwarf_range_list();
+  off_t base = 0;
+  unsigned int shndx0 = 0;
+
+  // Correct the offset.  For incremental update links, we have a
+  // relocated offset that is relative to the output section, but
+  // here we need an offset relative to the input section.
+  offset -= this->output_section_offset_;
+
+  // Read the range list at OFFSET.
+  const unsigned char* prle = this->ranges_buffer_ + offset;
+  while (prle < this->ranges_buffer_end_)
+    {
+      off_t start;
+      off_t end;
+      unsigned int shndx1 = 0;
+      unsigned int shndx2 = 0;
+      size_t len;
+
+      // Read the entry type.
+      unsigned int rle_type = *prle++;
+      offset += 1;
+
+      if (rle_type == elfcpp::DW_RLE_end_of_list)
+       break;
+
+      switch (rle_type)
+       {
+         case elfcpp::DW_RLE_base_address:
+           if (addr_size == 4)
+             base = this->dwinfo_->read_from_pointer<32>(prle);
+           else
+             base = this->dwinfo_->read_from_pointer<64>(prle);
+           if (this->ranges_reloc_mapper_ != NULL)
+               shndx0 = this->lookup_reloc(offset, &base);
+           prle += addr_size;
+           offset += addr_size;
+           break;
+
+         case elfcpp::DW_RLE_offset_pair:
+           start = read_unsigned_LEB_128(prle, &len);
+           prle += len;
+           offset += len;
+           end = read_unsigned_LEB_128(prle, &len);
+           prle += len;
+           offset += len;
+           if (shndx0 == 0 || object->is_section_included(shndx0))
+             ranges->add(shndx0, base + start, base + end);
+           break;
+
+         case elfcpp::DW_RLE_start_end:
+           if (addr_size == 4)
+             {
+               start = this->dwinfo_->read_from_pointer<32>(prle);
+               end = this->dwinfo_->read_from_pointer<32>(prle + 4);
+             }
+           else
+             {
+               start = this->dwinfo_->read_from_pointer<64>(prle);
+               end = this->dwinfo_->read_from_pointer<64>(prle + 8);
+             }
+           if (this->ranges_reloc_mapper_ != NULL)
+             {
+               shndx1 = this->lookup_reloc(offset, &start);
+               shndx2 = this->lookup_reloc(offset + addr_size, &end);
+               if (shndx1 != shndx2)
+                 gold_warning(_("%s: DWARF info may be corrupt; offsets in a "
+                                "range list entry are in different sections"),
+                              object->name().c_str());
+             }
+           prle += addr_size * 2;
+           offset += addr_size * 2;
+           if (shndx1 == 0 || object->is_section_included(shndx1))
+             ranges->add(shndx1, start, end);
+           break;
+
+         case elfcpp::DW_RLE_start_length:
+           if (addr_size == 4)
+             start = this->dwinfo_->read_from_pointer<32>(prle);
+           else
+             start = this->dwinfo_->read_from_pointer<64>(prle);
+           if (this->ranges_reloc_mapper_ != NULL)
+             shndx1 = this->lookup_reloc(offset, &start);
+           prle += addr_size;
+           offset += addr_size;
+           end = start + read_unsigned_LEB_128(prle, &len);
+           prle += len;
+           offset += len;
+           if (shndx1 == 0 || object->is_section_included(shndx1))
+             ranges->add(shndx1, start, end);
+           break;
+
+         default:
+           gold_warning(_("%s: DWARF range list contains "
+                          "unsupported entry type (%d)"),
+                        object->name().c_str(), rle_type);
+           break;
+       }
+    }
+
+  return ranges;
+}
+
 // Look for a relocation at offset OFF in the range table,
 // and return the section index and offset of the target.
 
@@ -709,7 +845,13 @@ Dwarf_die::read_attributes()
          case elfcpp::DW_FORM_flag_present:
            attr_value.val.intval = 1;
            break;
+         case elfcpp::DW_FORM_implicit_const:
+           attr_value.val.intval =
+               this->abbrev_code_->attributes[i].implicit_const;
+           break;
          case elfcpp::DW_FORM_strp:
+         case elfcpp::DW_FORM_strp_sup:
+         case elfcpp::DW_FORM_line_strp:
            {
              off_t str_off;
              if (this->dwinfo_->offset_size() == 4)
@@ -722,6 +864,26 @@ Dwarf_die::read_attributes()
              attr_value.val.refval = str_off;
              break;
            }
+         case elfcpp::DW_FORM_strx:
+         case elfcpp::DW_FORM_GNU_str_index:
+           attr_value.val.uintval = read_unsigned_LEB_128(pattr, &len);
+           pattr += len;
+           break;
+         case elfcpp::DW_FORM_strx1:
+           attr_value.val.uintval = *pattr++;
+           break;
+         case elfcpp::DW_FORM_strx2:
+           attr_value.val.uintval =
+               this->dwinfo_->read_from_pointer<16>(&pattr);
+           break;
+         case elfcpp::DW_FORM_strx3:
+           attr_value.val.uintval =
+               this->dwinfo_->read_3bytes_from_pointer(&pattr);
+           break;
+         case elfcpp::DW_FORM_strx4:
+           attr_value.val.uintval =
+               this->dwinfo_->read_from_pointer<32>(&pattr);
+           break;
          case elfcpp::DW_FORM_sec_offset:
            {
              off_t sec_off;
@@ -747,7 +909,6 @@ Dwarf_die::read_attributes()
                  this->dwinfo_->lookup_reloc(attr_off, &sec_off);
              attr_value.aux.shndx = shndx;
              attr_value.val.refval = sec_off;
-             ref_form = true;
              break;
            }
          case elfcpp::DW_FORM_ref_addr:
@@ -815,6 +976,7 @@ Dwarf_die::read_attributes()
              break;
            }
          case elfcpp::DW_FORM_ref4:
+         case elfcpp::DW_FORM_ref_sup4:
            {
              off_t sec_off;
              sec_off = this->dwinfo_->read_from_pointer<32>(&pattr);
@@ -835,11 +997,20 @@ Dwarf_die::read_attributes()
              attr_value.val.intval = sec_off;
              break;
            }
+         case elfcpp::DW_FORM_data16:
+           {
+             // For now, treat this as a 16-byte block.
+             attr_value.val.blockval = pattr;
+             attr_value.aux.blocklen = 16;
+             pattr += 16;
+             break;
+           }
          case elfcpp::DW_FORM_ref_sig8:
            attr_value.val.uintval =
                this->dwinfo_->read_from_pointer<64>(&pattr);
            break;
          case elfcpp::DW_FORM_ref8:
+         case elfcpp::DW_FORM_ref_sup8:
            {
              off_t sec_off;
              sec_off = this->dwinfo_->read_from_pointer<64>(&pattr);
@@ -856,11 +1027,29 @@ Dwarf_die::read_attributes()
            pattr += len;
            break;
          case elfcpp::DW_FORM_udata:
+           attr_value.val.uintval = read_unsigned_LEB_128(pattr, &len);
+           pattr += len;
+           break;
+         case elfcpp::DW_FORM_addrx:
          case elfcpp::DW_FORM_GNU_addr_index:
-         case elfcpp::DW_FORM_GNU_str_index:
            attr_value.val.uintval = read_unsigned_LEB_128(pattr, &len);
            pattr += len;
            break;
+         case elfcpp::DW_FORM_addrx1:
+           attr_value.val.uintval = *pattr++;
+           break;
+         case elfcpp::DW_FORM_addrx2:
+           attr_value.val.uintval =
+               this->dwinfo_->read_from_pointer<16>(&pattr);
+           break;
+         case elfcpp::DW_FORM_addrx3:
+           attr_value.val.uintval =
+               this->dwinfo_->read_3bytes_from_pointer(&pattr);
+           break;
+         case elfcpp::DW_FORM_addrx4:
+           attr_value.val.uintval =
+               this->dwinfo_->read_from_pointer<32>(&pattr);
+           break;
          case elfcpp::DW_FORM_sdata:
            attr_value.val.intval = read_signed_LEB_128(pattr, &len);
            pattr += len;
@@ -870,6 +1059,11 @@ Dwarf_die::read_attributes()
            len = strlen(attr_value.val.stringval);
            pattr += len + 1;
            break;
+         case elfcpp::DW_FORM_loclistx:
+         case elfcpp::DW_FORM_rnglistx:
+           attr_value.val.uintval = read_unsigned_LEB_128(pattr, &len);
+           pattr += len;
+           break;
          default:
            return false;
        }
@@ -954,9 +1148,12 @@ Dwarf_die::skip_attributes()
       switch(form)
        {
          case elfcpp::DW_FORM_flag_present:
+         case elfcpp::DW_FORM_implicit_const:
            break;
          case elfcpp::DW_FORM_strp:
          case elfcpp::DW_FORM_sec_offset:
+         case elfcpp::DW_FORM_strp_sup:
+         case elfcpp::DW_FORM_line_strp:
            pattr += this->dwinfo_->offset_size();
            break;
          case elfcpp::DW_FORM_addr:
@@ -993,23 +1190,42 @@ Dwarf_die::skip_attributes()
          case elfcpp::DW_FORM_data1:
          case elfcpp::DW_FORM_ref1:
          case elfcpp::DW_FORM_flag:
+         case elfcpp::DW_FORM_strx1:
+         case elfcpp::DW_FORM_addrx1:
            pattr += 1;
            break;
          case elfcpp::DW_FORM_data2:
          case elfcpp::DW_FORM_ref2:
+         case elfcpp::DW_FORM_strx2:
+         case elfcpp::DW_FORM_addrx2:
            pattr += 2;
            break;
+         case elfcpp::DW_FORM_strx3:
+         case elfcpp::DW_FORM_addrx3:
+           pattr += 3;
+           break;
          case elfcpp::DW_FORM_data4:
          case elfcpp::DW_FORM_ref4:
+         case elfcpp::DW_FORM_ref_sup4:
+         case elfcpp::DW_FORM_strx4:
+         case elfcpp::DW_FORM_addrx4:
            pattr += 4;
            break;
          case elfcpp::DW_FORM_data8:
          case elfcpp::DW_FORM_ref8:
          case elfcpp::DW_FORM_ref_sig8:
+         case elfcpp::DW_FORM_ref_sup8:
            pattr += 8;
            break;
+         case elfcpp::DW_FORM_data16:
+           pattr += 16;
+           break;
          case elfcpp::DW_FORM_ref_udata:
          case elfcpp::DW_FORM_udata:
+         case elfcpp::DW_FORM_addrx:
+         case elfcpp::DW_FORM_strx:
+         case elfcpp::DW_FORM_loclistx:
+         case elfcpp::DW_FORM_rnglistx:
          case elfcpp::DW_FORM_GNU_addr_index:
          case elfcpp::DW_FORM_GNU_str_index:
            read_unsigned_LEB_128(pattr, &len);
@@ -1313,6 +1529,13 @@ Dwarf_info_reader::do_parse()
          elfcpp::Swap_unaligned<16, big_endian>::readval(pinfo);
       pinfo += 2;
 
+      // DWARF 5: Read the unit type (1 byte) and address size (1 byte).
+      if (this->cu_version_ >= 5)
+       {
+         this->unit_type_ = *pinfo++;
+         this->address_size_ = *pinfo++;
+       }
+
       // Read debug_abbrev_offset (4 or 8 bytes).
       if (this->offset_size_ == 4)
        abbrev_offset = elfcpp::Swap_unaligned<32, big_endian>::readval(pinfo);
@@ -1333,13 +1556,14 @@ Dwarf_info_reader::do_parse()
        }
       pinfo += this->offset_size_;
 
-      // Read address_size (1 byte).
-      this->address_size_ = *pinfo++;
+      // DWARF 2-4: Read address_size (1 byte).
+      if (this->cu_version_ < 5)
+       this->address_size_ = *pinfo++;
 
       // For type units, read the two extra fields.
       uint64_t signature = 0;
       off_t type_offset = 0;
-      if (this->is_type_unit_)
+      if (this->is_type_unit())
         {
          if (!this->check_buffer(pinfo + 8 + this->offset_size_))
            break;
@@ -1369,7 +1593,7 @@ Dwarf_info_reader::do_parse()
       if (root_die.tag() != 0)
        {
          // Visit the CU or TU.
-         if (this->is_type_unit_)
+         if (this->is_type_unit())
            this->visit_type_unit(section_offset + this->cu_offset_,
                                  cu_end - cu_start, type_offset, signature,
                                  &root_die);
@@ -1460,6 +1684,19 @@ Dwarf_info_reader::read_from_pointer(const unsigned char** source)
   return return_value;
 }
 
+// Read a 3-byte integer.  Update SOURCE after read.
+inline typename elfcpp::Valtype_base<32>::Valtype
+Dwarf_info_reader::read_3bytes_from_pointer(const unsigned char** source)
+{
+  typename elfcpp::Valtype_base<32>::Valtype return_value;
+  if (this->object_->is_big_endian())
+    return_value = ((*source)[0] << 16) | ((*source)[1] << 8) | (*source)[2];
+  else
+    return_value = ((*source)[2] << 16) | ((*source)[1] << 8) | (*source)[0];
+  *source += 3;
+  return return_value;
+}
+
 // Look for a relocation at offset ATTR_OFF in the dwarf info,
 // and return the section index and offset of the target.
 
@@ -1561,27 +1798,40 @@ Sized_dwarf_line_info<size, big_endian>::Sized_dwarf_line_info(
     Object* object,
     unsigned int read_shndx)
   : data_valid_(false), buffer_(NULL), buffer_start_(NULL),
+    str_buffer_(NULL), str_buffer_start_(NULL),
     reloc_mapper_(NULL), symtab_buffer_(NULL), directories_(), files_(),
-    current_header_index_(-1)
+    current_header_index_(-1), reloc_map_(), line_number_map_()
 {
-  unsigned int debug_shndx;
+  unsigned int debug_line_shndx = 0;
+  unsigned int debug_line_str_shndx = 0;
 
-  for (debug_shndx = 1; debug_shndx < object->shnum(); ++debug_shndx)
+  for (unsigned int i = 1; i < object->shnum(); ++i)
     {
+      section_size_type buffer_size;
+      bool is_new = false;
+
       // FIXME: do this more efficiently: section_name() isn't super-fast
-      std::string name = object->section_name(debug_shndx);
+      std::string name = object->section_name(i);
       if (name == ".debug_line" || name == ".zdebug_line")
        {
-         section_size_type buffer_size;
-         bool is_new = false;
-         this->buffer_ = object->decompressed_section_contents(debug_shndx,
-                                                               &buffer_size,
-                                                               &is_new);
+         this->buffer_ =
+             object->decompressed_section_contents(i, &buffer_size, &is_new);
          if (is_new)
            this->buffer_start_ = this->buffer_;
          this->buffer_end_ = this->buffer_ + buffer_size;
-         break;
+         debug_line_shndx = i;
+       }
+      else if (name == ".debug_line_str" || name == ".zdebug_line_str")
+       {
+         this->str_buffer_ =
+             object->decompressed_section_contents(i, &buffer_size, &is_new);
+         if (is_new)
+           this->str_buffer_start_ = this->str_buffer_;
+         this->str_buffer_end_ = this->str_buffer_ + buffer_size;
+         debug_line_str_shndx = i;
        }
+      if (debug_line_shndx > 0 && debug_line_str_shndx > 0)
+        break;
     }
   if (this->buffer_ == NULL)
     return;
@@ -1594,7 +1844,7 @@ Sized_dwarf_line_info<size, big_endian>::Sized_dwarf_line_info(
       unsigned int reloc_sh_type = object->section_type(i);
       if ((reloc_sh_type == elfcpp::SHT_REL
           || reloc_sh_type == elfcpp::SHT_RELA)
-         && object->section_info(i) == debug_shndx)
+         && object->section_info(i) == debug_line_shndx)
        {
          reloc_shndx = i;
          this->track_relocs_type_ = reloc_sh_type;
@@ -1640,65 +1890,80 @@ Sized_dwarf_line_info<size, big_endian>::read_header_prolog(
   uint32_t initial_length = elfcpp::Swap_unaligned<32, big_endian>::readval(lineptr);
   lineptr += 4;
 
-  // In DWARF2/3, if the initial length is all 1 bits, then the offset
+  // In DWARF, if the initial length is all 1 bits, then the offset
   // size is 8 and we need to read the next 8 bytes for the real length.
   if (initial_length == 0xffffffff)
     {
-      header_.offset_size = 8;
+      this->header_.offset_size = 8;
       initial_length = elfcpp::Swap_unaligned<64, big_endian>::readval(lineptr);
       lineptr += 8;
     }
   else
-    header_.offset_size = 4;
+    this->header_.offset_size = 4;
 
-  header_.total_length = initial_length;
+  this->header_.total_length = initial_length;
 
-  gold_assert(lineptr + header_.total_length <= buffer_end_);
+  this->end_of_unit_ = lineptr + initial_length;
+  gold_assert(this->end_of_unit_ <= buffer_end_);
 
-  header_.version = elfcpp::Swap_unaligned<16, big_endian>::readval(lineptr);
+  this->header_.version =
+      elfcpp::Swap_unaligned<16, big_endian>::readval(lineptr);
   lineptr += 2;
 
-  // Skip address size and segment selector for DWARF5.
-  if (header_.version >= 5)
-    lineptr += 2;
+  // We can only read versions 2-5 of the DWARF line number table.
+  // For other versions, just skip the entire line number table.
+  if (this->header_.version < 2 || this->header_.version > 5)
+    return this->end_of_unit_;
 
-  if (header_.offset_size == 4)
-    header_.prologue_length = elfcpp::Swap_unaligned<32, big_endian>::readval(lineptr);
+  // DWARF 5 only: address size and segment selector.
+  if (this->header_.version >= 5)
+    {
+      this->header_.address_size = *lineptr;
+      // We ignore the segment selector.
+      lineptr += 2;
+    }
+
+  if (this->header_.offset_size == 4)
+    this->header_.prologue_length =
+       elfcpp::Swap_unaligned<32, big_endian>::readval(lineptr);
   else
-    header_.prologue_length = elfcpp::Swap_unaligned<64, big_endian>::readval(lineptr);
-  lineptr += header_.offset_size;
+    this->header_.prologue_length =
+       elfcpp::Swap_unaligned<64, big_endian>::readval(lineptr);
+  lineptr += this->header_.offset_size;
 
-  header_.min_insn_length = *lineptr;
+  this->end_of_header_length_ = lineptr;
+
+  this->header_.min_insn_length = *lineptr;
   lineptr += 1;
 
-  if (header_.version < 4)
-    header_.max_ops_per_insn = 1;
+  if (this->header_.version < 4)
+    this->header_.max_ops_per_insn = 1;
   else
     {
       // DWARF 4 added the maximum_operations_per_instruction field.
-      header_.max_ops_per_insn = *lineptr;
+      this->header_.max_ops_per_insn = *lineptr;
       lineptr += 1;
       // TODO: Add support for values other than 1.
-      gold_assert(header_.max_ops_per_insn == 1);
+      gold_assert(this->header_.max_ops_per_insn == 1);
     }
 
-  header_.default_is_stmt = *lineptr;
+  this->header_.default_is_stmt = *lineptr;
   lineptr += 1;
 
-  header_.line_base = *reinterpret_cast<const signed char*>(lineptr);
+  this->header_.line_base = *reinterpret_cast<const signed char*>(lineptr);
   lineptr += 1;
 
-  header_.line_range = *lineptr;
+  this->header_.line_range = *lineptr;
   lineptr += 1;
 
-  header_.opcode_base = *lineptr;
+  this->header_.opcode_base = *lineptr;
   lineptr += 1;
 
-  header_.std_opcode_lengths.resize(header_.opcode_base + 1);
-  header_.std_opcode_lengths[0] = 0;
-  for (int i = 1; i < header_.opcode_base; i++)
+  this->header_.std_opcode_lengths.resize(this->header_.opcode_base + 1);
+  this->header_.std_opcode_lengths[0] = 0;
+  for (int i = 1; i < this->header_.opcode_base; i++)
     {
-      header_.std_opcode_lengths[i] = *lineptr;
+      this->header_.std_opcode_lengths[i] = *lineptr;
       lineptr += 1;
     }
 
@@ -1707,10 +1972,11 @@ Sized_dwarf_line_info<size, big_endian>::read_header_prolog(
 
 // The header for a debug_line section is mildly complicated, because
 // the line info is very tightly encoded.
+// This routine is for DWARF versions 2, 3, and 4.
 
 template<int size, bool big_endian>
 const unsigned char*
-Sized_dwarf_line_info<size, big_endian>::read_header_tables(
+Sized_dwarf_line_info<size, big_endian>::read_header_tables_v2(
     const unsigned char* lineptr)
 {
   ++this->current_header_index_;
@@ -1775,6 +2041,169 @@ Sized_dwarf_line_info<size, big_endian>::read_header_tables(
   return lineptr;
 }
 
+// This routine is for DWARF version 5.
+
+template<int size, bool big_endian>
+const unsigned char*
+Sized_dwarf_line_info<size, big_endian>::read_header_tables_v5(
+    const unsigned char* lineptr)
+{
+  size_t len;
+
+  ++this->current_header_index_;
+
+  gold_assert(static_cast<int>(this->directories_.size())
+             == this->current_header_index_);
+  gold_assert(static_cast<int>(this->files_.size())
+             == this->current_header_index_);
+
+  // Read the directory list.
+  unsigned int format_count = *lineptr;
+  lineptr += 1;
+
+  unsigned int *types = new unsigned int[format_count];
+  unsigned int *forms = new unsigned int[format_count];
+
+  for (unsigned int i = 0; i < format_count; i++)
+    {
+      types[i] = read_unsigned_LEB_128(lineptr, &len);
+      lineptr += len;
+      forms[i] = read_unsigned_LEB_128(lineptr, &len);
+      lineptr += len;
+    }
+
+  uint64_t entry_count = read_unsigned_LEB_128(lineptr, &len);
+  lineptr += len;
+  this->directories_.push_back(std::vector<std::string>(0));
+  std::vector<std::string>& dir_list = this->directories_.back();
+
+  for (unsigned int j = 0; j < entry_count; j++)
+    {
+      std::string dirname;
+
+      for (unsigned int i = 0; i < format_count; i++)
+       {
+        if (types[i] == elfcpp::DW_LNCT_path)
+          {
+            if (forms[i] == elfcpp::DW_FORM_string)
+              {
+                dirname = reinterpret_cast<const char*>(lineptr);
+                lineptr += dirname.size() + 1;
+              }
+            else if (forms[i] == elfcpp::DW_FORM_line_strp)
+              {
+                uint64_t offset;
+                if (this->header_.offset_size == 4)
+                  offset =
+                      elfcpp::Swap_unaligned<32, big_endian>::readval(lineptr);
+                else
+                  offset =
+                      elfcpp::Swap_unaligned<64, big_endian>::readval(lineptr);
+                typename Reloc_map::const_iterator it
+                    = this->reloc_map_.find(lineptr - this->buffer_);
+                if (it != reloc_map_.end())
+                  {
+                    if (this->track_relocs_type_ == elfcpp::SHT_RELA)
+                      offset = 0;
+                    offset += it->second.second;
+                  }
+                lineptr += this->header_.offset_size;
+                dirname = reinterpret_cast<const char*>(this->str_buffer_
+                                                        + offset);
+              }
+            else
+              return lineptr;
+          }
+        else
+          return lineptr;
+       }
+      dir_list.push_back(dirname);
+    }
+
+  delete[] types;
+  delete[] forms;
+
+  // Read the filenames list.
+  format_count = *lineptr;
+  lineptr += 1;
+
+  types = new unsigned int[format_count];
+  forms = new unsigned int[format_count];
+
+  for (unsigned int i = 0; i < format_count; i++)
+    {
+      types[i] = read_unsigned_LEB_128(lineptr, &len);
+      lineptr += len;
+      forms[i] = read_unsigned_LEB_128(lineptr, &len);
+      lineptr += len;
+    }
+
+  entry_count = read_unsigned_LEB_128(lineptr, &len);
+  lineptr += len;
+  this->files_.push_back(
+      std::vector<std::pair<int, std::string> >(0));
+  std::vector<std::pair<int, std::string> >& file_list = this->files_.back();
+
+  for (unsigned int j = 0; j < entry_count; j++)
+    {
+      const char* path = NULL;
+      int dirindex = 0;
+
+      for (unsigned int i = 0; i < format_count; i++)
+       {
+        if (types[i] == elfcpp::DW_LNCT_path)
+          {
+            if (forms[i] == elfcpp::DW_FORM_string)
+              {
+                path = reinterpret_cast<const char*>(lineptr);
+                lineptr += strlen(path) + 1;
+              }
+            else if (forms[i] == elfcpp::DW_FORM_line_strp)
+              {
+                uint64_t offset;
+                if (this->header_.offset_size == 4)
+                  offset = elfcpp::Swap_unaligned<32, big_endian>::readval(lineptr);
+                else
+                  offset = elfcpp::Swap_unaligned<64, big_endian>::readval(lineptr);
+                typename Reloc_map::const_iterator it
+                    = this->reloc_map_.find(lineptr - this->buffer_);
+                if (it != reloc_map_.end())
+                  {
+                    if (this->track_relocs_type_ == elfcpp::SHT_RELA)
+                      offset = 0;
+                    offset += it->second.second;
+                  }
+                lineptr += this->header_.offset_size;
+                path = reinterpret_cast<const char*>(this->str_buffer_
+                                                     + offset);
+              }
+            else
+              return lineptr;
+          }
+        else if (types[i] == elfcpp::DW_LNCT_directory_index)
+          {
+            if (forms[i] == elfcpp::DW_FORM_udata)
+              {
+                dirindex = read_unsigned_LEB_128(lineptr, &len);
+                lineptr += len;
+              }
+            else
+              return lineptr;
+          }
+        else
+          return lineptr;
+       }
+      gold_debug(DEBUG_LOCATION, "File %3d: %s",
+                static_cast<int>(file_list.size()), path);
+      file_list.push_back(std::make_pair(dirindex, path));
+    }
+
+  delete[] types;
+  delete[] forms;
+
+  return lineptr;
+}
+
 // Process a single opcode in the .debug.line structure.
 
 template<int size, bool big_endian>
@@ -1790,15 +2219,15 @@ Sized_dwarf_line_info<size, big_endian>::process_one_opcode(
 
   // If the opcode is great than the opcode_base, it is a special
   // opcode. Most line programs consist mainly of special opcodes.
-  if (opcode >= header_.opcode_base)
+  if (opcode >= this->header_.opcode_base)
     {
-      opcode -= header_.opcode_base;
-      const int advance_address = ((opcode / header_.line_range)
-                                   * header_.min_insn_length);
+      opcode -= this->header_.opcode_base;
+      const int advance_address = ((opcode / this->header_.line_range)
+                                   * this->header_.min_insn_length);
       lsm->address += advance_address;
 
-      const int advance_line = ((opcode % header_.line_range)
-                                + header_.line_base);
+      const int advance_line = ((opcode % this->header_.line_range)
+                                + this->header_.line_base);
       lsm->line_num += advance_line;
       lsm->basic_block = true;
       *len = oplen;
@@ -1818,13 +2247,13 @@ Sized_dwarf_line_info<size, big_endian>::process_one_opcode(
         const uint64_t advance_address
             = read_unsigned_LEB_128(start, &templen);
         oplen += templen;
-        lsm->address += header_.min_insn_length * advance_address;
+        lsm->address += this->header_.min_insn_length * advance_address;
       }
       break;
 
     case elfcpp::DW_LNS_advance_line:
       {
-        const uint64_t advance_line = read_signed_LEB_128(start, &templen);
+        const int64_t advance_line = read_signed_LEB_128(start, &templen);
         oplen += templen;
         lsm->line_num += advance_line;
       }
@@ -1865,9 +2294,9 @@ Sized_dwarf_line_info<size, big_endian>::process_one_opcode(
 
     case elfcpp::DW_LNS_const_add_pc:
       {
-        const int advance_address = (header_.min_insn_length
-                                     * ((255 - header_.opcode_base)
-                                        / header_.line_range));
+        const int advance_address = (this->header_.min_insn_length
+                                     * ((255 - this->header_.opcode_base)
+                                        / this->header_.line_range));
         lsm->address += advance_address;
       }
       break;
@@ -1950,7 +2379,7 @@ Sized_dwarf_line_info<size, big_endian>::process_one_opcode(
     default:
       {
         // Ignore unknown opcode  silently
-        for (int i = 0; i < header_.std_opcode_lengths[opcode]; i++)
+        for (int i = 0; i < this->header_.std_opcode_lengths[opcode]; i++)
           {
             size_t templen;
             read_unsigned_LEB_128(start, &templen);
@@ -1970,28 +2399,24 @@ Sized_dwarf_line_info<size, big_endian>::process_one_opcode(
 template<int size, bool big_endian>
 unsigned const char*
 Sized_dwarf_line_info<size, big_endian>::read_lines(unsigned const char* lineptr,
+                                                    unsigned const char* endptr,
                                                     unsigned int shndx)
 {
   struct LineStateMachine lsm;
 
-  // LENGTHSTART is the place the length field is based on.  It is the
-  // point in the header after the initial length field.
-  const unsigned char* lengthstart = buffer_;
-
-  // In 64 bit dwarf, the initial length is 12 bytes, because of the
-  // 0xffffffff at the start.
-  if (header_.offset_size == 8)
-    lengthstart += 12;
-  else
-    lengthstart += 4;
-
-  while (lineptr < lengthstart + header_.total_length)
+  while (lineptr < endptr)
     {
-      ResetLineStateMachine(&lsm, header_.default_is_stmt);
+      ResetLineStateMachine(&lsm, this->header_.default_is_stmt);
       while (!lsm.end_sequence)
         {
           size_t oplength;
+
+         if (lineptr >= endptr)
+           break;
+
           bool add_line = this->process_one_opcode(lineptr, &lsm, &oplength);
+          lineptr += oplength;
+
           if (add_line
               && (shndx == -1U || lsm.shndx == -1U || shndx == lsm.shndx))
             {
@@ -2012,11 +2437,10 @@ Sized_dwarf_line_info<size, big_endian>::read_lines(unsigned const char* lineptr
                map.back().last_line_for_offset = false;
              map.push_back(entry);
             }
-          lineptr += oplength;
         }
     }
 
-  return lengthstart + header_.total_length;
+  return endptr;
 }
 
 // Read the relocations into a Reloc_map.
@@ -2057,9 +2481,17 @@ Sized_dwarf_line_info<size, big_endian>::read_line_mappings(unsigned int shndx)
     {
       const unsigned char* lineptr = this->buffer_;
       lineptr = this->read_header_prolog(lineptr);
-      lineptr = this->read_header_tables(lineptr);
-      lineptr = this->read_lines(lineptr, shndx);
-      this->buffer_ = lineptr;
+      if (this->header_.version >= 2 && this->header_.version <= 4)
+       {
+         lineptr = this->read_header_tables_v2(lineptr);
+         lineptr = this->read_lines(lineptr, this->end_of_unit_, shndx);
+       }
+      else if (this->header_.version == 5)
+       {
+         lineptr = this->read_header_tables_v5(lineptr);
+         lineptr = this->read_lines(lineptr, this->end_of_unit_, shndx);
+       }
+      this->buffer_ = this->end_of_unit_;
     }
 
   // Sort the lines numbers, so addr2line can use binary search.
@@ -2215,6 +2647,9 @@ Sized_dwarf_line_info<size, big_endian>::do_addr2line(
     off_t offset,
     std::vector<std::string>* other_lines)
 {
+  gold_debug(DEBUG_LOCATION, "do_addr2line: shndx %u offset %08x",
+            shndx, static_cast<int>(offset));
+
   if (this->data_valid_ == false)
     return "";
 
index 80b2231327cfe6d5c26eba5c01d54edea36de2e4..921a1f7c8765b61e6b7a6a083ad5abe6608cac90 100644 (file)
@@ -173,11 +173,12 @@ class Dwarf_abbrev_table
   // An attribute list entry.
   struct Attribute
   {
-    Attribute(unsigned int a, unsigned int f)
-      : attr(a), form(f)
+    Attribute(unsigned int a, unsigned int f, int c)
+      : attr(a), form(f), implicit_const(c)
     { }
     unsigned int attr;
     unsigned int form;
+    int implicit_const;
   };
 
   // An abbrev code entry.
@@ -190,9 +191,9 @@ class Dwarf_abbrev_table
     }
 
     void
-    add_attribute(unsigned int attr, unsigned int form)
+    add_attribute(unsigned int attr, unsigned int form, int implicit_const)
     {
-      this->attributes.push_back(Attribute(attr, form));
+      this->attributes.push_back(Attribute(attr, form, implicit_const));
     }
 
     // The DWARF tag.
@@ -349,14 +350,15 @@ class Dwarf_ranges_table
       delete this->ranges_reloc_mapper_;
   }
 
-  // Read the ranges table from an object file.
+  // Fetch the contents of the ranges table from an object file.
   bool
   read_ranges_table(Relobj* object,
                    const unsigned char* symtab,
                    off_t symtab_size,
-                   unsigned int ranges_shndx);
+                   unsigned int ranges_shndx,
+                   unsigned int version);
 
-  // Read the range table from an object file.
+  // Read the DWARF 2/3/4 range table.
   Dwarf_range_list*
   read_range_list(Relobj* object,
                  const unsigned char* symtab,
@@ -365,6 +367,15 @@ class Dwarf_ranges_table
                  unsigned int ranges_shndx,
                  off_t ranges_offset);
 
+  // Read the DWARF 5 rnglists table.
+  Dwarf_range_list*
+  read_range_list_v5(Relobj* object,
+                    const unsigned char* symtab,
+                    off_t symtab_size,
+                    unsigned int address_size,
+                    unsigned int ranges_shndx,
+                    off_t ranges_offset);
+
   // Look for a relocation at offset OFF in the range table,
   // and return the section index and offset of the target.
   unsigned int
@@ -490,8 +501,6 @@ class Dwarf_die
       unsigned int shndx;
       // Block length for block forms.
       unsigned int blocklen;
-      // Attribute offset for DW_FORM_strp.
-      unsigned int attr_off;
     } aux;
   };
 
@@ -684,6 +693,10 @@ class Dwarf_die
 // calls the various visit_xxx() methods for each header.  Clients
 // should derive a new class from this one and implement the
 // visit_compilation_unit() and visit_type_unit() functions.
+// IS_TYPE_UNIT is true if we are reading from a .debug_types section,
+// which is used only in DWARF 4. For DWARF 5, it will be false,
+// and we will determine whether it's a type init when we parse the
+// header.
 
 class Dwarf_info_reader
 {
@@ -695,7 +708,7 @@ class Dwarf_info_reader
                    unsigned int shndx,
                    unsigned int reloc_shndx,
                    unsigned int reloc_type)
-    : is_type_unit_(is_type_unit), object_(object), symtab_(symtab),
+    : object_(object), symtab_(symtab),
       symtab_size_(symtab_size), shndx_(shndx), reloc_shndx_(reloc_shndx),
       reloc_type_(reloc_type), abbrev_shndx_(0), string_shndx_(0),
       buffer_(NULL), buffer_end_(NULL), cu_offset_(0), cu_length_(0),
@@ -703,7 +716,12 @@ class Dwarf_info_reader
       abbrev_table_(), ranges_table_(this),
       reloc_mapper_(NULL), string_buffer_(NULL), string_buffer_end_(NULL),
       owns_string_buffer_(false), string_output_section_offset_(0)
-  { }
+  {
+    // For DWARF 4, we infer the unit type from the section name.
+    // For DWARF 5, we will read this from the unit header.
+    this->unit_type_ =
+       (is_type_unit ? elfcpp::DW_UT_type : elfcpp::DW_UT_compile);
+  }
 
   virtual
   ~Dwarf_info_reader()
@@ -714,6 +732,13 @@ class Dwarf_info_reader
       delete[] this->string_buffer_;
   }
 
+  bool
+  is_type_unit() const
+  {
+    return (this->unit_type_ == elfcpp::DW_UT_type
+           || this->unit_type_ == elfcpp::DW_UT_split_type);
+  }
+
   // Begin parsing the debug info.  This calls visit_compilation_unit()
   // or visit_type_unit() for each compilation or type unit found in the
   // section, and visit_die() for each top-level DIE.
@@ -745,6 +770,9 @@ class Dwarf_info_reader
   inline typename elfcpp::Valtype_base<valsize>::Valtype
   read_from_pointer(const unsigned char** source);
 
+  inline typename elfcpp::Valtype_base<32>::Valtype
+  read_3bytes_from_pointer(const unsigned char** source);
+
   // Look for a relocation at offset ATTR_OFF in the dwarf info,
   // and return the section index and offset of the target.
   unsigned int
@@ -818,12 +846,20 @@ class Dwarf_info_reader
   Dwarf_range_list*
   read_range_list(unsigned int ranges_shndx, off_t ranges_offset)
   {
-    return this->ranges_table_.read_range_list(this->object_,
-                                              this->symtab_,
-                                              this->symtab_size_,
-                                              this->address_size_,
-                                              ranges_shndx,
-                                              ranges_offset);
+    if (this->cu_version_ < 5)
+      return this->ranges_table_.read_range_list(this->object_,
+                                                this->symtab_,
+                                                this->symtab_size_,
+                                                this->address_size_,
+                                                ranges_shndx,
+                                                ranges_offset);
+    else
+      return this->ranges_table_.read_range_list_v5(this->object_,
+                                                   this->symtab_,
+                                                   this->symtab_size_,
+                                                   this->address_size_,
+                                                   ranges_shndx,
+                                                   ranges_offset);
   }
 
   // Return the object.
@@ -873,8 +909,8 @@ class Dwarf_info_reader
   bool
   do_read_string_table(unsigned int string_shndx);
 
-  // True if this is a type unit; false for a compilation unit.
-  bool is_type_unit_;
+  // The unit type (DW_UT_xxx).
+  unsigned int unit_type_;
   // The object containing the .debug_info or .debug_types input section.
   Relobj* object_;
   // The ELF symbol table.
@@ -1008,6 +1044,8 @@ class Sized_dwarf_line_info : public Dwarf_line_info
   {
     if (this->buffer_start_ != NULL)
       delete[] this->buffer_start_;
+    if (this->str_buffer_start_ != NULL)
+      delete[] this->str_buffer_start_;
   }
 
  private:
@@ -1030,19 +1068,23 @@ class Sized_dwarf_line_info : public Dwarf_line_info
   void
   read_relocs();
 
-  // Reads the DWARF2/3 header for this line info.  Each takes as input
+  // Reads the DWARF header for this line info.  Each takes as input
   // a starting buffer position, and returns the ending position.
   const unsigned char*
   read_header_prolog(const unsigned char* lineptr);
 
   const unsigned char*
-  read_header_tables(const unsigned char* lineptr);
+  read_header_tables_v2(const unsigned char* lineptr);
+
+  const unsigned char*
+  read_header_tables_v5(const unsigned char* lineptr);
 
-  // Reads the DWARF2/3 line information.  If shndx is non-negative,
+  // Reads the DWARF line information.  If shndx is non-negative,
   // discard all line information that doesn't pertain to the given
   // section.
   const unsigned char*
-  read_lines(const unsigned char* lineptr, unsigned int shndx);
+  read_lines(const unsigned char* lineptr, const unsigned char* endptr,
+            unsigned int shndx);
 
   // Process a single line info opcode at START using the state
   // machine at LSM.  Return true if we should define a line using the
@@ -1069,6 +1111,7 @@ class Sized_dwarf_line_info : public Dwarf_line_info
   {
     off_t total_length;
     int version;
+    int address_size;
     off_t prologue_length;
     int min_insn_length; // insn stands for instruction
     int max_ops_per_insn; // Added in DWARF-4.
@@ -1089,6 +1132,20 @@ class Sized_dwarf_line_info : public Dwarf_line_info
   // of the buffer.
   const unsigned char* buffer_start_;
 
+  // str_buffer is the buffer for the line table strings.
+  const unsigned char* str_buffer_;
+  const unsigned char* str_buffer_end_;
+  // If the buffer was allocated temporarily, and therefore must be
+  // deallocated in the dtor, this contains a pointer to the start
+  // of the buffer.
+  const unsigned char* str_buffer_start_;
+
+  // Pointer to the end of the header_length field (aka prologue_length).
+  const unsigned char* end_of_header_length_;
+
+  // Pointer to the end of the current compilation unit.
+  const unsigned char* end_of_unit_;
+
   // This has relocations that point into buffer.
   Sized_elf_reloc_mapper<size, big_endian>* reloc_mapper_;
   // The type of the reloc section in track_relocs_--SHT_REL or SHT_RELA.