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

/* BFD back-end for HPPA BSD core files.
   Copyright 1993, 1994, 1995, 1998, 1999, 2001
   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);
  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_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.
7898deda NC	2	Copyright 1993, 1994, 1995, 1998, 1999, 2001
7898deda NC	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);
3fde5a36	186	core_stacksec (abfd)->vma = USRSTACK;
252b5132 RH	187
	188	core_datasec (abfd) = make_bfd_asection (abfd, ".data",
	189	SEC_ALLOC + SEC_LOAD
	190	+ SEC_HAS_CONTENTS,
	191	clicksz * u.u_dsize,
	192	NBPG * (USIZE + KSTAKSIZE), 2);
	193	core_datasec (abfd)->vma = UDATASEG;
	194
	195	core_regsec (abfd) = make_bfd_asection (abfd, ".reg",
	196	SEC_HAS_CONTENTS,
	197	KSTAKSIZE * NBPG,
	198	NBPG * USIZE, 2);
	199	core_regsec (abfd)->vma = 0;
	200
	201	strncpy (core_command (abfd), u.u_comm, MAXCOMLEN + 1);
	202	core_signal (abfd) = u.u_code;
	203	return abfd->xvec;
	204	}
	205
	206	static char *
	207	hppabsd_core_core_file_failing_command (abfd)
	208	bfd *abfd;
	209	{
	210	return core_command (abfd);
	211	}
	212
	213	/* ARGSUSED */
	214	static int
	215	hppabsd_core_core_file_failing_signal (abfd)
	216	bfd *abfd;
	217	{
	218	return core_signal (abfd);
	219	}
	220
	221	/* ARGSUSED */
	222	static boolean
	223	hppabsd_core_core_file_matches_executable_p (core_bfd, exec_bfd)
	224	bfd core_bfd, exec_bfd;
	225	{
	226	/* There's no way to know this... */
	227	return true;
	228	}
252b5132 RH	229	\f
	230	#define hppabsd_core_get_symtab_upper_bound \
	231	_bfd_nosymbols_get_symtab_upper_bound
	232	#define hppabsd_core_get_symtab _bfd_nosymbols_get_symtab
	233	#define hppabsd_core_print_symbol _bfd_nosymbols_print_symbol
	234	#define hppabsd_core_get_symbol_info _bfd_nosymbols_get_symbol_info
	235	#define hppabsd_core_bfd_is_local_label_name \
	236	_bfd_nosymbols_bfd_is_local_label_name
	237	#define hppabsd_core_get_lineno _bfd_nosymbols_get_lineno
	238	#define hppabsd_core_find_nearest_line _bfd_nosymbols_find_nearest_line
	239	#define hppabsd_core_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
	240	#define hppabsd_core_read_minisymbols _bfd_nosymbols_read_minisymbols
	241	#define hppabsd_core_minisymbol_to_symbol _bfd_nosymbols_minisymbol_to_symbol
	242
	243	/* If somebody calls any byte-swapping routines, shoot them. */
	244	static void
	245	swap_abort ()
	246	{
	247	/* This way doesn't require any declaration for ANSI to fuck up. */
3fde5a36	248	abort ();
252b5132 RH	249	}
	250
	251	#define NO_GET ((bfd_vma () PARAMS (( const bfd_byte ))) swap_abort )
	252	#define NO_PUT ((void () PARAMS ((bfd_vma, bfd_byte ))) swap_abort )
	253	#define NO_SIGNED_GET \
	254	((bfd_signed_vma () PARAMS ((const bfd_byte ))) swap_abort )
	255
	256	const bfd_target hppabsd_core_vec =
	257	{
	258	"hppabsd-core",
	259	bfd_target_unknown_flavour,
	260	BFD_ENDIAN_BIG, /* target byte order */
	261	BFD_ENDIAN_BIG, /* target headers byte order */
	262	(HAS_RELOC \| EXEC_P \| /* object flags */
	263	HAS_LINENO \| HAS_DEBUG \|
	264	HAS_SYMS \| HAS_LOCALS \| WP_TEXT \| D_PAGED),
	265	(SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD \| SEC_RELOC), /* section flags */
	266	0, /* symbol prefix */
	267	' ', /* ar_pad_char */
	268	16, /* ar_max_namelen */
	269	NO_GET, NO_SIGNED_GET, NO_PUT, /* 64 bit data */
	270	NO_GET, NO_SIGNED_GET, NO_PUT, /* 32 bit data */
	271	NO_GET, NO_SIGNED_GET, NO_PUT, /* 16 bit data */
	272	NO_GET, NO_SIGNED_GET, NO_PUT, /* 64 bit hdrs */
	273	NO_GET, NO_SIGNED_GET, NO_PUT, /* 32 bit hdrs */
	274	NO_GET, NO_SIGNED_GET, NO_PUT, /* 16 bit hdrs */
	275
	276	{ /* bfd_check_format */
	277	_bfd_dummy_target, /* unknown format */
	278	_bfd_dummy_target, /* object file */
	279	_bfd_dummy_target, /* archive */
	280	hppabsd_core_core_file_p /* a core file */
	281	},
	282	{ /* bfd_set_format */
	283	bfd_false, bfd_false,
	284	bfd_false, bfd_false
	285	},
	286	{ /* bfd_write_contents */
	287	bfd_false, bfd_false,
	288	bfd_false, bfd_false
	289	},
3fde5a36	290
252b5132 RH	291	BFD_JUMP_TABLE_GENERIC (_bfd_generic),
	292	BFD_JUMP_TABLE_COPY (_bfd_generic),
	293	BFD_JUMP_TABLE_CORE (hppabsd_core),
	294	BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
	295	BFD_JUMP_TABLE_SYMBOLS (hppabsd_core),
	296	BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
	297	BFD_JUMP_TABLE_WRITE (_bfd_generic),
	298	BFD_JUMP_TABLE_LINK (_bfd_nolink),
	299	BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
	300
c3c89269	301	NULL,
3fde5a36	302
252b5132 RH	303	(PTR) 0 /* backend_data */
	304	};
	305	#endif