Move more code to line-header.c

This moves some more code out of read.c and into line-header.c.
dwarf_decode_line_header is split into two -- the part remaining in
read.c handles interfacing to the dwarf2_cu; while the part in
line-header.c (more or less) purely handles the actual decoding.

gdb/ChangeLog
2020-03-26  Tom Tromey  <tom@tromey.com>

	* dwarf2/line-header.h (dwarf_decode_line_header): Declare.
	* dwarf2/read.c
	(dwarf2_statement_list_fits_in_line_number_section_complaint):
	Move to line-header.c.
	(read_checked_initial_length_and_offset, read_formatted_entries):
	Likewise.
	(dwarf_decode_line_header): Split into two.
	* dwarf2/line-header.c
	(dwarf2_statement_list_fits_in_line_number_section_complaint):
	Move from read.c.
	(read_checked_initial_length_and_offset, read_formatted_entries):
	Likewise.
	(dwarf_decode_line_header): New function, split from read.c.

1 files changed, 335 insertions, 0 deletions

diff --git a/gdb/dwarf2/line-header.c b/gdb/dwarf2/line-header.c
index f417f2d0fae..58749e9594b 100644
--- a/gdb/dwarf2/line-header.c
+++ b/gdb/dwarf2/line-header.c
@@ -18,6 +18,8 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
+#include "dwarf2/comp-unit.h"
+#include "dwarf2/leb.h"
 #include "dwarf2/line-header.h"
 #include "dwarf2/read.h"
 #include "complaints.h"
@@ -112,3 +114,336 @@ line_header::file_full_name (int file, const char *comp_dir) const
   else
     return file_file_name (file);
 }
+
+static void
+dwarf2_statement_list_fits_in_line_number_section_complaint (void)
+{
+  complaint (_("statement list doesn't fit in .debug_line section"));
+}
+
+/* Cover function for read_initial_length.
+   Returns the length of the object at BUF, and stores the size of the
+   initial length in *BYTES_READ and stores the size that offsets will be in
+   *OFFSET_SIZE.
+   If the initial length size is not equivalent to that specified in
+   CU_HEADER then issue a complaint.
+   This is useful when reading non-comp-unit headers.  */
+
+static LONGEST
+read_checked_initial_length_and_offset (bfd *abfd, const gdb_byte *buf,
+					const struct comp_unit_head *cu_header,
+					unsigned int *bytes_read,
+					unsigned int *offset_size)
+{
+  LONGEST length = read_initial_length (abfd, buf, bytes_read);
+
+  gdb_assert (cu_header->initial_length_size == 4
+	      || cu_header->initial_length_size == 8
+	      || cu_header->initial_length_size == 12);
+
+  if (cu_header->initial_length_size != *bytes_read)
+    complaint (_("intermixed 32-bit and 64-bit DWARF sections"));
+
+  *offset_size = (*bytes_read == 4) ? 4 : 8;
+  return length;
+}
+
+/* Read directory or file name entry format, starting with byte of
+   format count entries, ULEB128 pairs of entry formats, ULEB128 of
+   entries count and the entries themselves in the described entry
+   format.  */
+
+static void
+read_formatted_entries (struct dwarf2_per_objfile *dwarf2_per_objfile,
+			bfd *abfd, const gdb_byte **bufp,
+			struct line_header *lh,
+			const struct comp_unit_head *cu_header,
+			void (*callback) (struct line_header *lh,
+					  const char *name,
+					  dir_index d_index,
+					  unsigned int mod_time,
+					  unsigned int length))
+{
+  gdb_byte format_count, formati;
+  ULONGEST data_count, datai;
+  const gdb_byte *buf = *bufp;
+  const gdb_byte *format_header_data;
+  unsigned int bytes_read;
+
+  format_count = read_1_byte (abfd, buf);
+  buf += 1;
+  format_header_data = buf;
+  for (formati = 0; formati < format_count; formati++)
+    {
+      read_unsigned_leb128 (abfd, buf, &bytes_read);
+      buf += bytes_read;
+      read_unsigned_leb128 (abfd, buf, &bytes_read);
+      buf += bytes_read;
+    }
+
+  data_count = read_unsigned_leb128 (abfd, buf, &bytes_read);
+  buf += bytes_read;
+  for (datai = 0; datai < data_count; datai++)
+    {
+      const gdb_byte *format = format_header_data;
+      struct file_entry fe;
+
+      for (formati = 0; formati < format_count; formati++)
+	{
+	  ULONGEST content_type = read_unsigned_leb128 (abfd, format, &bytes_read);
+	  format += bytes_read;
+
+	  ULONGEST form  = read_unsigned_leb128 (abfd, format, &bytes_read);
+	  format += bytes_read;
+
+	  gdb::optional<const char *> string;
+	  gdb::optional<unsigned int> uint;
+
+	  switch (form)
+	    {
+	    case DW_FORM_string:
+	      string.emplace (read_direct_string (abfd, buf, &bytes_read));
+	      buf += bytes_read;
+	      break;
+
+	    case DW_FORM_line_strp:
+	      string.emplace
+		(dwarf2_per_objfile->read_line_string (buf,
+						       cu_header,
+						       &bytes_read));
+	      buf += bytes_read;
+	      break;
+
+	    case DW_FORM_data1:
+	      uint.emplace (read_1_byte (abfd, buf));
+	      buf += 1;
+	      break;
+
+	    case DW_FORM_data2:
+	      uint.emplace (read_2_bytes (abfd, buf));
+	      buf += 2;
+	      break;
+
+	    case DW_FORM_data4:
+	      uint.emplace (read_4_bytes (abfd, buf));
+	      buf += 4;
+	      break;
+
+	    case DW_FORM_data8:
+	      uint.emplace (read_8_bytes (abfd, buf));
+	      buf += 8;
+	      break;
+
+	    case DW_FORM_data16:
+	      /*  This is used for MD5, but file_entry does not record MD5s. */
+	      buf += 16;
+	      break;
+
+	    case DW_FORM_udata:
+	      uint.emplace (read_unsigned_leb128 (abfd, buf, &bytes_read));
+	      buf += bytes_read;
+	      break;
+
+	    case DW_FORM_block:
+	      /* It is valid only for DW_LNCT_timestamp which is ignored by
+		 current GDB.  */
+	      break;
+	    }
+
+	  switch (content_type)
+	    {
+	    case DW_LNCT_path:
+	      if (string.has_value ())
+		fe.name = *string;
+	      break;
+	    case DW_LNCT_directory_index:
+	      if (uint.has_value ())
+		fe.d_index = (dir_index) *uint;
+	      break;
+	    case DW_LNCT_timestamp:
+	      if (uint.has_value ())
+		fe.mod_time = *uint;
+	      break;
+	    case DW_LNCT_size:
+	      if (uint.has_value ())
+		fe.length = *uint;
+	      break;
+	    case DW_LNCT_MD5:
+	      break;
+	    default:
+	      complaint (_("Unknown format content type %s"),
+			 pulongest (content_type));
+	    }
+	}
+
+      callback (lh, fe.name, fe.d_index, fe.mod_time, fe.length);
+    }
+
+  *bufp = buf;
+}
+
+/* See line-header.h.  */
+
+line_header_up
+dwarf_decode_line_header  (sect_offset sect_off, bool is_dwz,
+			   struct dwarf2_per_objfile *dwarf2_per_objfile,
+			   struct dwarf2_section_info *section,
+			   const struct comp_unit_head *cu_header)
+{
+  const gdb_byte *line_ptr;
+  unsigned int bytes_read, offset_size;
+  int i;
+  const char *cur_dir, *cur_file;
+
+  bfd *abfd = section->get_bfd_owner ();
+
+  /* Make sure that at least there's room for the total_length field.
+     That could be 12 bytes long, but we're just going to fudge that.  */
+  if (to_underlying (sect_off) + 4 >= section->size)
+    {
+      dwarf2_statement_list_fits_in_line_number_section_complaint ();
+      return 0;
+    }
+
+  line_header_up lh (new line_header ());
+
+  lh->sect_off = sect_off;
+  lh->offset_in_dwz = is_dwz;
+
+  line_ptr = section->buffer + to_underlying (sect_off);
+
+  /* Read in the header.  */
+  lh->total_length =
+    read_checked_initial_length_and_offset (abfd, line_ptr, cu_header,
+					    &bytes_read, &offset_size);
+  line_ptr += bytes_read;
+
+  const gdb_byte *start_here = line_ptr;
+
+  if (line_ptr + lh->total_length > (section->buffer + section->size))
+    {
+      dwarf2_statement_list_fits_in_line_number_section_complaint ();
+      return 0;
+    }
+  lh->statement_program_end = start_here + lh->total_length;
+  lh->version = read_2_bytes (abfd, line_ptr);
+  line_ptr += 2;
+  if (lh->version > 5)
+    {
+      /* This is a version we don't understand.  The format could have
+	 changed in ways we don't handle properly so just punt.  */
+      complaint (_("unsupported version in .debug_line section"));
+      return NULL;
+    }
+  if (lh->version >= 5)
+    {
+      gdb_byte segment_selector_size;
+
+      /* Skip address size.  */
+      read_1_byte (abfd, line_ptr);
+      line_ptr += 1;
+
+      segment_selector_size = read_1_byte (abfd, line_ptr);
+      line_ptr += 1;
+      if (segment_selector_size != 0)
+	{
+	  complaint (_("unsupported segment selector size %u "
+		       "in .debug_line section"),
+		     segment_selector_size);
+	  return NULL;
+	}
+    }
+  lh->header_length = read_offset (abfd, line_ptr, offset_size);
+  line_ptr += offset_size;
+  lh->statement_program_start = line_ptr + lh->header_length;
+  lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
+  line_ptr += 1;
+  if (lh->version >= 4)
+    {
+      lh->maximum_ops_per_instruction = read_1_byte (abfd, line_ptr);
+      line_ptr += 1;
+    }
+  else
+    lh->maximum_ops_per_instruction = 1;
+
+  if (lh->maximum_ops_per_instruction == 0)
+    {
+      lh->maximum_ops_per_instruction = 1;
+      complaint (_("invalid maximum_ops_per_instruction "
+		   "in `.debug_line' section"));
+    }
+
+  lh->default_is_stmt = read_1_byte (abfd, line_ptr);
+  line_ptr += 1;
+  lh->line_base = read_1_signed_byte (abfd, line_ptr);
+  line_ptr += 1;
+  lh->line_range = read_1_byte (abfd, line_ptr);
+  line_ptr += 1;
+  lh->opcode_base = read_1_byte (abfd, line_ptr);
+  line_ptr += 1;
+  lh->standard_opcode_lengths.reset (new unsigned char[lh->opcode_base]);
+
+  lh->standard_opcode_lengths[0] = 1;  /* This should never be used anyway.  */
+  for (i = 1; i < lh->opcode_base; ++i)
+    {
+      lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
+      line_ptr += 1;
+    }
+
+  if (lh->version >= 5)
+    {
+      /* Read directory table.  */
+      read_formatted_entries (dwarf2_per_objfile, abfd, &line_ptr, lh.get (),
+			      cu_header,
+			      [] (struct line_header *header, const char *name,
+				  dir_index d_index, unsigned int mod_time,
+				  unsigned int length)
+	{
+	  header->add_include_dir (name);
+	});
+
+      /* Read file name table.  */
+      read_formatted_entries (dwarf2_per_objfile, abfd, &line_ptr, lh.get (),
+			      cu_header,
+			      [] (struct line_header *header, const char *name,
+				  dir_index d_index, unsigned int mod_time,
+				  unsigned int length)
+	{
+	  header->add_file_name (name, d_index, mod_time, length);
+	});
+    }
+  else
+    {
+      /* Read directory table.  */
+      while ((cur_dir = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
+	{
+	  line_ptr += bytes_read;
+	  lh->add_include_dir (cur_dir);
+	}
+      line_ptr += bytes_read;
+
+      /* Read file name table.  */
+      while ((cur_file = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
+	{
+	  unsigned int mod_time, length;
+	  dir_index d_index;
+
+	  line_ptr += bytes_read;
+	  d_index = (dir_index) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
+	  line_ptr += bytes_read;
+	  mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
+	  line_ptr += bytes_read;
+	  length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
+	  line_ptr += bytes_read;
+
+	  lh->add_file_name (cur_file, d_index, mod_time, length);
+	}
+      line_ptr += bytes_read;
+    }
+
+  if (line_ptr > (section->buffer + section->size))
+    complaint (_("line number info header doesn't "
+		 "fit in `.debug_line' section"));
+
+  return lh;
+}