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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.20.1/] [bfd/] [elfcode.h] - Blame information for rev 298

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

Line No. Rev Author Line
1 205 julius
/* ELF executable support for BFD.
2
   Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3
   2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4
   Free Software Foundation, Inc.
5
 
6
   Written by Fred Fish @ Cygnus Support, from information published
7
   in "UNIX System V Release 4, Programmers Guide: ANSI C and
8
   Programming Support Tools".  Sufficient support for gdb.
9
 
10
   Rewritten by Mark Eichin @ Cygnus Support, from information
11
   published in "System V Application Binary Interface", chapters 4
12
   and 5, as well as the various "Processor Supplement" documents
13
   derived from it. Added support for assembler and other object file
14
   utilities.  Further work done by Ken Raeburn (Cygnus Support), Michael
15
   Meissner (Open Software Foundation), and Peter Hoogenboom (University
16
   of Utah) to finish and extend this.
17
 
18
   This file is part of BFD, the Binary File Descriptor library.
19
 
20
   This program is free software; you can redistribute it and/or modify
21
   it under the terms of the GNU General Public License as published by
22
   the Free Software Foundation; either version 3 of the License, or
23
   (at your option) any later version.
24
 
25
   This program is distributed in the hope that it will be useful,
26
   but WITHOUT ANY WARRANTY; without even the implied warranty of
27
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
28
   GNU General Public License for more details.
29
 
30
   You should have received a copy of the GNU General Public License
31
   along with this program; if not, write to the Free Software
32
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
33
   MA 02110-1301, USA.  */
34
 
35
 
36
/* Problems and other issues to resolve.
37
 
38
   (1)  BFD expects there to be some fixed number of "sections" in
39
        the object file.  I.E. there is a "section_count" variable in the
40
        bfd structure which contains the number of sections.  However, ELF
41
        supports multiple "views" of a file.  In particular, with current
42
        implementations, executable files typically have two tables, a
43
        program header table and a section header table, both of which
44
        partition the executable.
45
 
46
        In ELF-speak, the "linking view" of the file uses the section header
47
        table to access "sections" within the file, and the "execution view"
48
        uses the program header table to access "segments" within the file.
49
        "Segments" typically may contain all the data from one or more
50
        "sections".
51
 
52
        Note that the section header table is optional in ELF executables,
53
        but it is this information that is most useful to gdb.  If the
54
        section header table is missing, then gdb should probably try
55
        to make do with the program header table.  (FIXME)
56
 
57
   (2)  The code in this file is compiled twice, once in 32-bit mode and
58
        once in 64-bit mode.  More of it should be made size-independent
59
        and moved into elf.c.
60
 
61
   (3)  ELF section symbols are handled rather sloppily now.  This should
62
        be cleaned up, and ELF section symbols reconciled with BFD section
63
        symbols.
64
 
65
   (4)  We need a published spec for 64-bit ELF.  We've got some stuff here
66
        that we're using for SPARC V9 64-bit chips, but don't assume that
67
        it's cast in stone.
68
 */
69
 
70
#include "sysdep.h"
71
#include "bfd.h"
72
#include "libiberty.h"
73
#include "bfdlink.h"
74
#include "libbfd.h"
75
#include "elf-bfd.h"
76
 
77
/* Renaming structures, typedefs, macros and functions to be size-specific.  */
78
#define Elf_External_Ehdr       NAME(Elf,External_Ehdr)
79
#define Elf_External_Sym        NAME(Elf,External_Sym)
80
#define Elf_External_Shdr       NAME(Elf,External_Shdr)
81
#define Elf_External_Phdr       NAME(Elf,External_Phdr)
82
#define Elf_External_Rel        NAME(Elf,External_Rel)
83
#define Elf_External_Rela       NAME(Elf,External_Rela)
84
#define Elf_External_Dyn        NAME(Elf,External_Dyn)
85
 
86
#define elf_core_file_failing_command   NAME(bfd_elf,core_file_failing_command)
87
#define elf_core_file_failing_signal    NAME(bfd_elf,core_file_failing_signal)
88
#define elf_core_file_matches_executable_p \
89
  NAME(bfd_elf,core_file_matches_executable_p)
90
#define elf_object_p                    NAME(bfd_elf,object_p)
91
#define elf_core_file_p                 NAME(bfd_elf,core_file_p)
92
#define elf_get_symtab_upper_bound      NAME(bfd_elf,get_symtab_upper_bound)
93
#define elf_get_dynamic_symtab_upper_bound \
94
  NAME(bfd_elf,get_dynamic_symtab_upper_bound)
95
#define elf_swap_reloc_in               NAME(bfd_elf,swap_reloc_in)
96
#define elf_swap_reloca_in              NAME(bfd_elf,swap_reloca_in)
97
#define elf_swap_reloc_out              NAME(bfd_elf,swap_reloc_out)
98
#define elf_swap_reloca_out             NAME(bfd_elf,swap_reloca_out)
99
#define elf_swap_symbol_in              NAME(bfd_elf,swap_symbol_in)
100
#define elf_swap_symbol_out             NAME(bfd_elf,swap_symbol_out)
101
#define elf_swap_phdr_in                NAME(bfd_elf,swap_phdr_in)
102
#define elf_swap_phdr_out               NAME(bfd_elf,swap_phdr_out)
103
#define elf_swap_dyn_in                 NAME(bfd_elf,swap_dyn_in)
104
#define elf_swap_dyn_out                NAME(bfd_elf,swap_dyn_out)
105
#define elf_get_reloc_upper_bound       NAME(bfd_elf,get_reloc_upper_bound)
106
#define elf_canonicalize_reloc          NAME(bfd_elf,canonicalize_reloc)
107
#define elf_slurp_symbol_table          NAME(bfd_elf,slurp_symbol_table)
108
#define elf_canonicalize_symtab         NAME(bfd_elf,canonicalize_symtab)
109
#define elf_canonicalize_dynamic_symtab \
110
  NAME(bfd_elf,canonicalize_dynamic_symtab)
111
#define elf_get_synthetic_symtab \
112
  NAME(bfd_elf,get_synthetic_symtab)
113
#define elf_make_empty_symbol           NAME(bfd_elf,make_empty_symbol)
114
#define elf_get_symbol_info             NAME(bfd_elf,get_symbol_info)
115
#define elf_get_lineno                  NAME(bfd_elf,get_lineno)
116
#define elf_set_arch_mach               NAME(bfd_elf,set_arch_mach)
117
#define elf_find_nearest_line           NAME(bfd_elf,find_nearest_line)
118
#define elf_sizeof_headers              NAME(bfd_elf,sizeof_headers)
119
#define elf_set_section_contents        NAME(bfd_elf,set_section_contents)
120
#define elf_no_info_to_howto            NAME(bfd_elf,no_info_to_howto)
121
#define elf_no_info_to_howto_rel        NAME(bfd_elf,no_info_to_howto_rel)
122
#define elf_find_section                NAME(bfd_elf,find_section)
123
#define elf_write_shdrs_and_ehdr        NAME(bfd_elf,write_shdrs_and_ehdr)
124
#define elf_write_out_phdrs             NAME(bfd_elf,write_out_phdrs)
125
#define elf_checksum_contents           NAME(bfd_elf,checksum_contents)
126
#define elf_write_relocs                NAME(bfd_elf,write_relocs)
127
#define elf_slurp_reloc_table           NAME(bfd_elf,slurp_reloc_table)
128
 
129
#if ARCH_SIZE == 64
130
#define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
131
#define ELF_R_SYM(X)    ELF64_R_SYM(X)
132
#define ELF_R_TYPE(X)   ELF64_R_TYPE(X)
133
#define ELFCLASS        ELFCLASS64
134
#define FILE_ALIGN      8
135
#define LOG_FILE_ALIGN  3
136
#endif
137
#if ARCH_SIZE == 32
138
#define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
139
#define ELF_R_SYM(X)    ELF32_R_SYM(X)
140
#define ELF_R_TYPE(X)   ELF32_R_TYPE(X)
141
#define ELFCLASS        ELFCLASS32
142
#define FILE_ALIGN      4
143
#define LOG_FILE_ALIGN  2
144
#endif
145
 
146
#if DEBUG & 2
147
static void elf_debug_section (int, Elf_Internal_Shdr *);
148
#endif
149
#if DEBUG & 1
150
static void elf_debug_file (Elf_Internal_Ehdr *);
151
#endif
152
 
153
/* Structure swapping routines */
154
 
155
/* Should perhaps use put_offset, put_word, etc.  For now, the two versions
156
   can be handled by explicitly specifying 32 bits or "the long type".  */
157
#if ARCH_SIZE == 64
158
#define H_PUT_WORD              H_PUT_64
159
#define H_PUT_SIGNED_WORD       H_PUT_S64
160
#define H_GET_WORD              H_GET_64
161
#define H_GET_SIGNED_WORD       H_GET_S64
162
#endif
163
#if ARCH_SIZE == 32
164
#define H_PUT_WORD              H_PUT_32
165
#define H_PUT_SIGNED_WORD       H_PUT_S32
166
#define H_GET_WORD              H_GET_32
167
#define H_GET_SIGNED_WORD       H_GET_S32
168
#endif
169
 
170
/* Translate an ELF symbol in external format into an ELF symbol in internal
171
   format.  */
172
 
173
bfd_boolean
174
elf_swap_symbol_in (bfd *abfd,
175
                    const void *psrc,
176
                    const void *pshn,
177
                    Elf_Internal_Sym *dst)
178
{
179
  const Elf_External_Sym *src = (const Elf_External_Sym *) psrc;
180
  const Elf_External_Sym_Shndx *shndx = (const Elf_External_Sym_Shndx *) pshn;
181
  int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
182
 
183
  dst->st_name = H_GET_32 (abfd, src->st_name);
184
  if (signed_vma)
185
    dst->st_value = H_GET_SIGNED_WORD (abfd, src->st_value);
186
  else
187
    dst->st_value = H_GET_WORD (abfd, src->st_value);
188
  dst->st_size = H_GET_WORD (abfd, src->st_size);
189
  dst->st_info = H_GET_8 (abfd, src->st_info);
190
  dst->st_other = H_GET_8 (abfd, src->st_other);
191
  dst->st_shndx = H_GET_16 (abfd, src->st_shndx);
192
  if (dst->st_shndx == (SHN_XINDEX & 0xffff))
193
    {
194
      if (shndx == NULL)
195
        return FALSE;
196
      dst->st_shndx = H_GET_32 (abfd, shndx->est_shndx);
197
    }
198
  else if (dst->st_shndx >= (SHN_LORESERVE & 0xffff))
199
    dst->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
200
  return TRUE;
201
}
202
 
203
/* Translate an ELF symbol in internal format into an ELF symbol in external
204
   format.  */
205
 
206
void
207
elf_swap_symbol_out (bfd *abfd,
208
                     const Elf_Internal_Sym *src,
209
                     void *cdst,
210
                     void *shndx)
211
{
212
  unsigned int tmp;
213
  Elf_External_Sym *dst = (Elf_External_Sym *) cdst;
214
  H_PUT_32 (abfd, src->st_name, dst->st_name);
215
  H_PUT_WORD (abfd, src->st_value, dst->st_value);
216
  H_PUT_WORD (abfd, src->st_size, dst->st_size);
217
  H_PUT_8 (abfd, src->st_info, dst->st_info);
218
  H_PUT_8 (abfd, src->st_other, dst->st_other);
219
  tmp = src->st_shndx;
220
  if (tmp >= (SHN_LORESERVE & 0xffff) && tmp < SHN_LORESERVE)
221
    {
222
      if (shndx == NULL)
223
        abort ();
224
      H_PUT_32 (abfd, tmp, shndx);
225
      tmp = SHN_XINDEX & 0xffff;
226
    }
227
  H_PUT_16 (abfd, tmp, dst->st_shndx);
228
}
229
 
230
/* Translate an ELF file header in external format into an ELF file header in
231
   internal format.  */
232
 
233
static void
234
elf_swap_ehdr_in (bfd *abfd,
235
                  const Elf_External_Ehdr *src,
236
                  Elf_Internal_Ehdr *dst)
237
{
238
  int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
239
  memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
240
  dst->e_type = H_GET_16 (abfd, src->e_type);
241
  dst->e_machine = H_GET_16 (abfd, src->e_machine);
242
  dst->e_version = H_GET_32 (abfd, src->e_version);
243
  if (signed_vma)
244
    dst->e_entry = H_GET_SIGNED_WORD (abfd, src->e_entry);
245
  else
246
    dst->e_entry = H_GET_WORD (abfd, src->e_entry);
247
  dst->e_phoff = H_GET_WORD (abfd, src->e_phoff);
248
  dst->e_shoff = H_GET_WORD (abfd, src->e_shoff);
249
  dst->e_flags = H_GET_32 (abfd, src->e_flags);
250
  dst->e_ehsize = H_GET_16 (abfd, src->e_ehsize);
251
  dst->e_phentsize = H_GET_16 (abfd, src->e_phentsize);
252
  dst->e_phnum = H_GET_16 (abfd, src->e_phnum);
253
  dst->e_shentsize = H_GET_16 (abfd, src->e_shentsize);
254
  dst->e_shnum = H_GET_16 (abfd, src->e_shnum);
255
  dst->e_shstrndx = H_GET_16 (abfd, src->e_shstrndx);
256
}
257
 
258
/* Translate an ELF file header in internal format into an ELF file header in
259
   external format.  */
260
 
261
static void
262
elf_swap_ehdr_out (bfd *abfd,
263
                   const Elf_Internal_Ehdr *src,
264
                   Elf_External_Ehdr *dst)
265
{
266
  unsigned int tmp;
267
  int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
268
  memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
269
  /* note that all elements of dst are *arrays of unsigned char* already...  */
270
  H_PUT_16 (abfd, src->e_type, dst->e_type);
271
  H_PUT_16 (abfd, src->e_machine, dst->e_machine);
272
  H_PUT_32 (abfd, src->e_version, dst->e_version);
273
  if (signed_vma)
274
    H_PUT_SIGNED_WORD (abfd, src->e_entry, dst->e_entry);
275
  else
276
    H_PUT_WORD (abfd, src->e_entry, dst->e_entry);
277
  H_PUT_WORD (abfd, src->e_phoff, dst->e_phoff);
278
  H_PUT_WORD (abfd, src->e_shoff, dst->e_shoff);
279
  H_PUT_32 (abfd, src->e_flags, dst->e_flags);
280
  H_PUT_16 (abfd, src->e_ehsize, dst->e_ehsize);
281
  H_PUT_16 (abfd, src->e_phentsize, dst->e_phentsize);
282
  H_PUT_16 (abfd, src->e_phnum, dst->e_phnum);
283
  H_PUT_16 (abfd, src->e_shentsize, dst->e_shentsize);
284
  tmp = src->e_shnum;
285
  if (tmp >= (SHN_LORESERVE & 0xffff))
286
    tmp = SHN_UNDEF;
287
  H_PUT_16 (abfd, tmp, dst->e_shnum);
288
  tmp = src->e_shstrndx;
289
  if (tmp >= (SHN_LORESERVE & 0xffff))
290
    tmp = SHN_XINDEX & 0xffff;
291
  H_PUT_16 (abfd, tmp, dst->e_shstrndx);
292
}
293
 
294
/* Translate an ELF section header table entry in external format into an
295
   ELF section header table entry in internal format.  */
296
 
297
static void
298
elf_swap_shdr_in (bfd *abfd,
299
                  const Elf_External_Shdr *src,
300
                  Elf_Internal_Shdr *dst)
301
{
302
  int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
303
 
304
  dst->sh_name = H_GET_32 (abfd, src->sh_name);
305
  dst->sh_type = H_GET_32 (abfd, src->sh_type);
306
  dst->sh_flags = H_GET_WORD (abfd, src->sh_flags);
307
  if (signed_vma)
308
    dst->sh_addr = H_GET_SIGNED_WORD (abfd, src->sh_addr);
309
  else
310
    dst->sh_addr = H_GET_WORD (abfd, src->sh_addr);
311
  dst->sh_offset = H_GET_WORD (abfd, src->sh_offset);
312
  dst->sh_size = H_GET_WORD (abfd, src->sh_size);
313
  dst->sh_link = H_GET_32 (abfd, src->sh_link);
314
  dst->sh_info = H_GET_32 (abfd, src->sh_info);
315
  dst->sh_addralign = H_GET_WORD (abfd, src->sh_addralign);
316
  dst->sh_entsize = H_GET_WORD (abfd, src->sh_entsize);
317
  dst->bfd_section = NULL;
318
  dst->contents = NULL;
319
}
320
 
321
/* Translate an ELF section header table entry in internal format into an
322
   ELF section header table entry in external format.  */
323
 
324
static void
325
elf_swap_shdr_out (bfd *abfd,
326
                   const Elf_Internal_Shdr *src,
327
                   Elf_External_Shdr *dst)
328
{
329
  /* note that all elements of dst are *arrays of unsigned char* already...  */
330
  H_PUT_32 (abfd, src->sh_name, dst->sh_name);
331
  H_PUT_32 (abfd, src->sh_type, dst->sh_type);
332
  H_PUT_WORD (abfd, src->sh_flags, dst->sh_flags);
333
  H_PUT_WORD (abfd, src->sh_addr, dst->sh_addr);
334
  H_PUT_WORD (abfd, src->sh_offset, dst->sh_offset);
335
  H_PUT_WORD (abfd, src->sh_size, dst->sh_size);
336
  H_PUT_32 (abfd, src->sh_link, dst->sh_link);
337
  H_PUT_32 (abfd, src->sh_info, dst->sh_info);
338
  H_PUT_WORD (abfd, src->sh_addralign, dst->sh_addralign);
339
  H_PUT_WORD (abfd, src->sh_entsize, dst->sh_entsize);
340
}
341
 
342
/* Translate an ELF program header table entry in external format into an
343
   ELF program header table entry in internal format.  */
344
 
345
void
346
elf_swap_phdr_in (bfd *abfd,
347
                  const Elf_External_Phdr *src,
348
                  Elf_Internal_Phdr *dst)
349
{
350
  int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
351
 
352
  dst->p_type = H_GET_32 (abfd, src->p_type);
353
  dst->p_flags = H_GET_32 (abfd, src->p_flags);
354
  dst->p_offset = H_GET_WORD (abfd, src->p_offset);
355
  if (signed_vma)
356
    {
357
      dst->p_vaddr = H_GET_SIGNED_WORD (abfd, src->p_vaddr);
358
      dst->p_paddr = H_GET_SIGNED_WORD (abfd, src->p_paddr);
359
    }
360
  else
361
    {
362
      dst->p_vaddr = H_GET_WORD (abfd, src->p_vaddr);
363
      dst->p_paddr = H_GET_WORD (abfd, src->p_paddr);
364
    }
365
  dst->p_filesz = H_GET_WORD (abfd, src->p_filesz);
366
  dst->p_memsz = H_GET_WORD (abfd, src->p_memsz);
367
  dst->p_align = H_GET_WORD (abfd, src->p_align);
368
}
369
 
370
void
371
elf_swap_phdr_out (bfd *abfd,
372
                   const Elf_Internal_Phdr *src,
373
                   Elf_External_Phdr *dst)
374
{
375
  const struct elf_backend_data *bed;
376
  bfd_vma p_paddr;
377
 
378
  bed = get_elf_backend_data (abfd);
379
  p_paddr = bed->want_p_paddr_set_to_zero ? 0 : src->p_paddr;
380
 
381
  /* note that all elements of dst are *arrays of unsigned char* already...  */
382
  H_PUT_32 (abfd, src->p_type, dst->p_type);
383
  H_PUT_WORD (abfd, src->p_offset, dst->p_offset);
384
  H_PUT_WORD (abfd, src->p_vaddr, dst->p_vaddr);
385
  H_PUT_WORD (abfd, p_paddr, dst->p_paddr);
386
  H_PUT_WORD (abfd, src->p_filesz, dst->p_filesz);
387
  H_PUT_WORD (abfd, src->p_memsz, dst->p_memsz);
388
  H_PUT_32 (abfd, src->p_flags, dst->p_flags);
389
  H_PUT_WORD (abfd, src->p_align, dst->p_align);
390
}
391
 
392
/* Translate an ELF reloc from external format to internal format.  */
393
void
394
elf_swap_reloc_in (bfd *abfd,
395
                   const bfd_byte *s,
396
                   Elf_Internal_Rela *dst)
397
{
398
  const Elf_External_Rel *src = (const Elf_External_Rel *) s;
399
  dst->r_offset = H_GET_WORD (abfd, src->r_offset);
400
  dst->r_info = H_GET_WORD (abfd, src->r_info);
401
  dst->r_addend = 0;
402
}
403
 
404
void
405
elf_swap_reloca_in (bfd *abfd,
406
                    const bfd_byte *s,
407
                    Elf_Internal_Rela *dst)
408
{
409
  const Elf_External_Rela *src = (const Elf_External_Rela *) s;
410
  dst->r_offset = H_GET_WORD (abfd, src->r_offset);
411
  dst->r_info = H_GET_WORD (abfd, src->r_info);
412
  dst->r_addend = H_GET_SIGNED_WORD (abfd, src->r_addend);
413
}
414
 
415
/* Translate an ELF reloc from internal format to external format.  */
416
void
417
elf_swap_reloc_out (bfd *abfd,
418
                    const Elf_Internal_Rela *src,
419
                    bfd_byte *d)
420
{
421
  Elf_External_Rel *dst = (Elf_External_Rel *) d;
422
  H_PUT_WORD (abfd, src->r_offset, dst->r_offset);
423
  H_PUT_WORD (abfd, src->r_info, dst->r_info);
424
}
425
 
426
void
427
elf_swap_reloca_out (bfd *abfd,
428
                     const Elf_Internal_Rela *src,
429
                     bfd_byte *d)
430
{
431
  Elf_External_Rela *dst = (Elf_External_Rela *) d;
432
  H_PUT_WORD (abfd, src->r_offset, dst->r_offset);
433
  H_PUT_WORD (abfd, src->r_info, dst->r_info);
434
  H_PUT_SIGNED_WORD (abfd, src->r_addend, dst->r_addend);
435
}
436
 
437
void
438
elf_swap_dyn_in (bfd *abfd,
439
                 const void *p,
440
                 Elf_Internal_Dyn *dst)
441
{
442
  const Elf_External_Dyn *src = (const Elf_External_Dyn *) p;
443
 
444
  dst->d_tag = H_GET_WORD (abfd, src->d_tag);
445
  dst->d_un.d_val = H_GET_WORD (abfd, src->d_un.d_val);
446
}
447
 
448
void
449
elf_swap_dyn_out (bfd *abfd,
450
                  const Elf_Internal_Dyn *src,
451
                  void *p)
452
{
453
  Elf_External_Dyn *dst = (Elf_External_Dyn *) p;
454
 
455
  H_PUT_WORD (abfd, src->d_tag, dst->d_tag);
456
  H_PUT_WORD (abfd, src->d_un.d_val, dst->d_un.d_val);
457
}
458
 
459
/* ELF .o/exec file reading */
460
 
461
/* Begin processing a given object.
462
 
463
   First we validate the file by reading in the ELF header and checking
464
   the magic number.  */
465
 
466
static inline bfd_boolean
467
elf_file_p (Elf_External_Ehdr *x_ehdrp)
468
{
469
  return ((x_ehdrp->e_ident[EI_MAG0] == ELFMAG0)
470
          && (x_ehdrp->e_ident[EI_MAG1] == ELFMAG1)
471
          && (x_ehdrp->e_ident[EI_MAG2] == ELFMAG2)
472
          && (x_ehdrp->e_ident[EI_MAG3] == ELFMAG3));
473
}
474
 
475
/* Check to see if the file associated with ABFD matches the target vector
476
   that ABFD points to.
477
 
478
   Note that we may be called several times with the same ABFD, but different
479
   target vectors, most of which will not match.  We have to avoid leaving
480
   any side effects in ABFD, or any data it points to (like tdata), if the
481
   file does not match the target vector.  */
482
 
483
const bfd_target *
484
elf_object_p (bfd *abfd)
485
{
486
  Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
487
  Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
488
  Elf_External_Shdr x_shdr;     /* Section header table entry, external form */
489
  Elf_Internal_Shdr i_shdr;
490
  Elf_Internal_Shdr *i_shdrp;   /* Section header table, internal form */
491
  unsigned int shindex;
492
  const struct elf_backend_data *ebd;
493
  struct bfd_preserve preserve;
494
  asection *s;
495
  bfd_size_type amt;
496
  const bfd_target *target;
497
  const bfd_target * const *target_ptr;
498
 
499
  preserve.marker = NULL;
500
 
501
  /* Read in the ELF header in external format.  */
502
 
503
  if (bfd_bread (&x_ehdr, sizeof (x_ehdr), abfd) != sizeof (x_ehdr))
504
    {
505
      if (bfd_get_error () != bfd_error_system_call)
506
        goto got_wrong_format_error;
507
      else
508
        goto got_no_match;
509
    }
510
 
511
  /* Now check to see if we have a valid ELF file, and one that BFD can
512
     make use of.  The magic number must match, the address size ('class')
513
     and byte-swapping must match our XVEC entry, and it must have a
514
     section header table (FIXME: See comments re sections at top of this
515
     file).  */
516
 
517
  if (! elf_file_p (&x_ehdr)
518
      || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT
519
      || x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
520
    goto got_wrong_format_error;
521
 
522
  /* Check that file's byte order matches xvec's */
523
  switch (x_ehdr.e_ident[EI_DATA])
524
    {
525
    case ELFDATA2MSB:           /* Big-endian */
526
      if (! bfd_header_big_endian (abfd))
527
        goto got_wrong_format_error;
528
      break;
529
    case ELFDATA2LSB:           /* Little-endian */
530
      if (! bfd_header_little_endian (abfd))
531
        goto got_wrong_format_error;
532
      break;
533
    case ELFDATANONE:           /* No data encoding specified */
534
    default:                    /* Unknown data encoding specified */
535
      goto got_wrong_format_error;
536
    }
537
 
538
  if (!bfd_preserve_save (abfd, &preserve))
539
    goto got_no_match;
540
 
541
  target = abfd->xvec;
542
 
543
  /* Allocate an instance of the elf_obj_tdata structure and hook it up to
544
     the tdata pointer in the bfd.  */
545
 
546
  if (! (*target->_bfd_set_format[bfd_object]) (abfd))
547
    goto got_no_match;
548
  preserve.marker = elf_tdata (abfd);
549
 
550
  /* Now that we know the byte order, swap in the rest of the header */
551
  i_ehdrp = elf_elfheader (abfd);
552
  elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
553
#if DEBUG & 1
554
  elf_debug_file (i_ehdrp);
555
#endif
556
 
557
  /* Reject ET_CORE (header indicates core file, not object file) */
558
  if (i_ehdrp->e_type == ET_CORE)
559
    goto got_wrong_format_error;
560
 
561
  /* If this is a relocatable file and there is no section header
562
     table, then we're hosed.  */
563
  if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_type == ET_REL)
564
    goto got_wrong_format_error;
565
 
566
  /* As a simple sanity check, verify that what BFD thinks is the
567
     size of each section header table entry actually matches the size
568
     recorded in the file, but only if there are any sections.  */
569
  if (i_ehdrp->e_shentsize != sizeof (x_shdr) && i_ehdrp->e_shnum != 0)
570
    goto got_wrong_format_error;
571
 
572
  /* Further sanity check.  */
573
  if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_shnum != 0)
574
    goto got_wrong_format_error;
575
 
576
  ebd = get_elf_backend_data (abfd);
577
  if (ebd->s->arch_size != ARCH_SIZE)
578
    goto got_wrong_format_error;
579
 
580
  /* Check that the ELF e_machine field matches what this particular
581
     BFD format expects.  */
582
  if (ebd->elf_machine_code != i_ehdrp->e_machine
583
      && (ebd->elf_machine_alt1 == 0
584
          || i_ehdrp->e_machine != ebd->elf_machine_alt1)
585
      && (ebd->elf_machine_alt2 == 0
586
          || i_ehdrp->e_machine != ebd->elf_machine_alt2))
587
    {
588
      if (ebd->elf_machine_code != EM_NONE)
589
        goto got_wrong_format_error;
590
 
591
      /* This is the generic ELF target.  Let it match any ELF target
592
         for which we do not have a specific backend.  */
593
      for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
594
        {
595
          const struct elf_backend_data *back;
596
 
597
          if ((*target_ptr)->flavour != bfd_target_elf_flavour)
598
            continue;
599
          back = xvec_get_elf_backend_data (*target_ptr);
600
          if (back->s->arch_size != ARCH_SIZE)
601
            continue;
602
          if (back->elf_machine_code == i_ehdrp->e_machine
603
              || (back->elf_machine_alt1 != 0
604
                  && back->elf_machine_alt1 == i_ehdrp->e_machine)
605
              || (back->elf_machine_alt2 != 0
606
                  && back->elf_machine_alt2 == i_ehdrp->e_machine))
607
            {
608
              /* target_ptr is an ELF backend which matches this
609
                 object file, so reject the generic ELF target.  */
610
              goto got_wrong_format_error;
611
            }
612
        }
613
    }
614
 
615
  if (i_ehdrp->e_type == ET_EXEC)
616
    abfd->flags |= EXEC_P;
617
  else if (i_ehdrp->e_type == ET_DYN)
618
    abfd->flags |= DYNAMIC;
619
 
620
  if (i_ehdrp->e_phnum > 0)
621
    abfd->flags |= D_PAGED;
622
 
623
  if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
624
    {
625
      /* It's OK if this fails for the generic target.  */
626
      if (ebd->elf_machine_code != EM_NONE)
627
        goto got_no_match;
628
    }
629
 
630
  if (ebd->elf_machine_code != EM_NONE
631
      && i_ehdrp->e_ident[EI_OSABI] != ebd->elf_osabi)
632
    {
633
      if (ebd->elf_osabi != ELFOSABI_NONE)
634
        goto got_wrong_format_error;
635
 
636
      /* This is an ELFOSABI_NONE ELF target.  Let it match any ELF
637
         target of the compatible machine for which we do not have a
638
         backend with matching ELFOSABI.  */
639
      for (target_ptr = bfd_target_vector;
640
           *target_ptr != NULL;
641
           target_ptr++)
642
        {
643
          const struct elf_backend_data *back;
644
 
645
          /* Skip this target and targets with incompatible byte
646
             order.  */
647
          if (*target_ptr == target
648
              || (*target_ptr)->flavour != bfd_target_elf_flavour
649
              || (*target_ptr)->byteorder != target->byteorder
650
              || ((*target_ptr)->header_byteorder
651
                  != target->header_byteorder))
652
            continue;
653
 
654
          back = xvec_get_elf_backend_data (*target_ptr);
655
          if (back->elf_osabi == i_ehdrp->e_ident[EI_OSABI]
656
              && (back->elf_machine_code == i_ehdrp->e_machine
657
                  || (back->elf_machine_alt1 != 0
658
                      && back->elf_machine_alt1 == i_ehdrp->e_machine)
659
                  || (back->elf_machine_alt2 != 0
660
                      && back->elf_machine_alt2 == i_ehdrp->e_machine)))
661
            {
662
              /* target_ptr is an ELF backend which matches this
663
                 object file, so reject the ELFOSABI_NONE ELF target.  */
664
              goto got_wrong_format_error;
665
            }
666
        }
667
    }
668
 
669
  if (i_ehdrp->e_shoff != 0)
670
    {
671
      bfd_signed_vma where = i_ehdrp->e_shoff;
672
 
673
      if (where != (file_ptr) where)
674
        goto got_wrong_format_error;
675
 
676
      /* Seek to the section header table in the file.  */
677
      if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
678
        goto got_no_match;
679
 
680
      /* Read the first section header at index 0, and convert to internal
681
         form.  */
682
      if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
683
        goto got_no_match;
684
      elf_swap_shdr_in (abfd, &x_shdr, &i_shdr);
685
 
686
      /* If the section count is zero, the actual count is in the first
687
         section header.  */
688
      if (i_ehdrp->e_shnum == SHN_UNDEF)
689
        {
690
          i_ehdrp->e_shnum = i_shdr.sh_size;
691
          if (i_ehdrp->e_shnum != i_shdr.sh_size
692
              || i_ehdrp->e_shnum == 0)
693
            goto got_wrong_format_error;
694
        }
695
 
696
      /* And similarly for the string table index.  */
697
      if (i_ehdrp->e_shstrndx == (SHN_XINDEX & 0xffff))
698
        {
699
          i_ehdrp->e_shstrndx = i_shdr.sh_link;
700
          if (i_ehdrp->e_shstrndx != i_shdr.sh_link)
701
            goto got_wrong_format_error;
702
        }
703
 
704
      /* Sanity check that we can read all of the section headers.
705
         It ought to be good enough to just read the last one.  */
706
      if (i_ehdrp->e_shnum != 1)
707
        {
708
          /* Check that we don't have a totally silly number of sections.  */
709
          if (i_ehdrp->e_shnum > (unsigned int) -1 / sizeof (x_shdr)
710
              || i_ehdrp->e_shnum > (unsigned int) -1 / sizeof (i_shdr))
711
            goto got_wrong_format_error;
712
 
713
          where += (i_ehdrp->e_shnum - 1) * sizeof (x_shdr);
714
          if (where != (file_ptr) where)
715
            goto got_wrong_format_error;
716
          if ((bfd_size_type) where <= i_ehdrp->e_shoff)
717
            goto got_wrong_format_error;
718
 
719
          if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
720
            goto got_no_match;
721
          if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
722
            goto got_no_match;
723
 
724
          /* Back to where we were.  */
725
          where = i_ehdrp->e_shoff + sizeof (x_shdr);
726
          if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
727
            goto got_no_match;
728
        }
729
    }
730
 
731
  /* Allocate space for a copy of the section header table in
732
     internal form.  */
733
  if (i_ehdrp->e_shnum != 0)
734
    {
735
      Elf_Internal_Shdr *shdrp;
736
      unsigned int num_sec;
737
 
738
      amt = sizeof (*i_shdrp) * i_ehdrp->e_shnum;
739
      i_shdrp = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
740
      if (!i_shdrp)
741
        goto got_no_match;
742
      num_sec = i_ehdrp->e_shnum;
743
      elf_numsections (abfd) = num_sec;
744
      amt = sizeof (i_shdrp) * num_sec;
745
      elf_elfsections (abfd) = (Elf_Internal_Shdr **) bfd_alloc (abfd, amt);
746
      if (!elf_elfsections (abfd))
747
        goto got_no_match;
748
 
749
      memcpy (i_shdrp, &i_shdr, sizeof (*i_shdrp));
750
      for (shdrp = i_shdrp, shindex = 0; shindex < num_sec; shindex++)
751
        elf_elfsections (abfd)[shindex] = shdrp++;
752
 
753
      /* Read in the rest of the section header table and convert it
754
         to internal form.  */
755
      for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++)
756
        {
757
          if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
758
            goto got_no_match;
759
          elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex);
760
 
761
          /* Sanity check sh_link and sh_info.  */
762
          if (i_shdrp[shindex].sh_link >= num_sec)
763
            {
764
              /* PR 10478: Accept sparc binaries with a sh_link
765
                 field set to SHN_BEFORE or SHN_AFTER.  */
766
              switch (ebd->elf_machine_code)
767
                {
768
                case EM_OLD_SPARCV9:
769
                case EM_SPARC32PLUS:
770
                case EM_SPARCV9:
771
                case EM_SPARC:
772
                  if (i_shdrp[shindex].sh_link == (SHN_LORESERVE & 0xffff) /* SHN_BEFORE */
773
                      || i_shdrp[shindex].sh_link == ((SHN_LORESERVE + 1) & 0xffff) /* SHN_AFTER */)
774
                    break;
775
                  /* Otherwise fall through.  */
776
                default:
777
                  goto got_wrong_format_error;
778
                }
779
            }
780
 
781
          if (((i_shdrp[shindex].sh_flags & SHF_INFO_LINK)
782
               || i_shdrp[shindex].sh_type == SHT_RELA
783
               || i_shdrp[shindex].sh_type == SHT_REL)
784
              && i_shdrp[shindex].sh_info >= num_sec)
785
            goto got_wrong_format_error;
786
 
787
          /* If the section is loaded, but not page aligned, clear
788
             D_PAGED.  */
789
          if (i_shdrp[shindex].sh_size != 0
790
              && (i_shdrp[shindex].sh_flags & SHF_ALLOC) != 0
791
              && i_shdrp[shindex].sh_type != SHT_NOBITS
792
              && (((i_shdrp[shindex].sh_addr - i_shdrp[shindex].sh_offset)
793
                   % ebd->minpagesize)
794
                  != 0))
795
            abfd->flags &= ~D_PAGED;
796
        }
797
    }
798
 
799
  /* A further sanity check.  */
800
  if (i_ehdrp->e_shnum != 0)
801
    {
802
      if (i_ehdrp->e_shstrndx >= elf_numsections (abfd))
803
        {
804
          /* PR 2257:
805
             We used to just goto got_wrong_format_error here
806
             but there are binaries in existance for which this test
807
             will prevent the binutils from working with them at all.
808
             So we are kind, and reset the string index value to 0
809
             so that at least some processing can be done.  */
810
          i_ehdrp->e_shstrndx = SHN_UNDEF;
811
          _bfd_error_handler (_("warning: %s has a corrupt string table index - ignoring"), abfd->filename);
812
        }
813
    }
814
  else if (i_ehdrp->e_shstrndx != SHN_UNDEF)
815
    goto got_wrong_format_error;
816
 
817
  /* Read in the program headers.  */
818
  if (i_ehdrp->e_phnum == 0)
819
    elf_tdata (abfd)->phdr = NULL;
820
  else
821
    {
822
      Elf_Internal_Phdr *i_phdr;
823
      unsigned int i;
824
 
825
      amt = i_ehdrp->e_phnum * sizeof (Elf_Internal_Phdr);
826
      elf_tdata (abfd)->phdr = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
827
      if (elf_tdata (abfd)->phdr == NULL)
828
        goto got_no_match;
829
      if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
830
        goto got_no_match;
831
      i_phdr = elf_tdata (abfd)->phdr;
832
      for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++)
833
        {
834
          Elf_External_Phdr x_phdr;
835
 
836
          if (bfd_bread (&x_phdr, sizeof x_phdr, abfd) != sizeof x_phdr)
837
            goto got_no_match;
838
          elf_swap_phdr_in (abfd, &x_phdr, i_phdr);
839
        }
840
    }
841
 
842
  if (i_ehdrp->e_shstrndx != 0 && i_ehdrp->e_shoff != 0)
843
    {
844
      unsigned int num_sec;
845
 
846
      /* Once all of the section headers have been read and converted, we
847
         can start processing them.  Note that the first section header is
848
         a dummy placeholder entry, so we ignore it.  */
849
      num_sec = elf_numsections (abfd);
850
      for (shindex = 1; shindex < num_sec; shindex++)
851
        if (!bfd_section_from_shdr (abfd, shindex))
852
          goto got_no_match;
853
 
854
      /* Set up ELF sections for SHF_GROUP and SHF_LINK_ORDER.  */
855
      if (! _bfd_elf_setup_sections (abfd))
856
        goto got_wrong_format_error;
857
    }
858
 
859
  /* Let the backend double check the format and override global
860
     information.  */
861
  if (ebd->elf_backend_object_p)
862
    {
863
      if (! (*ebd->elf_backend_object_p) (abfd))
864
        goto got_wrong_format_error;
865
    }
866
 
867
  /* Remember the entry point specified in the ELF file header.  */
868
  bfd_set_start_address (abfd, i_ehdrp->e_entry);
869
 
870
  /* If we have created any reloc sections that are associated with
871
     debugging sections, mark the reloc sections as debugging as well.  */
872
  for (s = abfd->sections; s != NULL; s = s->next)
873
    {
874
      if ((elf_section_data (s)->this_hdr.sh_type == SHT_REL
875
           || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)
876
          && elf_section_data (s)->this_hdr.sh_info > 0)
877
        {
878
          unsigned long targ_index;
879
          asection *targ_sec;
880
 
881
          targ_index = elf_section_data (s)->this_hdr.sh_info;
882
          targ_sec = bfd_section_from_elf_index (abfd, targ_index);
883
          if (targ_sec != NULL
884
              && (targ_sec->flags & SEC_DEBUGGING) != 0)
885
            s->flags |= SEC_DEBUGGING;
886
        }
887
    }
888
 
889
  bfd_preserve_finish (abfd, &preserve);
890
  return target;
891
 
892
 got_wrong_format_error:
893
  /* There is way too much undoing of half-known state here.  The caller,
894
     bfd_check_format_matches, really shouldn't iterate on live bfd's to
895
     check match/no-match like it does.  We have to rely on that a call to
896
     bfd_default_set_arch_mach with the previously known mach, undoes what
897
     was done by the first bfd_default_set_arch_mach (with mach 0) here.
898
     For this to work, only elf-data and the mach may be changed by the
899
     target-specific elf_backend_object_p function.  Note that saving the
900
     whole bfd here and restoring it would be even worse; the first thing
901
     you notice is that the cached bfd file position gets out of sync.  */
902
  bfd_set_error (bfd_error_wrong_format);
903
 
904
 got_no_match:
905
  if (preserve.marker != NULL)
906
    bfd_preserve_restore (abfd, &preserve);
907
  return NULL;
908
}
909
 
910
/* ELF .o/exec file writing */
911
 
912
/* Write out the relocs.  */
913
 
914
void
915
elf_write_relocs (bfd *abfd, asection *sec, void *data)
916
{
917
  bfd_boolean *failedp = (bfd_boolean *) data;
918
  Elf_Internal_Shdr *rela_hdr;
919
  bfd_vma addr_offset;
920
  void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
921
  size_t extsize;
922
  bfd_byte *dst_rela;
923
  unsigned int idx;
924
  asymbol *last_sym;
925
  int last_sym_idx;
926
 
927
  /* If we have already failed, don't do anything.  */
928
  if (*failedp)
929
    return;
930
 
931
  if ((sec->flags & SEC_RELOC) == 0)
932
    return;
933
 
934
  /* The linker backend writes the relocs out itself, and sets the
935
     reloc_count field to zero to inhibit writing them here.  Also,
936
     sometimes the SEC_RELOC flag gets set even when there aren't any
937
     relocs.  */
938
  if (sec->reloc_count == 0)
939
    return;
940
 
941
  /* If we have opened an existing file for update, reloc_count may be
942
     set even though we are not linking.  In that case we have nothing
943
     to do.  */
944
  if (sec->orelocation == NULL)
945
    return;
946
 
947
  rela_hdr = &elf_section_data (sec)->rel_hdr;
948
 
949
  rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count;
950
  rela_hdr->contents = (unsigned char *) bfd_alloc (abfd, rela_hdr->sh_size);
951
  if (rela_hdr->contents == NULL)
952
    {
953
      *failedp = TRUE;
954
      return;
955
    }
956
 
957
  /* Figure out whether the relocations are RELA or REL relocations.  */
958
  if (rela_hdr->sh_type == SHT_RELA)
959
    {
960
      swap_out = elf_swap_reloca_out;
961
      extsize = sizeof (Elf_External_Rela);
962
    }
963
  else if (rela_hdr->sh_type == SHT_REL)
964
    {
965
      swap_out = elf_swap_reloc_out;
966
      extsize = sizeof (Elf_External_Rel);
967
    }
968
  else
969
    /* Every relocation section should be either an SHT_RELA or an
970
       SHT_REL section.  */
971
    abort ();
972
 
973
  /* The address of an ELF reloc is section relative for an object
974
     file, and absolute for an executable file or shared library.
975
     The address of a BFD reloc is always section relative.  */
976
  addr_offset = 0;
977
  if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
978
    addr_offset = sec->vma;
979
 
980
  /* orelocation has the data, reloc_count has the count...  */
981
  last_sym = 0;
982
  last_sym_idx = 0;
983
  dst_rela = rela_hdr->contents;
984
 
985
  for (idx = 0; idx < sec->reloc_count; idx++, dst_rela += extsize)
986
    {
987
      Elf_Internal_Rela src_rela;
988
      arelent *ptr;
989
      asymbol *sym;
990
      int n;
991
 
992
      ptr = sec->orelocation[idx];
993
      sym = *ptr->sym_ptr_ptr;
994
      if (sym == last_sym)
995
        n = last_sym_idx;
996
      else if (bfd_is_abs_section (sym->section) && sym->value == 0)
997
        n = STN_UNDEF;
998
      else
999
        {
1000
          last_sym = sym;
1001
          n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
1002
          if (n < 0)
1003
            {
1004
              *failedp = TRUE;
1005
              return;
1006
            }
1007
          last_sym_idx = n;
1008
        }
1009
 
1010
      if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
1011
          && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
1012
          && ! _bfd_elf_validate_reloc (abfd, ptr))
1013
        {
1014
          *failedp = TRUE;
1015
          return;
1016
        }
1017
 
1018
      src_rela.r_offset = ptr->address + addr_offset;
1019
      src_rela.r_info = ELF_R_INFO (n, ptr->howto->type);
1020
      src_rela.r_addend = ptr->addend;
1021
      (*swap_out) (abfd, &src_rela, dst_rela);
1022
    }
1023
}
1024
 
1025
/* Write out the program headers.  */
1026
 
1027
int
1028
elf_write_out_phdrs (bfd *abfd,
1029
                     const Elf_Internal_Phdr *phdr,
1030
                     unsigned int count)
1031
{
1032
  while (count--)
1033
    {
1034
      Elf_External_Phdr extphdr;
1035
      elf_swap_phdr_out (abfd, phdr, &extphdr);
1036
      if (bfd_bwrite (&extphdr, sizeof (Elf_External_Phdr), abfd)
1037
          != sizeof (Elf_External_Phdr))
1038
        return -1;
1039
      phdr++;
1040
    }
1041
  return 0;
1042
}
1043
 
1044
/* Write out the section headers and the ELF file header.  */
1045
 
1046
bfd_boolean
1047
elf_write_shdrs_and_ehdr (bfd *abfd)
1048
{
1049
  Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
1050
  Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
1051
  Elf_External_Shdr *x_shdrp;   /* Section header table, external form */
1052
  Elf_Internal_Shdr **i_shdrp;  /* Section header table, internal form */
1053
  unsigned int count;
1054
  bfd_size_type amt;
1055
 
1056
  i_ehdrp = elf_elfheader (abfd);
1057
  i_shdrp = elf_elfsections (abfd);
1058
 
1059
  /* swap the header before spitting it out...  */
1060
 
1061
#if DEBUG & 1
1062
  elf_debug_file (i_ehdrp);
1063
#endif
1064
  elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
1065
  amt = sizeof (x_ehdr);
1066
  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
1067
      || bfd_bwrite (&x_ehdr, amt, abfd) != amt)
1068
    return FALSE;
1069
 
1070
  /* Some fields in the first section header handle overflow of ehdr
1071
     fields.  */
1072
  if (i_ehdrp->e_shnum >= (SHN_LORESERVE & 0xffff))
1073
    i_shdrp[0]->sh_size = i_ehdrp->e_shnum;
1074
  if (i_ehdrp->e_shstrndx >= (SHN_LORESERVE & 0xffff))
1075
    i_shdrp[0]->sh_link = i_ehdrp->e_shstrndx;
1076
 
1077
  /* at this point we've concocted all the ELF sections...  */
1078
  amt = i_ehdrp->e_shnum;
1079
  amt *= sizeof (*x_shdrp);
1080
  x_shdrp = (Elf_External_Shdr *) bfd_alloc (abfd, amt);
1081
  if (!x_shdrp)
1082
    return FALSE;
1083
 
1084
  for (count = 0; count < i_ehdrp->e_shnum; i_shdrp++, count++)
1085
    {
1086
#if DEBUG & 2
1087
      elf_debug_section (count, *i_shdrp);
1088
#endif
1089
      elf_swap_shdr_out (abfd, *i_shdrp, x_shdrp + count);
1090
    }
1091
  if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0
1092
      || bfd_bwrite (x_shdrp, amt, abfd) != amt)
1093
    return FALSE;
1094
 
1095
  /* need to dump the string table too...  */
1096
 
1097
  return TRUE;
1098
}
1099
 
1100
bfd_boolean
1101
elf_checksum_contents (bfd *abfd,
1102
                       void (*process) (const void *, size_t, void *),
1103
                       void *arg)
1104
{
1105
  Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
1106
  Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
1107
  Elf_Internal_Phdr *i_phdrp = elf_tdata (abfd)->phdr;
1108
  unsigned int count, num;
1109
 
1110
  {
1111
    Elf_External_Ehdr x_ehdr;
1112
    Elf_Internal_Ehdr i_ehdr;
1113
 
1114
    i_ehdr = *i_ehdrp;
1115
    i_ehdr.e_phoff = i_ehdr.e_shoff = 0;
1116
    elf_swap_ehdr_out (abfd, &i_ehdr, &x_ehdr);
1117
    (*process) (&x_ehdr, sizeof x_ehdr, arg);
1118
  }
1119
 
1120
  num = i_ehdrp->e_phnum;
1121
  for (count = 0; count < num; count++)
1122
    {
1123
      Elf_External_Phdr x_phdr;
1124
      elf_swap_phdr_out (abfd, &i_phdrp[count], &x_phdr);
1125
      (*process) (&x_phdr, sizeof x_phdr, arg);
1126
    }
1127
 
1128
  num = elf_numsections (abfd);
1129
  for (count = 0; count < num; count++)
1130
    {
1131
      Elf_Internal_Shdr i_shdr;
1132
      Elf_External_Shdr x_shdr;
1133
 
1134
      i_shdr = *i_shdrp[count];
1135
      i_shdr.sh_offset = 0;
1136
 
1137
      elf_swap_shdr_out (abfd, &i_shdr, &x_shdr);
1138
      (*process) (&x_shdr, sizeof x_shdr, arg);
1139
 
1140
      if (i_shdr.contents)
1141
        (*process) (i_shdr.contents, i_shdr.sh_size, arg);
1142
    }
1143
 
1144
  return TRUE;
1145
}
1146
 
1147
long
1148
elf_slurp_symbol_table (bfd *abfd, asymbol **symptrs, bfd_boolean dynamic)
1149
{
1150
  Elf_Internal_Shdr *hdr;
1151
  Elf_Internal_Shdr *verhdr;
1152
  unsigned long symcount;       /* Number of external ELF symbols */
1153
  elf_symbol_type *sym;         /* Pointer to current bfd symbol */
1154
  elf_symbol_type *symbase;     /* Buffer for generated bfd symbols */
1155
  Elf_Internal_Sym *isym;
1156
  Elf_Internal_Sym *isymend;
1157
  Elf_Internal_Sym *isymbuf = NULL;
1158
  Elf_External_Versym *xver;
1159
  Elf_External_Versym *xverbuf = NULL;
1160
  const struct elf_backend_data *ebd;
1161
  bfd_size_type amt;
1162
 
1163
  /* Read each raw ELF symbol, converting from external ELF form to
1164
     internal ELF form, and then using the information to create a
1165
     canonical bfd symbol table entry.
1166
 
1167
     Note that we allocate the initial bfd canonical symbol buffer
1168
     based on a one-to-one mapping of the ELF symbols to canonical
1169
     symbols.  We actually use all the ELF symbols, so there will be no
1170
     space left over at the end.  When we have all the symbols, we
1171
     build the caller's pointer vector.  */
1172
 
1173
  if (! dynamic)
1174
    {
1175
      hdr = &elf_tdata (abfd)->symtab_hdr;
1176
      verhdr = NULL;
1177
    }
1178
  else
1179
    {
1180
      hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1181
      if (elf_dynversym (abfd) == 0)
1182
        verhdr = NULL;
1183
      else
1184
        verhdr = &elf_tdata (abfd)->dynversym_hdr;
1185
      if ((elf_tdata (abfd)->dynverdef_section != 0
1186
           && elf_tdata (abfd)->verdef == NULL)
1187
          || (elf_tdata (abfd)->dynverref_section != 0
1188
              && elf_tdata (abfd)->verref == NULL))
1189
        {
1190
          if (!_bfd_elf_slurp_version_tables (abfd, FALSE))
1191
            return -1;
1192
        }
1193
    }
1194
 
1195
  ebd = get_elf_backend_data (abfd);
1196
  symcount = hdr->sh_size / sizeof (Elf_External_Sym);
1197
  if (symcount == 0)
1198
    sym = symbase = NULL;
1199
  else
1200
    {
1201
      isymbuf = bfd_elf_get_elf_syms (abfd, hdr, symcount, 0,
1202
                                      NULL, NULL, NULL);
1203
      if (isymbuf == NULL)
1204
        return -1;
1205
 
1206
      amt = symcount;
1207
      amt *= sizeof (elf_symbol_type);
1208
      symbase = (elf_symbol_type *) bfd_zalloc (abfd, amt);
1209
      if (symbase == (elf_symbol_type *) NULL)
1210
        goto error_return;
1211
 
1212
      /* Read the raw ELF version symbol information.  */
1213
      if (verhdr != NULL
1214
          && verhdr->sh_size / sizeof (Elf_External_Versym) != symcount)
1215
        {
1216
          (*_bfd_error_handler)
1217
            (_("%s: version count (%ld) does not match symbol count (%ld)"),
1218
             abfd->filename,
1219
             (long) (verhdr->sh_size / sizeof (Elf_External_Versym)),
1220
             symcount);
1221
 
1222
          /* Slurp in the symbols without the version information,
1223
             since that is more helpful than just quitting.  */
1224
          verhdr = NULL;
1225
        }
1226
 
1227
      if (verhdr != NULL)
1228
        {
1229
          if (bfd_seek (abfd, verhdr->sh_offset, SEEK_SET) != 0)
1230
            goto error_return;
1231
 
1232
          xverbuf = (Elf_External_Versym *) bfd_malloc (verhdr->sh_size);
1233
          if (xverbuf == NULL && verhdr->sh_size != 0)
1234
            goto error_return;
1235
 
1236
          if (bfd_bread (xverbuf, verhdr->sh_size, abfd) != verhdr->sh_size)
1237
            goto error_return;
1238
        }
1239
 
1240
      /* Skip first symbol, which is a null dummy.  */
1241
      xver = xverbuf;
1242
      if (xver != NULL)
1243
        ++xver;
1244
      isymend = isymbuf + symcount;
1245
      for (isym = isymbuf + 1, sym = symbase; isym < isymend; isym++, sym++)
1246
        {
1247
          memcpy (&sym->internal_elf_sym, isym, sizeof (Elf_Internal_Sym));
1248
          sym->symbol.the_bfd = abfd;
1249
 
1250
          sym->symbol.name = bfd_elf_sym_name (abfd, hdr, isym, NULL);
1251
 
1252
          sym->symbol.value = isym->st_value;
1253
 
1254
          if (isym->st_shndx == SHN_UNDEF)
1255
            {
1256
              sym->symbol.section = bfd_und_section_ptr;
1257
            }
1258
          else if (isym->st_shndx == SHN_ABS)
1259
            {
1260
              sym->symbol.section = bfd_abs_section_ptr;
1261
            }
1262
          else if (isym->st_shndx == SHN_COMMON)
1263
            {
1264
              sym->symbol.section = bfd_com_section_ptr;
1265
              /* Elf puts the alignment into the `value' field, and
1266
                 the size into the `size' field.  BFD wants to see the
1267
                 size in the value field, and doesn't care (at the
1268
                 moment) about the alignment.  */
1269
              sym->symbol.value = isym->st_size;
1270
            }
1271
          else
1272
            {
1273
              sym->symbol.section
1274
                = bfd_section_from_elf_index (abfd, isym->st_shndx);
1275
              if (sym->symbol.section == NULL)
1276
                {
1277
                  /* This symbol is in a section for which we did not
1278
                     create a BFD section.  Just use bfd_abs_section,
1279
                     although it is wrong.  FIXME.  */
1280
                  sym->symbol.section = bfd_abs_section_ptr;
1281
                }
1282
            }
1283
 
1284
          /* If this is a relocatable file, then the symbol value is
1285
             already section relative.  */
1286
          if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
1287
            sym->symbol.value -= sym->symbol.section->vma;
1288
 
1289
          switch (ELF_ST_BIND (isym->st_info))
1290
            {
1291
            case STB_LOCAL:
1292
              sym->symbol.flags |= BSF_LOCAL;
1293
              break;
1294
            case STB_GLOBAL:
1295
              if (isym->st_shndx != SHN_UNDEF && isym->st_shndx != SHN_COMMON)
1296
                sym->symbol.flags |= BSF_GLOBAL;
1297
              break;
1298
            case STB_WEAK:
1299
              sym->symbol.flags |= BSF_WEAK;
1300
              break;
1301
            case STB_GNU_UNIQUE:
1302
              sym->symbol.flags |= BSF_GNU_UNIQUE;
1303
              break;
1304
            }
1305
 
1306
          switch (ELF_ST_TYPE (isym->st_info))
1307
            {
1308
            case STT_SECTION:
1309
              sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
1310
              break;
1311
            case STT_FILE:
1312
              sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
1313
              break;
1314
            case STT_FUNC:
1315
              sym->symbol.flags |= BSF_FUNCTION;
1316
              break;
1317
            case STT_COMMON:
1318
              /* FIXME: Do we have to put the size field into the value field
1319
                 as we do with symbols in SHN_COMMON sections (see above) ?  */
1320
              /* Fall through.  */
1321
            case STT_OBJECT:
1322
              sym->symbol.flags |= BSF_OBJECT;
1323
              break;
1324
            case STT_TLS:
1325
              sym->symbol.flags |= BSF_THREAD_LOCAL;
1326
              break;
1327
            case STT_RELC:
1328
              sym->symbol.flags |= BSF_RELC;
1329
              break;
1330
            case STT_SRELC:
1331
              sym->symbol.flags |= BSF_SRELC;
1332
              break;
1333
            case STT_GNU_IFUNC:
1334
              sym->symbol.flags |= BSF_GNU_INDIRECT_FUNCTION;
1335
              break;
1336
            }
1337
 
1338
          if (dynamic)
1339
            sym->symbol.flags |= BSF_DYNAMIC;
1340
 
1341
          if (xver != NULL)
1342
            {
1343
              Elf_Internal_Versym iversym;
1344
 
1345
              _bfd_elf_swap_versym_in (abfd, xver, &iversym);
1346
              sym->version = iversym.vs_vers;
1347
              xver++;
1348
            }
1349
 
1350
          /* Do some backend-specific processing on this symbol.  */
1351
          if (ebd->elf_backend_symbol_processing)
1352
            (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol);
1353
        }
1354
    }
1355
 
1356
  /* Do some backend-specific processing on this symbol table.  */
1357
  if (ebd->elf_backend_symbol_table_processing)
1358
    (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount);
1359
 
1360
  /* We rely on the zalloc to clear out the final symbol entry.  */
1361
 
1362
  symcount = sym - symbase;
1363
 
1364
  /* Fill in the user's symbol pointer vector if needed.  */
1365
  if (symptrs)
1366
    {
1367
      long l = symcount;
1368
 
1369
      sym = symbase;
1370
      while (l-- > 0)
1371
        {
1372
          *symptrs++ = &sym->symbol;
1373
          sym++;
1374
        }
1375
      *symptrs = 0;              /* Final null pointer */
1376
    }
1377
 
1378
  if (xverbuf != NULL)
1379
    free (xverbuf);
1380
  if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1381
    free (isymbuf);
1382
  return symcount;
1383
 
1384
error_return:
1385
  if (xverbuf != NULL)
1386
    free (xverbuf);
1387
  if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1388
    free (isymbuf);
1389
  return -1;
1390
}
1391
 
1392
/* Read relocations for ASECT from REL_HDR.  There are RELOC_COUNT of
1393
   them.  */
1394
 
1395
static bfd_boolean
1396
elf_slurp_reloc_table_from_section (bfd *abfd,
1397
                                    asection *asect,
1398
                                    Elf_Internal_Shdr *rel_hdr,
1399
                                    bfd_size_type reloc_count,
1400
                                    arelent *relents,
1401
                                    asymbol **symbols,
1402
                                    bfd_boolean dynamic)
1403
{
1404
  const struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
1405
  void *allocated = NULL;
1406
  bfd_byte *native_relocs;
1407
  arelent *relent;
1408
  unsigned int i;
1409
  int entsize;
1410
  unsigned int symcount;
1411
 
1412
  allocated = bfd_malloc (rel_hdr->sh_size);
1413
  if (allocated == NULL)
1414
    goto error_return;
1415
 
1416
  if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
1417
      || (bfd_bread (allocated, rel_hdr->sh_size, abfd)
1418
          != rel_hdr->sh_size))
1419
    goto error_return;
1420
 
1421
  native_relocs = (bfd_byte *) allocated;
1422
 
1423
  entsize = rel_hdr->sh_entsize;
1424
  BFD_ASSERT (entsize == sizeof (Elf_External_Rel)
1425
              || entsize == sizeof (Elf_External_Rela));
1426
 
1427
  if (dynamic)
1428
    symcount = bfd_get_dynamic_symcount (abfd);
1429
  else
1430
    symcount = bfd_get_symcount (abfd);
1431
 
1432
  for (i = 0, relent = relents;
1433
       i < reloc_count;
1434
       i++, relent++, native_relocs += entsize)
1435
    {
1436
      Elf_Internal_Rela rela;
1437
 
1438
      if (entsize == sizeof (Elf_External_Rela))
1439
        elf_swap_reloca_in (abfd, native_relocs, &rela);
1440
      else
1441
        elf_swap_reloc_in (abfd, native_relocs, &rela);
1442
 
1443
      /* The address of an ELF reloc is section relative for an object
1444
         file, and absolute for an executable file or shared library.
1445
         The address of a normal BFD reloc is always section relative,
1446
         and the address of a dynamic reloc is absolute..  */
1447
      if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
1448
        relent->address = rela.r_offset;
1449
      else
1450
        relent->address = rela.r_offset - asect->vma;
1451
 
1452
      if (ELF_R_SYM (rela.r_info) == 0)
1453
        relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1454
      else if (ELF_R_SYM (rela.r_info) > symcount)
1455
        {
1456
          (*_bfd_error_handler)
1457
            (_("%s(%s): relocation %d has invalid symbol index %ld"),
1458
             abfd->filename, asect->name, i, ELF_R_SYM (rela.r_info));
1459
          relent->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
1460
        }
1461
      else
1462
        {
1463
          asymbol **ps;
1464
 
1465
          ps = symbols + ELF_R_SYM (rela.r_info) - 1;
1466
 
1467
          relent->sym_ptr_ptr = ps;
1468
        }
1469
 
1470
      relent->addend = rela.r_addend;
1471
 
1472
      if ((entsize == sizeof (Elf_External_Rela)
1473
           && ebd->elf_info_to_howto != NULL)
1474
          || ebd->elf_info_to_howto_rel == NULL)
1475
        (*ebd->elf_info_to_howto) (abfd, relent, &rela);
1476
      else
1477
        (*ebd->elf_info_to_howto_rel) (abfd, relent, &rela);
1478
    }
1479
 
1480
  if (allocated != NULL)
1481
    free (allocated);
1482
 
1483
  return TRUE;
1484
 
1485
 error_return:
1486
  if (allocated != NULL)
1487
    free (allocated);
1488
  return FALSE;
1489
}
1490
 
1491
/* Read in and swap the external relocs.  */
1492
 
1493
bfd_boolean
1494
elf_slurp_reloc_table (bfd *abfd,
1495
                       asection *asect,
1496
                       asymbol **symbols,
1497
                       bfd_boolean dynamic)
1498
{
1499
  struct bfd_elf_section_data * const d = elf_section_data (asect);
1500
  Elf_Internal_Shdr *rel_hdr;
1501
  Elf_Internal_Shdr *rel_hdr2;
1502
  bfd_size_type reloc_count;
1503
  bfd_size_type reloc_count2;
1504
  arelent *relents;
1505
  bfd_size_type amt;
1506
 
1507
  if (asect->relocation != NULL)
1508
    return TRUE;
1509
 
1510
  if (! dynamic)
1511
    {
1512
      if ((asect->flags & SEC_RELOC) == 0
1513
          || asect->reloc_count == 0)
1514
        return TRUE;
1515
 
1516
      rel_hdr = &d->rel_hdr;
1517
      reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1518
      rel_hdr2 = d->rel_hdr2;
1519
      reloc_count2 = (rel_hdr2 ? NUM_SHDR_ENTRIES (rel_hdr2) : 0);
1520
 
1521
      BFD_ASSERT (asect->reloc_count == reloc_count + reloc_count2);
1522
      BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
1523
                  || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
1524
 
1525
    }
1526
  else
1527
    {
1528
      /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1529
         case because relocations against this section may use the
1530
         dynamic symbol table, and in that case bfd_section_from_shdr
1531
         in elf.c does not update the RELOC_COUNT.  */
1532
      if (asect->size == 0)
1533
        return TRUE;
1534
 
1535
      rel_hdr = &d->this_hdr;
1536
      reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1537
      rel_hdr2 = NULL;
1538
      reloc_count2 = 0;
1539
    }
1540
 
1541
  amt = (reloc_count + reloc_count2) * sizeof (arelent);
1542
  relents = (arelent *) bfd_alloc (abfd, amt);
1543
  if (relents == NULL)
1544
    return FALSE;
1545
 
1546
  if (!elf_slurp_reloc_table_from_section (abfd, asect,
1547
                                           rel_hdr, reloc_count,
1548
                                           relents,
1549
                                           symbols, dynamic))
1550
    return FALSE;
1551
 
1552
  if (rel_hdr2
1553
      && !elf_slurp_reloc_table_from_section (abfd, asect,
1554
                                              rel_hdr2, reloc_count2,
1555
                                              relents + reloc_count,
1556
                                              symbols, dynamic))
1557
    return FALSE;
1558
 
1559
  asect->relocation = relents;
1560
  return TRUE;
1561
}
1562
 
1563
#if DEBUG & 2
1564
static void
1565
elf_debug_section (int num, Elf_Internal_Shdr *hdr)
1566
{
1567
  fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num,
1568
           hdr->bfd_section != NULL ? hdr->bfd_section->name : "",
1569
           (long) hdr);
1570
  fprintf (stderr,
1571
           "sh_name      = %ld\tsh_type      = %ld\tsh_flags     = %ld\n",
1572
           (long) hdr->sh_name,
1573
           (long) hdr->sh_type,
1574
           (long) hdr->sh_flags);
1575
  fprintf (stderr,
1576
           "sh_addr      = %ld\tsh_offset    = %ld\tsh_size      = %ld\n",
1577
           (long) hdr->sh_addr,
1578
           (long) hdr->sh_offset,
1579
           (long) hdr->sh_size);
1580
  fprintf (stderr,
1581
           "sh_link      = %ld\tsh_info      = %ld\tsh_addralign = %ld\n",
1582
           (long) hdr->sh_link,
1583
           (long) hdr->sh_info,
1584
           (long) hdr->sh_addralign);
1585
  fprintf (stderr, "sh_entsize   = %ld\n",
1586
           (long) hdr->sh_entsize);
1587
  fflush (stderr);
1588
}
1589
#endif
1590
 
1591
#if DEBUG & 1
1592
static void
1593
elf_debug_file (Elf_Internal_Ehdr *ehdrp)
1594
{
1595
  fprintf (stderr, "e_entry      = 0x%.8lx\n", (long) ehdrp->e_entry);
1596
  fprintf (stderr, "e_phoff      = %ld\n", (long) ehdrp->e_phoff);
1597
  fprintf (stderr, "e_phnum      = %ld\n", (long) ehdrp->e_phnum);
1598
  fprintf (stderr, "e_phentsize  = %ld\n", (long) ehdrp->e_phentsize);
1599
  fprintf (stderr, "e_shoff      = %ld\n", (long) ehdrp->e_shoff);
1600
  fprintf (stderr, "e_shnum      = %ld\n", (long) ehdrp->e_shnum);
1601
  fprintf (stderr, "e_shentsize  = %ld\n", (long) ehdrp->e_shentsize);
1602
}
1603
#endif
1604
 
1605
/* Create a new BFD as if by bfd_openr.  Rather than opening a file,
1606
   reconstruct an ELF file by reading the segments out of remote memory
1607
   based on the ELF file header at EHDR_VMA and the ELF program headers it
1608
   points to.  If not null, *LOADBASEP is filled in with the difference
1609
   between the VMAs from which the segments were read, and the VMAs the
1610
   file headers (and hence BFD's idea of each section's VMA) put them at.
1611
 
1612
   The function TARGET_READ_MEMORY is called to copy LEN bytes from the
1613
   remote memory at target address VMA into the local buffer at MYADDR; it
1614
   should return zero on success or an `errno' code on failure.  TEMPL must
1615
   be a BFD for a target with the word size and byte order found in the
1616
   remote memory.  */
1617
 
1618
bfd *
1619
NAME(_bfd_elf,bfd_from_remote_memory)
1620
  (bfd *templ,
1621
   bfd_vma ehdr_vma,
1622
   bfd_vma *loadbasep,
1623
   int (*target_read_memory) (bfd_vma, bfd_byte *, int))
1624
{
1625
  Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
1626
  Elf_Internal_Ehdr i_ehdr;     /* Elf file header, internal form */
1627
  Elf_External_Phdr *x_phdrs;
1628
  Elf_Internal_Phdr *i_phdrs, *last_phdr;
1629
  bfd *nbfd;
1630
  struct bfd_in_memory *bim;
1631
  int contents_size;
1632
  bfd_byte *contents;
1633
  int err;
1634
  unsigned int i;
1635
  bfd_vma loadbase;
1636
  bfd_boolean loadbase_set;
1637
 
1638
  /* Read in the ELF header in external format.  */
1639
  err = target_read_memory (ehdr_vma, (bfd_byte *) &x_ehdr, sizeof x_ehdr);
1640
  if (err)
1641
    {
1642
      bfd_set_error (bfd_error_system_call);
1643
      errno = err;
1644
      return NULL;
1645
    }
1646
 
1647
  /* Now check to see if we have a valid ELF file, and one that BFD can
1648
     make use of.  The magic number must match, the address size ('class')
1649
     and byte-swapping must match our XVEC entry.  */
1650
 
1651
  if (! elf_file_p (&x_ehdr)
1652
      || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT
1653
      || x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
1654
    {
1655
      bfd_set_error (bfd_error_wrong_format);
1656
      return NULL;
1657
    }
1658
 
1659
  /* Check that file's byte order matches xvec's */
1660
  switch (x_ehdr.e_ident[EI_DATA])
1661
    {
1662
    case ELFDATA2MSB:           /* Big-endian */
1663
      if (! bfd_header_big_endian (templ))
1664
        {
1665
          bfd_set_error (bfd_error_wrong_format);
1666
          return NULL;
1667
        }
1668
      break;
1669
    case ELFDATA2LSB:           /* Little-endian */
1670
      if (! bfd_header_little_endian (templ))
1671
        {
1672
          bfd_set_error (bfd_error_wrong_format);
1673
          return NULL;
1674
        }
1675
      break;
1676
    case ELFDATANONE:           /* No data encoding specified */
1677
    default:                    /* Unknown data encoding specified */
1678
      bfd_set_error (bfd_error_wrong_format);
1679
      return NULL;
1680
    }
1681
 
1682
  elf_swap_ehdr_in (templ, &x_ehdr, &i_ehdr);
1683
 
1684
  /* The file header tells where to find the program headers.
1685
     These are what we use to actually choose what to read.  */
1686
 
1687
  if (i_ehdr.e_phentsize != sizeof (Elf_External_Phdr) || i_ehdr.e_phnum == 0)
1688
    {
1689
      bfd_set_error (bfd_error_wrong_format);
1690
      return NULL;
1691
    }
1692
 
1693
  x_phdrs = (Elf_External_Phdr *)
1694
      bfd_malloc (i_ehdr.e_phnum * (sizeof *x_phdrs + sizeof *i_phdrs));
1695
  if (x_phdrs == NULL)
1696
    {
1697
      bfd_set_error (bfd_error_no_memory);
1698
      return NULL;
1699
    }
1700
  err = target_read_memory (ehdr_vma + i_ehdr.e_phoff, (bfd_byte *) x_phdrs,
1701
                            i_ehdr.e_phnum * sizeof x_phdrs[0]);
1702
  if (err)
1703
    {
1704
      free (x_phdrs);
1705
      bfd_set_error (bfd_error_system_call);
1706
      errno = err;
1707
      return NULL;
1708
    }
1709
  i_phdrs = (Elf_Internal_Phdr *) &x_phdrs[i_ehdr.e_phnum];
1710
 
1711
  contents_size = 0;
1712
  last_phdr = NULL;
1713
  loadbase = ehdr_vma;
1714
  loadbase_set = FALSE;
1715
  for (i = 0; i < i_ehdr.e_phnum; ++i)
1716
    {
1717
      elf_swap_phdr_in (templ, &x_phdrs[i], &i_phdrs[i]);
1718
      if (i_phdrs[i].p_type == PT_LOAD)
1719
        {
1720
          bfd_vma segment_end;
1721
          segment_end = (i_phdrs[i].p_offset + i_phdrs[i].p_filesz
1722
                         + i_phdrs[i].p_align - 1) & -i_phdrs[i].p_align;
1723
          if (segment_end > (bfd_vma) contents_size)
1724
            contents_size = segment_end;
1725
 
1726
          /* LOADADDR is the `Base address' from the gELF specification:
1727
             `lowest p_vaddr value for a PT_LOAD segment' is P_VADDR from the
1728
             first PT_LOAD as PT_LOADs are ordered by P_VADDR.  */
1729
          if (!loadbase_set && (i_phdrs[i].p_offset & -i_phdrs[i].p_align) == 0)
1730
            {
1731
              loadbase = ehdr_vma - (i_phdrs[i].p_vaddr & -i_phdrs[i].p_align);
1732
              loadbase_set = TRUE;
1733
            }
1734
 
1735
          last_phdr = &i_phdrs[i];
1736
        }
1737
    }
1738
  if (last_phdr == NULL)
1739
    {
1740
      /* There were no PT_LOAD segments, so we don't have anything to read.  */
1741
      free (x_phdrs);
1742
      bfd_set_error (bfd_error_wrong_format);
1743
      return NULL;
1744
    }
1745
 
1746
  /* Trim the last segment so we don't bother with zeros in the last page
1747
     that are off the end of the file.  However, if the extra bit in that
1748
     page includes the section headers, keep them.  */
1749
  if ((bfd_vma) contents_size > last_phdr->p_offset + last_phdr->p_filesz
1750
      && (bfd_vma) contents_size >= (i_ehdr.e_shoff
1751
                                     + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1752
    {
1753
      contents_size = last_phdr->p_offset + last_phdr->p_filesz;
1754
      if ((bfd_vma) contents_size < (i_ehdr.e_shoff
1755
                                     + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1756
        contents_size = i_ehdr.e_shoff + i_ehdr.e_shnum * i_ehdr.e_shentsize;
1757
    }
1758
  else
1759
    contents_size = last_phdr->p_offset + last_phdr->p_filesz;
1760
 
1761
  /* Now we know the size of the whole image we want read in.  */
1762
  contents = (bfd_byte *) bfd_zmalloc (contents_size);
1763
  if (contents == NULL)
1764
    {
1765
      free (x_phdrs);
1766
      bfd_set_error (bfd_error_no_memory);
1767
      return NULL;
1768
    }
1769
 
1770
  for (i = 0; i < i_ehdr.e_phnum; ++i)
1771
    if (i_phdrs[i].p_type == PT_LOAD)
1772
      {
1773
        bfd_vma start = i_phdrs[i].p_offset & -i_phdrs[i].p_align;
1774
        bfd_vma end = (i_phdrs[i].p_offset + i_phdrs[i].p_filesz
1775
                       + i_phdrs[i].p_align - 1) & -i_phdrs[i].p_align;
1776
        if (end > (bfd_vma) contents_size)
1777
          end = contents_size;
1778
        err = target_read_memory ((loadbase + i_phdrs[i].p_vaddr)
1779
                                  & -i_phdrs[i].p_align,
1780
                                  contents + start, end - start);
1781
        if (err)
1782
          {
1783
            free (x_phdrs);
1784
            free (contents);
1785
            bfd_set_error (bfd_error_system_call);
1786
            errno = err;
1787
            return NULL;
1788
          }
1789
      }
1790
  free (x_phdrs);
1791
 
1792
  /* If the segments visible in memory didn't include the section headers,
1793
     then clear them from the file header.  */
1794
  if ((bfd_vma) contents_size < (i_ehdr.e_shoff
1795
                                 + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1796
    {
1797
      memset (&x_ehdr.e_shoff, 0, sizeof x_ehdr.e_shoff);
1798
      memset (&x_ehdr.e_shnum, 0, sizeof x_ehdr.e_shnum);
1799
      memset (&x_ehdr.e_shstrndx, 0, sizeof x_ehdr.e_shstrndx);
1800
    }
1801
 
1802
  /* This will normally have been in the first PT_LOAD segment.  But it
1803
     conceivably could be missing, and we might have just changed it.  */
1804
  memcpy (contents, &x_ehdr, sizeof x_ehdr);
1805
 
1806
  /* Now we have a memory image of the ELF file contents.  Make a BFD.  */
1807
  bim = (struct bfd_in_memory *) bfd_malloc (sizeof (struct bfd_in_memory));
1808
  if (bim == NULL)
1809
    {
1810
      free (contents);
1811
      bfd_set_error (bfd_error_no_memory);
1812
      return NULL;
1813
    }
1814
  nbfd = _bfd_new_bfd ();
1815
  if (nbfd == NULL)
1816
    {
1817
      free (bim);
1818
      free (contents);
1819
      bfd_set_error (bfd_error_no_memory);
1820
      return NULL;
1821
    }
1822
  nbfd->filename = "<in-memory>";
1823
  nbfd->xvec = templ->xvec;
1824
  bim->size = contents_size;
1825
  bim->buffer = contents;
1826
  nbfd->iostream = bim;
1827
  nbfd->flags = BFD_IN_MEMORY;
1828
  nbfd->direction = read_direction;
1829
  nbfd->mtime = time (NULL);
1830
  nbfd->mtime_set = TRUE;
1831
 
1832
  if (loadbasep)
1833
    *loadbasep = loadbase;
1834
  return nbfd;
1835
}
1836
 
1837
#include "elfcore.h"
1838
 
1839
/* Size-dependent data and functions.  */
1840
const struct elf_size_info NAME(_bfd_elf,size_info) = {
1841
  sizeof (Elf_External_Ehdr),
1842
  sizeof (Elf_External_Phdr),
1843
  sizeof (Elf_External_Shdr),
1844
  sizeof (Elf_External_Rel),
1845
  sizeof (Elf_External_Rela),
1846
  sizeof (Elf_External_Sym),
1847
  sizeof (Elf_External_Dyn),
1848
  sizeof (Elf_External_Note),
1849
  4,
1850
  1,
1851
  ARCH_SIZE, LOG_FILE_ALIGN,
1852
  ELFCLASS, EV_CURRENT,
1853
  elf_write_out_phdrs,
1854
  elf_write_shdrs_and_ehdr,
1855
  elf_checksum_contents,
1856
  elf_write_relocs,
1857
  elf_swap_symbol_in,
1858
  elf_swap_symbol_out,
1859
  elf_slurp_reloc_table,
1860
  elf_slurp_symbol_table,
1861
  elf_swap_dyn_in,
1862
  elf_swap_dyn_out,
1863
  elf_swap_reloc_in,
1864
  elf_swap_reloc_out,
1865
  elf_swap_reloca_in,
1866
  elf_swap_reloca_out
1867
};

powered by: WebSVN 2.1.0

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