[deliverable/binutils-gdb.git] / gdb / dwarf2 / line-header.c

/* DWARF 2 debugging format support for GDB.

   Copyright (C) 1994-2020 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   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"
#include "filenames.h"

void
line_header::add_include_dir (const char *include_dir)
{
  if (dwarf_line_debug >= 2)
    {
      size_t new_size;
      if (version >= 5)
        new_size = m_include_dirs.size ();
      else
        new_size = m_include_dirs.size () + 1;
      fprintf_unfiltered (gdb_stdlog, "Adding dir %zu: %s\n",
			  new_size, include_dir);
    }
  m_include_dirs.push_back (include_dir);
}

void
line_header::add_file_name (const char *name,
			    dir_index d_index,
			    unsigned int mod_time,
			    unsigned int length)
{
  if (dwarf_line_debug >= 2)
    {
      size_t new_size;
      if (version >= 5)
        new_size = file_names_size ();
      else
        new_size = file_names_size () + 1;
      fprintf_unfiltered (gdb_stdlog, "Adding file %zu: %s\n",
			  new_size, name);
    }
  m_file_names.emplace_back (name, d_index, mod_time, length);
}

gdb::unique_xmalloc_ptr<char>
line_header::file_file_name (int file) const
{
  /* Is the file number a valid index into the line header's file name
     table?  Remember that file numbers start with one, not zero.  */
  if (is_valid_file_index (file))
    {
      const file_entry *fe = file_name_at (file);

      if (!IS_ABSOLUTE_PATH (fe->name))
	{
	  const char *dir = fe->include_dir (this);
	  if (dir != NULL)
	    return gdb::unique_xmalloc_ptr<char> (concat (dir, SLASH_STRING,
							  fe->name,
							  (char *) NULL));
	}
      return make_unique_xstrdup (fe->name);
    }
  else
    {
      /* The compiler produced a bogus file number.  We can at least
         record the macro definitions made in the file, even if we
         won't be able to find the file by name.  */
      char fake_name[80];

      xsnprintf (fake_name, sizeof (fake_name),
		 "<bad macro file number %d>", file);

      complaint (_("bad file number in macro information (%d)"),
                 file);

      return make_unique_xstrdup (fake_name);
    }
}

gdb::unique_xmalloc_ptr<char>
line_header::file_full_name (int file, const char *comp_dir) const
{
  /* Is the file number a valid index into the line header's file name
     table?  Remember that file numbers start with one, not zero.  */
  if (is_valid_file_index (file))
    {
      gdb::unique_xmalloc_ptr<char> relative = file_file_name (file);

      if (IS_ABSOLUTE_PATH (relative.get ()) || comp_dir == NULL)
	return relative;
      return gdb::unique_xmalloc_ptr<char> (concat (comp_dir, SLASH_STRING,
						    relative.get (),
						    (char *) NULL));
    }
  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 (dwarf2_per_objfile *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
		(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,
			   dwarf2_per_objfile *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 (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 (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;
}
Commit	Line	Data
8fdd972c TT	1	/* DWARF 2 debugging format support for GDB.
	2
	3	Copyright (C) 1994-2020 Free Software Foundation, Inc.
	4
	5	This file is part of GDB.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 3 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	19
	20	#include "defs.h"
0df7ad3a TT	21	#include "dwarf2/comp-unit.h"
0df7ad3a TT	22	#include "dwarf2/leb.h"
8fdd972c TT	23	#include "dwarf2/line-header.h"
	24	#include "dwarf2/read.h"
	25	#include "complaints.h"
	26	#include "filenames.h"
	27
	28	void
	29	line_header::add_include_dir (const char *include_dir)
	30	{
	31	if (dwarf_line_debug >= 2)
	32	{
	33	size_t new_size;
	34	if (version >= 5)
	35	new_size = m_include_dirs.size ();
	36	else
	37	new_size = m_include_dirs.size () + 1;
	38	fprintf_unfiltered (gdb_stdlog, "Adding dir %zu: %s\n",
	39	new_size, include_dir);
	40	}
	41	m_include_dirs.push_back (include_dir);
	42	}
	43
	44	void
	45	line_header::add_file_name (const char *name,
	46	dir_index d_index,
	47	unsigned int mod_time,
	48	unsigned int length)
	49	{
	50	if (dwarf_line_debug >= 2)
	51	{
	52	size_t new_size;
	53	if (version >= 5)
	54	new_size = file_names_size ();
	55	else
	56	new_size = file_names_size () + 1;
	57	fprintf_unfiltered (gdb_stdlog, "Adding file %zu: %s\n",
	58	new_size, name);
	59	}
	60	m_file_names.emplace_back (name, d_index, mod_time, length);
	61	}
	62
	63	gdb::unique_xmalloc_ptr<char>
8844c11b	64	line_header::file_file_name (int file) const
8fdd972c TT	65	{
	66	/* Is the file number a valid index into the line header's file name
	67	table? Remember that file numbers start with one, not zero. */
	68	if (is_valid_file_index (file))
	69	{
	70	const file_entry *fe = file_name_at (file);
	71
	72	if (!IS_ABSOLUTE_PATH (fe->name))
	73	{
	74	const char *dir = fe->include_dir (this);
	75	if (dir != NULL)
	76	return gdb::unique_xmalloc_ptr<char> (concat (dir, SLASH_STRING,
	77	fe->name,
	78	(char *) NULL));
	79	}
	80	return make_unique_xstrdup (fe->name);
	81	}
	82	else
	83	{
	84	/* The compiler produced a bogus file number. We can at least
	85	record the macro definitions made in the file, even if we
	86	won't be able to find the file by name. */
	87	char fake_name[80];
	88
	89	xsnprintf (fake_name, sizeof (fake_name),
	90	"<bad macro file number %d>", file);
	91
	92	complaint (_("bad file number in macro information (%d)"),
	93	file);
	94
	95	return make_unique_xstrdup (fake_name);
	96	}
	97	}
	98
	99	gdb::unique_xmalloc_ptr<char>
8844c11b	100	line_header::file_full_name (int file, const char *comp_dir) const
8fdd972c TT	101	{
	102	/* Is the file number a valid index into the line header's file name
	103	table? Remember that file numbers start with one, not zero. */
	104	if (is_valid_file_index (file))
	105	{
	106	gdb::unique_xmalloc_ptr<char> relative = file_file_name (file);
	107
	108	if (IS_ABSOLUTE_PATH (relative.get ()) \|\| comp_dir == NULL)
	109	return relative;
	110	return gdb::unique_xmalloc_ptr<char> (concat (comp_dir, SLASH_STRING,
	111	relative.get (),
	112	(char *) NULL));
	113	}
	114	else
	115	return file_file_name (file);
	116	}
0df7ad3a TT	117
	118	static void
	119	dwarf2_statement_list_fits_in_line_number_section_complaint (void)
	120	{
	121	complaint (_("statement list doesn't fit in .debug_line section"));
	122	}
	123
	124	/* Cover function for read_initial_length.
	125	Returns the length of the object at BUF, and stores the size of the
	126	initial length in *BYTES_READ and stores the size that offsets will be in
	127	*OFFSET_SIZE.
	128	If the initial length size is not equivalent to that specified in
	129	CU_HEADER then issue a complaint.
	130	This is useful when reading non-comp-unit headers. */
	131
	132	static LONGEST
	133	read_checked_initial_length_and_offset (bfd abfd, const gdb_byte buf,
	134	const struct comp_unit_head *cu_header,
	135	unsigned int *bytes_read,
	136	unsigned int *offset_size)
	137	{
	138	LONGEST length = read_initial_length (abfd, buf, bytes_read);
	139
	140	gdb_assert (cu_header->initial_length_size == 4
	141	\|\| cu_header->initial_length_size == 8
	142	\|\| cu_header->initial_length_size == 12);
	143
	144	if (cu_header->initial_length_size != *bytes_read)
	145	complaint (_("intermixed 32-bit and 64-bit DWARF sections"));
	146
	147	offset_size = (bytes_read == 4) ? 4 : 8;
	148	return length;
	149	}
	150
	151	/* Read directory or file name entry format, starting with byte of
	152	format count entries, ULEB128 pairs of entry formats, ULEB128 of
	153	entries count and the entries themselves in the described entry
	154	format. */
	155
	156	static void
976ca316 SM	157	read_formatted_entries (dwarf2_per_objfile per_objfile, bfd abfd,
976ca316 SM	158	const gdb_byte *bufp, struct line_header lh,
0df7ad3a TT	159	const struct comp_unit_head *cu_header,
	160	void (callback) (struct line_header lh,
	161	const char *name,
	162	dir_index d_index,
	163	unsigned int mod_time,
	164	unsigned int length))
	165	{
	166	gdb_byte format_count, formati;
	167	ULONGEST data_count, datai;
	168	const gdb_byte buf = bufp;
	169	const gdb_byte *format_header_data;
	170	unsigned int bytes_read;
	171
	172	format_count = read_1_byte (abfd, buf);
	173	buf += 1;
	174	format_header_data = buf;
	175	for (formati = 0; formati < format_count; formati++)
	176	{
	177	read_unsigned_leb128 (abfd, buf, &bytes_read);
	178	buf += bytes_read;
	179	read_unsigned_leb128 (abfd, buf, &bytes_read);
	180	buf += bytes_read;
	181	}
	182
	183	data_count = read_unsigned_leb128 (abfd, buf, &bytes_read);
	184	buf += bytes_read;
	185	for (datai = 0; datai < data_count; datai++)
	186	{
	187	const gdb_byte *format = format_header_data;
	188	struct file_entry fe;
	189
	190	for (formati = 0; formati < format_count; formati++)
	191	{
	192	ULONGEST content_type = read_unsigned_leb128 (abfd, format, &bytes_read);
	193	format += bytes_read;
	194
	195	ULONGEST form = read_unsigned_leb128 (abfd, format, &bytes_read);
	196	format += bytes_read;
	197
	198	gdb::optional<const char *> string;
	199	gdb::optional<unsigned int> uint;
	200
	201	switch (form)
	202	{
	203	case DW_FORM_string:
	204	string.emplace (read_direct_string (abfd, buf, &bytes_read));
	205	buf += bytes_read;
	206	break;
	207
	208	case DW_FORM_line_strp:
	209	string.emplace
976ca316	210	(per_objfile->read_line_string (buf, cu_header, &bytes_read));
0df7ad3a TT	211	buf += bytes_read;
	212	break;
	213
	214	case DW_FORM_data1:
	215	uint.emplace (read_1_byte (abfd, buf));
	216	buf += 1;
	217	break;
	218
	219	case DW_FORM_data2:
	220	uint.emplace (read_2_bytes (abfd, buf));
	221	buf += 2;
	222	break;
	223
	224	case DW_FORM_data4:
	225	uint.emplace (read_4_bytes (abfd, buf));
	226	buf += 4;
	227	break;
	228
	229	case DW_FORM_data8:
	230	uint.emplace (read_8_bytes (abfd, buf));
	231	buf += 8;
	232	break;
	233
	234	case DW_FORM_data16:
	235	/* This is used for MD5, but file_entry does not record MD5s. */
	236	buf += 16;
	237	break;
	238
	239	case DW_FORM_udata:
	240	uint.emplace (read_unsigned_leb128 (abfd, buf, &bytes_read));
	241	buf += bytes_read;
	242	break;
	243
	244	case DW_FORM_block:
	245	/* It is valid only for DW_LNCT_timestamp which is ignored by
	246	current GDB. */
	247	break;
	248	}
	249
	250	switch (content_type)
	251	{
	252	case DW_LNCT_path:
	253	if (string.has_value ())
	254	fe.name = *string;
	255	break;
	256	case DW_LNCT_directory_index:
	257	if (uint.has_value ())
	258	fe.d_index = (dir_index) *uint;
	259	break;
	260	case DW_LNCT_timestamp:
	261	if (uint.has_value ())
	262	fe.mod_time = *uint;
	263	break;
	264	case DW_LNCT_size:
	265	if (uint.has_value ())
	266	fe.length = *uint;
	267	break;
	268	case DW_LNCT_MD5:
	269	break;
	270	default:
	271	complaint (_("Unknown format content type %s"),
	272	pulongest (content_type));
	273	}
	274	}
275
276	callback (lh, fe.name, fe.d_index, fe.mod_time, fe.length);
277	}
278
279	*bufp = buf;
280	}
281
282	/* See line-header.h. */
283
284	line_header_up
285	dwarf_decode_line_header (sect_offset sect_off, bool is_dwz,
976ca316	286	dwarf2_per_objfile *per_objfile,
0df7ad3a TT	287	struct dwarf2_section_info *section,
	288	const struct comp_unit_head *cu_header)
	289	{
	290	const gdb_byte *line_ptr;
	291	unsigned int bytes_read, offset_size;
	292	int i;
	293	const char cur_dir, cur_file;
	294
	295	bfd *abfd = section->get_bfd_owner ();
	296
	297	/* Make sure that at least there's room for the total_length field.
	298	That could be 12 bytes long, but we're just going to fudge that. */
	299	if (to_underlying (sect_off) + 4 >= section->size)
	300	{
	301	dwarf2_statement_list_fits_in_line_number_section_complaint ();
	302	return 0;
	303	}
	304
	305	line_header_up lh (new line_header ());
	306
	307	lh->sect_off = sect_off;
	308	lh->offset_in_dwz = is_dwz;
	309
	310	line_ptr = section->buffer + to_underlying (sect_off);
	311
	312	/* Read in the header. */
	313	lh->total_length =
	314	read_checked_initial_length_and_offset (abfd, line_ptr, cu_header,
	315	&bytes_read, &offset_size);
	316	line_ptr += bytes_read;
	317
	318	const gdb_byte *start_here = line_ptr;
	319
	320	if (line_ptr + lh->total_length > (section->buffer + section->size))
	321	{
	322	dwarf2_statement_list_fits_in_line_number_section_complaint ();
	323	return 0;
	324	}
	325	lh->statement_program_end = start_here + lh->total_length;
	326	lh->version = read_2_bytes (abfd, line_ptr);
	327	line_ptr += 2;
	328	if (lh->version > 5)
	329	{
	330	/* This is a version we don't understand. The format could have
	331	changed in ways we don't handle properly so just punt. */
	332	complaint (_("unsupported version in .debug_line section"));
	333	return NULL;
	334	}
	335	if (lh->version >= 5)
	336	{
	337	gdb_byte segment_selector_size;
	338
	339	/* Skip address size. */
	340	read_1_byte (abfd, line_ptr);
	341	line_ptr += 1;
	342
	343	segment_selector_size = read_1_byte (abfd, line_ptr);
	344	line_ptr += 1;
	345	if (segment_selector_size != 0)
	346	{
	347	complaint (_("unsupported segment selector size %u "
	348	"in .debug_line section"),
	349	segment_selector_size);
	350	return NULL;
351	}
352	}
353	lh->header_length = read_offset (abfd, line_ptr, offset_size);
354	line_ptr += offset_size;
355	lh->statement_program_start = line_ptr + lh->header_length;
356	lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
357	line_ptr += 1;
358	if (lh->version >= 4)
359	{
360	lh->maximum_ops_per_instruction = read_1_byte (abfd, line_ptr);
361	line_ptr += 1;
362	}
363	else
364	lh->maximum_ops_per_instruction = 1;
365
366	if (lh->maximum_ops_per_instruction == 0)
367	{
368	lh->maximum_ops_per_instruction = 1;
369	complaint (_("invalid maximum_ops_per_instruction "
370	"in `.debug_line' section"));
371	}
372
373	lh->default_is_stmt = read_1_byte (abfd, line_ptr);
374	line_ptr += 1;
375	lh->line_base = read_1_signed_byte (abfd, line_ptr);
376	line_ptr += 1;
377	lh->line_range = read_1_byte (abfd, line_ptr);
378	line_ptr += 1;
379	lh->opcode_base = read_1_byte (abfd, line_ptr);
380	line_ptr += 1;
381	lh->standard_opcode_lengths.reset (new unsigned char[lh->opcode_base]);
382
383	lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
384	for (i = 1; i < lh->opcode_base; ++i)
385	{
386	lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
387	line_ptr += 1;
388	}
389
390	if (lh->version >= 5)
391	{
392	/* Read directory table. */
976ca316	393	read_formatted_entries (per_objfile, abfd, &line_ptr, lh.get (),
0df7ad3a TT	394	cu_header,
	395	[] (struct line_header header, const char name,
	396	dir_index d_index, unsigned int mod_time,
	397	unsigned int length)
	398	{
	399	header->add_include_dir (name);
	400	});
	401
	402	/* Read file name table. */
976ca316	403	read_formatted_entries (per_objfile, abfd, &line_ptr, lh.get (),
0df7ad3a TT	404	cu_header,
	405	[] (struct line_header header, const char name,
	406	dir_index d_index, unsigned int mod_time,
	407	unsigned int length)
	408	{
	409	header->add_file_name (name, d_index, mod_time, length);
	410	});
	411	}
	412	else
	413	{
	414	/* Read directory table. */
	415	while ((cur_dir = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
	416	{
	417	line_ptr += bytes_read;
	418	lh->add_include_dir (cur_dir);
	419	}
	420	line_ptr += bytes_read;
	421
	422	/* Read file name table. */
	423	while ((cur_file = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
	424	{
	425	unsigned int mod_time, length;
	426	dir_index d_index;
	427
	428	line_ptr += bytes_read;
	429	d_index = (dir_index) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
	430	line_ptr += bytes_read;
	431	mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
	432	line_ptr += bytes_read;
	433	length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
	434	line_ptr += bytes_read;
	435
	436	lh->add_file_name (cur_file, d_index, mod_time, length);
	437	}
	438	line_ptr += bytes_read;
	439	}
	440
	441	if (line_ptr > (section->buffer + section->size))
	442	complaint (_("line number info header doesn't "
	443	"fit in `.debug_line' section"));
	444
	445	return lh;
	446	}