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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [bfd/] [elfcore.h] - Blame information for rev 156

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* ELF core file support for BFD.
2
   Copyright 1995, 1996, 1997, 1998, 2000, 2001, 2002, 2003, 2005, 2007
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 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->elf_machine_code == i_ehdrp->e_machine
163
              || (back->elf_machine_alt1 != 0
164
                  && i_ehdrp->e_machine == back->elf_machine_alt1)
165
              || (back->elf_machine_alt2 != 0
166
                  && i_ehdrp->e_machine == back->elf_machine_alt2))
167
            {
168
              /* target_ptr is an ELF backend which matches this
169
                 object file, so reject the generic ELF target.  */
170
              goto wrong;
171
            }
172
        }
173
    }
174
 
175
  /* If there is no program header, or the type is not a core file, then
176
     we are hosed.  */
177
  if (i_ehdrp->e_phoff == 0 || i_ehdrp->e_type != ET_CORE)
178
    goto wrong;
179
 
180
  /* Does BFD's idea of the phdr size match the size
181
     recorded in the file? */
182
  if (i_ehdrp->e_phentsize != sizeof (Elf_External_Phdr))
183
    goto wrong;
184
 
185
  /* Move to the start of the program headers.  */
186
  if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
187
    goto wrong;
188
 
189
  /* Allocate space for the program headers.  */
190
  amt = sizeof (*i_phdrp) * i_ehdrp->e_phnum;
191
  i_phdrp = bfd_alloc (abfd, amt);
192
  if (!i_phdrp)
193
    goto fail;
194
 
195
  elf_tdata (abfd)->phdr = i_phdrp;
196
 
197
  /* Read and convert to internal form.  */
198
  for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
199
    {
200
      Elf_External_Phdr x_phdr;
201
 
202
      if (bfd_bread (&x_phdr, sizeof (x_phdr), abfd) != sizeof (x_phdr))
203
        goto fail;
204
 
205
      elf_swap_phdr_in (abfd, &x_phdr, i_phdrp + phindex);
206
    }
207
 
208
  /* Set the machine architecture.  Do this before processing the
209
     program headers since we need to know the architecture type
210
     when processing the notes of some systems' core files.  */
211
  if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0)
212
      /* It's OK if this fails for the generic target.  */
213
      && ebd->elf_machine_code != EM_NONE)
214
    goto fail;
215
 
216
  /* Let the backend double check the format and override global
217
     information.  We do this before processing the program headers
218
     to allow the correct machine (as opposed to just the default
219
     machine) to be set, making it possible for grok_prstatus and
220
     grok_psinfo to rely on the mach setting.  */
221
  if (ebd->elf_backend_object_p != NULL
222
      && ! ebd->elf_backend_object_p (abfd))
223
    goto wrong;
224
 
225
  /* Process each program header.  */
226
  for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
227
    if (! bfd_section_from_phdr (abfd, i_phdrp + phindex, (int) phindex))
228
      goto fail;
229
 
230
  /* Save the entry point from the ELF header.  */
231
  bfd_get_start_address (abfd) = i_ehdrp->e_entry;
232
 
233
  bfd_preserve_finish (abfd, &preserve);
234
  return abfd->xvec;
235
 
236
wrong:
237
  /* There is way too much undoing of half-known state here.  The caller,
238
     bfd_check_format_matches, really shouldn't iterate on live bfd's to
239
     check match/no-match like it does.  We have to rely on that a call to
240
     bfd_default_set_arch_mach with the previously known mach, undoes what
241
     was done by the first bfd_default_set_arch_mach (with mach 0) here.
242
     For this to work, only elf-data and the mach may be changed by the
243
     target-specific elf_backend_object_p function.  Note that saving the
244
     whole bfd here and restoring it would be even worse; the first thing
245
     you notice is that the cached bfd file position gets out of sync.  */
246
  bfd_set_error (bfd_error_wrong_format);
247
 
248
fail:
249
  if (preserve.marker != NULL)
250
    bfd_preserve_restore (abfd, &preserve);
251
  return NULL;
252
}

powered by: WebSVN 2.1.0

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