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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [bfd/] [elfcode.h] - Blame information for rev 24

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

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

powered by: WebSVN 2.1.0

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