[deliverable/binutils-gdb.git] / libctf / ctf-open-bfd.c

/* Opening CTF files with BFD.
   Copyright (C) 2019-2020 Free Software Foundation, Inc.

   This file is part of libctf.

   libctf 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, 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; see the file COPYING.  If not see
   <http://www.gnu.org/licenses/>.  */

#include <ctf-impl.h>
#include <stddef.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <elf.h>
#include <bfd.h>
#include "swap.h"
#include "ctf-endian.h"

#include "elf-bfd.h"

/* Make a new struct ctf_archive_internal wrapper for a ctf_archive or a
   ctf_file.  Closes ARC and/or FP on error.  Arrange to free the SYMSECT or
   STRSECT, as needed, on close (though the STRSECT interior is bound to the bfd
   * and is not actually freed by this machinery).  */

static struct ctf_archive_internal *
ctf_new_archive_internal (int is_archive, struct ctf_archive *arc,
			  ctf_file_t *fp, const ctf_sect_t *symsect,
			  const ctf_sect_t *strsect,
			  int *errp)
{
  struct ctf_archive_internal *arci;

  if ((arci = calloc (1, sizeof (struct ctf_archive_internal))) == NULL)
    {
      if (is_archive)
	ctf_arc_close_internal (arc);
      else
	ctf_file_close (fp);
      return (ctf_set_open_errno (errp, errno));
    }
  arci->ctfi_is_archive = is_archive;
  if (is_archive)
    arci->ctfi_archive = arc;
  else
    arci->ctfi_file = fp;
  if (symsect)
     memcpy (&arci->ctfi_symsect, symsect, sizeof (struct ctf_sect));
  if (strsect)
     memcpy (&arci->ctfi_strsect, strsect, sizeof (struct ctf_sect));

  return arci;
}

/* Free the BFD bits of a CTF file on ctf_arc_close().  */

static void
ctf_bfdclose (struct ctf_archive_internal *arci)
{
  if (arci->ctfi_abfd != NULL)
    if (!bfd_close_all_done (arci->ctfi_abfd))
      ctf_dprintf ("Cannot close BFD: %s\n", bfd_errmsg (bfd_get_error()));
}

/* Open a CTF file given the specified BFD.  */

ctf_archive_t *
ctf_bfdopen (struct bfd *abfd, int *errp)
{
  ctf_archive_t *arc;
  asection *ctf_asect;
  bfd_byte *contents;
  ctf_sect_t ctfsect;

  libctf_init_debug();

  if ((ctf_asect = bfd_get_section_by_name (abfd, _CTF_SECTION)) == NULL)
    {
      return (ctf_set_open_errno (errp, ECTF_NOCTFDATA));
    }

  if (!bfd_malloc_and_get_section (abfd, ctf_asect, &contents))
    {
      ctf_dprintf ("ctf_bfdopen(): cannot malloc CTF section: %s\n",
		   bfd_errmsg (bfd_get_error()));
      return (ctf_set_open_errno (errp, ECTF_FMT));
    }

  ctfsect.cts_name = _CTF_SECTION;
  ctfsect.cts_entsize = 1;
  ctfsect.cts_size = bfd_section_size (ctf_asect);
  ctfsect.cts_data = contents;

  if ((arc = ctf_bfdopen_ctfsect (abfd, &ctfsect, errp)) != NULL)
    {
      arc->ctfi_data = (void *) ctfsect.cts_data;
      return arc;
    }

  free (contents);
  return NULL;				/* errno is set for us.  */
}

/* Open a CTF file given the specified BFD and CTF section (which may contain a
   CTF archive or a file).  Takes ownership of the ctfsect, and frees it
   later.  */

ctf_archive_t *
ctf_bfdopen_ctfsect (struct bfd *abfd _libctf_unused_,
		     const ctf_sect_t *ctfsect, int *errp)
{
  struct ctf_archive *arc = NULL;
  ctf_archive_t *arci;
  ctf_file_t *fp = NULL;
  ctf_sect_t *symsectp = NULL;
  ctf_sect_t *strsectp = NULL;
  const char *bfderrstr = NULL;
  int is_archive;

#ifdef HAVE_BFD_ELF
  ctf_sect_t symsect, strsect;
  Elf_Internal_Shdr *strhdr;
  Elf_Internal_Shdr *symhdr = &elf_symtab_hdr (abfd);
  size_t symcount = symhdr->sh_size / symhdr->sh_entsize;
  Elf_Internal_Sym *isymbuf;
  bfd_byte *symtab;
  const char *strtab = NULL;
  /* TODO: handle SYMTAB_SHNDX.  */

  if ((symtab = malloc (symhdr->sh_size)) == NULL)
    {
      bfderrstr = "Cannot malloc symbol table";
      goto err;
    }

  isymbuf = bfd_elf_get_elf_syms (abfd, symhdr, symcount, 0,
				  NULL, symtab, NULL);
  free (isymbuf);
  if (isymbuf == NULL)
    {
      bfderrstr = "Cannot read symbol table";
      goto err_free_sym;
    }

  if (elf_elfsections (abfd) != NULL
      && symhdr->sh_link < elf_numsections (abfd))
    {
      strhdr = elf_elfsections (abfd)[symhdr->sh_link];
      if (strhdr->contents == NULL)
	{
	  if ((strtab = bfd_elf_get_str_section (abfd, symhdr->sh_link)) == NULL)
	    {
	      bfderrstr = "Cannot read string table";
	      goto err_free_sym;
	    }
	}
      else
	strtab = (const char *) strhdr->contents;
    }

  if (strtab)
    {
      /* The names here are more or less arbitrary, but there is no point
	 thrashing around digging the name out of the shstrtab given that we don't
	 use it for anything but debugging.  */

      strsect.cts_data = strtab;
      strsect.cts_name = ".strtab";
      strsect.cts_size = strhdr->sh_size;
      strsectp = &strsect;

      assert (symhdr->sh_entsize == get_elf_backend_data (abfd)->s->sizeof_sym);
      symsect.cts_name = ".symtab";
      symsect.cts_entsize = symhdr->sh_entsize;
      symsect.cts_size = symhdr->sh_size;
      symsect.cts_data = symtab;
      symsectp = &symsect;
    }
#endif

  if (ctfsect->cts_size > sizeof (uint64_t) &&
      ((*(uint64_t *) ctfsect->cts_data) == CTFA_MAGIC))
    {
      is_archive = 1;
      if ((arc = ctf_arc_bufopen ((void *) ctfsect->cts_data,
				  ctfsect->cts_size, errp)) == NULL)
	goto err_free_str;
    }
  else
    {
      is_archive = 0;
      if ((fp = ctf_bufopen (ctfsect, symsectp, strsectp, errp)) == NULL)
	{
	  ctf_dprintf ("ctf_internal_open(): cannot open CTF: %s\n",
		       ctf_errmsg (*errp));
	  goto err_free_str;
	}
    }
  arci = ctf_new_archive_internal (is_archive, arc, fp, symsectp, strsectp,
				   errp);

  if (arci)
    return arci;
 err_free_str: ;
#ifdef HAVE_BFD_ELF
 err_free_sym:
  free (symtab);
#endif
err: _libctf_unused_;
  if (bfderrstr)
    {
      ctf_dprintf ("ctf_bfdopen(): %s: %s\n", bfderrstr,
		   bfd_errmsg (bfd_get_error()));
      ctf_set_open_errno (errp, ECTF_FMT);
    }
  return NULL;
}

/* Open the specified file descriptor and return a pointer to a CTF archive that
   contains one or more CTF containers.  The file can be an ELF file, a raw CTF
   file, or a CTF archive.  The caller is responsible for closing the file
   descriptor when it is no longer needed.  If this is an ELF file, TARGET, if
   non-NULL, should be the name of a suitable BFD target.  */

ctf_archive_t *
ctf_fdopen (int fd, const char *filename, const char *target, int *errp)
{
  ctf_archive_t *arci;
  bfd *abfd;
  int nfd;

  struct stat st;
  ssize_t nbytes;

  ctf_preamble_t ctfhdr;
  uint64_t arc_magic;

  memset (&ctfhdr, 0, sizeof (ctfhdr));

  libctf_init_debug();

  if (fstat (fd, &st) == -1)
    return (ctf_set_open_errno (errp, errno));

  if ((nbytes = ctf_pread (fd, &ctfhdr, sizeof (ctfhdr), 0)) <= 0)
    return (ctf_set_open_errno (errp, nbytes < 0 ? errno : ECTF_FMT));

  /* If we have read enough bytes to form a CTF header and the magic string
     matches, in either endianness, attempt to interpret the file as raw
     CTF.  */

  if ((size_t) nbytes >= sizeof (ctf_preamble_t)
      && (ctfhdr.ctp_magic == CTF_MAGIC
	  || ctfhdr.ctp_magic == bswap_16 (CTF_MAGIC)))
    {
      ctf_file_t *fp = NULL;
      void *data;

      if ((data = ctf_mmap (st.st_size, 0, fd)) == NULL)
	return (ctf_set_open_errno (errp, errno));

      if ((fp = ctf_simple_open (data, (size_t) st.st_size, NULL, 0, 0,
				 NULL, 0, errp)) == NULL)
	{
	  ctf_munmap (data, (size_t) st.st_size);
	  return NULL;			/* errno is set for us.  */
	}

      fp->ctf_data_mmapped = data;
      fp->ctf_data_mmapped_len = (size_t) st.st_size;

      return ctf_new_archive_internal (0, NULL, fp, NULL, NULL, errp);
    }

  if ((nbytes = ctf_pread (fd, &arc_magic, sizeof (arc_magic), 0)) <= 0)
    return (ctf_set_open_errno (errp, nbytes < 0 ? errno : ECTF_FMT));

  if ((size_t) nbytes >= sizeof (uint64_t) && le64toh (arc_magic) == CTFA_MAGIC)
    {
      struct ctf_archive *arc;

      if ((arc = ctf_arc_open_internal (filename, errp)) == NULL)
	return NULL;			/* errno is set for us.  */

      return ctf_new_archive_internal (1, arc, NULL, NULL, NULL, errp);
    }

  /* Attempt to open the file with BFD.  We must dup the fd first, since bfd
     takes ownership of the passed fd.  */

  if ((nfd = dup (fd)) < 0)
      return (ctf_set_open_errno (errp, errno));

  if ((abfd = bfd_fdopenr (filename, target, nfd)) == NULL)
    {
      ctf_dprintf ("Cannot open BFD from %s: %s\n",
		   filename ? filename : "(unknown file)",
		   bfd_errmsg (bfd_get_error()));
      return (ctf_set_open_errno (errp, ECTF_FMT));
    }
  bfd_set_cacheable (abfd, 1);

  if (!bfd_check_format (abfd, bfd_object))
    {
      ctf_dprintf ("BFD format problem in %s: %s\n",
		   filename ? filename : "(unknown file)",
		   bfd_errmsg (bfd_get_error()));
      if (bfd_get_error() == bfd_error_file_ambiguously_recognized)
	return (ctf_set_open_errno (errp, ECTF_BFD_AMBIGUOUS));
      else
	return (ctf_set_open_errno (errp, ECTF_FMT));
    }

  if ((arci = ctf_bfdopen (abfd, errp)) == NULL)
    {
      if (!bfd_close_all_done (abfd))
	ctf_dprintf ("Cannot close BFD: %s\n", bfd_errmsg (bfd_get_error()));
      return NULL;			/* errno is set for us.  */
    }
  arci->ctfi_bfd_close = ctf_bfdclose;
  arci->ctfi_abfd = abfd;

  return arci;
}

/* Open the specified file and return a pointer to a CTF container.  The file
   can be either an ELF file or raw CTF file.  This is just a convenient
   wrapper around ctf_fdopen() for callers.  */

ctf_archive_t *
ctf_open (const char *filename, const char *target, int *errp)
{
  ctf_archive_t *arc;
  int fd;

  if ((fd = open (filename, O_RDONLY)) == -1)
    {
      if (errp != NULL)
	*errp = errno;
      return NULL;
    }

  arc = ctf_fdopen (fd, filename, target, errp);
  (void) close (fd);
  return arc;
}

/* Public entry point: open a CTF archive, or CTF file.  Returns the archive, or
   NULL and an error in *err.  Despite the fact that this uses CTF archives, it
   must be in this file to avoid dragging in BFD into non-BFD-using programs.  */
ctf_archive_t *
ctf_arc_open (const char *filename, int *errp)
{
  return ctf_open (filename, NULL, errp);
}
Commit	Line	Data
143dce84	1	/* Opening CTF files with BFD.
b3adc24a	2	Copyright (C) 2019-2020 Free Software Foundation, Inc.
143dce84 NA	3
	4	This file is part of libctf.
	5
	6	libctf is free software; you can redistribute it and/or modify it under
	7	the terms of the GNU General Public License as published by the Free
	8	Software Foundation; either version 3, or (at your option) any later
	9	version.
	10
	11	This program is distributed in the hope that it will be useful, but
	12	WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
	14	See the GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with this program; see the file COPYING. If not see
	18	<http://www.gnu.org/licenses/>. */
	19
	20	#include <ctf-impl.h>
	21	#include <stddef.h>
6d5944fc	22	#include <assert.h>
143dce84 NA	23	#include <sys/types.h>
	24	#include <sys/stat.h>
	25	#include <errno.h>
	26	#include <string.h>
	27	#include <fcntl.h>
	28	#include <elf.h>
	29	#include <bfd.h>
cf02c44d NA	30	#include "swap.h"
cf02c44d NA	31	#include "ctf-endian.h"
143dce84 NA	32
	33	#include "elf-bfd.h"
	34
	35	/* Make a new struct ctf_archive_internal wrapper for a ctf_archive or a
6d5944fc NA	36	ctf_file. Closes ARC and/or FP on error. Arrange to free the SYMSECT or
	37	STRSECT, as needed, on close (though the STRSECT interior is bound to the bfd
	38	* and is not actually freed by this machinery). */
143dce84 NA	39
	40	static struct ctf_archive_internal *
	41	ctf_new_archive_internal (int is_archive, struct ctf_archive *arc,
	42	ctf_file_t fp, const ctf_sect_t symsect,
	43	const ctf_sect_t *strsect,
	44	int *errp)
	45	{
	46	struct ctf_archive_internal *arci;
	47
	48	if ((arci = calloc (1, sizeof (struct ctf_archive_internal))) == NULL)
	49	{
	50	if (is_archive)
	51	ctf_arc_close_internal (arc);
	52	else
	53	ctf_file_close (fp);
	54	return (ctf_set_open_errno (errp, errno));
	55	}
	56	arci->ctfi_is_archive = is_archive;
	57	if (is_archive)
	58	arci->ctfi_archive = arc;
	59	else
	60	arci->ctfi_file = fp;
	61	if (symsect)
	62	memcpy (&arci->ctfi_symsect, symsect, sizeof (struct ctf_sect));
	63	if (strsect)
	64	memcpy (&arci->ctfi_strsect, strsect, sizeof (struct ctf_sect));
	65
	66	return arci;
	67	}
	68
f046147d	69	/* Free the BFD bits of a CTF file on ctf_arc_close(). */
143dce84 NA	70
	71	static void
	72	ctf_bfdclose (struct ctf_archive_internal *arci)
	73	{
	74	if (arci->ctfi_abfd != NULL)
	75	if (!bfd_close_all_done (arci->ctfi_abfd))
	76	ctf_dprintf ("Cannot close BFD: %s\n", bfd_errmsg (bfd_get_error()));
	77	}
	78
	79	/* Open a CTF file given the specified BFD. */
	80
	81	ctf_archive_t *
	82	ctf_bfdopen (struct bfd abfd, int errp)
	83	{
	84	ctf_archive_t *arc;
	85	asection *ctf_asect;
	86	bfd_byte *contents;
	87	ctf_sect_t ctfsect;
	88
	89	libctf_init_debug();
	90
	91	if ((ctf_asect = bfd_get_section_by_name (abfd, _CTF_SECTION)) == NULL)
	92	{
	93	return (ctf_set_open_errno (errp, ECTF_NOCTFDATA));
	94	}
	95
	96	if (!bfd_malloc_and_get_section (abfd, ctf_asect, &contents))
	97	{
	98	ctf_dprintf ("ctf_bfdopen(): cannot malloc CTF section: %s\n",
	99	bfd_errmsg (bfd_get_error()));
	100	return (ctf_set_open_errno (errp, ECTF_FMT));
	101	}
	102
	103	ctfsect.cts_name = _CTF_SECTION;
143dce84	104	ctfsect.cts_entsize = 1;
fd361982	105	ctfsect.cts_size = bfd_section_size (ctf_asect);
143dce84 NA	106	ctfsect.cts_data = contents;
	107
	108	if ((arc = ctf_bfdopen_ctfsect (abfd, &ctfsect, errp)) != NULL)
	109	{
	110	arc->ctfi_data = (void *) ctfsect.cts_data;
	111	return arc;
	112	}
	113
	114	free (contents);
	115	return NULL; /* errno is set for us. */
	116	}
	117
	118	/* Open a CTF file given the specified BFD and CTF section (which may contain a
	119	CTF archive or a file). Takes ownership of the ctfsect, and frees it
	120	later. */
	121
	122	ctf_archive_t *
9698cf9b NA	123	ctf_bfdopen_ctfsect (struct bfd *abfd _libctf_unused_,
9698cf9b NA	124	const ctf_sect_t ctfsect, int errp)
143dce84 NA	125	{
	126	struct ctf_archive *arc = NULL;
	127	ctf_archive_t *arci;
	128	ctf_file_t *fp = NULL;
	129	ctf_sect_t *symsectp = NULL;
	130	ctf_sect_t *strsectp = NULL;
	131	const char *bfderrstr = NULL;
	132	int is_archive;
	133
9698cf9b	134	#ifdef HAVE_BFD_ELF
143dce84	135	ctf_sect_t symsect, strsect;
6d5944fc NA	136	Elf_Internal_Shdr *strhdr;
	137	Elf_Internal_Shdr *symhdr = &elf_symtab_hdr (abfd);
	138	size_t symcount = symhdr->sh_size / symhdr->sh_entsize;
	139	Elf_Internal_Sym *isymbuf;
	140	bfd_byte *symtab;
	141	const char *strtab = NULL;
143dce84 NA	142	/* TODO: handle SYMTAB_SHNDX. */
143dce84 NA	143
6d5944fc	144	if ((symtab = malloc (symhdr->sh_size)) == NULL)
143dce84	145	{
6d5944fc NA	146	bfderrstr = "Cannot malloc symbol table";
	147	goto err;
	148	}
143dce84	149
6d5944fc NA	150	isymbuf = bfd_elf_get_elf_syms (abfd, symhdr, symcount, 0,
	151	NULL, symtab, NULL);
	152	free (isymbuf);
	153	if (isymbuf == NULL)
	154	{
	155	bfderrstr = "Cannot read symbol table";
	156	goto err_free_sym;
	157	}
143dce84	158
6d5944fc NA	159	if (elf_elfsections (abfd) != NULL
	160	&& symhdr->sh_link < elf_numsections (abfd))
	161	{
	162	strhdr = elf_elfsections (abfd)[symhdr->sh_link];
	163	if (strhdr->contents == NULL)
143dce84	164	{
6d5944fc	165	if ((strtab = bfd_elf_get_str_section (abfd, symhdr->sh_link)) == NULL)
143dce84	166	{
6d5944fc NA	167	bfderrstr = "Cannot read string table";
6d5944fc NA	168	goto err_free_sym;
143dce84	169	}
143dce84	170	}
6d5944fc NA	171	else
	172	strtab = (const char *) strhdr->contents;
	173	}
	174
	175	if (strtab)
	176	{
	177	/* The names here are more or less arbitrary, but there is no point
	178	thrashing around digging the name out of the shstrtab given that we don't
	179	use it for anything but debugging. */
	180
	181	strsect.cts_data = strtab;
	182	strsect.cts_name = ".strtab";
	183	strsect.cts_size = strhdr->sh_size;
	184	strsectp = &strsect;
	185
	186	assert (symhdr->sh_entsize == get_elf_backend_data (abfd)->s->sizeof_sym);
	187	symsect.cts_name = ".symtab";
	188	symsect.cts_entsize = symhdr->sh_entsize;
	189	symsect.cts_size = symhdr->sh_size;
	190	symsect.cts_data = symtab;
	191	symsectp = &symsect;
143dce84	192	}
9698cf9b	193	#endif
143dce84 NA	194
	195	if (ctfsect->cts_size > sizeof (uint64_t) &&
	196	(((uint64_t ) ctfsect->cts_data) == CTFA_MAGIC))
	197	{
	198	is_archive = 1;
	199	if ((arc = ctf_arc_bufopen ((void *) ctfsect->cts_data,
	200	ctfsect->cts_size, errp)) == NULL)
6d5944fc	201	goto err_free_str;
143dce84 NA	202	}
	203	else
	204	{
	205	is_archive = 0;
	206	if ((fp = ctf_bufopen (ctfsect, symsectp, strsectp, errp)) == NULL)
	207	{
	208	ctf_dprintf ("ctf_internal_open(): cannot open CTF: %s\n",
	209	ctf_errmsg (*errp));
6d5944fc	210	goto err_free_str;
143dce84 NA	211	}
	212	}
	213	arci = ctf_new_archive_internal (is_archive, arc, fp, symsectp, strsectp,
	214	errp);
	215
	216	if (arci)
	217	return arci;
6d5944fc	218	err_free_str: ;
9698cf9b	219	#ifdef HAVE_BFD_ELF
6d5944fc NA	220	err_free_sym:
6d5944fc NA	221	free (symtab);
9698cf9b	222	#endif
143dce84 NA	223	err: _libctf_unused_;
	224	if (bfderrstr)
	225	{
	226	ctf_dprintf ("ctf_bfdopen(): %s: %s\n", bfderrstr,
	227	bfd_errmsg (bfd_get_error()));
	228	ctf_set_open_errno (errp, ECTF_FMT);
	229	}
	230	return NULL;
	231	}
	232
	233	/* Open the specified file descriptor and return a pointer to a CTF archive that
	234	contains one or more CTF containers. The file can be an ELF file, a raw CTF
	235	file, or a CTF archive. The caller is responsible for closing the file
	236	descriptor when it is no longer needed. If this is an ELF file, TARGET, if
	237	non-NULL, should be the name of a suitable BFD target. */
	238
	239	ctf_archive_t *
	240	ctf_fdopen (int fd, const char filename, const char target, int *errp)
	241	{
	242	ctf_archive_t *arci;
	243	bfd *abfd;
	244	int nfd;
	245
	246	struct stat st;
	247	ssize_t nbytes;
	248
	249	ctf_preamble_t ctfhdr;
	250	uint64_t arc_magic;
	251
	252	memset (&ctfhdr, 0, sizeof (ctfhdr));
	253
	254	libctf_init_debug();
	255
	256	if (fstat (fd, &st) == -1)
	257	return (ctf_set_open_errno (errp, errno));
	258
	259	if ((nbytes = ctf_pread (fd, &ctfhdr, sizeof (ctfhdr), 0)) <= 0)
	260	return (ctf_set_open_errno (errp, nbytes < 0 ? errno : ECTF_FMT));
	261
cf02c44d NA	262	/* If we have read enough bytes to form a CTF header and the magic string
	263	matches, in either endianness, attempt to interpret the file as raw
	264	CTF. */
143dce84	265
cf02c44d NA	266	if ((size_t) nbytes >= sizeof (ctf_preamble_t)
	267	&& (ctfhdr.ctp_magic == CTF_MAGIC
	268	\|\| ctfhdr.ctp_magic == bswap_16 (CTF_MAGIC)))
143dce84 NA	269	{
	270	ctf_file_t *fp = NULL;
	271	void *data;
	272
143dce84 NA	273	if ((data = ctf_mmap (st.st_size, 0, fd)) == NULL)
	274	return (ctf_set_open_errno (errp, errno));
	275
	276	if ((fp = ctf_simple_open (data, (size_t) st.st_size, NULL, 0, 0,
	277	NULL, 0, errp)) == NULL)
cf02c44d NA	278	{
	279	ctf_munmap (data, (size_t) st.st_size);
	280	return NULL; /* errno is set for us. */
	281	}
	282
143dce84 NA	283	fp->ctf_data_mmapped = data;
	284	fp->ctf_data_mmapped_len = (size_t) st.st_size;
	285
	286	return ctf_new_archive_internal (0, NULL, fp, NULL, NULL, errp);
	287	}
	288
	289	if ((nbytes = ctf_pread (fd, &arc_magic, sizeof (arc_magic), 0)) <= 0)
	290	return (ctf_set_open_errno (errp, nbytes < 0 ? errno : ECTF_FMT));
	291
cf02c44d	292	if ((size_t) nbytes >= sizeof (uint64_t) && le64toh (arc_magic) == CTFA_MAGIC)
143dce84 NA	293	{
	294	struct ctf_archive *arc;
	295
	296	if ((arc = ctf_arc_open_internal (filename, errp)) == NULL)
	297	return NULL; /* errno is set for us. */
	298
	299	return ctf_new_archive_internal (1, arc, NULL, NULL, NULL, errp);
	300	}
	301
	302	/* Attempt to open the file with BFD. We must dup the fd first, since bfd
	303	takes ownership of the passed fd. */
	304
	305	if ((nfd = dup (fd)) < 0)
	306	return (ctf_set_open_errno (errp, errno));
	307
	308	if ((abfd = bfd_fdopenr (filename, target, nfd)) == NULL)
	309	{
	310	ctf_dprintf ("Cannot open BFD from %s: %s\n",
	311	filename ? filename : "(unknown file)",
	312	bfd_errmsg (bfd_get_error()));
	313	return (ctf_set_open_errno (errp, ECTF_FMT));
	314	}
edc8bbe9	315	bfd_set_cacheable (abfd, 1);
143dce84 NA	316
	317	if (!bfd_check_format (abfd, bfd_object))
	318	{
	319	ctf_dprintf ("BFD format problem in %s: %s\n",
	320	filename ? filename : "(unknown file)",
	321	bfd_errmsg (bfd_get_error()));
	322	if (bfd_get_error() == bfd_error_file_ambiguously_recognized)
	323	return (ctf_set_open_errno (errp, ECTF_BFD_AMBIGUOUS));
	324	else
	325	return (ctf_set_open_errno (errp, ECTF_FMT));
	326	}
	327
	328	if ((arci = ctf_bfdopen (abfd, errp)) == NULL)
	329	{
	330	if (!bfd_close_all_done (abfd))
	331	ctf_dprintf ("Cannot close BFD: %s\n", bfd_errmsg (bfd_get_error()));
	332	return NULL; /* errno is set for us. */
	333	}
	334	arci->ctfi_bfd_close = ctf_bfdclose;
	335	arci->ctfi_abfd = abfd;
	336
	337	return arci;
	338	}
	339
	340	/* Open the specified file and return a pointer to a CTF container. The file
	341	can be either an ELF file or raw CTF file. This is just a convenient
	342	wrapper around ctf_fdopen() for callers. */
	343
	344	ctf_archive_t *
	345	ctf_open (const char filename, const char target, int *errp)
	346	{
	347	ctf_archive_t *arc;
	348	int fd;
	349
	350	if ((fd = open (filename, O_RDONLY)) == -1)
	351	{
	352	if (errp != NULL)
	353	*errp = errno;
	354	return NULL;
	355	}
	356
	357	arc = ctf_fdopen (fd, filename, target, errp);
	358	(void) close (fd);
	359	return arc;
	360	}
	361
	362	/* Public entry point: open a CTF archive, or CTF file. Returns the archive, or
	363	NULL and an error in *err. Despite the fact that this uses CTF archives, it
	364	must be in this file to avoid dragging in BFD into non-BFD-using programs. */
	365	ctf_archive_t *
	366	ctf_arc_open (const char filename, int errp)
	367	{
	368	return ctf_open (filename, NULL, errp);
	369	}