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

/* BFD back-end for HPPA BSD core files.
   Copyright 1993, 1994 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 <stdio.h>
#include <sys/types.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>
#include <errno.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 = (asymbol *) bfd_zalloc (abfd, 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_read ((void *) &u, 1, 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, 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);
  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);
  core_datasec (abfd)->vma = UDATASEG;

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

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

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 _bfd_nosymbols_bfd_is_local_label
#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,
    true,			/* target byte order */
    true,			/* 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),

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