[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 asymbol *sco5_core_make_empty_symbol PARAMS ((bfd *));
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 asymbol *
sco5_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 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 */
}

#define sco5_core_get_symtab_upper_bound _bfd_nosymbols_get_symtab_upper_bound
#define sco5_core_get_symtab _bfd_nosymbols_get_symtab
#define sco5_core_print_symbol _bfd_nosymbols_print_symbol
#define sco5_core_get_symbol_info _bfd_nosymbols_get_symbol_info
#define sco5_core_bfd_is_local_label_name _bfd_nosymbols_bfd_is_local_label_name
#define sco5_core_get_lineno _bfd_nosymbols_get_lineno
#define sco5_core_find_nearest_line _bfd_nosymbols_find_nearest_line
#define sco5_core_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
#define sco5_core_read_minisymbols _bfd_nosymbols_read_minisymbols
#define sco5_core_minisymbol_to_symbol _bfd_nosymbols_minisymbol_to_symbol

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