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

/* BFD back-end for HPPA BSD core files.
   Copyright 1993 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., 675 Mass Ave, Cambridge, MA 02139, 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.  In the config/XXXXXX.mh file for such a system add
   HDEFINES=-DHPPABSD_CORE
   HDEPFILES=hppabsd-core.o

   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,
					    bfd_vma, unsigned int));
static asymbol *hppabsd_core_make_empty_symbol PARAMS ((bfd *));
static 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, vma, alignment_power)
     bfd *abfd;
     CONST char *name;
     flagword flags;
     bfd_size_type _raw_size;
     bfd_vma vma;
     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->vma = vma;
  asect->filepos = bfd_tell (abfd);
  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 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;

  /* 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)
    {
      bfd_set_error (bfd_error_no_memory);
      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_ALLOC + 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
/* No archive file support via this BFD */
#define	hppabsd_core_openr_next_archived_file \
	bfd_generic_openr_next_archived_file
#define	hppabsd_core_generic_stat_arch_elt	bfd_generic_stat_arch_elt
#define	hppabsd_core_slurp_armap		bfd_false
#define	hppabsd_core_slurp_extended_name_table	bfd_true
#define	hppabsd_core_write_armap		(boolean (*) PARAMS	\
    ((bfd *arch, unsigned int elength, struct orl *map, \
      unsigned int orl_count, int stridx))) bfd_false
#define	hppabsd_core_truncate_arname		bfd_dont_truncate_arname

#define	hppabsd_core_close_and_cleanup		bfd_generic_close_and_cleanup
#define	hppabsd_core_set_section_contents	(boolean (*) PARAMS	\
        ((bfd *abfd, asection *section, PTR data, file_ptr offset,	\
        bfd_size_type count))) bfd_generic_set_section_contents
#define	hppabsd_core_get_section_contents \
	bfd_generic_get_section_contents
#define	hppabsd_core_new_section_hook		(boolean (*) PARAMS	\
	((bfd *, sec_ptr))) bfd_true
#define	hppabsd_core_get_symtab_upper_bound	bfd_0l
#define	hppabsd_core_get_symtab			(long (*) PARAMS \
        ((bfd *, struct symbol_cache_entry **))) bfd_0l
#define	hppabsd_core_get_reloc_upper_bound	(long (*) PARAMS \
	((bfd *, sec_ptr))) bfd_0l
#define	hppabsd_core_canonicalize_reloc		(long (*) PARAMS \
	((bfd *, sec_ptr, arelent **, struct symbol_cache_entry**))) bfd_0l
#define	hppabsd_core_print_symbol		(void (*) PARAMS	\
	((bfd *, PTR, struct symbol_cache_entry  *,			\
	bfd_print_symbol_type))) bfd_false
#define	hppabsd_core_get_symbol_info		(void (*) PARAMS	\
	((bfd *, struct symbol_cache_entry  *,			\
	symbol_info *))) bfd_false
#define	hppabsd_core_get_lineno			(alent * (*) PARAMS	\
	((bfd *, struct symbol_cache_entry *))) bfd_nullvoidptr
#define	hppabsd_core_set_arch_mach		(boolean (*) PARAMS	\
	((bfd *, enum bfd_architecture, unsigned long))) bfd_false
#define	hppabsd_core_find_nearest_line		(boolean (*) PARAMS	\
        ((bfd *abfd, struct sec  *section,				\
         struct symbol_cache_entry  **symbols,bfd_vma offset,		\
         CONST char **file, CONST char **func, unsigned int *line))) bfd_false
#define	hppabsd_core_sizeof_headers		(int (*) PARAMS	\
	((bfd *, boolean))) bfd_0

#define hppabsd_core_bfd_debug_info_start	bfd_void
#define hppabsd_core_bfd_debug_info_end		bfd_void
#define hppabsd_core_bfd_debug_info_accumulate	(void (*) PARAMS	\
	((bfd *, struct sec *))) bfd_void
#define hppabsd_core_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
#define hppabsd_core_bfd_relax_section		bfd_generic_relax_section
#define hppabsd_core_bfd_reloc_type_lookup \
  ((CONST struct reloc_howto_struct *(*) PARAMS ((bfd *, bfd_reloc_code_real_type))) bfd_nullvoidptr)
#define hppabsd_core_bfd_make_debug_symbol \
  ((asymbol *(*) PARAMS ((bfd *, void *, unsigned long))) bfd_nullvoidptr)
#define hppabsd_core_bfd_link_hash_table_create \
  ((struct bfd_link_hash_table *(*) PARAMS ((bfd *))) bfd_nullvoidptr)
#define hppabsd_core_bfd_link_add_symbols \
  ((boolean (*) PARAMS ((bfd *, struct bfd_link_info *))) bfd_false)
#define hppabsd_core_bfd_final_link \
  ((boolean (*) PARAMS ((bfd *, struct bfd_link_info *))) bfd_false)
#define hppabsd_core_bfd_copy_private_section_data \
  ((boolean (*) PARAMS ((bfd *, asection *, bfd *, asection *))) bfd_false)
#define hppabsd_core_bfd_copy_private_bfd_data \
  ((boolean (*) PARAMS ((bfd *, bfd *))) bfd_false)
#define hppabsd_core_bfd_is_local_label \
  ((boolean (*) PARAMS ((bfd *, asymbol *))) bfd_false)
#define hppabsd_core_bfd_free_cached_info bfd_true

/* 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 )

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 | DYNAMIC | 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 */
    3,							   /* minimum alignment power */
    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
    },
    
    JUMP_TABLE(hppabsd_core),
    (PTR) 0			/* backend_data */
};
#endif
Commit	Line	Data
4c3721d5 ILT	1	/* BFD back-end for HPPA BSD core files.
	2	Copyright 1993 Free Software Foundation, Inc.
	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
	18	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	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
	31	core files. In the config/XXXXXX.mh file for such a system add
	32	HDEFINES=-DHPPABSD_CORE
	33	HDEPFILES=hppabsd-core.o
	34
	35	I would not expect this to be of use to any other host/target, but
	36	you never know. */
	37
	38	#include "bfd.h"
	39	#include "sysdep.h"
	40	#include "libbfd.h"
	41
	42	#if defined (HOST_HPPABSD)
	43
	44	#include "machine/vmparam.h"
	45
	46	#include <stdio.h>
	47	#include <sys/types.h>
	48	#include <sys/param.h>
	49	#include <sys/dir.h>
	50	#include <signal.h>
	51	#include <machine/reg.h>
	52	#include <sys/user.h> /* After a.out.h */
	53	#include <sys/file.h>
	54	#include <errno.h>
	55
	56	static asection make_bfd_asection PARAMS ((bfd , CONST char *,
	57	flagword, bfd_size_type,
	58	bfd_vma, unsigned int));
	59	static asymbol hppabsd_core_make_empty_symbol PARAMS ((bfd ));
	60	static bfd_target hppabsd_core_core_file_p PARAMS ((bfd ));
	61	static char hppabsd_core_core_file_failing_command PARAMS ((bfd ));
	62	static int hppabsd_core_core_file_failing_signal PARAMS ((bfd *));
	63	static boolean hppabsd_core_core_file_matches_executable_p
	64	PARAMS ((bfd , bfd ));
65	static void swap_abort PARAMS ((void));
66
67	/* These are stored in the bfd's tdata. */
68
69	struct hppabsd_core_struct
70	{
71	int sig;
72	char cmd[MAXCOMLEN + 1];
73	asection *data_section;
74	asection *stack_section;
75	asection *reg_section;
76	};
77
78	#define core_hdr(bfd) ((bfd)->tdata.hppabsd_core_data)
79	#define core_signal(bfd) (core_hdr(bfd)->sig)
80	#define core_command(bfd) (core_hdr(bfd)->cmd)
81	#define core_datasec(bfd) (core_hdr(bfd)->data_section)
82	#define core_stacksec(bfd) (core_hdr(bfd)->stack_section)
83	#define core_regsec(bfd) (core_hdr(bfd)->reg_section)
84
85	static asection *
86	make_bfd_asection (abfd, name, flags, _raw_size, vma, alignment_power)
87	bfd *abfd;
88	CONST char *name;
89	flagword flags;
90	bfd_size_type _raw_size;
91	bfd_vma vma;
92	unsigned int alignment_power;
93	{
94	asection *asect;
95
96	asect = bfd_make_section (abfd, name);
97	if (!asect)
98	return NULL;
99
100	asect->flags = flags;
101	asect->_raw_size = _raw_size;
102	asect->vma = vma;
103	asect->filepos = bfd_tell (abfd);
104	asect->alignment_power = alignment_power;
105
106	return asect;
107	}
108
109	static asymbol *
110	hppabsd_core_make_empty_symbol (abfd)
111	bfd *abfd;
112	{
113	asymbol new = (asymbol ) bfd_zalloc (abfd, sizeof (asymbol));
9783e04a DM	114	if (new)
9783e04a DM	115	new->the_bfd = abfd;
4c3721d5 ILT	116	return new;
	117	}
	118
	119	static bfd_target *
	120	hppabsd_core_core_file_p (abfd)
	121	bfd *abfd;
	122	{
	123	int val;
	124	struct user u;
	125	struct hppabsd_core_struct *coredata;
	126	int clicksz;
	127
	128	/* Try to read in the u-area. We will need information from this
	129	to know how to grok the rest of the core structures. */
	130	val = bfd_read ((void *) &u, 1, sizeof u, abfd);
	131	if (val != sizeof u)
	132	{
4002f18a ILT	133	if (bfd_get_error () != bfd_error_system_call)
4002f18a ILT	134	bfd_set_error (bfd_error_wrong_format);
4c3721d5 ILT	135	return NULL;
	136	}
	137
	138	/* Get the page size out of the u structure. This will be different
	139	for PA 1.0 machines and PA 1.1 machines. Yuk! */
	140	clicksz = u.u_pcb.pcb_pgsz;
	141
	142	/* Sanity checks. Make sure the size of the core file matches the
	143	the size computed from information within the core itself. */
	144	{
	145	FILE *stream = bfd_cache_lookup (abfd);
	146	struct stat statbuf;
	147	if (stream == NULL \|\| fstat (fileno (stream), &statbuf) < 0)
	148	{
326e32d7	149	bfd_set_error (bfd_error_system_call);
4c3721d5 ILT	150	return NULL;
	151	}
	152	if (NBPG * (UPAGES + u.u_dsize + u.u_ssize) > statbuf.st_size)
	153	{
326e32d7	154	bfd_set_error (bfd_error_file_truncated);
4c3721d5 ILT	155	return NULL;
	156	}
	157	if (clicksz * (UPAGES + u.u_dsize + u.u_ssize) < statbuf.st_size)
	158	{
	159	/* The file is too big. Maybe it's not a core file
	160	or we otherwise have bad values for u_dsize and u_ssize). */
326e32d7	161	bfd_set_error (bfd_error_wrong_format);
4c3721d5 ILT	162	return NULL;
	163	}
	164	}
	165
	166	/* OK, we believe you. You're a core file (sure, sure). */
	167
	168	coredata = (struct hppabsd_core_struct *)
	169	bfd_zalloc (abfd, sizeof (struct hppabsd_core_struct));
9783e04a DM	170	if (!coredata)
9783e04a DM	171	{
326e32d7	172	bfd_set_error (bfd_error_no_memory);
9783e04a DM	173	return NULL;
9783e04a DM	174	}
4c3721d5 ILT	175
	176	/* Make the core data and available via the tdata part of the BFD. */
	177	abfd->tdata.hppabsd_core_data = coredata;
	178
	179	/* Create the sections. */
	180	core_stacksec (abfd) = make_bfd_asection (abfd, ".stack",
	181	SEC_ALLOC + SEC_HAS_CONTENTS,
	182	clicksz * u.u_ssize,
	183	NBPG * (USIZE + KSTAKSIZE)
	184	+ clicksz * u.u_dsize, 2);
	185	core_stacksec (abfd)->vma = USRSTACK;
	186
	187	core_datasec (abfd) = make_bfd_asection (abfd, ".data",
	188	SEC_ALLOC + SEC_LOAD
	189	+ SEC_HAS_CONTENTS,
	190	clicksz * u.u_dsize,
	191	NBPG * (USIZE + KSTAKSIZE), 2);
	192	core_datasec (abfd)->vma = UDATASEG;
	193
	194	core_regsec (abfd) = make_bfd_asection (abfd, ".reg",
	195	SEC_ALLOC + SEC_HAS_CONTENTS,
	196	KSTAKSIZE * NBPG,
	197	NBPG * USIZE, 2);
	198	core_regsec (abfd)->vma = 0;
	199
	200	strncpy (core_command (abfd), u.u_comm, MAXCOMLEN + 1);
	201	core_signal (abfd) = u.u_code;
	202	return abfd->xvec;
	203	}
	204
	205	static char *
	206	hppabsd_core_core_file_failing_command (abfd)
	207	bfd *abfd;
	208	{
	209	return core_command (abfd);
	210	}
	211
	212	/* ARGSUSED */
	213	static int
	214	hppabsd_core_core_file_failing_signal (abfd)
	215	bfd *abfd;
	216	{
	217	return core_signal (abfd);
	218	}
	219
	220	/* ARGSUSED */
	221	static boolean
	222	hppabsd_core_core_file_matches_executable_p (core_bfd, exec_bfd)
	223	bfd core_bfd, exec_bfd;
	224	{
	225	/* There's no way to know this... */
	226	return true;
	227	}
	228
	229	\f
	230	/* No archive file support via this BFD */
	231	#define hppabsd_core_openr_next_archived_file \
	232	bfd_generic_openr_next_archived_file
	233	#define hppabsd_core_generic_stat_arch_elt bfd_generic_stat_arch_elt
	234	#define hppabsd_core_slurp_armap bfd_false
	235	#define hppabsd_core_slurp_extended_name_table bfd_true
	236	#define hppabsd_core_write_armap (boolean (*) PARAMS \
	237	((bfd arch, unsigned int elength, struct orl map, \
	238	unsigned int orl_count, int stridx))) bfd_false
239	#define hppabsd_core_truncate_arname bfd_dont_truncate_arname
240
241	#define hppabsd_core_close_and_cleanup bfd_generic_close_and_cleanup
242	#define hppabsd_core_set_section_contents (boolean (*) PARAMS \
243	((bfd abfd, asection section, PTR data, file_ptr offset, \
9783e04a	244	bfd_size_type count))) bfd_generic_set_section_contents
4c3721d5 ILT	245	#define hppabsd_core_get_section_contents \
	246	bfd_generic_get_section_contents
	247	#define hppabsd_core_new_section_hook (boolean (*) PARAMS \
	248	((bfd *, sec_ptr))) bfd_true
326e32d7 ILT	249	#define hppabsd_core_get_symtab_upper_bound bfd_0l
	250	#define hppabsd_core_get_symtab (long (*) PARAMS \
	251	((bfd , struct symbol_cache_entry *))) bfd_0l
	252	#define hppabsd_core_get_reloc_upper_bound (long (*) PARAMS \
	253	((bfd *, sec_ptr))) bfd_0l
	254	#define hppabsd_core_canonicalize_reloc (long (*) PARAMS \
	255	((bfd , sec_ptr, arelent , struct symbol_cache_entry*))) bfd_0l
4c3721d5 ILT	256	#define hppabsd_core_print_symbol (void (*) PARAMS \
	257	((bfd , PTR, struct symbol_cache_entry , \
	258	bfd_print_symbol_type))) bfd_false
	259	#define hppabsd_core_get_symbol_info (void (*) PARAMS \
	260	((bfd , struct symbol_cache_entry , \
	261	symbol_info *))) bfd_false
	262	#define hppabsd_core_get_lineno (alent * (*) PARAMS \
	263	((bfd , struct symbol_cache_entry ))) bfd_nullvoidptr
	264	#define hppabsd_core_set_arch_mach (boolean (*) PARAMS \
	265	((bfd *, enum bfd_architecture, unsigned long))) bfd_false
	266	#define hppabsd_core_find_nearest_line (boolean (*) PARAMS \
	267	((bfd abfd, struct sec section, \
	268	struct symbol_cache_entry **symbols,bfd_vma offset, \
	269	CONST char file, CONST char func, unsigned int *line))) bfd_false
	270	#define hppabsd_core_sizeof_headers (int (*) PARAMS \
	271	((bfd *, boolean))) bfd_0
	272
	273	#define hppabsd_core_bfd_debug_info_start bfd_void
	274	#define hppabsd_core_bfd_debug_info_end bfd_void
	275	#define hppabsd_core_bfd_debug_info_accumulate (void (*) PARAMS \
	276	((bfd , struct sec ))) bfd_void
	277	#define hppabsd_core_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
	278	#define hppabsd_core_bfd_relax_section bfd_generic_relax_section
	279	#define hppabsd_core_bfd_reloc_type_lookup \
	280	((CONST struct reloc_howto_struct () PARAMS ((bfd *, bfd_reloc_code_real_type))) bfd_nullvoidptr)
	281	#define hppabsd_core_bfd_make_debug_symbol \
	282	((asymbol () PARAMS ((bfd , void , unsigned long))) bfd_nullvoidptr)
	283	#define hppabsd_core_bfd_link_hash_table_create \
	284	((struct bfd_link_hash_table () PARAMS ((bfd *))) bfd_nullvoidptr)
	285	#define hppabsd_core_bfd_link_add_symbols \
	286	((boolean () PARAMS ((bfd , struct bfd_link_info *))) bfd_false)
	287	#define hppabsd_core_bfd_final_link \
	288	((boolean () PARAMS ((bfd , struct bfd_link_info *))) bfd_false)
326e32d7 ILT	289	#define hppabsd_core_bfd_copy_private_section_data \
	290	((boolean () PARAMS ((bfd , asection , bfd , asection *))) bfd_false)
	291	#define hppabsd_core_bfd_copy_private_bfd_data \
	292	((boolean () PARAMS ((bfd , bfd *))) bfd_false)
	293	#define hppabsd_core_bfd_is_local_label \
	294	((boolean () PARAMS ((bfd , asymbol *))) bfd_false)
9deaaaf1	295	#define hppabsd_core_bfd_free_cached_info bfd_true
4c3721d5 ILT	296
	297	/* If somebody calls any byte-swapping routines, shoot them. */
	298	static void
	299	swap_abort ()
	300	{
	301	/* This way doesn't require any declaration for ANSI to fuck up. */
	302	abort ();
	303	}
	304
9783e04a	305	#define NO_GET ((bfd_vma () PARAMS (( const bfd_byte ))) swap_abort )
4c3721d5	306	#define NO_PUT ((void () PARAMS ((bfd_vma, bfd_byte ))) swap_abort )
9783e04a DM	307	#define NO_SIGNED_GET \
9783e04a DM	308	((bfd_signed_vma () PARAMS ((const bfd_byte ))) swap_abort )
4c3721d5 ILT	309
	310	bfd_target hppabsd_core_vec =
	311	{
	312	"hppabsd-core",
	313	bfd_target_unknown_flavour,
	314	true, /* target byte order */
	315	true, /* target headers byte order */
	316	(HAS_RELOC \| EXEC_P \| /* object flags */
	317	HAS_LINENO \| HAS_DEBUG \|
	318	HAS_SYMS \| HAS_LOCALS \| DYNAMIC \| WP_TEXT \| D_PAGED),
	319	(SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD \| SEC_RELOC), /* section flags */
	320	0, /* symbol prefix */
	321	' ', /* ar_pad_char */
	322	16, /* ar_max_namelen */
	323	3, /* minimum alignment power */
	324	NO_GET, NO_SIGNED_GET, NO_PUT, /* 64 bit data */
	325	NO_GET, NO_SIGNED_GET, NO_PUT, /* 32 bit data */
	326	NO_GET, NO_SIGNED_GET, NO_PUT, /* 16 bit data */
	327	NO_GET, NO_SIGNED_GET, NO_PUT, /* 64 bit hdrs */
	328	NO_GET, NO_SIGNED_GET, NO_PUT, /* 32 bit hdrs */
	329	NO_GET, NO_SIGNED_GET, NO_PUT, /* 16 bit hdrs */
	330
	331	{ /* bfd_check_format */
	332	_bfd_dummy_target, /* unknown format */
	333	_bfd_dummy_target, /* object file */
	334	_bfd_dummy_target, /* archive */
	335	hppabsd_core_core_file_p /* a core file */
	336	},
	337	{ /* bfd_set_format */
	338	bfd_false, bfd_false,
	339	bfd_false, bfd_false
	340	},
	341	{ /* bfd_write_contents */
	342	bfd_false, bfd_false,
	343	bfd_false, bfd_false
	344	},
	345
	346	JUMP_TABLE(hppabsd_core),
	347	(PTR) 0 /* backend_data */
	348	};
	349	#endif