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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [bfd/] [lynx-core.c] - Diff between revs 156 and 816

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

Rev 156 Rev 816
/* BFD back end for Lynx core files
/* BFD back end for Lynx core files
   Copyright 1993, 1994, 1995, 2001, 2002, 2004, 2006, 2007
   Copyright 1993, 1994, 1995, 2001, 2002, 2004, 2006, 2007
   Free Software Foundation, Inc.
   Free Software Foundation, Inc.
   Written by Stu Grossman of Cygnus Support.
   Written by Stu Grossman of Cygnus Support.
 
 
   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 3 of the License, or
   the Free Software Foundation; either version 3 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., 51 Franklin Street - Fifth Floor, Boston,
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */
   MA 02110-1301, USA.  */
 
 
#include "sysdep.h"
#include "sysdep.h"
#include "bfd.h"
#include "bfd.h"
#include "libbfd.h"
#include "libbfd.h"
 
 
#ifdef LYNX_CORE
#ifdef LYNX_CORE
 
 
#include <sys/conf.h>
#include <sys/conf.h>
#include <sys/kernel.h>
#include <sys/kernel.h>
/* sys/kernel.h should define this, but doesn't always, sigh.  */
/* sys/kernel.h should define this, but doesn't always, sigh.  */
#ifndef __LYNXOS
#ifndef __LYNXOS
#define __LYNXOS
#define __LYNXOS
#endif
#endif
#include <sys/mem.h>
#include <sys/mem.h>
#include <sys/signal.h>
#include <sys/signal.h>
#include <sys/time.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <sys/resource.h>
#include <sys/itimer.h>
#include <sys/itimer.h>
#include <sys/file.h>
#include <sys/file.h>
#include <sys/proc.h>
#include <sys/proc.h>
 
 
/* These are stored in the bfd's tdata */
/* These are stored in the bfd's tdata */
 
 
struct lynx_core_struct
struct lynx_core_struct
{
{
  int sig;
  int sig;
  char cmd[PNMLEN + 1];
  char cmd[PNMLEN + 1];
};
};
 
 
#define core_hdr(bfd) ((bfd)->tdata.lynx_core_data)
#define core_hdr(bfd) ((bfd)->tdata.lynx_core_data)
#define core_signal(bfd) (core_hdr(bfd)->sig)
#define core_signal(bfd) (core_hdr(bfd)->sig)
#define core_command(bfd) (core_hdr(bfd)->cmd)
#define core_command(bfd) (core_hdr(bfd)->cmd)
 
 
#define lynx_core_file_matches_executable_p generic_core_file_matches_executable_p
#define lynx_core_file_matches_executable_p generic_core_file_matches_executable_p
 
 
/* Handle Lynx core dump file.  */
/* Handle Lynx core dump file.  */
 
 
static asection *
static asection *
make_bfd_asection (abfd, name, flags, size, vma, filepos)
make_bfd_asection (abfd, name, flags, size, vma, filepos)
     bfd *abfd;
     bfd *abfd;
     const char *name;
     const char *name;
     flagword flags;
     flagword flags;
     bfd_size_type size;
     bfd_size_type size;
     bfd_vma vma;
     bfd_vma vma;
     file_ptr filepos;
     file_ptr filepos;
{
{
  asection *asect;
  asection *asect;
  char *newname;
  char *newname;
 
 
  newname = bfd_alloc (abfd, (bfd_size_type) strlen (name) + 1);
  newname = bfd_alloc (abfd, (bfd_size_type) strlen (name) + 1);
  if (!newname)
  if (!newname)
    return NULL;
    return NULL;
 
 
  strcpy (newname, name);
  strcpy (newname, name);
 
 
  asect = bfd_make_section_with_flags (abfd, newname, flags);
  asect = bfd_make_section_with_flags (abfd, newname, flags);
  if (!asect)
  if (!asect)
    return NULL;
    return NULL;
 
 
  asect->size = size;
  asect->size = size;
  asect->vma = vma;
  asect->vma = vma;
  asect->filepos = filepos;
  asect->filepos = filepos;
  asect->alignment_power = 2;
  asect->alignment_power = 2;
 
 
  return asect;
  return asect;
}
}
 
 
const bfd_target *
const bfd_target *
lynx_core_file_p (abfd)
lynx_core_file_p (abfd)
     bfd *abfd;
     bfd *abfd;
{
{
  int secnum;
  int secnum;
  struct pssentry pss;
  struct pssentry pss;
  bfd_size_type tcontext_size;
  bfd_size_type tcontext_size;
  core_st_t *threadp;
  core_st_t *threadp;
  int pagesize;
  int pagesize;
  asection *newsect;
  asection *newsect;
  bfd_size_type amt;
  bfd_size_type amt;
 
 
  pagesize = getpagesize ();    /* Serious cross-target issue here...  This
  pagesize = getpagesize ();    /* Serious cross-target issue here...  This
                                   really needs to come from a system-specific
                                   really needs to come from a system-specific
                                   header file.  */
                                   header file.  */
 
 
  /* Get the pss entry from the core file */
  /* Get the pss entry from the core file */
 
 
  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
    return NULL;
    return NULL;
 
 
  amt = sizeof pss;
  amt = sizeof pss;
  if (bfd_bread ((void *) &pss, amt, abfd) != amt)
  if (bfd_bread ((void *) &pss, amt, abfd) != amt)
    {
    {
      /* Too small to be a core file */
      /* Too small to be a core file */
      if (bfd_get_error () != bfd_error_system_call)
      if (bfd_get_error () != bfd_error_system_call)
        bfd_set_error (bfd_error_wrong_format);
        bfd_set_error (bfd_error_wrong_format);
      return NULL;
      return NULL;
    }
    }
 
 
  amt = sizeof (struct lynx_core_struct);
  amt = sizeof (struct lynx_core_struct);
  core_hdr (abfd) = (struct lynx_core_struct *) bfd_zalloc (abfd, amt);
  core_hdr (abfd) = (struct lynx_core_struct *) bfd_zalloc (abfd, amt);
 
 
  if (!core_hdr (abfd))
  if (!core_hdr (abfd))
    return NULL;
    return NULL;
 
 
  strncpy (core_command (abfd), pss.pname, PNMLEN + 1);
  strncpy (core_command (abfd), pss.pname, PNMLEN + 1);
 
 
  /* Compute the size of the thread contexts */
  /* Compute the size of the thread contexts */
 
 
  tcontext_size = pss.threadcnt * sizeof (core_st_t);
  tcontext_size = pss.threadcnt * sizeof (core_st_t);
 
 
  /* Allocate space for the thread contexts */
  /* Allocate space for the thread contexts */
 
 
  threadp = (core_st_t *) bfd_alloc (abfd, tcontext_size);
  threadp = (core_st_t *) bfd_alloc (abfd, tcontext_size);
  if (!threadp)
  if (!threadp)
    goto fail;
    goto fail;
 
 
  /* Save thread contexts */
  /* Save thread contexts */
 
 
  if (bfd_seek (abfd, (file_ptr) pagesize, SEEK_SET) != 0)
  if (bfd_seek (abfd, (file_ptr) pagesize, SEEK_SET) != 0)
    goto fail;
    goto fail;
 
 
  if (bfd_bread ((void *) threadp, tcontext_size, abfd) != tcontext_size)
  if (bfd_bread ((void *) threadp, tcontext_size, abfd) != tcontext_size)
    {
    {
      /* Probably too small to be a core file */
      /* Probably too small to be a core file */
      if (bfd_get_error () != bfd_error_system_call)
      if (bfd_get_error () != bfd_error_system_call)
        bfd_set_error (bfd_error_wrong_format);
        bfd_set_error (bfd_error_wrong_format);
      goto fail;
      goto fail;
    }
    }
 
 
  core_signal (abfd) = threadp->currsig;
  core_signal (abfd) = threadp->currsig;
 
 
  newsect = make_bfd_asection (abfd, ".stack",
  newsect = make_bfd_asection (abfd, ".stack",
                               SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS,
                               SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS,
                               pss.ssize,
                               pss.ssize,
                               pss.slimit,
                               pss.slimit,
                               pagesize + tcontext_size);
                               pagesize + tcontext_size);
  if (!newsect)
  if (!newsect)
    goto fail;
    goto fail;
 
 
  newsect = make_bfd_asection (abfd, ".data",
  newsect = make_bfd_asection (abfd, ".data",
                               SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS,
                               SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS,
                               pss.data_len + pss.bss_len,
                               pss.data_len + pss.bss_len,
                               pss.data_start,
                               pss.data_start,
                               pagesize + tcontext_size + pss.ssize
                               pagesize + tcontext_size + pss.ssize
#if defined (SPARC) || defined (__SPARC__)
#if defined (SPARC) || defined (__SPARC__)
                               /* SPARC Lynx seems to start dumping
                               /* SPARC Lynx seems to start dumping
                                  the .data section at a page
                                  the .data section at a page
                                  boundary.  It's OK to check a
                                  boundary.  It's OK to check a
                                  #define like SPARC here because this
                                  #define like SPARC here because this
                                  file can only be compiled on a Lynx
                                  file can only be compiled on a Lynx
                                  host.  */
                                  host.  */
                               + pss.data_start % pagesize
                               + pss.data_start % pagesize
#endif
#endif
                               );
                               );
  if (!newsect)
  if (!newsect)
    goto fail;
    goto fail;
 
 
/* And, now for the .reg/XXX pseudo sections.  Each thread has it's own
/* And, now for the .reg/XXX pseudo sections.  Each thread has it's own
   .reg/XXX section, where XXX is the thread id (without leading zeros).  The
   .reg/XXX section, where XXX is the thread id (without leading zeros).  The
   currently running thread (at the time of the core dump) also has an alias
   currently running thread (at the time of the core dump) also has an alias
   called `.reg' (just to keep GDB happy).  Note that we use `.reg/XXX' as
   called `.reg' (just to keep GDB happy).  Note that we use `.reg/XXX' as
   opposed to `.regXXX' because GDB expects that .reg2 will be the floating-
   opposed to `.regXXX' because GDB expects that .reg2 will be the floating-
   point registers.  */
   point registers.  */
 
 
  newsect = make_bfd_asection (abfd, ".reg",
  newsect = make_bfd_asection (abfd, ".reg",
                               SEC_HAS_CONTENTS,
                               SEC_HAS_CONTENTS,
                               sizeof (core_st_t),
                               sizeof (core_st_t),
                               0,
                               0,
                               pagesize);
                               pagesize);
  if (!newsect)
  if (!newsect)
    goto fail;
    goto fail;
 
 
  for (secnum = 0; secnum < pss.threadcnt; secnum++)
  for (secnum = 0; secnum < pss.threadcnt; secnum++)
    {
    {
      char secname[100];
      char secname[100];
 
 
      sprintf (secname, ".reg/%d", BUILDPID (0, threadp[secnum].tid));
      sprintf (secname, ".reg/%d", BUILDPID (0, threadp[secnum].tid));
      newsect = make_bfd_asection (abfd, secname,
      newsect = make_bfd_asection (abfd, secname,
                                   SEC_HAS_CONTENTS,
                                   SEC_HAS_CONTENTS,
                                   sizeof (core_st_t),
                                   sizeof (core_st_t),
                                   0,
                                   0,
                                   pagesize + secnum * sizeof (core_st_t));
                                   pagesize + secnum * sizeof (core_st_t));
      if (!newsect)
      if (!newsect)
        goto fail;
        goto fail;
    }
    }
 
 
  return abfd->xvec;
  return abfd->xvec;
 
 
 fail:
 fail:
  bfd_release (abfd, core_hdr (abfd));
  bfd_release (abfd, core_hdr (abfd));
  core_hdr (abfd) = NULL;
  core_hdr (abfd) = NULL;
  bfd_section_list_clear (abfd);
  bfd_section_list_clear (abfd);
  return NULL;
  return NULL;
}
}
 
 
char *
char *
lynx_core_file_failing_command (abfd)
lynx_core_file_failing_command (abfd)
     bfd *abfd;
     bfd *abfd;
{
{
  return core_command (abfd);
  return core_command (abfd);
}
}
 
 
int
int
lynx_core_file_failing_signal (abfd)
lynx_core_file_failing_signal (abfd)
     bfd *abfd;
     bfd *abfd;
{
{
  return core_signal (abfd);
  return core_signal (abfd);
}
}
 
 
#endif /* LYNX_CORE */
#endif /* LYNX_CORE */
 
 

powered by: WebSVN 2.1.0

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