~ubuntu-branches/ubuntu/quantal/gclcvs/quantal

« back to all changes in this revision

Viewing changes to binutils/bfd/hppabsd-core.c

  • Committer: Bazaar Package Importer
  • Author(s): Camm Maguire
  • Date: 2004-06-24 15:13:46 UTC
  • Revision ID: james.westby@ubuntu.com-20040624151346-xh0xaaktyyp7aorc
Tags: 2.7.0-26
C_GC_OFFSET is 2 on m68k-linux

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/* BFD back-end for HPPA BSD core files.
 
2
   Copyright 1993, 1994, 1995, 1998, 1999, 2001, 2002
 
3
   Free Software Foundation, Inc.
 
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
   Written by the Center for Software Science at the University of Utah
 
22
   and by Cygnus Support.
 
23
 
 
24
   The core file structure for the Utah 4.3BSD and OSF1 ports on the
 
25
   PA is a mix between traditional cores and hpux cores -- just
 
26
   different enough that supporting this format would tend to add
 
27
   gross hacks to trad-core.c or hpux-core.c.  So instead we keep any
 
28
   gross hacks isolated to this file.  */
 
29
 
 
30
/* This file can only be compiled on systems which use HPPA-BSD style
 
31
   core files.
 
32
 
 
33
   I would not expect this to be of use to any other host/target, but
 
34
   you never know.  */
 
35
 
 
36
#include "bfd.h"
 
37
#include "sysdep.h"
 
38
#include "libbfd.h"
 
39
 
 
40
#if defined (HOST_HPPABSD)
 
41
 
 
42
#include "machine/vmparam.h"
 
43
 
 
44
#include <sys/param.h>
 
45
#include <sys/dir.h>
 
46
#include <signal.h>
 
47
#include <machine/reg.h>
 
48
#include <sys/user.h>           /* After a.out.h  */
 
49
#include <sys/file.h>
 
50
 
 
51
static asection *make_bfd_asection PARAMS ((bfd *, const char *,
 
52
                                            flagword, bfd_size_type,
 
53
                                            file_ptr, unsigned int));
 
54
static const bfd_target *hppabsd_core_core_file_p PARAMS ((bfd *));
 
55
static char *hppabsd_core_core_file_failing_command PARAMS ((bfd *));
 
56
static int hppabsd_core_core_file_failing_signal PARAMS ((bfd *));
 
57
static boolean hppabsd_core_core_file_matches_executable_p
 
58
  PARAMS ((bfd *, bfd *));
 
59
static void swap_abort PARAMS ((void));
 
60
 
 
61
/* These are stored in the bfd's tdata.  */
 
62
 
 
63
struct hppabsd_core_struct
 
64
  {
 
65
    int sig;
 
66
    char cmd[MAXCOMLEN + 1];
 
67
    asection *data_section;
 
68
    asection *stack_section;
 
69
    asection *reg_section;
 
70
  };
 
71
 
 
72
#define core_hdr(bfd) ((bfd)->tdata.hppabsd_core_data)
 
73
#define core_signal(bfd) (core_hdr(bfd)->sig)
 
74
#define core_command(bfd) (core_hdr(bfd)->cmd)
 
75
#define core_datasec(bfd) (core_hdr(bfd)->data_section)
 
76
#define core_stacksec(bfd) (core_hdr(bfd)->stack_section)
 
77
#define core_regsec(bfd) (core_hdr(bfd)->reg_section)
 
78
 
 
79
static asection *
 
80
make_bfd_asection (abfd, name, flags, _raw_size, offset, alignment_power)
 
81
     bfd *abfd;
 
82
     const char *name;
 
83
     flagword flags;
 
84
     bfd_size_type _raw_size;
 
85
     file_ptr offset;
 
86
     unsigned int alignment_power;
 
87
{
 
88
  asection *asect;
 
89
 
 
90
  asect = bfd_make_section (abfd, name);
 
91
  if (!asect)
 
92
    return NULL;
 
93
 
 
94
  asect->flags = flags;
 
95
  asect->_raw_size = _raw_size;
 
96
  asect->filepos = offset;
 
97
  asect->alignment_power = alignment_power;
 
98
 
 
99
  return asect;
 
100
}
 
101
 
 
102
static const bfd_target *
 
103
hppabsd_core_core_file_p (abfd)
 
104
     bfd *abfd;
 
105
{
 
106
  int val;
 
107
  struct user u;
 
108
  struct hppabsd_core_struct *coredata;
 
109
  int clicksz;
 
110
 
 
111
  /* Try to read in the u-area.  We will need information from this
 
112
     to know how to grok the rest of the core structures.  */
 
113
  val = bfd_bread ((void *) &u, (bfd_size_type) sizeof u, abfd);
 
114
  if (val != sizeof u)
 
115
    {
 
116
      if (bfd_get_error () != bfd_error_system_call)
 
117
        bfd_set_error (bfd_error_wrong_format);
 
118
      return NULL;
 
119
    }
 
120
 
 
121
  /* Get the page size out of the u structure.  This will be different
 
122
     for PA 1.0 machines and PA 1.1 machines.   Yuk!  */
 
123
  clicksz = u.u_pcb.pcb_pgsz;
 
124
 
 
125
  /* clicksz must be a power of two >= 2k.  */
 
126
  if (clicksz < 0x800
 
127
      || clicksz != (clicksz & -clicksz))
 
128
    {
 
129
      bfd_set_error (bfd_error_wrong_format);
 
130
      return NULL;
 
131
    }
 
132
 
 
133
  /* Sanity checks.  Make sure the size of the core file matches the
 
134
     the size computed from information within the core itself.  */
 
135
  {
 
136
    FILE *stream = bfd_cache_lookup (abfd);
 
137
    struct stat statbuf;
 
138
    if (stream == NULL || fstat (fileno (stream), &statbuf) < 0)
 
139
      {
 
140
        bfd_set_error (bfd_error_system_call);
 
141
        return NULL;
 
142
      }
 
143
    if (NBPG * (UPAGES + u.u_dsize + u.u_ssize) > statbuf.st_size)
 
144
      {
 
145
        bfd_set_error (bfd_error_file_truncated);
 
146
        return NULL;
 
147
      }
 
148
    if (clicksz * (UPAGES + u.u_dsize + u.u_ssize) < statbuf.st_size)
 
149
      {
 
150
        /* The file is too big.  Maybe it's not a core file
 
151
           or we otherwise have bad values for u_dsize and u_ssize).  */
 
152
        bfd_set_error (bfd_error_wrong_format);
 
153
        return NULL;
 
154
      }
 
155
  }
 
156
 
 
157
  /* OK, we believe you.  You're a core file (sure, sure).  */
 
158
 
 
159
  coredata = (struct hppabsd_core_struct *)
 
160
    bfd_zalloc (abfd, (bfd_size_type) sizeof (struct hppabsd_core_struct));
 
161
  if (!coredata)
 
162
    return NULL;
 
163
 
 
164
  /* Make the core data and available via the tdata part of the BFD.  */
 
165
  abfd->tdata.hppabsd_core_data = coredata;
 
166
 
 
167
  /* Create the sections.  */
 
168
  core_stacksec (abfd) = make_bfd_asection (abfd, ".stack",
 
169
                                           SEC_ALLOC + SEC_HAS_CONTENTS,
 
170
                                           clicksz * u.u_ssize,
 
171
                                           NBPG * (USIZE + KSTAKSIZE)
 
172
                                             + clicksz * u.u_dsize, 2);
 
173
  if (core_stacksec (abfd) == NULL)
 
174
    goto fail;
 
175
  core_stacksec (abfd)->vma = USRSTACK;
 
176
 
 
177
  core_datasec (abfd) = make_bfd_asection (abfd, ".data",
 
178
                                          SEC_ALLOC + SEC_LOAD
 
179
                                            + SEC_HAS_CONTENTS,
 
180
                                          clicksz * u.u_dsize,
 
181
                                          NBPG * (USIZE + KSTAKSIZE), 2);
 
182
  if (core_datasec (abfd) == NULL)
 
183
    goto fail;
 
184
  core_datasec (abfd)->vma = UDATASEG;
 
185
 
 
186
  core_regsec (abfd) = make_bfd_asection (abfd, ".reg",
 
187
                                         SEC_HAS_CONTENTS,
 
188
                                         KSTAKSIZE * NBPG,
 
189
                                         NBPG * USIZE, 2);
 
190
  if (core_regsec (abfd) == NULL)
 
191
    goto fail;
 
192
  core_regsec (abfd)->vma = 0;
 
193
 
 
194
  strncpy (core_command (abfd), u.u_comm, MAXCOMLEN + 1);
 
195
  core_signal (abfd) = u.u_code;
 
196
  return abfd->xvec;
 
197
 
 
198
 fail:
 
199
  bfd_release (abfd, abfd->tdata.any);
 
200
  abfd->tdata.any = NULL;
 
201
  bfd_section_list_clear (abfd);
 
202
  return NULL;
 
203
}
 
204
 
 
205
static char *
 
206
hppabsd_core_core_file_failing_command (abfd)
 
207
     bfd *abfd;
 
208
{
 
209
  return core_command (abfd);
 
210
}
 
211
 
 
212
/* ARGSUSED */
 
213
static int
 
214
hppabsd_core_core_file_failing_signal (abfd)
 
215
     bfd *abfd;
 
216
{
 
217
  return core_signal (abfd);
 
218
}
 
219
 
 
220
/* ARGSUSED */
 
221
static boolean
 
222
hppabsd_core_core_file_matches_executable_p (core_bfd, exec_bfd)
 
223
     bfd *core_bfd, *exec_bfd;
 
224
{
 
225
  /* There's no way to know this...  */
 
226
  return true;
 
227
}
 
228
 
 
229
/* If somebody calls any byte-swapping routines, shoot them.  */
 
230
static void
 
231
swap_abort ()
 
232
{
 
233
  /* This way doesn't require any declaration for ANSI to fuck up.  */
 
234
  abort ();
 
235
}
 
236
 
 
237
#define NO_GET  ((bfd_vma (*) PARAMS ((   const bfd_byte *))) swap_abort )
 
238
#define NO_PUT  ((void    (*) PARAMS ((bfd_vma, bfd_byte *))) swap_abort )
 
239
#define NO_SIGNED_GET \
 
240
  ((bfd_signed_vma (*) PARAMS ((const bfd_byte *))) swap_abort )
 
241
 
 
242
const bfd_target hppabsd_core_vec =
 
243
  {
 
244
    "hppabsd-core",
 
245
    bfd_target_unknown_flavour,
 
246
    BFD_ENDIAN_BIG,             /* target byte order */
 
247
    BFD_ENDIAN_BIG,             /* target headers byte order */
 
248
    (HAS_RELOC | EXEC_P |       /* object flags */
 
249
     HAS_LINENO | HAS_DEBUG |
 
250
     HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
 
251
    (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
 
252
    0,                                                     /* symbol prefix */
 
253
    ' ',                                                   /* ar_pad_char */
 
254
    16,                                                    /* ar_max_namelen */
 
255
    NO_GET, NO_SIGNED_GET, NO_PUT,      /* 64 bit data */
 
256
    NO_GET, NO_SIGNED_GET, NO_PUT,      /* 32 bit data */
 
257
    NO_GET, NO_SIGNED_GET, NO_PUT,      /* 16 bit data */
 
258
    NO_GET, NO_SIGNED_GET, NO_PUT,      /* 64 bit hdrs */
 
259
    NO_GET, NO_SIGNED_GET, NO_PUT,      /* 32 bit hdrs */
 
260
    NO_GET, NO_SIGNED_GET, NO_PUT,      /* 16 bit hdrs */
 
261
 
 
262
    {                           /* bfd_check_format */
 
263
     _bfd_dummy_target,         /* unknown format */
 
264
     _bfd_dummy_target,         /* object file */
 
265
     _bfd_dummy_target,         /* archive */
 
266
     hppabsd_core_core_file_p   /* a core file */
 
267
    },
 
268
    {                           /* bfd_set_format */
 
269
     bfd_false, bfd_false,
 
270
     bfd_false, bfd_false
 
271
    },
 
272
    {                           /* bfd_write_contents */
 
273
     bfd_false, bfd_false,
 
274
     bfd_false, bfd_false
 
275
    },
 
276
 
 
277
    BFD_JUMP_TABLE_GENERIC (_bfd_generic),
 
278
    BFD_JUMP_TABLE_COPY (_bfd_generic),
 
279
    BFD_JUMP_TABLE_CORE (hppabsd_core),
 
280
    BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
 
281
    BFD_JUMP_TABLE_SYMBOLS (_bfd_nosymbols),
 
282
    BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
 
283
    BFD_JUMP_TABLE_WRITE (_bfd_generic),
 
284
    BFD_JUMP_TABLE_LINK (_bfd_nolink),
 
285
    BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 
286
 
 
287
    NULL,
 
288
 
 
289
    (PTR) 0                     /* backend_data */
 
290
};
 
291
#endif