[deliverable/binutils-gdb.git] / bfd / hppabsd-core.c

/* BFD back-end for HPPA BSD core files.
   Copyright 1993, 1994, 1995, 1998, 1999, 2001, 2002
   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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

   Written by the Center for Software Science at the University of Utah
   and by Cygnus Support.

   The core file structure for the Utah 4.3BSD and OSF1 ports on the
   PA is a mix between traditional cores and hpux cores -- just
   different enough that supporting this format would tend to add
   gross hacks to trad-core.c or hpux-core.c.  So instead we keep any
   gross hacks isolated to this file.  */

/* This file can only be compiled on systems which use HPPA-BSD style
   core files.

   I would not expect this to be of use to any other host/target, but
   you never know.  */

#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"

#if defined (HOST_HPPABSD)

#include "machine/vmparam.h"

#include <sys/param.h>
#include <sys/dir.h>
#include <signal.h>
#include <machine/reg.h>
#include <sys/user.h>		/* After a.out.h  */
#include <sys/file.h>

static asection *make_bfd_asection PARAMS ((bfd *, const char *,
					    flagword, bfd_size_type,
					    file_ptr, unsigned int));
static asymbol *hppabsd_core_make_empty_symbol PARAMS ((bfd *));
static const bfd_target *hppabsd_core_core_file_p PARAMS ((bfd *));
static char *hppabsd_core_core_file_failing_command PARAMS ((bfd *));
static int hppabsd_core_core_file_failing_signal PARAMS ((bfd *));
static boolean hppabsd_core_core_file_matches_executable_p
  PARAMS ((bfd *, bfd *));
static void swap_abort PARAMS ((void));

/* These are stored in the bfd's tdata.  */

struct hppabsd_core_struct
  {
    int sig;
    char cmd[MAXCOMLEN + 1];
    asection *data_section;
    asection *stack_section;
    asection *reg_section;
  };

#define core_hdr(bfd) ((bfd)->tdata.hppabsd_core_data)
#define core_signal(bfd) (core_hdr(bfd)->sig)
#define core_command(bfd) (core_hdr(bfd)->cmd)
#define core_datasec(bfd) (core_hdr(bfd)->data_section)
#define core_stacksec(bfd) (core_hdr(bfd)->stack_section)
#define core_regsec(bfd) (core_hdr(bfd)->reg_section)

static asection *
make_bfd_asection (abfd, name, flags, _raw_size, offset, alignment_power)
     bfd *abfd;
     const char *name;
     flagword flags;
     bfd_size_type _raw_size;
     file_ptr offset;
     unsigned int alignment_power;
{
  asection *asect;

  asect = bfd_make_section (abfd, name);
  if (!asect)
    return NULL;

  asect->flags = flags;
  asect->_raw_size = _raw_size;
  asect->filepos = offset;
  asect->alignment_power = alignment_power;

  return asect;
}

static asymbol *
hppabsd_core_make_empty_symbol (abfd)
     bfd *abfd;
{
  asymbol *new;

  new = (asymbol *) bfd_zalloc (abfd, (bfd_size_type) sizeof (asymbol));
  if (new)
    new->the_bfd = abfd;
  return new;
}

static const bfd_target *
hppabsd_core_core_file_p (abfd)
     bfd *abfd;
{
  int val;
  struct user u;
  struct hppabsd_core_struct *coredata;
  int clicksz;

  /* Try to read in the u-area.  We will need information from this
     to know how to grok the rest of the core structures.  */
  val = bfd_bread ((void *) &u, (bfd_size_type) sizeof u, abfd);
  if (val != sizeof u)
    {
      if (bfd_get_error () != bfd_error_system_call)
	bfd_set_error (bfd_error_wrong_format);
      return NULL;
    }

  /* Get the page size out of the u structure.  This will be different
     for PA 1.0 machines and PA 1.1 machines.   Yuk!  */
  clicksz = u.u_pcb.pcb_pgsz;

  /* clicksz must be a power of two >= 2k.  */
  if (clicksz < 0x800
      || clicksz != (clicksz & -clicksz))
    {
      bfd_set_error (bfd_error_wrong_format);
      return NULL;
    }

  /* Sanity checks.  Make sure the size of the core file matches the
     the size computed from information within the core itself.  */
  {
    FILE *stream = bfd_cache_lookup (abfd);
    struct stat statbuf;
    if (stream == NULL || fstat (fileno (stream), &statbuf) < 0)
      {
	bfd_set_error (bfd_error_system_call);
	return NULL;
      }
    if (NBPG * (UPAGES + u.u_dsize + u.u_ssize) > statbuf.st_size)
      {
	bfd_set_error (bfd_error_file_truncated);
	return NULL;
      }
    if (clicksz * (UPAGES + u.u_dsize + u.u_ssize) < statbuf.st_size)
      {
	/* The file is too big.  Maybe it's not a core file
	   or we otherwise have bad values for u_dsize and u_ssize).  */
	bfd_set_error (bfd_error_wrong_format);
	return NULL;
      }
  }

  /* OK, we believe you.  You're a core file (sure, sure).  */

  coredata = (struct hppabsd_core_struct *)
    bfd_zalloc (abfd, (bfd_size_type) sizeof (struct hppabsd_core_struct));
  if (!coredata)
    return NULL;

  /* Make the core data and available via the tdata part of the BFD.  */
  abfd->tdata.hppabsd_core_data = coredata;

  /* Create the sections.  */
  core_stacksec (abfd) = make_bfd_asection (abfd, ".stack",
					   SEC_ALLOC + SEC_HAS_CONTENTS,
					   clicksz * u.u_ssize,
					   NBPG * (USIZE + KSTAKSIZE)
					     + clicksz * u.u_dsize, 2);
  if (core_stacksec (abfd) == NULL)
    goto fail;
  core_stacksec (abfd)->vma = USRSTACK;

  core_datasec (abfd) = make_bfd_asection (abfd, ".data",
					  SEC_ALLOC + SEC_LOAD
					    + SEC_HAS_CONTENTS,
					  clicksz * u.u_dsize,
					  NBPG * (USIZE + KSTAKSIZE), 2);
  if (core_datasec (abfd) == NULL)
    goto fail;
  core_datasec (abfd)->vma = UDATASEG;

  core_regsec (abfd) = make_bfd_asection (abfd, ".reg",
					 SEC_HAS_CONTENTS,
					 KSTAKSIZE * NBPG,
					 NBPG * USIZE, 2);
  if (core_regsec (abfd) == NULL)
    goto fail;
  core_regsec (abfd)->vma = 0;

  strncpy (core_command (abfd), u.u_comm, MAXCOMLEN + 1);
  core_signal (abfd) = u.u_code;
  return abfd->xvec;

 fail:
  bfd_release (abfd, abfd->tdata.any);
  abfd->tdata.any = NULL;
  bfd_section_list_clear (abfd);
  return NULL;
}

static char *
hppabsd_core_core_file_failing_command (abfd)
     bfd *abfd;
{
  return core_command (abfd);
}

/* ARGSUSED */
static int
hppabsd_core_core_file_failing_signal (abfd)
     bfd *abfd;
{
  return core_signal (abfd);
}

/* ARGSUSED */
static boolean
hppabsd_core_core_file_matches_executable_p (core_bfd, exec_bfd)
     bfd *core_bfd, *exec_bfd;
{
  /* There's no way to know this...  */
  return true;
}
\f
#define hppabsd_core_get_symtab_upper_bound \
  _bfd_nosymbols_get_symtab_upper_bound
#define hppabsd_core_get_symtab _bfd_nosymbols_get_symtab
#define hppabsd_core_print_symbol _bfd_nosymbols_print_symbol
#define hppabsd_core_get_symbol_info _bfd_nosymbols_get_symbol_info
#define hppabsd_core_bfd_is_local_label_name \
  _bfd_nosymbols_bfd_is_local_label_name
#define hppabsd_core_get_lineno _bfd_nosymbols_get_lineno
#define hppabsd_core_find_nearest_line _bfd_nosymbols_find_nearest_line
#define hppabsd_core_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
#define hppabsd_core_read_minisymbols _bfd_nosymbols_read_minisymbols
#define hppabsd_core_minisymbol_to_symbol _bfd_nosymbols_minisymbol_to_symbol

/* If somebody calls any byte-swapping routines, shoot them.  */
static void
swap_abort ()
{
  /* This way doesn't require any declaration for ANSI to fuck up.  */
  abort ();
}

#define	NO_GET	((bfd_vma (*) PARAMS ((   const bfd_byte *))) swap_abort )
#define	NO_PUT	((void    (*) PARAMS ((bfd_vma, bfd_byte *))) swap_abort )
#define	NO_SIGNED_GET \
  ((bfd_signed_vma (*) PARAMS ((const bfd_byte *))) swap_abort )

const bfd_target hppabsd_core_vec =
  {
    "hppabsd-core",
    bfd_target_unknown_flavour,
    BFD_ENDIAN_BIG,		/* target byte order */
    BFD_ENDIAN_BIG,		/* target headers byte order */
    (HAS_RELOC | EXEC_P |	/* object flags */
     HAS_LINENO | HAS_DEBUG |
     HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
    (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
    0,			                                   /* symbol prefix */
    ' ',						   /* ar_pad_char */
    16,							   /* ar_max_namelen */
    NO_GET, NO_SIGNED_GET, NO_PUT,	/* 64 bit data */
    NO_GET, NO_SIGNED_GET, NO_PUT,	/* 32 bit data */
    NO_GET, NO_SIGNED_GET, NO_PUT,	/* 16 bit data */
    NO_GET, NO_SIGNED_GET, NO_PUT,	/* 64 bit hdrs */
    NO_GET, NO_SIGNED_GET, NO_PUT,	/* 32 bit hdrs */
    NO_GET, NO_SIGNED_GET, NO_PUT,	/* 16 bit hdrs */

    {				/* bfd_check_format */
     _bfd_dummy_target,		/* unknown format */
     _bfd_dummy_target,		/* object file */
     _bfd_dummy_target,		/* archive */
     hppabsd_core_core_file_p	/* a core file */
    },
    {				/* bfd_set_format */
     bfd_false, bfd_false,
     bfd_false, bfd_false
    },
    {				/* bfd_write_contents */
     bfd_false, bfd_false,
     bfd_false, bfd_false
    },

       BFD_JUMP_TABLE_GENERIC (_bfd_generic),
       BFD_JUMP_TABLE_COPY (_bfd_generic),
       BFD_JUMP_TABLE_CORE (hppabsd_core),
       BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
       BFD_JUMP_TABLE_SYMBOLS (hppabsd_core),
       BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
       BFD_JUMP_TABLE_WRITE (_bfd_generic),
       BFD_JUMP_TABLE_LINK (_bfd_nolink),
       BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),

    NULL,

    (PTR) 0			/* backend_data */
};
#endif
Commit	Line	Data
252b5132	1	/* BFD back-end for HPPA BSD core files.
9e7b37b3	2	Copyright 1993, 1994, 1995, 1998, 1999, 2001, 2002
7898deda	3	Free Software Foundation, Inc.
252b5132 RH	4
	5	This file is part of BFD, the Binary File Descriptor library.
	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 2 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, write to the Free Software
	19	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	20
	21	Written by the Center for Software Science at the University of Utah
3fde5a36	22	and by Cygnus Support.
252b5132 RH	23
	24	The core file structure for the Utah 4.3BSD and OSF1 ports on the
	25	PA is a mix between traditional cores and hpux cores -- just
	26	different enough that supporting this format would tend to add
	27	gross hacks to trad-core.c or hpux-core.c. So instead we keep any
	28	gross hacks isolated to this file. */
252b5132 RH	29
	30	/* This file can only be compiled on systems which use HPPA-BSD style
	31	core files.
	32
	33	I would not expect this to be of use to any other host/target, but
	34	you never know. */
	35
	36	#include "bfd.h"
	37	#include "sysdep.h"
	38	#include "libbfd.h"
	39
	40	#if defined (HOST_HPPABSD)
	41
	42	#include "machine/vmparam.h"
	43
	44	#include <sys/param.h>
	45	#include <sys/dir.h>
	46	#include <signal.h>
	47	#include <machine/reg.h>
	48	#include <sys/user.h> /* After a.out.h */
	49	#include <sys/file.h>
	50
dc810e39	51	static asection make_bfd_asection PARAMS ((bfd , const char *,
252b5132 RH	52	flagword, bfd_size_type,
	53	file_ptr, unsigned int));
	54	static asymbol hppabsd_core_make_empty_symbol PARAMS ((bfd ));
	55	static const bfd_target hppabsd_core_core_file_p PARAMS ((bfd ));
	56	static char hppabsd_core_core_file_failing_command PARAMS ((bfd ));
	57	static int hppabsd_core_core_file_failing_signal PARAMS ((bfd *));
	58	static boolean hppabsd_core_core_file_matches_executable_p
	59	PARAMS ((bfd , bfd ));
	60	static void swap_abort PARAMS ((void));
	61
	62	/* These are stored in the bfd's tdata. */
	63
	64	struct hppabsd_core_struct
	65	{
	66	int sig;
	67	char cmd[MAXCOMLEN + 1];
	68	asection *data_section;
	69	asection *stack_section;
	70	asection *reg_section;
	71	};
	72
	73	#define core_hdr(bfd) ((bfd)->tdata.hppabsd_core_data)
	74	#define core_signal(bfd) (core_hdr(bfd)->sig)
	75	#define core_command(bfd) (core_hdr(bfd)->cmd)
	76	#define core_datasec(bfd) (core_hdr(bfd)->data_section)
	77	#define core_stacksec(bfd) (core_hdr(bfd)->stack_section)
	78	#define core_regsec(bfd) (core_hdr(bfd)->reg_section)
	79
	80	static asection *
	81	make_bfd_asection (abfd, name, flags, _raw_size, offset, alignment_power)
	82	bfd *abfd;
dc810e39	83	const char *name;
252b5132 RH	84	flagword flags;
	85	bfd_size_type _raw_size;
	86	file_ptr offset;
	87	unsigned int alignment_power;
	88	{
	89	asection *asect;
	90
	91	asect = bfd_make_section (abfd, name);
	92	if (!asect)
	93	return NULL;
	94
	95	asect->flags = flags;
	96	asect->_raw_size = _raw_size;
	97	asect->filepos = offset;
	98	asect->alignment_power = alignment_power;
	99
	100	return asect;
	101	}
	102
	103	static asymbol *
	104	hppabsd_core_make_empty_symbol (abfd)
	105	bfd *abfd;
	106	{
dc810e39 AM	107	asymbol *new;
	108
	109	new = (asymbol *) bfd_zalloc (abfd, (bfd_size_type) sizeof (asymbol));
252b5132 RH	110	if (new)
	111	new->the_bfd = abfd;
	112	return new;
	113	}
	114
	115	static const bfd_target *
	116	hppabsd_core_core_file_p (abfd)
	117	bfd *abfd;
	118	{
	119	int val;
	120	struct user u;
	121	struct hppabsd_core_struct *coredata;
	122	int clicksz;
	123
	124	/* Try to read in the u-area. We will need information from this
	125	to know how to grok the rest of the core structures. */
dc810e39	126	val = bfd_bread ((void *) &u, (bfd_size_type) sizeof u, abfd);
252b5132 RH	127	if (val != sizeof u)
	128	{
	129	if (bfd_get_error () != bfd_error_system_call)
	130	bfd_set_error (bfd_error_wrong_format);
	131	return NULL;
	132	}
	133
	134	/* Get the page size out of the u structure. This will be different
	135	for PA 1.0 machines and PA 1.1 machines. Yuk! */
	136	clicksz = u.u_pcb.pcb_pgsz;
	137
	138	/* clicksz must be a power of two >= 2k. */
	139	if (clicksz < 0x800
	140	\|\| clicksz != (clicksz & -clicksz))
	141	{
	142	bfd_set_error (bfd_error_wrong_format);
	143	return NULL;
	144	}
	145
252b5132 RH	146	/* Sanity checks. Make sure the size of the core file matches the
	147	the size computed from information within the core itself. */
	148	{
	149	FILE *stream = bfd_cache_lookup (abfd);
	150	struct stat statbuf;
	151	if (stream == NULL \|\| fstat (fileno (stream), &statbuf) < 0)
	152	{
	153	bfd_set_error (bfd_error_system_call);
	154	return NULL;
	155	}
	156	if (NBPG * (UPAGES + u.u_dsize + u.u_ssize) > statbuf.st_size)
	157	{
	158	bfd_set_error (bfd_error_file_truncated);
	159	return NULL;
	160	}
	161	if (clicksz * (UPAGES + u.u_dsize + u.u_ssize) < statbuf.st_size)
	162	{
	163	/* The file is too big. Maybe it's not a core file
	164	or we otherwise have bad values for u_dsize and u_ssize). */
	165	bfd_set_error (bfd_error_wrong_format);
	166	return NULL;
	167	}
	168	}
	169
	170	/* OK, we believe you. You're a core file (sure, sure). */
	171
	172	coredata = (struct hppabsd_core_struct *)
dc810e39	173	bfd_zalloc (abfd, (bfd_size_type) sizeof (struct hppabsd_core_struct));
252b5132 RH	174	if (!coredata)
	175	return NULL;
	176
	177	/* Make the core data and available via the tdata part of the BFD. */
	178	abfd->tdata.hppabsd_core_data = coredata;
	179
	180	/* Create the sections. */
	181	core_stacksec (abfd) = make_bfd_asection (abfd, ".stack",
	182	SEC_ALLOC + SEC_HAS_CONTENTS,
	183	clicksz * u.u_ssize,
3fde5a36	184	NBPG * (USIZE + KSTAKSIZE)
252b5132	185	+ clicksz * u.u_dsize, 2);
9e7b37b3 AM	186	if (core_stacksec (abfd) == NULL)
9e7b37b3 AM	187	goto fail;
3fde5a36	188	core_stacksec (abfd)->vma = USRSTACK;
252b5132 RH	189
	190	core_datasec (abfd) = make_bfd_asection (abfd, ".data",
	191	SEC_ALLOC + SEC_LOAD
	192	+ SEC_HAS_CONTENTS,
	193	clicksz * u.u_dsize,
	194	NBPG * (USIZE + KSTAKSIZE), 2);
9e7b37b3 AM	195	if (core_datasec (abfd) == NULL)
9e7b37b3 AM	196	goto fail;
252b5132 RH	197	core_datasec (abfd)->vma = UDATASEG;
	198
	199	core_regsec (abfd) = make_bfd_asection (abfd, ".reg",
	200	SEC_HAS_CONTENTS,
	201	KSTAKSIZE * NBPG,
	202	NBPG * USIZE, 2);
9e7b37b3 AM	203	if (core_regsec (abfd) == NULL)
9e7b37b3 AM	204	goto fail;
252b5132 RH	205	core_regsec (abfd)->vma = 0;
	206
	207	strncpy (core_command (abfd), u.u_comm, MAXCOMLEN + 1);
	208	core_signal (abfd) = u.u_code;
	209	return abfd->xvec;
9e7b37b3 AM	210
	211	fail:
	212	bfd_release (abfd, abfd->tdata.any);
	213	abfd->tdata.any = NULL;
	214	bfd_section_list_clear (abfd);
	215	return NULL;
252b5132 RH	216	}
	217
	218	static char *
	219	hppabsd_core_core_file_failing_command (abfd)
	220	bfd *abfd;
	221	{
	222	return core_command (abfd);
	223	}
	224
	225	/* ARGSUSED */
	226	static int
	227	hppabsd_core_core_file_failing_signal (abfd)
	228	bfd *abfd;
	229	{
	230	return core_signal (abfd);
	231	}
	232
	233	/* ARGSUSED */
	234	static boolean
	235	hppabsd_core_core_file_matches_executable_p (core_bfd, exec_bfd)
	236	bfd core_bfd, exec_bfd;
	237	{
	238	/* There's no way to know this... */
	239	return true;
	240	}
252b5132 RH	241	\f
	242	#define hppabsd_core_get_symtab_upper_bound \
	243	_bfd_nosymbols_get_symtab_upper_bound
	244	#define hppabsd_core_get_symtab _bfd_nosymbols_get_symtab
	245	#define hppabsd_core_print_symbol _bfd_nosymbols_print_symbol
	246	#define hppabsd_core_get_symbol_info _bfd_nosymbols_get_symbol_info
	247	#define hppabsd_core_bfd_is_local_label_name \
	248	_bfd_nosymbols_bfd_is_local_label_name
	249	#define hppabsd_core_get_lineno _bfd_nosymbols_get_lineno
	250	#define hppabsd_core_find_nearest_line _bfd_nosymbols_find_nearest_line
	251	#define hppabsd_core_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
	252	#define hppabsd_core_read_minisymbols _bfd_nosymbols_read_minisymbols
	253	#define hppabsd_core_minisymbol_to_symbol _bfd_nosymbols_minisymbol_to_symbol
	254
	255	/* If somebody calls any byte-swapping routines, shoot them. */
	256	static void
	257	swap_abort ()
	258	{
	259	/* This way doesn't require any declaration for ANSI to fuck up. */
3fde5a36	260	abort ();
252b5132 RH	261	}
	262
	263	#define NO_GET ((bfd_vma () PARAMS (( const bfd_byte ))) swap_abort )
	264	#define NO_PUT ((void () PARAMS ((bfd_vma, bfd_byte ))) swap_abort )
	265	#define NO_SIGNED_GET \
	266	((bfd_signed_vma () PARAMS ((const bfd_byte ))) swap_abort )
	267
	268	const bfd_target hppabsd_core_vec =
	269	{
	270	"hppabsd-core",
	271	bfd_target_unknown_flavour,
	272	BFD_ENDIAN_BIG, /* target byte order */
	273	BFD_ENDIAN_BIG, /* target headers byte order */
	274	(HAS_RELOC \| EXEC_P \| /* object flags */
	275	HAS_LINENO \| HAS_DEBUG \|
	276	HAS_SYMS \| HAS_LOCALS \| WP_TEXT \| D_PAGED),
	277	(SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD \| SEC_RELOC), /* section flags */
	278	0, /* symbol prefix */
	279	' ', /* ar_pad_char */
	280	16, /* ar_max_namelen */
	281	NO_GET, NO_SIGNED_GET, NO_PUT, /* 64 bit data */
	282	NO_GET, NO_SIGNED_GET, NO_PUT, /* 32 bit data */
	283	NO_GET, NO_SIGNED_GET, NO_PUT, /* 16 bit data */
	284	NO_GET, NO_SIGNED_GET, NO_PUT, /* 64 bit hdrs */
	285	NO_GET, NO_SIGNED_GET, NO_PUT, /* 32 bit hdrs */
	286	NO_GET, NO_SIGNED_GET, NO_PUT, /* 16 bit hdrs */
	287
	288	{ /* bfd_check_format */
	289	_bfd_dummy_target, /* unknown format */
	290	_bfd_dummy_target, /* object file */
	291	_bfd_dummy_target, /* archive */
	292	hppabsd_core_core_file_p /* a core file */
	293	},
	294	{ /* bfd_set_format */
	295	bfd_false, bfd_false,
	296	bfd_false, bfd_false
	297	},
	298	{ /* bfd_write_contents */
	299	bfd_false, bfd_false,
	300	bfd_false, bfd_false
	301	},
3fde5a36	302
252b5132 RH	303	BFD_JUMP_TABLE_GENERIC (_bfd_generic),
	304	BFD_JUMP_TABLE_COPY (_bfd_generic),
	305	BFD_JUMP_TABLE_CORE (hppabsd_core),
	306	BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
	307	BFD_JUMP_TABLE_SYMBOLS (hppabsd_core),
	308	BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
	309	BFD_JUMP_TABLE_WRITE (_bfd_generic),
	310	BFD_JUMP_TABLE_LINK (_bfd_nolink),
	311	BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
	312
c3c89269	313	NULL,
3fde5a36	314
252b5132 RH	315	(PTR) 0 /* backend_data */
	316	};
	317	#endif