OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [tags/] [VER_5_3/] [gdb-5.3/] [bfd/] [ptrace-core.c] - Diff between revs 1182 and 1765

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 1182 Rev 1765
/* BFD backend for core files which use the ptrace_user structure
/* BFD backend for core files which use the ptrace_user structure
   Copyright 1993, 1994, 1995, 1996, 1998, 1999, 2001, 2002
   Copyright 1993, 1994, 1995, 1996, 1998, 1999, 2001, 2002
   Free Software Foundation, Inc.
   Free Software Foundation, Inc.
   The structure of this file is based on trad-core.c written by John Gilmore
   The structure of this file is based on trad-core.c written by John Gilmore
   of Cygnus Support.
   of Cygnus Support.
   Modified to work with the ptrace_user structure by Kevin A. Buettner.
   Modified to work with the ptrace_user structure by Kevin A. Buettner.
   (Longterm it may be better to merge this file with trad-core.c)
   (Longterm it may be better to merge this file with trad-core.c)
 
 
This file is part of BFD, the Binary File Descriptor library.
This file is part of BFD, the Binary File Descriptor library.
 
 
This program is free software; you can redistribute it and/or modify
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
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
(at your option) any later version.
 
 
This program is distributed in the hope that it will be useful,
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
GNU General Public License for more details.
 
 
You should have received a copy of the GNU General Public License
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 
#ifdef PTRACE_CORE
#ifdef PTRACE_CORE
 
 
#include "bfd.h"
#include "bfd.h"
#include "sysdep.h"
#include "sysdep.h"
#include "libbfd.h"
#include "libbfd.h"
 
 
#include <sys/param.h>
#include <sys/param.h>
#include <sys/dir.h>
#include <sys/dir.h>
#include <signal.h>
#include <signal.h>
#include <sys/ptrace.h>
#include <sys/ptrace.h>
 
 
struct trad_core_struct
struct trad_core_struct
  {
  {
    asection *data_section;
    asection *data_section;
    asection *stack_section;
    asection *stack_section;
    asection *reg_section;
    asection *reg_section;
    struct ptrace_user u;
    struct ptrace_user u;
  };
  };
 
 
#define core_upage(bfd) (&((bfd)->tdata.trad_core_data->u))
#define core_upage(bfd) (&((bfd)->tdata.trad_core_data->u))
#define core_datasec(bfd) ((bfd)->tdata.trad_core_data->data_section)
#define core_datasec(bfd) ((bfd)->tdata.trad_core_data->data_section)
#define core_stacksec(bfd) ((bfd)->tdata.trad_core_data->stack_section)
#define core_stacksec(bfd) ((bfd)->tdata.trad_core_data->stack_section)
#define core_regsec(bfd) ((bfd)->tdata.trad_core_data->reg_section)
#define core_regsec(bfd) ((bfd)->tdata.trad_core_data->reg_section)
 
 
/* forward declarations */
/* forward declarations */
 
 
const bfd_target *ptrace_unix_core_file_p PARAMS ((bfd *abfd));
const bfd_target *ptrace_unix_core_file_p PARAMS ((bfd *abfd));
char *          ptrace_unix_core_file_failing_command PARAMS ((bfd *abfd));
char *          ptrace_unix_core_file_failing_command PARAMS ((bfd *abfd));
int             ptrace_unix_core_file_failing_signal PARAMS ((bfd *abfd));
int             ptrace_unix_core_file_failing_signal PARAMS ((bfd *abfd));
boolean         ptrace_unix_core_file_matches_executable_p
boolean         ptrace_unix_core_file_matches_executable_p
                         PARAMS ((bfd *core_bfd, bfd *exec_bfd));
                         PARAMS ((bfd *core_bfd, bfd *exec_bfd));
static void     swap_abort PARAMS ((void));
static void     swap_abort PARAMS ((void));
 
 
/* ARGSUSED */
/* ARGSUSED */
const bfd_target *
const bfd_target *
ptrace_unix_core_file_p (abfd)
ptrace_unix_core_file_p (abfd)
     bfd *abfd;
     bfd *abfd;
 
 
{
{
  int val;
  int val;
  struct ptrace_user u;
  struct ptrace_user u;
  struct trad_core_struct *rawptr;
  struct trad_core_struct *rawptr;
  bfd_size_type amt;
  bfd_size_type amt;
 
 
  val = bfd_bread ((void *)&u, (bfd_size_type) sizeof u, abfd);
  val = bfd_bread ((void *)&u, (bfd_size_type) sizeof u, abfd);
  if (val != sizeof u || u.pt_magic != _BCS_PTRACE_MAGIC
  if (val != sizeof u || u.pt_magic != _BCS_PTRACE_MAGIC
      || u.pt_rev != _BCS_PTRACE_REV)
      || u.pt_rev != _BCS_PTRACE_REV)
    {
    {
      /* Too small to be a core file */
      /* Too small to be a core file */
      bfd_set_error (bfd_error_wrong_format);
      bfd_set_error (bfd_error_wrong_format);
      return 0;
      return 0;
    }
    }
 
 
  /* OK, we believe you.  You're a core file (sure, sure).  */
  /* OK, we believe you.  You're a core file (sure, sure).  */
 
 
  /* Allocate both the upage and the struct core_data at once, so
  /* Allocate both the upage and the struct core_data at once, so
     a single free() will free them both.  */
     a single free() will free them both.  */
  amt = sizeof (struct trad_core_struct);
  amt = sizeof (struct trad_core_struct);
  rawptr = (struct trad_core_struct *) bfd_zalloc (abfd, amt);
  rawptr = (struct trad_core_struct *) bfd_zalloc (abfd, amt);
 
 
  if (rawptr == NULL)
  if (rawptr == NULL)
    return 0;
    return 0;
 
 
  abfd->tdata.trad_core_data = rawptr;
  abfd->tdata.trad_core_data = rawptr;
 
 
  rawptr->u = u; /*Copy the uarea into the tdata part of the bfd */
  rawptr->u = u; /*Copy the uarea into the tdata part of the bfd */
 
 
  /* Create the sections.  */
  /* Create the sections.  */
 
 
  core_stacksec (abfd) = bfd_make_section_anyway (abfd, ".stack");
  core_stacksec (abfd) = bfd_make_section_anyway (abfd, ".stack");
  if (core_stacksec (abfd) == NULL)
  if (core_stacksec (abfd) == NULL)
    goto fail;
    goto fail;
  core_datasec (abfd) = bfd_make_section_anyway (abfd, ".data");
  core_datasec (abfd) = bfd_make_section_anyway (abfd, ".data");
  if (core_datasec (abfd) == NULL)
  if (core_datasec (abfd) == NULL)
    goto fail;
    goto fail;
  core_regsec (abfd) = bfd_make_section_anyway (abfd, ".reg");
  core_regsec (abfd) = bfd_make_section_anyway (abfd, ".reg");
  if (core_regsec (abfd) == NULL)
  if (core_regsec (abfd) == NULL)
    goto fail;
    goto fail;
 
 
  /* FIXME:  Need to worry about shared memory, library data, and library
  /* FIXME:  Need to worry about shared memory, library data, and library
     text.  I don't think that any of these things are supported on the
     text.  I don't think that any of these things are supported on the
     system on which I am developing this for though.  */
     system on which I am developing this for though.  */
 
 
  core_stacksec (abfd)->flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS;
  core_stacksec (abfd)->flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS;
  core_datasec (abfd)->flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS;
  core_datasec (abfd)->flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS;
  core_regsec (abfd)->flags = SEC_HAS_CONTENTS;
  core_regsec (abfd)->flags = SEC_HAS_CONTENTS;
 
 
  core_datasec (abfd)->_raw_size =  u.pt_dsize;
  core_datasec (abfd)->_raw_size =  u.pt_dsize;
  core_stacksec (abfd)->_raw_size = u.pt_ssize;
  core_stacksec (abfd)->_raw_size = u.pt_ssize;
  core_regsec (abfd)->_raw_size = sizeof (u);
  core_regsec (abfd)->_raw_size = sizeof (u);
 
 
  core_datasec (abfd)->vma = u.pt_o_data_start;
  core_datasec (abfd)->vma = u.pt_o_data_start;
  core_stacksec (abfd)->vma = USRSTACK - u.pt_ssize;
  core_stacksec (abfd)->vma = USRSTACK - u.pt_ssize;
  core_regsec (abfd)->vma = 0 - sizeof (u);      /* see trad-core.c */
  core_regsec (abfd)->vma = 0 - sizeof (u);      /* see trad-core.c */
 
 
  core_datasec (abfd)->filepos = (int) u.pt_dataptr;
  core_datasec (abfd)->filepos = (int) u.pt_dataptr;
  core_stacksec (abfd)->filepos = (int) (u.pt_dataptr + u.pt_dsize);
  core_stacksec (abfd)->filepos = (int) (u.pt_dataptr + u.pt_dsize);
  core_regsec (abfd)->filepos = 0; /* Register segment is ptrace_user */
  core_regsec (abfd)->filepos = 0; /* Register segment is ptrace_user */
 
 
  /* Align to word at least */
  /* Align to word at least */
  core_stacksec (abfd)->alignment_power = 2;
  core_stacksec (abfd)->alignment_power = 2;
  core_datasec (abfd)->alignment_power = 2;
  core_datasec (abfd)->alignment_power = 2;
  core_regsec (abfd)->alignment_power = 2;
  core_regsec (abfd)->alignment_power = 2;
 
 
  return abfd->xvec;
  return abfd->xvec;
 
 
 fail:
 fail:
  bfd_release (abfd, abfd->tdata.any);
  bfd_release (abfd, abfd->tdata.any);
  abfd->tdata.any = NULL;
  abfd->tdata.any = NULL;
  bfd_section_list_clear (abfd);
  bfd_section_list_clear (abfd);
  return NULL;
  return NULL;
}
}
 
 
char *
char *
ptrace_unix_core_file_failing_command (abfd)
ptrace_unix_core_file_failing_command (abfd)
     bfd *abfd;
     bfd *abfd;
{
{
  char *com = abfd->tdata.trad_core_data->u.pt_comm;
  char *com = abfd->tdata.trad_core_data->u.pt_comm;
  if (*com)
  if (*com)
    return com;
    return com;
  else
  else
    return 0;
    return 0;
}
}
 
 
/* ARGSUSED */
/* ARGSUSED */
int
int
ptrace_unix_core_file_failing_signal (abfd)
ptrace_unix_core_file_failing_signal (abfd)
     bfd *abfd;
     bfd *abfd;
{
{
  return abfd->tdata.trad_core_data->u.pt_sigframe.sig_num;
  return abfd->tdata.trad_core_data->u.pt_sigframe.sig_num;
}
}
 
 
/* ARGSUSED */
/* ARGSUSED */
boolean
boolean
ptrace_unix_core_file_matches_executable_p  (core_bfd, exec_bfd)
ptrace_unix_core_file_matches_executable_p  (core_bfd, exec_bfd)
     bfd *core_bfd, *exec_bfd;
     bfd *core_bfd, *exec_bfd;
{
{
  /* FIXME: Use pt_timdat field of the ptrace_user structure to match
  /* FIXME: Use pt_timdat field of the ptrace_user structure to match
     the date of the executable */
     the date of the executable */
  return true;
  return true;
}
}


/* If somebody calls any byte-swapping routines, shoot them.  */
/* If somebody calls any byte-swapping routines, shoot them.  */
static void
static void
swap_abort ()
swap_abort ()
{
{
  abort (); /* This way doesn't require any declaration for ANSI to fuck up */
  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_GET  ((bfd_vma (*) PARAMS ((   const bfd_byte *))) swap_abort )
#define NO_PUT  ((void    (*) PARAMS ((bfd_vma, bfd_byte *))) swap_abort )
#define NO_PUT  ((void    (*) PARAMS ((bfd_vma, bfd_byte *))) swap_abort )
#define NO_SIGNED_GET \
#define NO_SIGNED_GET \
  ((bfd_signed_vma (*) PARAMS ((const bfd_byte *))) swap_abort )
  ((bfd_signed_vma (*) PARAMS ((const bfd_byte *))) swap_abort )
 
 
const bfd_target ptrace_core_vec =
const bfd_target ptrace_core_vec =
  {
  {
    "trad-core",
    "trad-core",
    bfd_target_unknown_flavour,
    bfd_target_unknown_flavour,
    BFD_ENDIAN_UNKNOWN,         /* target byte order */
    BFD_ENDIAN_UNKNOWN,         /* target byte order */
    BFD_ENDIAN_UNKNOWN,         /* target headers byte order */
    BFD_ENDIAN_UNKNOWN,         /* target headers byte order */
    (HAS_RELOC | EXEC_P |       /* object flags */
    (HAS_RELOC | EXEC_P |       /* object flags */
     HAS_LINENO | HAS_DEBUG |
     HAS_LINENO | HAS_DEBUG |
     HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
     HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
    (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
    (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
    0,                                                      /* symbol prefix */
    0,                                                      /* symbol prefix */
    ' ',                                                   /* ar_pad_char */
    ' ',                                                   /* ar_pad_char */
    16,                                                    /* ar_max_namelen */
    16,                                                    /* ar_max_namelen */
    NO_GET, NO_SIGNED_GET, NO_PUT,      /* 64 bit data */
    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,      /* 32 bit data */
    NO_GET, NO_SIGNED_GET, NO_PUT,      /* 16 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,      /* 64 bit hdrs */
    NO_GET, NO_SIGNED_GET, NO_PUT,      /* 32 bit hdrs */
    NO_GET, NO_SIGNED_GET, NO_PUT,      /* 32 bit hdrs */
    NO_GET, NO_SIGNED_GET, NO_PUT,      /* 16 bit hdrs */
    NO_GET, NO_SIGNED_GET, NO_PUT,      /* 16 bit hdrs */
 
 
    {                           /* bfd_check_format */
    {                           /* bfd_check_format */
     _bfd_dummy_target,         /* unknown format */
     _bfd_dummy_target,         /* unknown format */
     _bfd_dummy_target,         /* object file */
     _bfd_dummy_target,         /* object file */
     _bfd_dummy_target,         /* archive */
     _bfd_dummy_target,         /* archive */
     ptrace_unix_core_file_p    /* a core file */
     ptrace_unix_core_file_p    /* a core file */
    },
    },
    {                           /* bfd_set_format */
    {                           /* bfd_set_format */
     bfd_false, bfd_false,
     bfd_false, bfd_false,
     bfd_false, bfd_false
     bfd_false, bfd_false
    },
    },
    {                           /* bfd_write_contents */
    {                           /* bfd_write_contents */
     bfd_false, bfd_false,
     bfd_false, bfd_false,
     bfd_false, bfd_false
     bfd_false, bfd_false
    },
    },
 
 
       BFD_JUMP_TABLE_GENERIC (_bfd_generic),
       BFD_JUMP_TABLE_GENERIC (_bfd_generic),
       BFD_JUMP_TABLE_COPY (_bfd_generic),
       BFD_JUMP_TABLE_COPY (_bfd_generic),
       BFD_JUMP_TABLE_CORE (ptrace_unix),
       BFD_JUMP_TABLE_CORE (ptrace_unix),
       BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
       BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
       BFD_JUMP_TABLE_SYMBOLS (_bfd_nosymbols),
       BFD_JUMP_TABLE_SYMBOLS (_bfd_nosymbols),
       BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
       BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
       BFD_JUMP_TABLE_WRITE (_bfd_generic),
       BFD_JUMP_TABLE_WRITE (_bfd_generic),
       BFD_JUMP_TABLE_LINK (_bfd_nolink),
       BFD_JUMP_TABLE_LINK (_bfd_nolink),
       BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
       BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 
 
    NULL,
    NULL,
 
 
    (PTR) 0                      /* backend_data */
    (PTR) 0                      /* backend_data */
};
};
 
 
#endif /* PTRACE_CORE */
#endif /* PTRACE_CORE */
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.