[thirdparty/binutils-gdb.git] / bfd / sco5-core.c

/* BFD back end for SCO5 core files (U-area and raw sections)
   Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   Written by Jouke Numan <jnuman@hiscom.nl>

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

#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
#include "libaout.h"		/* BFD a.out internal data structures */

#include <stdio.h>
#include <sys/types.h>
#include <sys/param.h>
#include <sys/dir.h>
#include <signal.h>

#include <sys/user.h>		/* After a.out.h  */
#include <sys/paccess.h>
#include <sys/region.h>

struct sco5_core_struct
{
  struct user u;
};

/* forward declarations */

static asection *make_bfd_asection
  PARAMS ((bfd *, const char *, flagword, bfd_size_type, bfd_vma, file_ptr));
static struct user *read_uarea PARAMS ((bfd *, int));
const bfd_target *sco5_core_file_p PARAMS ((bfd *abfd));
char *sco5_core_file_failing_command PARAMS ((bfd *abfd));
int sco5_core_file_failing_signal PARAMS ((bfd *abfd));
bfd_boolean sco5_core_file_matches_executable_p
  PARAMS ((bfd *core_bfd, bfd *exec_bfd));
static void swap_abort PARAMS ((void));

static asection *
make_bfd_asection (abfd, name, flags, _raw_size, vma, filepos)
     bfd *abfd;
     const char *name;
     flagword flags;
     bfd_size_type _raw_size;
     bfd_vma vma;
     file_ptr filepos;
{
  asection *asect;

  asect = bfd_make_section_anyway (abfd, name);
  if (!asect)
    return NULL;
  asect->flags = flags;
  asect->_raw_size = _raw_size;
  asect->vma = vma;
  asect->filepos = filepos;
  asect->alignment_power = 2;

  return asect;
}

static struct user *
read_uarea(abfd, filepos)
     bfd *abfd;
     int filepos;

{
  struct sco5_core_struct *rawptr;
  bfd_size_type amt = sizeof (struct sco5_core_struct);

  rawptr = (struct sco5_core_struct *) bfd_zmalloc (amt);
  if (rawptr == NULL)
    return NULL;

  abfd->tdata.sco5_core_data = rawptr;

  if (bfd_seek (abfd, (file_ptr) filepos, SEEK_SET) != 0
      || bfd_bread ((void *) &rawptr->u, (bfd_size_type) sizeof rawptr->u,
		   abfd) != sizeof rawptr->u)
    {
      bfd_set_error (bfd_error_wrong_format);
      return NULL;
    }

  /* Sanity check perhaps??? */
  if (rawptr->u.u_dsize > 0x1000000)    /* Remember, it's in pages...  */
    {
      bfd_set_error (bfd_error_wrong_format);
      return NULL;
    }
  if (rawptr->u.u_ssize > 0x1000000)
    {
      bfd_set_error (bfd_error_wrong_format);
      return NULL;
    }
  return &rawptr->u;
}

/* ARGSUSED */
const bfd_target *
sco5_core_file_p (abfd)
     bfd *abfd;
{
  int coffset_siz, val, nsecs, cheadoffs;
  int coresize;
  struct user *u;
  struct coreoffsets coffsets;
  struct coresecthead chead;
  char *secname;
  flagword flags;

  /* Read coreoffsets region at end of core (see core(FP)) */

  {
    FILE *stream = bfd_cache_lookup (abfd);
    struct stat statbuf;
    if (stream == NULL)
      return NULL;
    if (fstat (fileno (stream), &statbuf) < 0)
      {
	bfd_set_error (bfd_error_system_call);
	return NULL;
      }
    coresize = statbuf.st_size;
  }
  /* Last long in core is sizeof struct coreoffsets, read it */
  if ((bfd_seek (abfd, (file_ptr) (coresize - sizeof coffset_siz),
		 SEEK_SET) != 0)
      || bfd_bread ((void *) &coffset_siz, (bfd_size_type) sizeof coffset_siz,
		   abfd) != sizeof coffset_siz)
    {
      bfd_set_error (bfd_error_wrong_format);
      return NULL;
    }

  /* Use it to seek start of coreoffsets region, read it and determine
     validity */
  if ((bfd_seek (abfd, (file_ptr) (coresize - coffset_siz), SEEK_SET) != 0)
      || (bfd_bread ((void *) &coffsets, (bfd_size_type) sizeof coffsets, abfd)
	  != sizeof coffsets)
      || ((coffsets.u_info != 1) && (coffsets.u_info != C_VERSION)))
    {
      bfd_set_error (bfd_error_wrong_format);
      return NULL;
    }

  if (coffsets.u_info == 1)
    {
      /* Old version, no section heads, read info from user struct */

      u = read_uarea (abfd, coffsets.u_user);
      if (! u)
	goto fail;

      if (!make_bfd_asection (abfd, ".reg", SEC_HAS_CONTENTS,
			      (bfd_size_type) coffsets.u_usize,
			      0 - (bfd_vma) u->u_ar0,
			      (file_ptr) coffsets.u_user))
	goto fail;

      if (!make_bfd_asection (abfd, ".data",
			      SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS,
			      ((bfd_size_type) u->u_exdata.ux_dsize
			       + u->u_exdata.ux_bsize),
			      (bfd_vma) u->u_exdata.ux_datorg,
			      (file_ptr) coffsets.u_data))
	goto fail;

      if (!make_bfd_asection (abfd, ".stack",
			      SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS,
			      (bfd_size_type) u->u_ssize * NBPC,
			      (bfd_vma) u->u_sub,
			      (file_ptr) coffsets.u_stack))
	goto fail;

      return abfd->xvec;		/* Done for version 1 */
    }

  /* Immediately before coreoffsets region is a long with offset in core
     to first coresecthead (CORES_OFFSETS), the long before this is the
     number of section heads in the list. Read both longs and read the
     coresecthead and check its validity */

  if ((bfd_seek (abfd,
		 (file_ptr) (coresize - coffset_siz - 2 * sizeof coffset_siz),
		 SEEK_SET) != 0)
      || (bfd_bread ((void *) &nsecs, (bfd_size_type) sizeof nsecs, abfd)
	  != sizeof nsecs)
      || (bfd_bread ((void *) &cheadoffs, (bfd_size_type) sizeof cheadoffs,
		    abfd) != sizeof cheadoffs)
      || (bfd_seek (abfd, (file_ptr) cheadoffs, SEEK_SET) != 0)
      || (bfd_bread ((void *) &chead, (bfd_size_type) sizeof chead, abfd)
	  != sizeof chead)
      || (chead.cs_stype != CORES_OFFSETS)
      || (chead.cs_x.csx_magic != COREMAGIC_NUMBER))
    {
      bfd_set_error (bfd_error_wrong_format);
      goto fail;
    }

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

  /* Now loop over all regions and map them */
  nsecs--;				/* We've seen CORES_OFFSETS already */
  for (; nsecs; nsecs--)
    {
      if ((bfd_seek (abfd, (file_ptr) chead.cs_hseek, SEEK_SET) != 0)
	  || (bfd_bread ((void *) &chead, (bfd_size_type) sizeof chead, abfd)
	      != sizeof chead))
	{
	  bfd_set_error (bfd_error_wrong_format);
	  goto fail;
	}

      switch (chead.cs_stype)
	{
	case CORES_MAGIC:			/* Core header, check magic */
	  if (chead.cs_x.csx_magic != COREMAGIC_NUMBER)
	    {
	      bfd_set_error (bfd_error_wrong_format);
	      goto fail;
	    }
	  secname = NULL;
	  nsecs++;				/* MAGIC not in section cnt!*/
	  break;
	case CORES_UAREA:			/* U-area, read in tdata */
	  u = read_uarea (abfd, chead.cs_sseek);
	  if (! u)
	    goto fail;

	  /* This is tricky.  As the "register section", we give them
	     the entire upage and stack.  u.u_ar0 points to where
	     "register 0" is stored.  There are two tricks with this,
	     though.  One is that the rest of the registers might be
	     at positive or negative (or both) displacements from
	     *u_ar0.  The other is that u_ar0 is sometimes an absolute
	     address in kernel memory, and on other systems it is an
	     offset from the beginning of the `struct user'.

	     As a practical matter, we don't know where the registers
	     actually are, so we have to pass the whole area to GDB.
	     We encode the value of u_ar0 by setting the .regs section
	     up so that its virtual memory address 0 is at the place
	     pointed to by u_ar0 (by setting the vma of the start of
	     the section to -u_ar0).  GDB uses this info to locate the
	     regs, using minor trickery to get around the
	     offset-or-absolute-addr problem.  */

	  chead.cs_vaddr = 0 - (bfd_vma) u->u_ar0;

	  secname = ".reg";
	  flags = SEC_HAS_CONTENTS;

	  break;
	case CORES_PREGION:			/* A program region, map it */
	  switch (chead.cs_x.csx_preg.csxp_rtyp)
	    {
	    case PT_DATA:
	      secname = ".data";	/* Data region.		 */
	      break;
	    case PT_STACK:
	      secname = ".stack";	/* Stack region.	 */
	      break;
	    case PT_SHMEM:
	      secname = ".shmem";	/* Shared memory	 */
	      break;
	    case PT_LIBDAT:
	      secname = ".libdat";	/* Shared library data	 */
	      break;
	    case PT_V86:
	      secname = ".virt86";	/* Virtual 8086 mode	 */
	      break;
	    case PT_SHFIL:
	      secname = ".mmfile";	/* Memory mapped file	 */
	      break;
	    case PT_XDATA0:
	      secname = ".Xdat0";	/* XENIX data region, virtual 0 */
	      break;
	    default:
	      secname = "";
	    }
	  flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS;
	  break;
	case CORES_PROC:			/* struct proc */
	case CORES_ITIMER:			/* interval timers */
	case CORES_SCOUTSNAME:			/* struct scoutsname */
	  secname = NULL;	/* Ignore these */
	  break;
	default:
	  (*_bfd_error_handler) ("Unhandled SCO core file section type %d\n",
				 chead.cs_stype);
	  continue;
	}

      if (secname
	  && !make_bfd_asection (abfd, secname, flags,
				 (bfd_size_type) chead.cs_vsize,
				 (bfd_vma) chead.cs_vaddr,
				 (file_ptr) chead.cs_sseek))
	goto fail;

    }

  return abfd->xvec;

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

char *
sco5_core_file_failing_command (abfd)
     bfd *abfd;
{
  char *com = abfd->tdata.sco5_core_data->u.u_comm;
  if (*com)
    return com;
  else
    return NULL;
}

/* ARGSUSED */
int
sco5_core_file_failing_signal (ignore_abfd)
     bfd *ignore_abfd;
{
  return ((ignore_abfd->tdata.sco5_core_data->u.u_sysabort != 0)
	  ? ignore_abfd->tdata.sco5_core_data->u.u_sysabort
	  : -1);
}

/* ARGSUSED */
bfd_boolean
sco5_core_file_matches_executable_p  (core_bfd, exec_bfd)
     bfd *core_bfd ATTRIBUTE_UNUSED;
     bfd *exec_bfd ATTRIBUTE_UNUSED;
{
  return TRUE;		/* FIXME, We have no way of telling at this point */
}

/* If somebody calls any byte-swapping routines, shoot them.  */
static void
swap_abort ()
{
  abort (); /* This way doesn't require any declaration for ANSI to fuck up */
}
#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 sco5_core_vec =
  {
    "sco5-core",
    bfd_target_unknown_flavour,
    BFD_ENDIAN_LITTLE,	       /* target byte order */
    BFD_ENDIAN_LITTLE,	       /* 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 */
     sco5_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 (sco5),
    BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
    BFD_JUMP_TABLE_SYMBOLS (_bfd_nosymbols),
    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 */
};
Commit	Line	Data
252b5132	1	/* BFD back end for SCO5 core files (U-area and raw sections)
9e7b37b3	2	Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
252b5132 RH	3	Written by Jouke Numan <jnuman@hiscom.nl>
	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	#include "bfd.h"
	22	#include "sysdep.h"
	23	#include "libbfd.h"
b34976b6	24	#include "libaout.h" /* BFD a.out internal data structures */
252b5132 RH	25
	26	#include <stdio.h>
	27	#include <sys/types.h>
	28	#include <sys/param.h>
	29	#include <sys/dir.h>
	30	#include <signal.h>
	31
b34976b6	32	#include <sys/user.h> /* After a.out.h */
252b5132 RH	33	#include <sys/paccess.h>
	34	#include <sys/region.h>
	35
	36	struct sco5_core_struct
	37	{
	38	struct user u;
	39	};
	40
	41	/* forward declarations */
	42
b34976b6 AM	43	static asection *make_bfd_asection
b34976b6 AM	44	PARAMS ((bfd , const char , flagword, bfd_size_type, bfd_vma, file_ptr));
252b5132 RH	45	static struct user read_uarea PARAMS ((bfd , int));
	46	const bfd_target sco5_core_file_p PARAMS ((bfd abfd));
	47	char sco5_core_file_failing_command PARAMS ((bfd abfd));
	48	int sco5_core_file_failing_signal PARAMS ((bfd *abfd));
b34976b6 AM	49	bfd_boolean sco5_core_file_matches_executable_p
b34976b6 AM	50	PARAMS ((bfd core_bfd, bfd exec_bfd));
252b5132 RH	51	static void swap_abort PARAMS ((void));
	52
	53	static asection *
	54	make_bfd_asection (abfd, name, flags, _raw_size, vma, filepos)
	55	bfd *abfd;
	56	const char *name;
	57	flagword flags;
	58	bfd_size_type _raw_size;
	59	bfd_vma vma;
	60	file_ptr filepos;
	61	{
	62	asection *asect;
	63
	64	asect = bfd_make_section_anyway (abfd, name);
	65	if (!asect)
	66	return NULL;
	67	asect->flags = flags;
	68	asect->_raw_size = _raw_size;
	69	asect->vma = vma;
	70	asect->filepos = filepos;
	71	asect->alignment_power = 2;
	72
	73	return asect;
	74	}
	75
252b5132 RH	76	static struct user *
	77	read_uarea(abfd, filepos)
	78	bfd *abfd;
	79	int filepos;
	80
	81	{
	82	struct sco5_core_struct *rawptr;
dc810e39	83	bfd_size_type amt = sizeof (struct sco5_core_struct);
252b5132	84
dc810e39	85	rawptr = (struct sco5_core_struct *) bfd_zmalloc (amt);
252b5132 RH	86	if (rawptr == NULL)
	87	return NULL;
	88
	89	abfd->tdata.sco5_core_data = rawptr;
	90
dc810e39 AM	91	if (bfd_seek (abfd, (file_ptr) filepos, SEEK_SET) != 0
	92	\|\| bfd_bread ((void *) &rawptr->u, (bfd_size_type) sizeof rawptr->u,
	93	abfd) != sizeof rawptr->u)
252b5132 RH	94	{
	95	bfd_set_error (bfd_error_wrong_format);
	96	return NULL;
	97	}
	98
	99	/* Sanity check perhaps??? */
7b82c249	100	if (rawptr->u.u_dsize > 0x1000000) /* Remember, it's in pages... */
252b5132 RH	101	{
	102	bfd_set_error (bfd_error_wrong_format);
	103	return NULL;
	104	}
	105	if (rawptr->u.u_ssize > 0x1000000)
	106	{
	107	bfd_set_error (bfd_error_wrong_format);
	108	return NULL;
	109	}
	110	return &rawptr->u;
	111	}
	112
	113	/* ARGSUSED */
	114	const bfd_target *
	115	sco5_core_file_p (abfd)
	116	bfd *abfd;
	117	{
	118	int coffset_siz, val, nsecs, cheadoffs;
	119	int coresize;
	120	struct user *u;
	121	struct coreoffsets coffsets;
	122	struct coresecthead chead;
	123	char *secname;
	124	flagword flags;
	125
	126	/* Read coreoffsets region at end of core (see core(FP)) */
	127
	128	{
	129	FILE *stream = bfd_cache_lookup (abfd);
	130	struct stat statbuf;
	131	if (stream == NULL)
	132	return NULL;
	133	if (fstat (fileno (stream), &statbuf) < 0)
	134	{
b34976b6 AM	135	bfd_set_error (bfd_error_system_call);
b34976b6 AM	136	return NULL;
252b5132 RH	137	}
	138	coresize = statbuf.st_size;
	139	}
	140	/* Last long in core is sizeof struct coreoffsets, read it */
dc810e39 AM	141	if ((bfd_seek (abfd, (file_ptr) (coresize - sizeof coffset_siz),
	142	SEEK_SET) != 0)
	143	\|\| bfd_bread ((void *) &coffset_siz, (bfd_size_type) sizeof coffset_siz,
	144	abfd) != sizeof coffset_siz)
252b5132	145	{
7b82c249	146	bfd_set_error (bfd_error_wrong_format);
252b5132 RH	147	return NULL;
	148	}
	149
	150	/* Use it to seek start of coreoffsets region, read it and determine
	151	validity */
dc810e39 AM	152	if ((bfd_seek (abfd, (file_ptr) (coresize - coffset_siz), SEEK_SET) != 0)
dc810e39 AM	153	\|\| (bfd_bread ((void *) &coffsets, (bfd_size_type) sizeof coffsets, abfd)
252b5132 RH	154	!= sizeof coffsets)
	155	\|\| ((coffsets.u_info != 1) && (coffsets.u_info != C_VERSION)))
	156	{
7b82c249	157	bfd_set_error (bfd_error_wrong_format);
252b5132 RH	158	return NULL;
	159	}
	160
7b82c249 KH	161	if (coffsets.u_info == 1)
7b82c249 KH	162	{
252b5132 RH	163	/* Old version, no section heads, read info from user struct */
252b5132 RH	164
9e7b37b3	165	u = read_uarea (abfd, coffsets.u_user);
252b5132	166	if (! u)
9e7b37b3	167	goto fail;
252b5132	168
7b82c249	169	if (!make_bfd_asection (abfd, ".reg", SEC_HAS_CONTENTS,
b34976b6 AM	170	(bfd_size_type) coffsets.u_usize,
	171	0 - (bfd_vma) u->u_ar0,
	172	(file_ptr) coffsets.u_user))
9e7b37b3	173	goto fail;
7b82c249 KH	174
7b82c249 KH	175	if (!make_bfd_asection (abfd, ".data",
252b5132	176	SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS,
b34976b6	177	((bfd_size_type) u->u_exdata.ux_dsize
252b5132	178	+ u->u_exdata.ux_bsize),
b34976b6 AM	179	(bfd_vma) u->u_exdata.ux_datorg,
b34976b6 AM	180	(file_ptr) coffsets.u_data))
9e7b37b3	181	goto fail;
7b82c249 KH	182
	183	if (!make_bfd_asection (abfd, ".stack",
	184	SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS,
b34976b6 AM	185	(bfd_size_type) u->u_ssize * NBPC,
	186	(bfd_vma) u->u_sub,
	187	(file_ptr) coffsets.u_stack))
9e7b37b3	188	goto fail;
252b5132 RH	189
252b5132 RH	190	return abfd->xvec; /* Done for version 1 */
7b82c249	191	}
252b5132 RH	192
	193	/* Immediately before coreoffsets region is a long with offset in core
	194	to first coresecthead (CORES_OFFSETS), the long before this is the
	195	number of section heads in the list. Read both longs and read the
	196	coresecthead and check its validity */
7b82c249 KH	197
7b82c249 KH	198	if ((bfd_seek (abfd,
dc810e39	199	(file_ptr) (coresize - coffset_siz - 2 * sizeof coffset_siz),
252b5132	200	SEEK_SET) != 0)
dc810e39 AM	201	\|\| (bfd_bread ((void *) &nsecs, (bfd_size_type) sizeof nsecs, abfd)
	202	!= sizeof nsecs)
	203	\|\| (bfd_bread ((void *) &cheadoffs, (bfd_size_type) sizeof cheadoffs,
	204	abfd) != sizeof cheadoffs)
	205	\|\| (bfd_seek (abfd, (file_ptr) cheadoffs, SEEK_SET) != 0)
	206	\|\| (bfd_bread ((void *) &chead, (bfd_size_type) sizeof chead, abfd)
	207	!= sizeof chead)
252b5132 RH	208	\|\| (chead.cs_stype != CORES_OFFSETS)
	209	\|\| (chead.cs_x.csx_magic != COREMAGIC_NUMBER))
	210	{
	211	bfd_set_error (bfd_error_wrong_format);
9e7b37b3	212	goto fail;
252b5132 RH	213	}
	214
	215	/* OK, we believe you. You're a core file (sure, sure). */
	216
	217	/* Now loop over all regions and map them */
	218	nsecs--; /* We've seen CORES_OFFSETS already */
7b82c249	219	for (; nsecs; nsecs--)
252b5132	220	{
dc810e39 AM	221	if ((bfd_seek (abfd, (file_ptr) chead.cs_hseek, SEEK_SET) != 0)
	222	\|\| (bfd_bread ((void *) &chead, (bfd_size_type) sizeof chead, abfd)
	223	!= sizeof chead))
b34976b6 AM	224	{
b34976b6 AM	225	bfd_set_error (bfd_error_wrong_format);
9e7b37b3	226	goto fail;
b34976b6	227	}
252b5132	228
7b82c249	229	switch (chead.cs_stype)
252b5132 RH	230	{
	231	case CORES_MAGIC: /* Core header, check magic */
	232	if (chead.cs_x.csx_magic != COREMAGIC_NUMBER)
	233	{
	234	bfd_set_error (bfd_error_wrong_format);
9e7b37b3	235	goto fail;
252b5132 RH	236	}
	237	secname = NULL;
	238	nsecs++; /* MAGIC not in section cnt!*/
	239	break;
	240	case CORES_UAREA: /* U-area, read in tdata */
9e7b37b3	241	u = read_uarea (abfd, chead.cs_sseek);
252b5132	242	if (! u)
9e7b37b3	243	goto fail;
252b5132	244
b34976b6	245	/* This is tricky. As the "register section", we give them
252b5132 RH	246	the entire upage and stack. u.u_ar0 points to where
	247	"register 0" is stored. There are two tricks with this,
	248	though. One is that the rest of the registers might be
	249	at positive or negative (or both) displacements from
	250	*u_ar0. The other is that u_ar0 is sometimes an absolute
	251	address in kernel memory, and on other systems it is an
	252	offset from the beginning of the `struct user'.
7b82c249	253
252b5132 RH	254	As a practical matter, we don't know where the registers
	255	actually are, so we have to pass the whole area to GDB.
	256	We encode the value of u_ar0 by setting the .regs section
	257	up so that its virtual memory address 0 is at the place
	258	pointed to by u_ar0 (by setting the vma of the start of
	259	the section to -u_ar0). GDB uses this info to locate the
	260	regs, using minor trickery to get around the
7b82c249	261	offset-or-absolute-addr problem. */
252b5132 RH	262
	263	chead.cs_vaddr = 0 - (bfd_vma) u->u_ar0;
	264
b34976b6 AM	265	secname = ".reg";
b34976b6 AM	266	flags = SEC_HAS_CONTENTS;
252b5132	267
b34976b6	268	break;
252b5132 RH	269	case CORES_PREGION: /* A program region, map it */
	270	switch (chead.cs_x.csx_preg.csxp_rtyp)
	271	{
	272	case PT_DATA:
b34976b6	273	secname = ".data"; /* Data region. */
252b5132 RH	274	break;
252b5132 RH	275	case PT_STACK:
b34976b6	276	secname = ".stack"; /* Stack region. */
252b5132 RH	277	break;
252b5132 RH	278	case PT_SHMEM:
b34976b6	279	secname = ".shmem"; /* Shared memory */
252b5132 RH	280	break;
252b5132 RH	281	case PT_LIBDAT:
b34976b6	282	secname = ".libdat"; /* Shared library data */
252b5132 RH	283	break;
252b5132 RH	284	case PT_V86:
b34976b6	285	secname = ".virt86"; /* Virtual 8086 mode */
252b5132 RH	286	break;
252b5132 RH	287	case PT_SHFIL:
b34976b6	288	secname = ".mmfile"; /* Memory mapped file */
252b5132 RH	289	break;
252b5132 RH	290	case PT_XDATA0:
b34976b6	291	secname = ".Xdat0"; /* XENIX data region, virtual 0 */
252b5132 RH	292	break;
	293	default:
	294	secname = "";
	295	}
	296	flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS;
	297	break;
	298	case CORES_PROC: /* struct proc */
	299	case CORES_ITIMER: /* interval timers */
	300	case CORES_SCOUTSNAME: /* struct scoutsname */
	301	secname = NULL; /* Ignore these */
	302	break;
b34976b6 AM	303	default:
	304	(*_bfd_error_handler) ("Unhandled SCO core file section type %d\n",
	305	chead.cs_stype);
	306	continue;
	307	}
252b5132 RH	308
	309	if (secname
	310	&& !make_bfd_asection (abfd, secname, flags,
	311	(bfd_size_type) chead.cs_vsize,
	312	(bfd_vma) chead.cs_vaddr,
	313	(file_ptr) chead.cs_sseek))
9e7b37b3	314	goto fail;
252b5132 RH	315
	316	}
	317
	318	return abfd->xvec;
	319
9e7b37b3 AM	320	fail:
	321	if (abfd->tdata.any)
	322	{
	323	bfd_release (abfd, abfd->tdata.any);
	324	abfd->tdata.any = NULL;
	325	}
	326	bfd_section_list_clear (abfd);
	327	return NULL;
252b5132 RH	328	}
	329
	330	char *
	331	sco5_core_file_failing_command (abfd)
	332	bfd *abfd;
	333	{
	334	char *com = abfd->tdata.sco5_core_data->u.u_comm;
	335	if (*com)
	336	return com;
	337	else
	338	return NULL;
	339	}
	340
	341	/* ARGSUSED */
	342	int
	343	sco5_core_file_failing_signal (ignore_abfd)
	344	bfd *ignore_abfd;
	345	{
7b82c249 KH	346	return ((ignore_abfd->tdata.sco5_core_data->u.u_sysabort != 0)
7b82c249 KH	347	? ignore_abfd->tdata.sco5_core_data->u.u_sysabort
252b5132 RH	348	: -1);
	349	}
	350
	351	/* ARGSUSED */
b34976b6	352	bfd_boolean
252b5132	353	sco5_core_file_matches_executable_p (core_bfd, exec_bfd)
dc810e39 AM	354	bfd *core_bfd ATTRIBUTE_UNUSED;
dc810e39 AM	355	bfd *exec_bfd ATTRIBUTE_UNUSED;
252b5132	356	{
b34976b6	357	return TRUE; /* FIXME, We have no way of telling at this point */
252b5132 RH	358	}
252b5132 RH	359
252b5132 RH	360	/* If somebody calls any byte-swapping routines, shoot them. */
252b5132 RH	361	static void
7b82c249	362	swap_abort ()
252b5132	363	{
7b82c249	364	abort (); /* This way doesn't require any declaration for ANSI to fuck up */
252b5132 RH	365	}
	366	#define NO_GET ((bfd_vma () PARAMS (( const bfd_byte ))) swap_abort )
	367	#define NO_PUT ((void () PARAMS ((bfd_vma, bfd_byte ))) swap_abort )
	368	#define NO_SIGNED_GET \
	369	((bfd_signed_vma () PARAMS ((const bfd_byte ))) swap_abort )
	370
	371	const bfd_target sco5_core_vec =
	372	{
	373	"sco5-core",
	374	bfd_target_unknown_flavour,
b34976b6 AM	375	BFD_ENDIAN_LITTLE, /* target byte order */
	376	BFD_ENDIAN_LITTLE, /* target headers byte order */
	377	(HAS_RELOC \| EXEC_P \| /* object flags */
252b5132 RH	378	HAS_LINENO \| HAS_DEBUG \|
	379	HAS_SYMS \| HAS_LOCALS \| WP_TEXT \| D_PAGED),
	380	(SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD \| SEC_RELOC), /* section flags */
b34976b6 AM	381	0, /* symbol prefix */
	382	' ', /* ar_pad_char */
	383	16, /* ar_max_namelen */
	384	NO_GET, NO_SIGNED_GET, NO_PUT, /* 64 bit data */
	385	NO_GET, NO_SIGNED_GET, NO_PUT, /* 32 bit data */
	386	NO_GET, NO_SIGNED_GET, NO_PUT, /* 16 bit data */
	387	NO_GET, NO_SIGNED_GET, NO_PUT, /* 64 bit hdrs */
	388	NO_GET, NO_SIGNED_GET, NO_PUT, /* 32 bit hdrs */
	389	NO_GET, NO_SIGNED_GET, NO_PUT, /* 16 bit hdrs */
	390
	391	{ /* bfd_check_format */
	392	_bfd_dummy_target, /* unknown format */
	393	_bfd_dummy_target, /* object file */
	394	_bfd_dummy_target, /* archive */
	395	sco5_core_file_p /* a core file */
252b5132	396	},
b34976b6	397	{ /* bfd_set_format */
252b5132 RH	398	bfd_false, bfd_false,
	399	bfd_false, bfd_false
	400	},
b34976b6	401	{ /* bfd_write_contents */
252b5132 RH	402	bfd_false, bfd_false,
	403	bfd_false, bfd_false
	404	},
	405
3f3c5c34 AM	406	BFD_JUMP_TABLE_GENERIC (_bfd_generic),
	407	BFD_JUMP_TABLE_COPY (_bfd_generic),
	408	BFD_JUMP_TABLE_CORE (sco5),
	409	BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
	410	BFD_JUMP_TABLE_SYMBOLS (_bfd_nosymbols),
	411	BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
	412	BFD_JUMP_TABLE_WRITE (_bfd_generic),
	413	BFD_JUMP_TABLE_LINK (_bfd_nolink),
	414	BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
252b5132	415
c3c89269	416	NULL,
7b82c249	417
b34976b6	418	(PTR) 0 /* backend_data */
252b5132	419	};