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