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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [bfd/] [elfcore.h] - Blame information for rev 834

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* ELF core file support for BFD.
2
   Copyright 1995, 1996, 1997, 1998, 2000, 2001, 2002, 2003, 2005, 2007,
3
   2008, 2010 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 3 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., 51 Franklin Street - Fifth Floor, Boston,
20
   MA 02110-1301, USA.  */
21
 
22
char*
23
elf_core_file_failing_command (bfd *abfd)
24
{
25
  return elf_tdata (abfd)->core_command;
26
}
27
 
28
int
29
elf_core_file_failing_signal (bfd *abfd)
30
{
31
  return elf_tdata (abfd)->core_signal;
32
}
33
 
34
bfd_boolean
35
elf_core_file_matches_executable_p (bfd *core_bfd, bfd *exec_bfd)
36
{
37
  char* corename;
38
 
39
  /* xvecs must match if both are ELF files for the same target.  */
40
 
41
  if (core_bfd->xvec != exec_bfd->xvec)
42
    {
43
      bfd_set_error (bfd_error_system_call);
44
      return FALSE;
45
    }
46
 
47
  /* See if the name in the corefile matches the executable name.  */
48
  corename = elf_tdata (core_bfd)->core_program;
49
  if (corename != NULL)
50
    {
51
      const char* execname = strrchr (exec_bfd->filename, '/');
52
 
53
      execname = execname ? execname + 1 : exec_bfd->filename;
54
 
55
      if (strcmp (execname, corename) != 0)
56
        return FALSE;
57
    }
58
 
59
  return TRUE;
60
}
61
 
62
/*  Core files are simply standard ELF formatted files that partition
63
    the file using the execution view of the file (program header table)
64
    rather than the linking view.  In fact, there is no section header
65
    table in a core file.
66
 
67
    The process status information (including the contents of the general
68
    register set) and the floating point register set are stored in a
69
    segment of type PT_NOTE.  We handcraft a couple of extra bfd sections
70
    that allow standard bfd access to the general registers (.reg) and the
71
    floating point registers (.reg2).  */
72
 
73
const bfd_target *
74
elf_core_file_p (bfd *abfd)
75
{
76
  Elf_External_Ehdr x_ehdr;     /* Elf file header, external form.  */
77
  Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form.  */
78
  Elf_Internal_Phdr *i_phdrp;   /* Elf program header, internal form.  */
79
  unsigned int phindex;
80
  const struct elf_backend_data *ebd;
81
  struct bfd_preserve preserve;
82
  bfd_size_type amt;
83
 
84
  preserve.marker = NULL;
85
 
86
  /* Read in the ELF header in external format.  */
87
  if (bfd_bread (&x_ehdr, sizeof (x_ehdr), abfd) != sizeof (x_ehdr))
88
    {
89
      if (bfd_get_error () != bfd_error_system_call)
90
        goto wrong;
91
      else
92
        goto fail;
93
    }
94
 
95
  /* Check the magic number.  */
96
  if (! elf_file_p (&x_ehdr))
97
    goto wrong;
98
 
99
  /* FIXME: Check EI_VERSION here !  */
100
 
101
  /* Check the address size ("class").  */
102
  if (x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
103
    goto wrong;
104
 
105
  /* Check the byteorder.  */
106
  switch (x_ehdr.e_ident[EI_DATA])
107
    {
108
    case ELFDATA2MSB:           /* Big-endian.  */
109
      if (! bfd_big_endian (abfd))
110
        goto wrong;
111
      break;
112
    case ELFDATA2LSB:           /* Little-endian.  */
113
      if (! bfd_little_endian (abfd))
114
        goto wrong;
115
      break;
116
    default:
117
      goto wrong;
118
    }
119
 
120
  if (!bfd_preserve_save (abfd, &preserve))
121
    goto fail;
122
 
123
  /* Give abfd an elf_obj_tdata.  */
124
  if (! (*abfd->xvec->_bfd_set_format[bfd_core]) (abfd))
125
    goto fail;
126
  preserve.marker = elf_tdata (abfd);
127
 
128
  /* Swap in the rest of the header, now that we have the byte order.  */
129
  i_ehdrp = elf_elfheader (abfd);
130
  elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
131
 
132
#if DEBUG & 1
133
  elf_debug_file (i_ehdrp);
134
#endif
135
 
136
  ebd = get_elf_backend_data (abfd);
137
 
138
  /* Check that the ELF e_machine field matches what this particular
139
     BFD format expects.  */
140
 
141
  if (ebd->elf_machine_code != i_ehdrp->e_machine
142
      && (ebd->elf_machine_alt1 == 0
143
          || i_ehdrp->e_machine != ebd->elf_machine_alt1)
144
      && (ebd->elf_machine_alt2 == 0
145
          || i_ehdrp->e_machine != ebd->elf_machine_alt2))
146
    {
147
      const bfd_target * const *target_ptr;
148
 
149
      if (ebd->elf_machine_code != EM_NONE)
150
        goto wrong;
151
 
152
      /* This is the generic ELF target.  Let it match any ELF target
153
         for which we do not have a specific backend.  */
154
 
155
      for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
156
        {
157
          const struct elf_backend_data *back;
158
 
159
          if ((*target_ptr)->flavour != bfd_target_elf_flavour)
160
            continue;
161
          back = xvec_get_elf_backend_data (*target_ptr);
162
          if (back->s->arch_size != ARCH_SIZE)
163
            continue;
164
          if (back->elf_machine_code == i_ehdrp->e_machine
165
              || (back->elf_machine_alt1 != 0
166
                  && i_ehdrp->e_machine == back->elf_machine_alt1)
167
              || (back->elf_machine_alt2 != 0
168
                  && i_ehdrp->e_machine == back->elf_machine_alt2))
169
            {
170
              /* target_ptr is an ELF backend which matches this
171
                 object file, so reject the generic ELF target.  */
172
              goto wrong;
173
            }
174
        }
175
    }
176
 
177
  /* If there is no program header, or the type is not a core file, then
178
     we are hosed.  */
179
  if (i_ehdrp->e_phoff == 0 || i_ehdrp->e_type != ET_CORE)
180
    goto wrong;
181
 
182
  /* Does BFD's idea of the phdr size match the size
183
     recorded in the file? */
184
  if (i_ehdrp->e_phentsize != sizeof (Elf_External_Phdr))
185
    goto wrong;
186
 
187
  /* If the program header count is PN_XNUM(0xffff), the actual
188
     count is in the first section header.  */
189
  if (i_ehdrp->e_shoff != 0 && i_ehdrp->e_phnum == PN_XNUM)
190
    {
191
      Elf_External_Shdr x_shdr;
192
      Elf_Internal_Shdr i_shdr;
193
      bfd_signed_vma where = i_ehdrp->e_shoff;
194
 
195
      if (where != (file_ptr) where)
196
        goto wrong;
197
 
198
      /* Seek to the section header table in the file.  */
199
      if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
200
        goto fail;
201
 
202
      /* Read the first section header at index 0, and convert to internal
203
         form.  */
204
      if (bfd_bread (&x_shdr, sizeof (x_shdr), abfd) != sizeof (x_shdr))
205
        goto fail;
206
      elf_swap_shdr_in (abfd, &x_shdr, &i_shdr);
207
 
208
      if (i_shdr.sh_info != 0)
209
        {
210
          i_ehdrp->e_phnum = i_shdr.sh_info;
211
          if (i_ehdrp->e_phnum != i_shdr.sh_info)
212
            goto wrong;
213
        }
214
    }
215
 
216
  /* Sanity check that we can read all of the program headers.
217
     It ought to be good enough to just read the last one.  */
218
  if (i_ehdrp->e_phnum > 1)
219
    {
220
      Elf_External_Phdr x_phdr;
221
      Elf_Internal_Phdr i_phdr;
222
      bfd_signed_vma where;
223
 
224
      /* Check that we don't have a totally silly number of
225
         program headers.  */
226
      if (i_ehdrp->e_phnum > (unsigned int) -1 / sizeof (x_phdr)
227
          || i_ehdrp->e_phnum > (unsigned int) -1 / sizeof (i_phdr))
228
        goto wrong;
229
 
230
      where = i_ehdrp->e_phoff + (i_ehdrp->e_phnum - 1) * sizeof (x_phdr);
231
      if (where != (file_ptr) where)
232
        goto wrong;
233
      if ((bfd_size_type) where <= i_ehdrp->e_phoff)
234
        goto wrong;
235
 
236
      if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
237
        goto fail;
238
      if (bfd_bread (&x_phdr, sizeof (x_phdr), abfd) != sizeof (x_phdr))
239
        goto fail;
240
    }
241
 
242
  /* Move to the start of the program headers.  */
243
  if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
244
    goto wrong;
245
 
246
  /* Allocate space for the program headers.  */
247
  amt = sizeof (*i_phdrp) * i_ehdrp->e_phnum;
248
  i_phdrp = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
249
  if (!i_phdrp)
250
    goto fail;
251
 
252
  elf_tdata (abfd)->phdr = i_phdrp;
253
 
254
  /* Read and convert to internal form.  */
255
  for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
256
    {
257
      Elf_External_Phdr x_phdr;
258
 
259
      if (bfd_bread (&x_phdr, sizeof (x_phdr), abfd) != sizeof (x_phdr))
260
        goto fail;
261
 
262
      elf_swap_phdr_in (abfd, &x_phdr, i_phdrp + phindex);
263
    }
264
 
265
  /* Set the machine architecture.  Do this before processing the
266
     program headers since we need to know the architecture type
267
     when processing the notes of some systems' core files.  */
268
  if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0)
269
      /* It's OK if this fails for the generic target.  */
270
      && ebd->elf_machine_code != EM_NONE)
271
    goto fail;
272
 
273
  /* Let the backend double check the format and override global
274
     information.  We do this before processing the program headers
275
     to allow the correct machine (as opposed to just the default
276
     machine) to be set, making it possible for grok_prstatus and
277
     grok_psinfo to rely on the mach setting.  */
278
  if (ebd->elf_backend_object_p != NULL
279
      && ! ebd->elf_backend_object_p (abfd))
280
    goto wrong;
281
 
282
  /* Process each program header.  */
283
  for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
284
    if (! bfd_section_from_phdr (abfd, i_phdrp + phindex, (int) phindex))
285
      goto fail;
286
 
287
  /* Check for core truncation.  */
288
  {
289
    bfd_size_type high = 0;
290
    struct stat statbuf;
291
    for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
292
      {
293
        Elf_Internal_Phdr *p = i_phdrp + phindex;
294
        if (p->p_filesz)
295
          {
296
            bfd_size_type current = p->p_offset + p->p_filesz;
297
            if (high < current)
298
              high = current;
299
          }
300
      }
301
    if (bfd_stat (abfd, &statbuf) == 0)
302
      {
303
        if ((bfd_size_type) statbuf.st_size < high)
304
          {
305
            (*_bfd_error_handler)
306
              (_("Warning: %B is truncated: expected core file "
307
                 "size >= %lu, found: %lu."),
308
               abfd, (unsigned long) high, (unsigned long) statbuf.st_size);
309
          }
310
      }
311
  }
312
 
313
  /* Save the entry point from the ELF header.  */
314
  bfd_get_start_address (abfd) = i_ehdrp->e_entry;
315
 
316
  bfd_preserve_finish (abfd, &preserve);
317
  return abfd->xvec;
318
 
319
wrong:
320
  /* There is way too much undoing of half-known state here.  The caller,
321
     bfd_check_format_matches, really shouldn't iterate on live bfd's to
322
     check match/no-match like it does.  We have to rely on that a call to
323
     bfd_default_set_arch_mach with the previously known mach, undoes what
324
     was done by the first bfd_default_set_arch_mach (with mach 0) here.
325
     For this to work, only elf-data and the mach may be changed by the
326
     target-specific elf_backend_object_p function.  Note that saving the
327
     whole bfd here and restoring it would be even worse; the first thing
328
     you notice is that the cached bfd file position gets out of sync.  */
329
  bfd_set_error (bfd_error_wrong_format);
330
 
331
fail:
332
  if (preserve.marker != NULL)
333
    bfd_preserve_restore (abfd, &preserve);
334
  return NULL;
335
}

powered by: WebSVN 2.1.0

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