← Back to branch summary

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

« back to all changes in this revision

Viewing changes to binutils/bfd/netbsd-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:
binutils/bfd/netbsd-core.c
 
1
/* BFD back end for NetBSD style core files
 
2
   Copyright 1988, 1989, 1991, 1992, 1993, 1996, 1998, 1999, 2000, 2001,
 
3
   2002
 
4
   Free Software Foundation, Inc.
 
5
   Written by Paul Kranenburg, EUR
 
6
 
 
7
This file is part of BFD, the Binary File Descriptor library.
 
8
 
 
9
This program is free software; you can redistribute it and/or modify
 
10
it under the terms of the GNU General Public License as published by
 
11
the Free Software Foundation; either version 2 of the License, or
 
12
(at your option) any later version.
 
13
 
 
14
This program is distributed in the hope that it will be useful,
 
15
but WITHOUT ANY WARRANTY; without even the implied warranty of
 
16
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
17
GNU General Public License for more details.
 
18
 
 
19
You should have received a copy of the GNU General Public License
 
20
along with this program; if not, write to the Free Software
 
21
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
22
 
 
23
#include "bfd.h"
 
24
#include "sysdep.h"
 
25
#include "libbfd.h"
 
26
#include "libaout.h"           /* BFD a.out internal data structures */
 
27
 
 
28
#include <sys/param.h>
 
29
#include <sys/dir.h>
 
30
#include <signal.h>
 
31
#include <sys/core.h>
 
32
 
 
33
/*
 
34
 * FIXME: On NetBSD/sparc CORE_FPU_OFFSET should be (sizeof (struct trapframe))
 
35
 */
 
36
 
 
37
struct netbsd_core_struct {
 
38
        struct core core;
 
39
} *rawptr;
 
40
 
 
41
/* forward declarations */
 
42
 
 
43
static const bfd_target *netbsd_core_file_p PARAMS ((bfd *abfd));
 
44
static char *netbsd_core_file_failing_command PARAMS ((bfd *abfd));
 
45
static int netbsd_core_file_failing_signal PARAMS ((bfd *abfd));
 
46
static boolean netbsd_core_file_matches_executable_p
 
47
  PARAMS ((bfd *core_bfd, bfd *exec_bfd));
 
48
static void swap_abort PARAMS ((void));
 
49
 
 
50
/* Handle NetBSD-style core dump file.  */
 
51
 
 
52
/* ARGSUSED */
 
53
static const bfd_target *
 
54
netbsd_core_file_p (abfd)
 
55
     bfd *abfd;
 
56
 
 
57
{
 
58
  int i, val;
 
59
  file_ptr offset;
 
60
  asection *asect, *asect2;
 
61
  struct core core;
 
62
  struct coreseg coreseg;
 
63
  bfd_size_type amt = sizeof core;
 
64
 
 
65
  val = bfd_bread ((void *) &core, amt, abfd);
 
66
  if (val != sizeof core)
 
67
    {
 
68
      /* Too small to be a core file */
 
69
      bfd_set_error (bfd_error_wrong_format);
 
70
      return 0;
 
71
    }
 
72
 
 
73
  if (CORE_GETMAGIC (core) != COREMAGIC)
 
74
    {
 
75
      bfd_set_error (bfd_error_wrong_format);
 
76
      return 0;
 
77
    }
 
78
 
 
79
  amt = sizeof (struct netbsd_core_struct);
 
80
  rawptr = (struct netbsd_core_struct *) bfd_zalloc (abfd, amt);
 
81
  if (rawptr == NULL)
 
82
    return 0;
 
83
 
 
84
  rawptr->core = core;
 
85
  abfd->tdata.netbsd_core_data = rawptr;
 
86
 
 
87
  offset = core.c_hdrsize;
 
88
  for (i = 0; i < core.c_nseg; i++)
 
89
    {
 
90
      const char *sname;
 
91
      flagword flags;
 
92
 
 
93
      if (bfd_seek (abfd, offset, SEEK_SET) != 0)
 
94
        goto punt;
 
95
 
 
96
      val = bfd_bread ((void *) &coreseg, (bfd_size_type) sizeof coreseg, abfd);
 
97
      if (val != sizeof coreseg)
 
98
        {
 
99
          bfd_set_error (bfd_error_file_truncated);
 
100
          goto punt;
 
101
        }
 
102
      if (CORE_GETMAGIC (coreseg) != CORESEGMAGIC)
 
103
        {
 
104
          bfd_set_error (bfd_error_wrong_format);
 
105
          goto punt;
 
106
        }
 
107
 
 
108
      offset += core.c_seghdrsize;
 
109
 
 
110
      switch (CORE_GETFLAG (coreseg))
 
111
        {
 
112
        case CORE_CPU:
 
113
          sname = ".reg";
 
114
          flags = SEC_ALLOC + SEC_HAS_CONTENTS;
 
115
          break;
 
116
        case CORE_DATA:
 
117
          sname = ".data";
 
118
          flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS;
 
119
          break;
 
120
        case CORE_STACK:
 
121
          sname = ".stack";
 
122
          flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS;
 
123
          break;
 
124
        default:
 
125
          sname = ".unknown";
 
126
          flags = SEC_ALLOC + SEC_HAS_CONTENTS;
 
127
          break;
 
128
        }
 
129
      asect = bfd_make_section_anyway (abfd, sname);
 
130
      if (asect == NULL)
 
131
        goto punt;
 
132
 
 
133
      asect->flags = flags;
 
134
      asect->_raw_size = coreseg.c_size;
 
135
      asect->vma = coreseg.c_addr;
 
136
      asect->filepos = offset;
 
137
      asect->alignment_power = 2;
 
138
 
 
139
      offset += coreseg.c_size;
 
140
 
 
141
#ifdef CORE_FPU_OFFSET
 
142
      switch (CORE_GETFLAG (coreseg))
 
143
        {
 
144
        case CORE_CPU:
 
145
          /* Hackish...  */
 
146
          asect->_raw_size = CORE_FPU_OFFSET;
 
147
          asect2 = bfd_make_section_anyway (abfd, ".reg2");
 
148
          if (asect2 == NULL)
 
149
            goto punt;
 
150
          asect2->_raw_size = coreseg.c_size - CORE_FPU_OFFSET;
 
151
          asect2->vma = 0;
 
152
          asect2->filepos = asect->filepos + CORE_FPU_OFFSET;
 
153
          asect2->alignment_power = 2;
 
154
          asect2->flags = SEC_ALLOC + SEC_HAS_CONTENTS;
 
155
          break;
 
156
        }
 
157
#endif
 
158
    }
 
159
 
 
160
  /* OK, we believe you.  You're a core file (sure, sure).  */
 
161
  return abfd->xvec;
 
162
 
 
163
 punt:
 
164
  bfd_release (abfd, abfd->tdata.any);
 
165
  abfd->tdata.any = NULL;
 
166
  bfd_section_list_clear (abfd);
 
167
  return 0;
 
168
}
 
169
 
 
170
static char*
 
171
netbsd_core_file_failing_command (abfd)
 
172
        bfd *abfd;
 
173
{
 
174
 /*return core_command (abfd);*/
 
175
  return abfd->tdata.netbsd_core_data->core.c_name;
 
176
}
 
177
 
 
178
/* ARGSUSED */
 
179
static int
 
180
netbsd_core_file_failing_signal (abfd)
 
181
        bfd *abfd;
 
182
{
 
183
  /*return core_signal (abfd);*/
 
184
  return abfd->tdata.netbsd_core_data->core.c_signo;
 
185
}
 
186
 
 
187
/* ARGSUSED */
 
188
static boolean
 
189
netbsd_core_file_matches_executable_p  (core_bfd, exec_bfd)
 
190
     bfd *core_bfd ATTRIBUTE_UNUSED;
 
191
     bfd *exec_bfd ATTRIBUTE_UNUSED;
 
192
{
 
193
  return true;          /* FIXME, We have no way of telling at this point */
 
194
}
 
195
 
 
196
/* If somebody calls any byte-swapping routines, shoot them.  */
 
197
static void
 
198
swap_abort ()
 
199
{
 
200
  abort (); /* This way doesn't require any declaration for ANSI to fuck up */
 
201
}
 
202
#define NO_GET  ((bfd_vma (*) PARAMS ((   const bfd_byte *))) swap_abort )
 
203
#define NO_PUT  ((void    (*) PARAMS ((bfd_vma, bfd_byte *))) swap_abort )
 
204
#define NO_SIGNED_GET \
 
205
  ((bfd_signed_vma (*) PARAMS ((const bfd_byte *))) swap_abort )
 
206
 
 
207
const bfd_target netbsd_core_vec =
 
208
  {
 
209
    "netbsd-core",
 
210
    bfd_target_unknown_flavour,
 
211
    BFD_ENDIAN_UNKNOWN,         /* target byte order */
 
212
    BFD_ENDIAN_UNKNOWN,         /* target headers byte order */
 
213
    (HAS_RELOC | EXEC_P |       /* object flags */
 
214
     HAS_LINENO | HAS_DEBUG |
 
215
     HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
 
216
    (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
 
217
    0,                                                     /* symbol prefix */
 
218
    ' ',                                                   /* ar_pad_char */
 
219
    16,                                                    /* ar_max_namelen */
 
220
    NO_GET, NO_SIGNED_GET, NO_PUT,      /* 64 bit data */
 
221
    NO_GET, NO_SIGNED_GET, NO_PUT,      /* 32 bit data */
 
222
    NO_GET, NO_SIGNED_GET, NO_PUT,      /* 16 bit data */
 
223
    NO_GET, NO_SIGNED_GET, NO_PUT,      /* 64 bit hdrs */
 
224
    NO_GET, NO_SIGNED_GET, NO_PUT,      /* 32 bit hdrs */
 
225
    NO_GET, NO_SIGNED_GET, NO_PUT,      /* 16 bit hdrs */
 
226
 
 
227
    {                           /* bfd_check_format */
 
228
     _bfd_dummy_target,         /* unknown format */
 
229
     _bfd_dummy_target,         /* object file */
 
230
     _bfd_dummy_target,         /* archive */
 
231
     netbsd_core_file_p         /* a core file */
 
232
    },
 
233
    {                           /* bfd_set_format */
 
234
     bfd_false, bfd_false,
 
235
     bfd_false, bfd_false
 
236
    },
 
237
    {                           /* bfd_write_contents */
 
238
     bfd_false, bfd_false,
 
239
     bfd_false, bfd_false
 
240
    },
 
241
 
 
242
       BFD_JUMP_TABLE_GENERIC (_bfd_generic),
 
243
       BFD_JUMP_TABLE_COPY (_bfd_generic),
 
244
       BFD_JUMP_TABLE_CORE (netbsd),
 
245
       BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
 
246
       BFD_JUMP_TABLE_SYMBOLS (_bfd_nosymbols),
 
247
       BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
 
248
       BFD_JUMP_TABLE_WRITE (_bfd_generic),
 
249
       BFD_JUMP_TABLE_LINK (_bfd_nolink),
 
250
       BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 
251
 
 
252
    NULL,
 
253
 
 
254
    (PTR) 0                     /* backend_data */
 
255
};