--- /dev/null
+From 29dab7648672342418a9d32767e3b3182d9e6a30 Mon Sep 17 00:00:00 2001
+From: Cary Coutant <ccoutant@gmail.com>
+Date: Wed, 17 Mar 2021 21:31:15 -0700
+Subject: [PATCH] Add DWARF 5 support in gold.
+
+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.
+
+Upstream-Status: Backport [5cde809b7b9 Add DWARF 5 support in gold.]
+
+Signed-off-by: Martin Jansa <Martin.Jansa@gmail.com>
+---
+ elfcpp/dwarf.h | 89 +++++--
+ gold/dwarf_reader.cc | 591 +++++++++++++++++++++++++++++++++++++------
+ gold/dwarf_reader.h | 103 ++++++--
+ 3 files changed, 654 insertions(+), 129 deletions(-)
+
+diff --git a/elfcpp/dwarf.h b/elfcpp/dwarf.h
+index e24347f8481..c9a9e02369c 100644
+--- a/elfcpp/dwarf.h
++++ b/elfcpp/dwarf.h
+@@ -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.
+diff --git a/gold/dwarf_reader.cc b/gold/dwarf_reader.cc
+index f0e6b89bde2..83a0114ed39 100644
+--- a/gold/dwarf_reader.cc
++++ b/gold/dwarf_reader.cc
+@@ -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 "";
+
+diff --git a/gold/dwarf_reader.h b/gold/dwarf_reader.h
+index 80b2231327c..921a1f7c876 100644
+--- a/gold/dwarf_reader.h
++++ b/gold/dwarf_reader.h
+@@ -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.
