[thirdparty/binutils-gdb.git] / bfd / elfcore.h

/* ELF core file support for BFD.
   Copyright (C) 1995-2023 Free Software Foundation, Inc.

   This file is part of BFD, the Binary File Descriptor library.

   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, write to the Free Software
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */

char*
elf_core_file_failing_command (bfd *abfd)
{
  return elf_tdata (abfd)->core->command;
}

int
elf_core_file_failing_signal (bfd *abfd)
{
  return elf_tdata (abfd)->core->signal;
}

int
elf_core_file_pid (bfd *abfd)
{
  return elf_tdata (abfd)->core->pid;
}

bool
elf_core_file_matches_executable_p (bfd *core_bfd, bfd *exec_bfd)
{
  char* corename;

  /* xvecs must match if both are ELF files for the same target.  */

  if (core_bfd->xvec != exec_bfd->xvec)
    {
      bfd_set_error (bfd_error_system_call);
      return false;
    }

  /* If both BFDs have identical build-ids, then they match.  */
  if (core_bfd->build_id != NULL
      && exec_bfd->build_id != NULL
      && core_bfd->build_id->size == exec_bfd->build_id->size
      && memcmp (core_bfd->build_id->data, exec_bfd->build_id->data,
		 core_bfd->build_id->size) == 0)
    return true;

  /* See if the name in the corefile matches the executable name.  */
  corename = elf_tdata (core_bfd)->core->program;
  if (corename != NULL)
    {
      const char* execname = strrchr (bfd_get_filename (exec_bfd), '/');

      execname = execname ? execname + 1 : bfd_get_filename (exec_bfd);

      if (strcmp (execname, corename) != 0)
	return false;
    }

  return true;
}

/*  Core files are simply standard ELF formatted files that partition
    the file using the execution view of the file (program header table)
    rather than the linking view.  In fact, there is no section header
    table in a core file.

    The process status information (including the contents of the general
    register set) and the floating point register set are stored in a
    segment of type PT_NOTE.  We handcraft a couple of extra bfd sections
    that allow standard bfd access to the general registers (.reg) and the
    floating point registers (.reg2).  */

bfd_cleanup
elf_core_file_p (bfd *abfd)
{
  Elf_External_Ehdr x_ehdr;	/* Elf file header, external form.  */
  Elf_Internal_Ehdr *i_ehdrp;	/* Elf file header, internal form.  */
  Elf_Internal_Phdr *i_phdrp;	/* Elf program header, internal form.  */
  unsigned int phindex;
  const struct elf_backend_data *ebd;
  bfd_size_type amt;
  ufile_ptr filesize;

  /* Read in the ELF header in external format.  */
  if (bfd_bread (&x_ehdr, sizeof (x_ehdr), abfd) != sizeof (x_ehdr))
    {
      if (bfd_get_error () != bfd_error_system_call)
	goto wrong;
      else
	goto fail;
    }

  /* Check the magic number.  */
  if (! elf_file_p (&x_ehdr))
    goto wrong;

  /* FIXME: Check EI_VERSION here !  */

  /* Check the address size ("class").  */
  if (x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
    goto wrong;

  /* Check the byteorder.  */
  switch (x_ehdr.e_ident[EI_DATA])
    {
    case ELFDATA2MSB:		/* Big-endian.  */
      if (! bfd_big_endian (abfd))
	goto wrong;
      break;
    case ELFDATA2LSB:		/* Little-endian.  */
      if (! bfd_little_endian (abfd))
	goto wrong;
      break;
    default:
      goto wrong;
    }

  /* Give abfd an elf_obj_tdata.  */
  if (! (*abfd->xvec->_bfd_set_format[bfd_core]) (abfd))
    goto fail;

  /* Swap in the rest of the header, now that we have the byte order.  */
  i_ehdrp = elf_elfheader (abfd);
  elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);

#if DEBUG & 1
  elf_debug_file (i_ehdrp);
#endif

  ebd = get_elf_backend_data (abfd);

  /* Check that the ELF e_machine field matches what this particular
     BFD format expects.  */

  if (ebd->elf_machine_code != i_ehdrp->e_machine
      && (ebd->elf_machine_alt1 == 0
	  || i_ehdrp->e_machine != ebd->elf_machine_alt1)
      && (ebd->elf_machine_alt2 == 0
	  || i_ehdrp->e_machine != ebd->elf_machine_alt2)
      && ebd->elf_machine_code != EM_NONE)
    goto wrong;

  if (ebd->elf_machine_code != EM_NONE
      && i_ehdrp->e_ident[EI_OSABI] != ebd->elf_osabi
      && ebd->elf_osabi != ELFOSABI_NONE)
    goto wrong;

  /* If there is no program header, or the type is not a core file, then
     we are hosed.  */
  if (i_ehdrp->e_phoff == 0 || i_ehdrp->e_type != ET_CORE)
    goto wrong;

  /* Does BFD's idea of the phdr size match the size
     recorded in the file? */
  if (i_ehdrp->e_phentsize != sizeof (Elf_External_Phdr))
    goto wrong;

  /* If the program header count is PN_XNUM(0xffff), the actual
     count is in the first section header.  */
  if (i_ehdrp->e_shoff != 0 && i_ehdrp->e_phnum == PN_XNUM)
    {
      Elf_External_Shdr x_shdr;
      Elf_Internal_Shdr i_shdr;
      file_ptr where = (file_ptr) i_ehdrp->e_shoff;

      if (i_ehdrp->e_shoff < sizeof (x_ehdr))
	goto wrong;

      /* Seek to the section header table in the file.  */
      if (bfd_seek (abfd, where, SEEK_SET) != 0)
	goto fail;

      /* Read the first section header at index 0, and convert to internal
	 form.  */
      if (bfd_bread (&x_shdr, sizeof (x_shdr), abfd) != sizeof (x_shdr))
	goto fail;
      elf_swap_shdr_in (abfd, &x_shdr, &i_shdr);

      if (i_shdr.sh_info != 0)
	{
	  i_ehdrp->e_phnum = i_shdr.sh_info;
	  if (i_ehdrp->e_phnum != i_shdr.sh_info)
	    goto wrong;
	}
    }

  /* Sanity check that we can read all of the program headers.
     It ought to be good enough to just read the last one.  */
  if (i_ehdrp->e_phnum > 1)
    {
      Elf_External_Phdr x_phdr;
      Elf_Internal_Phdr i_phdr;
      file_ptr where;

      /* Check that we don't have a totally silly number of
	 program headers.  */
      if (i_ehdrp->e_phnum > (unsigned int) -1 / sizeof (x_phdr)
	  || i_ehdrp->e_phnum > (unsigned int) -1 / sizeof (i_phdr))
	goto wrong;

      where = (file_ptr)(i_ehdrp->e_phoff + (i_ehdrp->e_phnum - 1) * sizeof (x_phdr));
      if ((bfd_size_type) where <= i_ehdrp->e_phoff)
	goto wrong;

      if (bfd_seek (abfd, where, SEEK_SET) != 0)
	goto fail;
      if (bfd_bread (&x_phdr, sizeof (x_phdr), abfd) != sizeof (x_phdr))
	goto fail;
    }

  /* Move to the start of the program headers.  */
  if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
    goto wrong;

  /* Allocate space for the program headers.  */
  amt = sizeof (*i_phdrp) * i_ehdrp->e_phnum;
  i_phdrp = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
  if (!i_phdrp)
    goto fail;

  elf_tdata (abfd)->phdr = i_phdrp;

  /* Read and convert to internal form.  */
  for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
    {
      Elf_External_Phdr x_phdr;

      if (bfd_bread (&x_phdr, sizeof (x_phdr), abfd) != sizeof (x_phdr))
	goto fail;

      elf_swap_phdr_in (abfd, &x_phdr, i_phdrp + phindex);
    }

  /* Set the machine architecture.  Do this before processing the
     program headers since we need to know the architecture type
     when processing the notes of some systems' core files.  */
  if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0)
      /* It's OK if this fails for the generic target.  */
      && ebd->elf_machine_code != EM_NONE)
    goto fail;

  /* Let the backend double check the format and override global
     information.  We do this before processing the program headers
     to allow the correct machine (as opposed to just the default
     machine) to be set, making it possible for grok_prstatus and
     grok_psinfo to rely on the mach setting.  */
  if (ebd->elf_backend_object_p != NULL
      && ! ebd->elf_backend_object_p (abfd))
    goto wrong;

  /* Process each program header.  */
  for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
    if (! bfd_section_from_phdr (abfd, i_phdrp + phindex, (int) phindex))
      goto fail;

  /* Check for core truncation.  */
  filesize = bfd_get_file_size (abfd);
  if (filesize != 0)
    {
      for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
	{
	  Elf_Internal_Phdr *p = i_phdrp + phindex;
	  if (p->p_filesz
	      && (p->p_offset >= filesize
		  || p->p_filesz > filesize - p->p_offset))
	    {
	      _bfd_error_handler (_("warning: %pB has a segment "
				    "extending past end of file"), abfd);
	      abfd->read_only = 1;
	      break;
	    }
      }
  }

  /* Save the entry point from the ELF header.  */
  abfd->start_address = i_ehdrp->e_entry;
  return _bfd_no_cleanup;

 wrong:
  bfd_set_error (bfd_error_wrong_format);
 fail:
  return NULL;
}

/* Attempt to find a build-id in a core file from the core file BFD.
   OFFSET is the file offset to a PT_LOAD segment that may contain
   the build-id note.  Returns TRUE upon success, FALSE otherwise.  */

bool
NAME(_bfd_elf, core_find_build_id)
  (bfd *abfd,
   bfd_vma offset)
{
  Elf_External_Ehdr x_ehdr;	/* Elf file header, external form.   */
  Elf_Internal_Ehdr i_ehdr;	/* Elf file header, internal form.   */
  Elf_Internal_Phdr *i_phdr;
  unsigned int i;
  size_t amt;

  /* Seek to the position of the segment at OFFSET.  */
  if (bfd_seek (abfd, offset, SEEK_SET) != 0)
    goto fail;

  /* Read in the ELF header in external format.  */
  if (bfd_bread (&x_ehdr, sizeof (x_ehdr), abfd) != sizeof (x_ehdr))
    {
      if (bfd_get_error () != bfd_error_system_call)
	goto wrong;
      else
	goto fail;
    }

  /* Now check to see if we have a valid ELF file, and one that BFD can
     make use of.  The magic number must match, the address size ('class')
     and byte-swapping must match our XVEC entry, and it must have a
     section header table (FIXME: See comments re sections at top of this
     file).  */
  if (! elf_file_p (&x_ehdr)
      || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT
      || x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
    goto wrong;

  /* Check that file's byte order matches xvec's.  */
  switch (x_ehdr.e_ident[EI_DATA])
    {
    case ELFDATA2MSB:		/* Big-endian.  */
      if (! bfd_header_big_endian (abfd))
	goto wrong;
      break;
    case ELFDATA2LSB:		/* Little-endian.  */
      if (! bfd_header_little_endian (abfd))
	goto wrong;
      break;
    case ELFDATANONE:		/* No data encoding specified.  */
    default:			/* Unknown data encoding specified . */
      goto wrong;
    }

  elf_swap_ehdr_in (abfd, &x_ehdr, &i_ehdr);
#if DEBUG
  elf_debug_file (&i_ehdr);
#endif

  if (i_ehdr.e_phentsize != sizeof (Elf_External_Phdr) || i_ehdr.e_phnum == 0)
    goto fail;

  /* Read in program headers.  */
  if (_bfd_mul_overflow (i_ehdr.e_phnum, sizeof (*i_phdr), &amt))
    {
      bfd_set_error (bfd_error_file_too_big);
      goto fail;
    }
  i_phdr = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
  if (i_phdr == NULL)
    goto fail;

  if (bfd_seek (abfd, (file_ptr) (offset + i_ehdr.e_phoff), SEEK_SET) != 0)
    goto fail;

  /* Read in program headers and parse notes.  */
  for (i = 0; i < i_ehdr.e_phnum; ++i, ++i_phdr)
    {
      Elf_External_Phdr x_phdr;

      if (bfd_bread (&x_phdr, sizeof (x_phdr), abfd) != sizeof (x_phdr))
	goto fail;
      elf_swap_phdr_in (abfd, &x_phdr, i_phdr);

      if (i_phdr->p_type == PT_NOTE && i_phdr->p_filesz > 0)
	{
	  elf_read_notes (abfd, offset + i_phdr->p_offset,
			  i_phdr->p_filesz, i_phdr->p_align);

	  /* Make sure ABFD returns to processing the program headers.  */
	  if (bfd_seek (abfd, (file_ptr) (offset + i_ehdr.e_phoff
					  + (i + 1) * sizeof (x_phdr)),
			SEEK_SET) != 0)
	    goto fail;

	  if (abfd->build_id != NULL)
	    return true;
	}
    }

  /* Having gotten this far, we have a valid ELF section, but no
     build-id was found.  */
  goto fail;

 wrong:
  bfd_set_error (bfd_error_wrong_format);
 fail:
  return false;
}
Commit	Line	Data
252b5132	1	/* ELF core file support for BFD.
d87bef3a	2	Copyright (C) 1995-2023 Free Software Foundation, Inc.
252b5132	3
3193e234	4	This file is part of BFD, the Binary File Descriptor library.
252b5132	5
3193e234 NC	6	This program is free software; you can redistribute it and/or modify
3193e234 NC	7	it under the terms of the GNU General Public License as published by
cd123cb7	8	the Free Software Foundation; either version 3 of the License, or
3193e234	9	(at your option) any later version.
252b5132	10
3193e234 NC	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
252b5132	15
3193e234 NC	16	You should have received a copy of the GNU General Public License
3193e234 NC	17	along with this program; if not, write to the Free Software
cd123cb7 NC	18	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
cd123cb7 NC	19	MA 02110-1301, USA. */
252b5132	20
252b5132	21	char*
268b6b39	22	elf_core_file_failing_command (bfd *abfd)
252b5132	23	{
228e534f	24	return elf_tdata (abfd)->core->command;
252b5132 RH	25	}
	26
	27	int
268b6b39	28	elf_core_file_failing_signal (bfd *abfd)
252b5132	29	{
228e534f	30	return elf_tdata (abfd)->core->signal;
252b5132 RH	31	}
252b5132 RH	32
261b8d08 PA	33	int
	34	elf_core_file_pid (bfd *abfd)
	35	{
228e534f	36	return elf_tdata (abfd)->core->pid;
261b8d08 PA	37	}
261b8d08 PA	38
0a1b45a2	39	bool
268b6b39	40	elf_core_file_matches_executable_p (bfd core_bfd, bfd exec_bfd)
252b5132 RH	41	{
	42	char* corename;
	43
3e932841	44	/* xvecs must match if both are ELF files for the same target. */
252b5132 RH	45
	46	if (core_bfd->xvec != exec_bfd->xvec)
	47	{
	48	bfd_set_error (bfd_error_system_call);
0a1b45a2	49	return false;
252b5132 RH	50	}
252b5132 RH	51
864619bb KS	52	/* If both BFDs have identical build-ids, then they match. */
	53	if (core_bfd->build_id != NULL
	54	&& exec_bfd->build_id != NULL
	55	&& core_bfd->build_id->size == exec_bfd->build_id->size
	56	&& memcmp (core_bfd->build_id->data, exec_bfd->build_id->data,
	57	core_bfd->build_id->size) == 0)
0a1b45a2	58	return true;
864619bb	59
3e932841	60	/* See if the name in the corefile matches the executable name. */
228e534f	61	corename = elf_tdata (core_bfd)->core->program;
252b5132 RH	62	if (corename != NULL)
252b5132 RH	63	{
765cf5f6	64	const char* execname = strrchr (bfd_get_filename (exec_bfd), '/');
3193e234	65
765cf5f6	66	execname = execname ? execname + 1 : bfd_get_filename (exec_bfd);
252b5132	67
268b6b39	68	if (strcmp (execname, corename) != 0)
0a1b45a2	69	return false;
252b5132 RH	70	}
252b5132 RH	71
0a1b45a2	72	return true;
252b5132 RH	73	}
252b5132 RH	74
252b5132 RH	75	/* Core files are simply standard ELF formatted files that partition
	76	the file using the execution view of the file (program header table)
	77	rather than the linking view. In fact, there is no section header
	78	table in a core file.
	79
	80	The process status information (including the contents of the general
	81	register set) and the floating point register set are stored in a
	82	segment of type PT_NOTE. We handcraft a couple of extra bfd sections
	83	that allow standard bfd access to the general registers (.reg) and the
3193e234	84	floating point registers (.reg2). */
252b5132	85
cb001c0d	86	bfd_cleanup
268b6b39	87	elf_core_file_p (bfd *abfd)
252b5132	88	{
3193e234 NC	89	Elf_External_Ehdr x_ehdr; /* Elf file header, external form. */
	90	Elf_Internal_Ehdr i_ehdrp; / Elf file header, internal form. */
	91	Elf_Internal_Phdr i_phdrp; / Elf program header, internal form. */
252b5132	92	unsigned int phindex;
9c5bfbb7	93	const struct elf_backend_data *ebd;
dc810e39	94	bfd_size_type amt;
c45c3dba	95	ufile_ptr filesize;
252b5132 RH	96
252b5132 RH	97	/* Read in the ELF header in external format. */
268b6b39	98	if (bfd_bread (&x_ehdr, sizeof (x_ehdr), abfd) != sizeof (x_ehdr))
252b5132 RH	99	{
252b5132 RH	100	if (bfd_get_error () != bfd_error_system_call)
a7f84125 AM	101	goto wrong;
	102	else
	103	goto fail;
252b5132 RH	104	}
252b5132 RH	105
3e932841	106	/* Check the magic number. */
82e51918	107	if (! elf_file_p (&x_ehdr))
60bcf0fa	108	goto wrong;
252b5132	109
3193e234	110	/* FIXME: Check EI_VERSION here ! */
252b5132	111
3e932841	112	/* Check the address size ("class"). */
252b5132 RH	113	if (x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
	114	goto wrong;
	115
3e932841	116	/* Check the byteorder. */
252b5132 RH	117	switch (x_ehdr.e_ident[EI_DATA])
252b5132 RH	118	{
3193e234	119	case ELFDATA2MSB: /* Big-endian. */
252b5132 RH	120	if (! bfd_big_endian (abfd))
	121	goto wrong;
	122	break;
3193e234	123	case ELFDATA2LSB: /* Little-endian. */
252b5132 RH	124	if (! bfd_little_endian (abfd))
	125	goto wrong;
	126	break;
	127	default:
	128	goto wrong;
	129	}
	130
0c83546a AM	131	/* Give abfd an elf_obj_tdata. */
	132	if (! (*abfd->xvec->_bfd_set_format[bfd_core]) (abfd))
	133	goto fail;
a7f84125	134
3e932841	135	/* Swap in the rest of the header, now that we have the byte order. */
252b5132 RH	136	i_ehdrp = elf_elfheader (abfd);
	137	elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
	138
	139	#if DEBUG & 1
	140	elf_debug_file (i_ehdrp);
	141	#endif
	142
	143	ebd = get_elf_backend_data (abfd);
	144
	145	/* Check that the ELF e_machine field matches what this particular
	146	BFD format expects. */
	147
	148	if (ebd->elf_machine_code != i_ehdrp->e_machine
	149	&& (ebd->elf_machine_alt1 == 0
	150	\|\| i_ehdrp->e_machine != ebd->elf_machine_alt1)
	151	&& (ebd->elf_machine_alt2 == 0
8ad7c8be AM	152	\|\| i_ehdrp->e_machine != ebd->elf_machine_alt2)
	153	&& ebd->elf_machine_code != EM_NONE)
	154	goto wrong;
476288fa	155
8ad7c8be AM	156	if (ebd->elf_machine_code != EM_NONE
	157	&& i_ehdrp->e_ident[EI_OSABI] != ebd->elf_osabi
	158	&& ebd->elf_osabi != ELFOSABI_NONE)
	159	goto wrong;
252b5132 RH	160
252b5132 RH	161	/* If there is no program header, or the type is not a core file, then
3e932841	162	we are hosed. */
252b5132 RH	163	if (i_ehdrp->e_phoff == 0 \|\| i_ehdrp->e_type != ET_CORE)
	164	goto wrong;
	165
	166	/* Does BFD's idea of the phdr size match the size
	167	recorded in the file? */
	168	if (i_ehdrp->e_phentsize != sizeof (Elf_External_Phdr))
	169	goto wrong;
	170
ecd12bc1 AM	171	/* If the program header count is PN_XNUM(0xffff), the actual
	172	count is in the first section header. */
	173	if (i_ehdrp->e_shoff != 0 && i_ehdrp->e_phnum == PN_XNUM)
	174	{
	175	Elf_External_Shdr x_shdr;
	176	Elf_Internal_Shdr i_shdr;
b32a5c16	177	file_ptr where = (file_ptr) i_ehdrp->e_shoff;
ecd12bc1	178
8ad7c8be AM	179	if (i_ehdrp->e_shoff < sizeof (x_ehdr))
	180	goto wrong;
	181
ecd12bc1	182	/* Seek to the section header table in the file. */
b32a5c16	183	if (bfd_seek (abfd, where, SEEK_SET) != 0)
ecd12bc1 AM	184	goto fail;
	185
	186	/* Read the first section header at index 0, and convert to internal
	187	form. */
	188	if (bfd_bread (&x_shdr, sizeof (x_shdr), abfd) != sizeof (x_shdr))
	189	goto fail;
	190	elf_swap_shdr_in (abfd, &x_shdr, &i_shdr);
	191
	192	if (i_shdr.sh_info != 0)
	193	{
	194	i_ehdrp->e_phnum = i_shdr.sh_info;
	195	if (i_ehdrp->e_phnum != i_shdr.sh_info)
	196	goto wrong;
	197	}
	198	}
	199
	200	/* Sanity check that we can read all of the program headers.
	201	It ought to be good enough to just read the last one. */
	202	if (i_ehdrp->e_phnum > 1)
	203	{
	204	Elf_External_Phdr x_phdr;
	205	Elf_Internal_Phdr i_phdr;
b32a5c16	206	file_ptr where;
ecd12bc1 AM	207
	208	/* Check that we don't have a totally silly number of
	209	program headers. */
	210	if (i_ehdrp->e_phnum > (unsigned int) -1 / sizeof (x_phdr)
	211	\|\| i_ehdrp->e_phnum > (unsigned int) -1 / sizeof (i_phdr))
	212	goto wrong;
	213
b32a5c16	214	where = (file_ptr)(i_ehdrp->e_phoff + (i_ehdrp->e_phnum - 1) * sizeof (x_phdr));
ecd12bc1 AM	215	if ((bfd_size_type) where <= i_ehdrp->e_phoff)
	216	goto wrong;
	217
b32a5c16	218	if (bfd_seek (abfd, where, SEEK_SET) != 0)
ecd12bc1 AM	219	goto fail;
	220	if (bfd_bread (&x_phdr, sizeof (x_phdr), abfd) != sizeof (x_phdr))
	221	goto fail;
	222	}
	223
d20966a7	224	/* Move to the start of the program headers. */
dc810e39	225	if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
d20966a7	226	goto wrong;
3e932841 KH	227
3e932841 KH	228	/* Allocate space for the program headers. */
dc810e39	229	amt = sizeof (i_phdrp) i_ehdrp->e_phnum;
a50b1753	230	i_phdrp = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
252b5132	231	if (!i_phdrp)
0ab2f69a	232	goto fail;
252b5132 RH	233
	234	elf_tdata (abfd)->phdr = i_phdrp;
	235
3e932841	236	/* Read and convert to internal form. */
252b5132 RH	237	for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
	238	{
	239	Elf_External_Phdr x_phdr;
3193e234	240
268b6b39	241	if (bfd_bread (&x_phdr, sizeof (x_phdr), abfd) != sizeof (x_phdr))
0ab2f69a	242	goto fail;
252b5132 RH	243
	244	elf_swap_phdr_in (abfd, &x_phdr, i_phdrp + phindex);
	245	}
	246
702248bb JT	247	/* Set the machine architecture. Do this before processing the
	248	program headers since we need to know the architecture type
	249	when processing the notes of some systems' core files. */
5cba516c	250	if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0)
252b5132	251	/* It's OK if this fails for the generic target. */
5cba516c NC	252	&& ebd->elf_machine_code != EM_NONE)
	253	goto fail;
	254
	255	/* Let the backend double check the format and override global
	256	information. We do this before processing the program headers
	257	to allow the correct machine (as opposed to just the default
	258	machine) to be set, making it possible for grok_prstatus and
	259	grok_psinfo to rely on the mach setting. */
	260	if (ebd->elf_backend_object_p != NULL
	261	&& ! ebd->elf_backend_object_p (abfd))
	262	goto wrong;
252b5132	263
a94cef6a JT	264	/* Process each program header. */
a94cef6a JT	265	for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
3193e234 NC	266	if (! bfd_section_from_phdr (abfd, i_phdrp + phindex, (int) phindex))
3193e234 NC	267	goto fail;
a94cef6a	268
536d0ff4	269	/* Check for core truncation. */
c45c3dba AM	270	filesize = bfd_get_file_size (abfd);
	271	if (filesize != 0)
	272	{
	273	for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
	274	{
	275	Elf_Internal_Phdr *p = i_phdrp + phindex;
	276	if (p->p_filesz
	277	&& (p->p_offset >= filesize
	278	\|\| p->p_filesz > filesize - p->p_offset))
	279	{
	280	_bfd_error_handler (_("warning: %pB has a segment "
	281	"extending past end of file"), abfd);
	282	abfd->read_only = 1;
	283	break;
	284	}
536d0ff4 AM	285	}
536d0ff4 AM	286	}
68ffbac6	287
3e932841	288	/* Save the entry point from the ELF header. */
ed48ec2e	289	abfd->start_address = i_ehdrp->e_entry;
cb001c0d	290	return _bfd_no_cleanup;
0ab2f69a	291
dc1e8a47	292	wrong:
0ab2f69a	293	bfd_set_error (bfd_error_wrong_format);
dc1e8a47	294	fail:
0ab2f69a	295	return NULL;
252b5132	296	}
864619bb KS	297
	298	/* Attempt to find a build-id in a core file from the core file BFD.
	299	OFFSET is the file offset to a PT_LOAD segment that may contain
	300	the build-id note. Returns TRUE upon success, FALSE otherwise. */
	301
0a1b45a2	302	bool
864619bb KS	303	NAME(_bfd_elf, core_find_build_id)
	304	(bfd *abfd,
	305	bfd_vma offset)
	306	{
	307	Elf_External_Ehdr x_ehdr; /* Elf file header, external form. */
	308	Elf_Internal_Ehdr i_ehdr; /* Elf file header, internal form. */
	309	Elf_Internal_Phdr *i_phdr;
	310	unsigned int i;
1f4361a7	311	size_t amt;
864619bb KS	312
	313	/* Seek to the position of the segment at OFFSET. */
	314	if (bfd_seek (abfd, offset, SEEK_SET) != 0)
	315	goto fail;
	316
	317	/* Read in the ELF header in external format. */
	318	if (bfd_bread (&x_ehdr, sizeof (x_ehdr), abfd) != sizeof (x_ehdr))
	319	{
	320	if (bfd_get_error () != bfd_error_system_call)
	321	goto wrong;
	322	else
	323	goto fail;
	324	}
	325
	326	/* Now check to see if we have a valid ELF file, and one that BFD can
	327	make use of. The magic number must match, the address size ('class')
	328	and byte-swapping must match our XVEC entry, and it must have a
	329	section header table (FIXME: See comments re sections at top of this
	330	file). */
	331	if (! elf_file_p (&x_ehdr)
	332	\|\| x_ehdr.e_ident[EI_VERSION] != EV_CURRENT
	333	\|\| x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
	334	goto wrong;
	335
	336	/* Check that file's byte order matches xvec's. */
	337	switch (x_ehdr.e_ident[EI_DATA])
	338	{
	339	case ELFDATA2MSB: /* Big-endian. */
	340	if (! bfd_header_big_endian (abfd))
	341	goto wrong;
	342	break;
	343	case ELFDATA2LSB: /* Little-endian. */
	344	if (! bfd_header_little_endian (abfd))
	345	goto wrong;
	346	break;
	347	case ELFDATANONE: /* No data encoding specified. */
	348	default: /* Unknown data encoding specified . */
	349	goto wrong;
	350	}
	351
	352	elf_swap_ehdr_in (abfd, &x_ehdr, &i_ehdr);
	353	#if DEBUG
	354	elf_debug_file (&i_ehdr);
	355	#endif
	356
	357	if (i_ehdr.e_phentsize != sizeof (Elf_External_Phdr) \|\| i_ehdr.e_phnum == 0)
	358	goto fail;
	359
	360	/* Read in program headers. */
1f4361a7 AM	361	if (_bfd_mul_overflow (i_ehdr.e_phnum, sizeof (*i_phdr), &amt))
	362	{
	363	bfd_set_error (bfd_error_file_too_big);
	364	goto fail;
	365	}
	366	i_phdr = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
864619bb KS	367	if (i_phdr == NULL)
	368	goto fail;
	369
	370	if (bfd_seek (abfd, (file_ptr) (offset + i_ehdr.e_phoff), SEEK_SET) != 0)
	371	goto fail;
	372
	373	/* Read in program headers and parse notes. */
	374	for (i = 0; i < i_ehdr.e_phnum; ++i, ++i_phdr)
	375	{
	376	Elf_External_Phdr x_phdr;
	377
	378	if (bfd_bread (&x_phdr, sizeof (x_phdr), abfd) != sizeof (x_phdr))
	379	goto fail;
	380	elf_swap_phdr_in (abfd, &x_phdr, i_phdr);
	381
	382	if (i_phdr->p_type == PT_NOTE && i_phdr->p_filesz > 0)
	383	{
	384	elf_read_notes (abfd, offset + i_phdr->p_offset,
	385	i_phdr->p_filesz, i_phdr->p_align);
ff5b3e14 KS	386
	387	/* Make sure ABFD returns to processing the program headers. */
	388	if (bfd_seek (abfd, (file_ptr) (offset + i_ehdr.e_phoff
	389	+ (i + 1) * sizeof (x_phdr)),
	390	SEEK_SET) != 0)
	391	goto fail;
	392
864619bb	393	if (abfd->build_id != NULL)
0a1b45a2	394	return true;
864619bb KS	395	}
	396	}
	397
	398	/* Having gotten this far, we have a valid ELF section, but no
	399	build-id was found. */
	400	goto fail;
	401
dc1e8a47	402	wrong:
864619bb	403	bfd_set_error (bfd_error_wrong_format);
dc1e8a47	404	fail:
0a1b45a2	405	return false;
864619bb	406	}