poky/meta/recipes-devtools/binutils/binutils/0018-Add-DWARF-5-support-in-gold.patch

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.