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

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 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
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 & 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 = 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 = 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 = 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
 
578
  /* Check that the ELF e_machine field matches what this particular
579
     BFD format expects.  */
580
  if (ebd->elf_machine_code != i_ehdrp->e_machine
581
      && (ebd->elf_machine_alt1 == 0
582
          || i_ehdrp->e_machine != ebd->elf_machine_alt1)
583
      && (ebd->elf_machine_alt2 == 0
584
          || i_ehdrp->e_machine != ebd->elf_machine_alt2))
585
    {
586
      if (ebd->elf_machine_code != EM_NONE)
587
        goto got_wrong_format_error;
588
 
589
      /* This is the generic ELF target.  Let it match any ELF target
590
         for which we do not have a specific backend.  */
591
      for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
592
        {
593
          const struct elf_backend_data *back;
594
 
595
          if ((*target_ptr)->flavour != bfd_target_elf_flavour)
596
            continue;
597
          back = xvec_get_elf_backend_data (*target_ptr);
598
          if (back->elf_machine_code == i_ehdrp->e_machine
599
              || (back->elf_machine_alt1 != 0
600
                  && back->elf_machine_alt1 == i_ehdrp->e_machine)
601
              || (back->elf_machine_alt2 != 0
602
                  && back->elf_machine_alt2 == i_ehdrp->e_machine))
603
            {
604
              /* target_ptr is an ELF backend which matches this
605
                 object file, so reject the generic ELF target.  */
606
              goto got_wrong_format_error;
607
            }
608
        }
609
    }
610
 
611
  if (i_ehdrp->e_type == ET_EXEC)
612
    abfd->flags |= EXEC_P;
613
  else if (i_ehdrp->e_type == ET_DYN)
614
    abfd->flags |= DYNAMIC;
615
 
616
  if (i_ehdrp->e_phnum > 0)
617
    abfd->flags |= D_PAGED;
618
 
619
  if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
620
    {
621
      /* It's OK if this fails for the generic target.  */
622
      if (ebd->elf_machine_code != EM_NONE)
623
        goto got_no_match;
624
    }
625
 
626
  if (ebd->elf_machine_code != EM_NONE
627
      && i_ehdrp->e_ident[EI_OSABI] != ebd->elf_osabi)
628
    {
629
      if (ebd->elf_osabi != ELFOSABI_NONE)
630
        goto got_wrong_format_error;
631
 
632
      /* This is an ELFOSABI_NONE ELF target.  Let it match any ELF
633
         target of the compatible machine for which we do not have a
634
         backend with matching ELFOSABI.  */
635
      for (target_ptr = bfd_target_vector;
636
           *target_ptr != NULL;
637
           target_ptr++)
638
        {
639
          const struct elf_backend_data *back;
640
 
641
          /* Skip this target and targets with incompatible byte
642
             order.  */
643
          if (*target_ptr == target
644
              || (*target_ptr)->flavour != bfd_target_elf_flavour
645
              || (*target_ptr)->byteorder != target->byteorder
646
              || ((*target_ptr)->header_byteorder
647
                  != target->header_byteorder))
648
            continue;
649
 
650
          back = xvec_get_elf_backend_data (*target_ptr);
651
          if (back->elf_osabi == i_ehdrp->e_ident[EI_OSABI]
652
              && (back->elf_machine_code == i_ehdrp->e_machine
653
                  || (back->elf_machine_alt1 != 0
654
                      && back->elf_machine_alt1 == i_ehdrp->e_machine)
655
                  || (back->elf_machine_alt2 != 0
656
                      && back->elf_machine_alt2 == i_ehdrp->e_machine)))
657
            {
658
              /* target_ptr is an ELF backend which matches this
659
                 object file, so reject the ELFOSABI_NONE ELF target.  */
660
              goto got_wrong_format_error;
661
            }
662
        }
663
    }
664
 
665
  if (i_ehdrp->e_shoff != 0)
666
    {
667
      bfd_signed_vma where = i_ehdrp->e_shoff;
668
 
669
      if (where != (file_ptr) where)
670
        goto got_wrong_format_error;
671
 
672
      /* Seek to the section header table in the file.  */
673
      if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
674
        goto got_no_match;
675
 
676
      /* Read the first section header at index 0, and convert to internal
677
         form.  */
678
      if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
679
        goto got_no_match;
680
      elf_swap_shdr_in (abfd, &x_shdr, &i_shdr);
681
 
682
      /* If the section count is zero, the actual count is in the first
683
         section header.  */
684
      if (i_ehdrp->e_shnum == SHN_UNDEF)
685
        {
686
          i_ehdrp->e_shnum = i_shdr.sh_size;
687
          if (i_ehdrp->e_shnum != i_shdr.sh_size
688
              || i_ehdrp->e_shnum == 0)
689
            goto got_wrong_format_error;
690
        }
691
 
692
      /* And similarly for the string table index.  */
693
      if (i_ehdrp->e_shstrndx == (SHN_XINDEX & 0xffff))
694
        {
695
          i_ehdrp->e_shstrndx = i_shdr.sh_link;
696
          if (i_ehdrp->e_shstrndx != i_shdr.sh_link)
697
            goto got_wrong_format_error;
698
        }
699
 
700
      /* Sanity check that we can read all of the section headers.
701
         It ought to be good enough to just read the last one.  */
702
      if (i_ehdrp->e_shnum != 1)
703
        {
704
          /* Check that we don't have a totally silly number of sections.  */
705
          if (i_ehdrp->e_shnum > (unsigned int) -1 / sizeof (x_shdr)
706
              || i_ehdrp->e_shnum > (unsigned int) -1 / sizeof (i_shdr))
707
            goto got_wrong_format_error;
708
 
709
          where += (i_ehdrp->e_shnum - 1) * sizeof (x_shdr);
710
          if (where != (file_ptr) where)
711
            goto got_wrong_format_error;
712
          if ((bfd_size_type) where <= i_ehdrp->e_shoff)
713
            goto got_wrong_format_error;
714
 
715
          if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
716
            goto got_no_match;
717
          if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
718
            goto got_no_match;
719
 
720
          /* Back to where we were.  */
721
          where = i_ehdrp->e_shoff + sizeof (x_shdr);
722
          if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
723
            goto got_no_match;
724
        }
725
    }
726
 
727
  /* Allocate space for a copy of the section header table in
728
     internal form.  */
729
  if (i_ehdrp->e_shnum != 0)
730
    {
731
      Elf_Internal_Shdr *shdrp;
732
      unsigned int num_sec;
733
 
734
      amt = sizeof (*i_shdrp) * i_ehdrp->e_shnum;
735
      i_shdrp = bfd_alloc (abfd, amt);
736
      if (!i_shdrp)
737
        goto got_no_match;
738
      num_sec = i_ehdrp->e_shnum;
739
      elf_numsections (abfd) = num_sec;
740
      amt = sizeof (i_shdrp) * num_sec;
741
      elf_elfsections (abfd) = bfd_alloc (abfd, amt);
742
      if (!elf_elfsections (abfd))
743
        goto got_no_match;
744
 
745
      memcpy (i_shdrp, &i_shdr, sizeof (*i_shdrp));
746
      for (shdrp = i_shdrp, shindex = 0; shindex < num_sec; shindex++)
747
        elf_elfsections (abfd)[shindex] = shdrp++;
748
 
749
      /* Read in the rest of the section header table and convert it
750
         to internal form.  */
751
      for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++)
752
        {
753
          if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
754
            goto got_no_match;
755
          elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex);
756
 
757
          /* Sanity check sh_link and sh_info.  */
758
          if (i_shdrp[shindex].sh_link >= num_sec)
759
            goto got_wrong_format_error;
760
 
761
          if (((i_shdrp[shindex].sh_flags & SHF_INFO_LINK)
762
               || i_shdrp[shindex].sh_type == SHT_RELA
763
               || i_shdrp[shindex].sh_type == SHT_REL)
764
              && i_shdrp[shindex].sh_info >= num_sec)
765
            goto got_wrong_format_error;
766
 
767
          /* If the section is loaded, but not page aligned, clear
768
             D_PAGED.  */
769
          if (i_shdrp[shindex].sh_size != 0
770
              && (i_shdrp[shindex].sh_flags & SHF_ALLOC) != 0
771
              && i_shdrp[shindex].sh_type != SHT_NOBITS
772
              && (((i_shdrp[shindex].sh_addr - i_shdrp[shindex].sh_offset)
773
                   % ebd->minpagesize)
774
                  != 0))
775
            abfd->flags &= ~D_PAGED;
776
        }
777
    }
778
 
779
  /* A further sanity check.  */
780
  if (i_ehdrp->e_shnum != 0)
781
    {
782
      if (i_ehdrp->e_shstrndx >= elf_numsections (abfd))
783
        {
784
          /* PR 2257:
785
             We used to just goto got_wrong_format_error here
786
             but there are binaries in existance for which this test
787
             will prevent the binutils from working with them at all.
788
             So we are kind, and reset the string index value to 0
789
             so that at least some processing can be done.  */
790
          i_ehdrp->e_shstrndx = SHN_UNDEF;
791
          _bfd_error_handler (_("warning: %s has a corrupt string table index - ignoring"), abfd->filename);
792
        }
793
    }
794
  else if (i_ehdrp->e_shstrndx != SHN_UNDEF)
795
    goto got_wrong_format_error;
796
 
797
  /* Read in the program headers.  */
798
  if (i_ehdrp->e_phnum == 0)
799
    elf_tdata (abfd)->phdr = NULL;
800
  else
801
    {
802
      Elf_Internal_Phdr *i_phdr;
803
      unsigned int i;
804
 
805
      amt = i_ehdrp->e_phnum * sizeof (Elf_Internal_Phdr);
806
      elf_tdata (abfd)->phdr = bfd_alloc (abfd, amt);
807
      if (elf_tdata (abfd)->phdr == NULL)
808
        goto got_no_match;
809
      if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
810
        goto got_no_match;
811
      i_phdr = elf_tdata (abfd)->phdr;
812
      for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++)
813
        {
814
          Elf_External_Phdr x_phdr;
815
 
816
          if (bfd_bread (&x_phdr, sizeof x_phdr, abfd) != sizeof x_phdr)
817
            goto got_no_match;
818
          elf_swap_phdr_in (abfd, &x_phdr, i_phdr);
819
        }
820
    }
821
 
822
  if (i_ehdrp->e_shstrndx != 0 && i_ehdrp->e_shoff != 0)
823
    {
824
      unsigned int num_sec;
825
 
826
      /* Once all of the section headers have been read and converted, we
827
         can start processing them.  Note that the first section header is
828
         a dummy placeholder entry, so we ignore it.  */
829
      num_sec = elf_numsections (abfd);
830
      for (shindex = 1; shindex < num_sec; shindex++)
831
        if (!bfd_section_from_shdr (abfd, shindex))
832
          goto got_no_match;
833
 
834
      /* Set up ELF sections for SHF_GROUP and SHF_LINK_ORDER.  */
835
      if (! _bfd_elf_setup_sections (abfd))
836
        goto got_wrong_format_error;
837
    }
838
 
839
  /* Let the backend double check the format and override global
840
     information.  */
841
  if (ebd->elf_backend_object_p)
842
    {
843
      if (! (*ebd->elf_backend_object_p) (abfd))
844
        goto got_wrong_format_error;
845
    }
846
 
847
  /* Remember the entry point specified in the ELF file header.  */
848
  bfd_set_start_address (abfd, i_ehdrp->e_entry);
849
 
850
  /* If we have created any reloc sections that are associated with
851
     debugging sections, mark the reloc sections as debugging as well.  */
852
  for (s = abfd->sections; s != NULL; s = s->next)
853
    {
854
      if ((elf_section_data (s)->this_hdr.sh_type == SHT_REL
855
           || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)
856
          && elf_section_data (s)->this_hdr.sh_info > 0)
857
        {
858
          unsigned long targ_index;
859
          asection *targ_sec;
860
 
861
          targ_index = elf_section_data (s)->this_hdr.sh_info;
862
          targ_sec = bfd_section_from_elf_index (abfd, targ_index);
863
          if (targ_sec != NULL
864
              && (targ_sec->flags & SEC_DEBUGGING) != 0)
865
            s->flags |= SEC_DEBUGGING;
866
        }
867
    }
868
 
869
  bfd_preserve_finish (abfd, &preserve);
870
  return target;
871
 
872
 got_wrong_format_error:
873
  /* There is way too much undoing of half-known state here.  The caller,
874
     bfd_check_format_matches, really shouldn't iterate on live bfd's to
875
     check match/no-match like it does.  We have to rely on that a call to
876
     bfd_default_set_arch_mach with the previously known mach, undoes what
877
     was done by the first bfd_default_set_arch_mach (with mach 0) here.
878
     For this to work, only elf-data and the mach may be changed by the
879
     target-specific elf_backend_object_p function.  Note that saving the
880
     whole bfd here and restoring it would be even worse; the first thing
881
     you notice is that the cached bfd file position gets out of sync.  */
882
  bfd_set_error (bfd_error_wrong_format);
883
 
884
 got_no_match:
885
  if (preserve.marker != NULL)
886
    bfd_preserve_restore (abfd, &preserve);
887
  return NULL;
888
}
889
 
890
/* ELF .o/exec file writing */
891
 
892
/* Write out the relocs.  */
893
 
894
void
895
elf_write_relocs (bfd *abfd, asection *sec, void *data)
896
{
897
  bfd_boolean *failedp = data;
898
  Elf_Internal_Shdr *rela_hdr;
899
  bfd_vma addr_offset;
900
  void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
901
  size_t extsize;
902
  bfd_byte *dst_rela;
903
  unsigned int idx;
904
  asymbol *last_sym;
905
  int last_sym_idx;
906
 
907
  /* If we have already failed, don't do anything.  */
908
  if (*failedp)
909
    return;
910
 
911
  if ((sec->flags & SEC_RELOC) == 0)
912
    return;
913
 
914
  /* The linker backend writes the relocs out itself, and sets the
915
     reloc_count field to zero to inhibit writing them here.  Also,
916
     sometimes the SEC_RELOC flag gets set even when there aren't any
917
     relocs.  */
918
  if (sec->reloc_count == 0)
919
    return;
920
 
921
  /* If we have opened an existing file for update, reloc_count may be
922
     set even though we are not linking.  In that case we have nothing
923
     to do.  */
924
  if (sec->orelocation == NULL)
925
    return;
926
 
927
  rela_hdr = &elf_section_data (sec)->rel_hdr;
928
 
929
  rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count;
930
  rela_hdr->contents = bfd_alloc (abfd, rela_hdr->sh_size);
931
  if (rela_hdr->contents == NULL)
932
    {
933
      *failedp = TRUE;
934
      return;
935
    }
936
 
937
  /* Figure out whether the relocations are RELA or REL relocations.  */
938
  if (rela_hdr->sh_type == SHT_RELA)
939
    {
940
      swap_out = elf_swap_reloca_out;
941
      extsize = sizeof (Elf_External_Rela);
942
    }
943
  else if (rela_hdr->sh_type == SHT_REL)
944
    {
945
      swap_out = elf_swap_reloc_out;
946
      extsize = sizeof (Elf_External_Rel);
947
    }
948
  else
949
    /* Every relocation section should be either an SHT_RELA or an
950
       SHT_REL section.  */
951
    abort ();
952
 
953
  /* The address of an ELF reloc is section relative for an object
954
     file, and absolute for an executable file or shared library.
955
     The address of a BFD reloc is always section relative.  */
956
  addr_offset = 0;
957
  if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
958
    addr_offset = sec->vma;
959
 
960
  /* orelocation has the data, reloc_count has the count...  */
961
  last_sym = 0;
962
  last_sym_idx = 0;
963
  dst_rela = rela_hdr->contents;
964
 
965
  for (idx = 0; idx < sec->reloc_count; idx++, dst_rela += extsize)
966
    {
967
      Elf_Internal_Rela src_rela;
968
      arelent *ptr;
969
      asymbol *sym;
970
      int n;
971
 
972
      ptr = sec->orelocation[idx];
973
      sym = *ptr->sym_ptr_ptr;
974
      if (sym == last_sym)
975
        n = last_sym_idx;
976
      else if (bfd_is_abs_section (sym->section) && sym->value == 0)
977
        n = STN_UNDEF;
978
      else
979
        {
980
          last_sym = sym;
981
          n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
982
          if (n < 0)
983
            {
984
              *failedp = TRUE;
985
              return;
986
            }
987
          last_sym_idx = n;
988
        }
989
 
990
      if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
991
          && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
992
          && ! _bfd_elf_validate_reloc (abfd, ptr))
993
        {
994
          *failedp = TRUE;
995
          return;
996
        }
997
 
998
      src_rela.r_offset = ptr->address + addr_offset;
999
      src_rela.r_info = ELF_R_INFO (n, ptr->howto->type);
1000
      src_rela.r_addend = ptr->addend;
1001
      (*swap_out) (abfd, &src_rela, dst_rela);
1002
    }
1003
}
1004
 
1005
/* Write out the program headers.  */
1006
 
1007
int
1008
elf_write_out_phdrs (bfd *abfd,
1009
                     const Elf_Internal_Phdr *phdr,
1010
                     unsigned int count)
1011
{
1012
  while (count--)
1013
    {
1014
      Elf_External_Phdr extphdr;
1015
      elf_swap_phdr_out (abfd, phdr, &extphdr);
1016
      if (bfd_bwrite (&extphdr, sizeof (Elf_External_Phdr), abfd)
1017
          != sizeof (Elf_External_Phdr))
1018
        return -1;
1019
      phdr++;
1020
    }
1021
  return 0;
1022
}
1023
 
1024
/* Write out the section headers and the ELF file header.  */
1025
 
1026
bfd_boolean
1027
elf_write_shdrs_and_ehdr (bfd *abfd)
1028
{
1029
  Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
1030
  Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
1031
  Elf_External_Shdr *x_shdrp;   /* Section header table, external form */
1032
  Elf_Internal_Shdr **i_shdrp;  /* Section header table, internal form */
1033
  unsigned int count;
1034
  bfd_size_type amt;
1035
 
1036
  i_ehdrp = elf_elfheader (abfd);
1037
  i_shdrp = elf_elfsections (abfd);
1038
 
1039
  /* swap the header before spitting it out...  */
1040
 
1041
#if DEBUG & 1
1042
  elf_debug_file (i_ehdrp);
1043
#endif
1044
  elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
1045
  amt = sizeof (x_ehdr);
1046
  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
1047
      || bfd_bwrite (&x_ehdr, amt, abfd) != amt)
1048
    return FALSE;
1049
 
1050
  /* Some fields in the first section header handle overflow of ehdr
1051
     fields.  */
1052
  if (i_ehdrp->e_shnum >= (SHN_LORESERVE & 0xffff))
1053
    i_shdrp[0]->sh_size = i_ehdrp->e_shnum;
1054
  if (i_ehdrp->e_shstrndx >= (SHN_LORESERVE & 0xffff))
1055
    i_shdrp[0]->sh_link = i_ehdrp->e_shstrndx;
1056
 
1057
  /* at this point we've concocted all the ELF sections...  */
1058
  amt = i_ehdrp->e_shnum;
1059
  amt *= sizeof (*x_shdrp);
1060
  x_shdrp = bfd_alloc (abfd, amt);
1061
  if (!x_shdrp)
1062
    return FALSE;
1063
 
1064
  for (count = 0; count < i_ehdrp->e_shnum; i_shdrp++, count++)
1065
    {
1066
#if DEBUG & 2
1067
      elf_debug_section (count, *i_shdrp);
1068
#endif
1069
      elf_swap_shdr_out (abfd, *i_shdrp, x_shdrp + count);
1070
    }
1071
  if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0
1072
      || bfd_bwrite (x_shdrp, amt, abfd) != amt)
1073
    return FALSE;
1074
 
1075
  /* need to dump the string table too...  */
1076
 
1077
  return TRUE;
1078
}
1079
 
1080
bfd_boolean
1081
elf_checksum_contents (bfd *abfd,
1082
                       void (*process) (const void *, size_t, void *),
1083
                       void *arg)
1084
{
1085
  Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
1086
  Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
1087
  Elf_Internal_Phdr *i_phdrp = elf_tdata (abfd)->phdr;
1088
  unsigned int count, num;
1089
 
1090
  {
1091
    Elf_External_Ehdr x_ehdr;
1092
    Elf_Internal_Ehdr i_ehdr;
1093
 
1094
    i_ehdr = *i_ehdrp;
1095
    i_ehdr.e_phoff = i_ehdr.e_shoff = 0;
1096
    elf_swap_ehdr_out (abfd, &i_ehdr, &x_ehdr);
1097
    (*process) (&x_ehdr, sizeof x_ehdr, arg);
1098
  }
1099
 
1100
  num = i_ehdrp->e_phnum;
1101
  for (count = 0; count < num; count++)
1102
    {
1103
      Elf_External_Phdr x_phdr;
1104
      elf_swap_phdr_out (abfd, &i_phdrp[count], &x_phdr);
1105
      (*process) (&x_phdr, sizeof x_phdr, arg);
1106
    }
1107
 
1108
  num = elf_numsections (abfd);
1109
  for (count = 0; count < num; count++)
1110
    {
1111
      Elf_Internal_Shdr i_shdr;
1112
      Elf_External_Shdr x_shdr;
1113
 
1114
      i_shdr = *i_shdrp[count];
1115
      i_shdr.sh_offset = 0;
1116
 
1117
      elf_swap_shdr_out (abfd, &i_shdr, &x_shdr);
1118
      (*process) (&x_shdr, sizeof x_shdr, arg);
1119
 
1120
      if (i_shdr.contents)
1121
        (*process) (i_shdr.contents, i_shdr.sh_size, arg);
1122
    }
1123
 
1124
  return TRUE;
1125
}
1126
 
1127
long
1128
elf_slurp_symbol_table (bfd *abfd, asymbol **symptrs, bfd_boolean dynamic)
1129
{
1130
  Elf_Internal_Shdr *hdr;
1131
  Elf_Internal_Shdr *verhdr;
1132
  unsigned long symcount;       /* Number of external ELF symbols */
1133
  elf_symbol_type *sym;         /* Pointer to current bfd symbol */
1134
  elf_symbol_type *symbase;     /* Buffer for generated bfd symbols */
1135
  Elf_Internal_Sym *isym;
1136
  Elf_Internal_Sym *isymend;
1137
  Elf_Internal_Sym *isymbuf = NULL;
1138
  Elf_External_Versym *xver;
1139
  Elf_External_Versym *xverbuf = NULL;
1140
  const struct elf_backend_data *ebd;
1141
  bfd_size_type amt;
1142
 
1143
  /* Read each raw ELF symbol, converting from external ELF form to
1144
     internal ELF form, and then using the information to create a
1145
     canonical bfd symbol table entry.
1146
 
1147
     Note that we allocate the initial bfd canonical symbol buffer
1148
     based on a one-to-one mapping of the ELF symbols to canonical
1149
     symbols.  We actually use all the ELF symbols, so there will be no
1150
     space left over at the end.  When we have all the symbols, we
1151
     build the caller's pointer vector.  */
1152
 
1153
  if (! dynamic)
1154
    {
1155
      hdr = &elf_tdata (abfd)->symtab_hdr;
1156
      verhdr = NULL;
1157
    }
1158
  else
1159
    {
1160
      hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1161
      if (elf_dynversym (abfd) == 0)
1162
        verhdr = NULL;
1163
      else
1164
        verhdr = &elf_tdata (abfd)->dynversym_hdr;
1165
      if ((elf_tdata (abfd)->dynverdef_section != 0
1166
           && elf_tdata (abfd)->verdef == NULL)
1167
          || (elf_tdata (abfd)->dynverref_section != 0
1168
              && elf_tdata (abfd)->verref == NULL))
1169
        {
1170
          if (!_bfd_elf_slurp_version_tables (abfd, FALSE))
1171
            return -1;
1172
        }
1173
    }
1174
 
1175
  ebd = get_elf_backend_data (abfd);
1176
  symcount = hdr->sh_size / sizeof (Elf_External_Sym);
1177
  if (symcount == 0)
1178
    sym = symbase = NULL;
1179
  else
1180
    {
1181
      isymbuf = bfd_elf_get_elf_syms (abfd, hdr, symcount, 0,
1182
                                      NULL, NULL, NULL);
1183
      if (isymbuf == NULL)
1184
        return -1;
1185
 
1186
      amt = symcount;
1187
      amt *= sizeof (elf_symbol_type);
1188
      symbase = bfd_zalloc (abfd, amt);
1189
      if (symbase == (elf_symbol_type *) NULL)
1190
        goto error_return;
1191
 
1192
      /* Read the raw ELF version symbol information.  */
1193
      if (verhdr != NULL
1194
          && verhdr->sh_size / sizeof (Elf_External_Versym) != symcount)
1195
        {
1196
          (*_bfd_error_handler)
1197
            (_("%s: version count (%ld) does not match symbol count (%ld)"),
1198
             abfd->filename,
1199
             (long) (verhdr->sh_size / sizeof (Elf_External_Versym)),
1200
             symcount);
1201
 
1202
          /* Slurp in the symbols without the version information,
1203
             since that is more helpful than just quitting.  */
1204
          verhdr = NULL;
1205
        }
1206
 
1207
      if (verhdr != NULL)
1208
        {
1209
          if (bfd_seek (abfd, verhdr->sh_offset, SEEK_SET) != 0)
1210
            goto error_return;
1211
 
1212
          xverbuf = bfd_malloc (verhdr->sh_size);
1213
          if (xverbuf == NULL && verhdr->sh_size != 0)
1214
            goto error_return;
1215
 
1216
          if (bfd_bread (xverbuf, verhdr->sh_size, abfd) != verhdr->sh_size)
1217
            goto error_return;
1218
        }
1219
 
1220
      /* Skip first symbol, which is a null dummy.  */
1221
      xver = xverbuf;
1222
      if (xver != NULL)
1223
        ++xver;
1224
      isymend = isymbuf + symcount;
1225
      for (isym = isymbuf + 1, sym = symbase; isym < isymend; isym++, sym++)
1226
        {
1227
          memcpy (&sym->internal_elf_sym, isym, sizeof (Elf_Internal_Sym));
1228
          sym->symbol.the_bfd = abfd;
1229
 
1230
          sym->symbol.name = bfd_elf_sym_name (abfd, hdr, isym, NULL);
1231
 
1232
          sym->symbol.value = isym->st_value;
1233
 
1234
          if (isym->st_shndx == SHN_UNDEF)
1235
            {
1236
              sym->symbol.section = bfd_und_section_ptr;
1237
            }
1238
          else if (isym->st_shndx == SHN_ABS)
1239
            {
1240
              sym->symbol.section = bfd_abs_section_ptr;
1241
            }
1242
          else if (isym->st_shndx == SHN_COMMON)
1243
            {
1244
              sym->symbol.section = bfd_com_section_ptr;
1245
              /* Elf puts the alignment into the `value' field, and
1246
                 the size into the `size' field.  BFD wants to see the
1247
                 size in the value field, and doesn't care (at the
1248
                 moment) about the alignment.  */
1249
              sym->symbol.value = isym->st_size;
1250
            }
1251
          else
1252
            {
1253
              sym->symbol.section
1254
                = bfd_section_from_elf_index (abfd, isym->st_shndx);
1255
              if (sym->symbol.section == NULL)
1256
                {
1257
                  /* This symbol is in a section for which we did not
1258
                     create a BFD section.  Just use bfd_abs_section,
1259
                     although it is wrong.  FIXME.  */
1260
                  sym->symbol.section = bfd_abs_section_ptr;
1261
                }
1262
            }
1263
 
1264
          /* If this is a relocatable file, then the symbol value is
1265
             already section relative.  */
1266
          if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
1267
            sym->symbol.value -= sym->symbol.section->vma;
1268
 
1269
          switch (ELF_ST_BIND (isym->st_info))
1270
            {
1271
            case STB_LOCAL:
1272
              sym->symbol.flags |= BSF_LOCAL;
1273
              break;
1274
            case STB_GLOBAL:
1275
              if (isym->st_shndx != SHN_UNDEF && isym->st_shndx != SHN_COMMON)
1276
                sym->symbol.flags |= BSF_GLOBAL;
1277
              break;
1278
            case STB_WEAK:
1279
              sym->symbol.flags |= BSF_WEAK;
1280
              break;
1281
            }
1282
 
1283
          switch (ELF_ST_TYPE (isym->st_info))
1284
            {
1285
            case STT_SECTION:
1286
              sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
1287
              break;
1288
            case STT_FILE:
1289
              sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
1290
              break;
1291
            case STT_FUNC:
1292
              sym->symbol.flags |= BSF_FUNCTION;
1293
              break;
1294
            case STT_COMMON:
1295
              /* FIXME: Do we have to put the size field into the value field
1296
                 as we do with symbols in SHN_COMMON sections (see above) ?  */
1297
              /* Fall through.  */
1298
            case STT_OBJECT:
1299
              sym->symbol.flags |= BSF_OBJECT;
1300
              break;
1301
            case STT_TLS:
1302
              sym->symbol.flags |= BSF_THREAD_LOCAL;
1303
              break;
1304
            case STT_RELC:
1305
              sym->symbol.flags |= BSF_RELC;
1306
              break;
1307
            case STT_SRELC:
1308
              sym->symbol.flags |= BSF_SRELC;
1309
              break;
1310
            }
1311
 
1312
          if (dynamic)
1313
            sym->symbol.flags |= BSF_DYNAMIC;
1314
 
1315
          if (xver != NULL)
1316
            {
1317
              Elf_Internal_Versym iversym;
1318
 
1319
              _bfd_elf_swap_versym_in (abfd, xver, &iversym);
1320
              sym->version = iversym.vs_vers;
1321
              xver++;
1322
            }
1323
 
1324
          /* Do some backend-specific processing on this symbol.  */
1325
          if (ebd->elf_backend_symbol_processing)
1326
            (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol);
1327
        }
1328
    }
1329
 
1330
  /* Do some backend-specific processing on this symbol table.  */
1331
  if (ebd->elf_backend_symbol_table_processing)
1332
    (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount);
1333
 
1334
  /* We rely on the zalloc to clear out the final symbol entry.  */
1335
 
1336
  symcount = sym - symbase;
1337
 
1338
  /* Fill in the user's symbol pointer vector if needed.  */
1339
  if (symptrs)
1340
    {
1341
      long l = symcount;
1342
 
1343
      sym = symbase;
1344
      while (l-- > 0)
1345
        {
1346
          *symptrs++ = &sym->symbol;
1347
          sym++;
1348
        }
1349
      *symptrs = 0;              /* Final null pointer */
1350
    }
1351
 
1352
  if (xverbuf != NULL)
1353
    free (xverbuf);
1354
  if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1355
    free (isymbuf);
1356
  return symcount;
1357
 
1358
error_return:
1359
  if (xverbuf != NULL)
1360
    free (xverbuf);
1361
  if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1362
    free (isymbuf);
1363
  return -1;
1364
}
1365
 
1366
/* Read relocations for ASECT from REL_HDR.  There are RELOC_COUNT of
1367
   them.  */
1368
 
1369
static bfd_boolean
1370
elf_slurp_reloc_table_from_section (bfd *abfd,
1371
                                    asection *asect,
1372
                                    Elf_Internal_Shdr *rel_hdr,
1373
                                    bfd_size_type reloc_count,
1374
                                    arelent *relents,
1375
                                    asymbol **symbols,
1376
                                    bfd_boolean dynamic)
1377
{
1378
  const struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
1379
  void *allocated = NULL;
1380
  bfd_byte *native_relocs;
1381
  arelent *relent;
1382
  unsigned int i;
1383
  int entsize;
1384
  unsigned int symcount;
1385
 
1386
  allocated = bfd_malloc (rel_hdr->sh_size);
1387
  if (allocated == NULL)
1388
    goto error_return;
1389
 
1390
  if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
1391
      || (bfd_bread (allocated, rel_hdr->sh_size, abfd)
1392
          != rel_hdr->sh_size))
1393
    goto error_return;
1394
 
1395
  native_relocs = allocated;
1396
 
1397
  entsize = rel_hdr->sh_entsize;
1398
  BFD_ASSERT (entsize == sizeof (Elf_External_Rel)
1399
              || entsize == sizeof (Elf_External_Rela));
1400
 
1401
  if (dynamic)
1402
    symcount = bfd_get_dynamic_symcount (abfd);
1403
  else
1404
    symcount = bfd_get_symcount (abfd);
1405
 
1406
  for (i = 0, relent = relents;
1407
       i < reloc_count;
1408
       i++, relent++, native_relocs += entsize)
1409
    {
1410
      Elf_Internal_Rela rela;
1411
 
1412
      if (entsize == sizeof (Elf_External_Rela))
1413
        elf_swap_reloca_in (abfd, native_relocs, &rela);
1414
      else
1415
        elf_swap_reloc_in (abfd, native_relocs, &rela);
1416
 
1417
      /* The address of an ELF reloc is section relative for an object
1418
         file, and absolute for an executable file or shared library.
1419
         The address of a normal BFD reloc is always section relative,
1420
         and the address of a dynamic reloc is absolute..  */
1421
      if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
1422
        relent->address = rela.r_offset;
1423
      else
1424
        relent->address = rela.r_offset - asect->vma;
1425
 
1426
      if (ELF_R_SYM (rela.r_info) == 0)
1427
        relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1428
      else if (ELF_R_SYM (rela.r_info) > symcount)
1429
        {
1430
          (*_bfd_error_handler)
1431
            (_("%s(%s): relocation %d has invalid symbol index %ld"),
1432
             abfd->filename, asect->name, i, ELF_R_SYM (rela.r_info));
1433
          relent->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
1434
        }
1435
      else
1436
        {
1437
          asymbol **ps;
1438
 
1439
          ps = symbols + ELF_R_SYM (rela.r_info) - 1;
1440
 
1441
          relent->sym_ptr_ptr = ps;
1442
        }
1443
 
1444
      relent->addend = rela.r_addend;
1445
 
1446
      if ((entsize == sizeof (Elf_External_Rela)
1447
           && ebd->elf_info_to_howto != NULL)
1448
          || ebd->elf_info_to_howto_rel == NULL)
1449
        (*ebd->elf_info_to_howto) (abfd, relent, &rela);
1450
      else
1451
        (*ebd->elf_info_to_howto_rel) (abfd, relent, &rela);
1452
    }
1453
 
1454
  if (allocated != NULL)
1455
    free (allocated);
1456
 
1457
  return TRUE;
1458
 
1459
 error_return:
1460
  if (allocated != NULL)
1461
    free (allocated);
1462
  return FALSE;
1463
}
1464
 
1465
/* Read in and swap the external relocs.  */
1466
 
1467
bfd_boolean
1468
elf_slurp_reloc_table (bfd *abfd,
1469
                       asection *asect,
1470
                       asymbol **symbols,
1471
                       bfd_boolean dynamic)
1472
{
1473
  struct bfd_elf_section_data * const d = elf_section_data (asect);
1474
  Elf_Internal_Shdr *rel_hdr;
1475
  Elf_Internal_Shdr *rel_hdr2;
1476
  bfd_size_type reloc_count;
1477
  bfd_size_type reloc_count2;
1478
  arelent *relents;
1479
  bfd_size_type amt;
1480
 
1481
  if (asect->relocation != NULL)
1482
    return TRUE;
1483
 
1484
  if (! dynamic)
1485
    {
1486
      if ((asect->flags & SEC_RELOC) == 0
1487
          || asect->reloc_count == 0)
1488
        return TRUE;
1489
 
1490
      rel_hdr = &d->rel_hdr;
1491
      reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1492
      rel_hdr2 = d->rel_hdr2;
1493
      reloc_count2 = (rel_hdr2 ? NUM_SHDR_ENTRIES (rel_hdr2) : 0);
1494
 
1495
      BFD_ASSERT (asect->reloc_count == reloc_count + reloc_count2);
1496
      BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
1497
                  || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
1498
 
1499
    }
1500
  else
1501
    {
1502
      /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1503
         case because relocations against this section may use the
1504
         dynamic symbol table, and in that case bfd_section_from_shdr
1505
         in elf.c does not update the RELOC_COUNT.  */
1506
      if (asect->size == 0)
1507
        return TRUE;
1508
 
1509
      rel_hdr = &d->this_hdr;
1510
      reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1511
      rel_hdr2 = NULL;
1512
      reloc_count2 = 0;
1513
    }
1514
 
1515
  amt = (reloc_count + reloc_count2) * sizeof (arelent);
1516
  relents = bfd_alloc (abfd, amt);
1517
  if (relents == NULL)
1518
    return FALSE;
1519
 
1520
  if (!elf_slurp_reloc_table_from_section (abfd, asect,
1521
                                           rel_hdr, reloc_count,
1522
                                           relents,
1523
                                           symbols, dynamic))
1524
    return FALSE;
1525
 
1526
  if (rel_hdr2
1527
      && !elf_slurp_reloc_table_from_section (abfd, asect,
1528
                                              rel_hdr2, reloc_count2,
1529
                                              relents + reloc_count,
1530
                                              symbols, dynamic))
1531
    return FALSE;
1532
 
1533
  asect->relocation = relents;
1534
  return TRUE;
1535
}
1536
 
1537
#if DEBUG & 2
1538
static void
1539
elf_debug_section (int num, Elf_Internal_Shdr *hdr)
1540
{
1541
  fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num,
1542
           hdr->bfd_section != NULL ? hdr->bfd_section->name : "",
1543
           (long) hdr);
1544
  fprintf (stderr,
1545
           "sh_name      = %ld\tsh_type      = %ld\tsh_flags     = %ld\n",
1546
           (long) hdr->sh_name,
1547
           (long) hdr->sh_type,
1548
           (long) hdr->sh_flags);
1549
  fprintf (stderr,
1550
           "sh_addr      = %ld\tsh_offset    = %ld\tsh_size      = %ld\n",
1551
           (long) hdr->sh_addr,
1552
           (long) hdr->sh_offset,
1553
           (long) hdr->sh_size);
1554
  fprintf (stderr,
1555
           "sh_link      = %ld\tsh_info      = %ld\tsh_addralign = %ld\n",
1556
           (long) hdr->sh_link,
1557
           (long) hdr->sh_info,
1558
           (long) hdr->sh_addralign);
1559
  fprintf (stderr, "sh_entsize   = %ld\n",
1560
           (long) hdr->sh_entsize);
1561
  fflush (stderr);
1562
}
1563
#endif
1564
 
1565
#if DEBUG & 1
1566
static void
1567
elf_debug_file (Elf_Internal_Ehdr *ehdrp)
1568
{
1569
  fprintf (stderr, "e_entry      = 0x%.8lx\n", (long) ehdrp->e_entry);
1570
  fprintf (stderr, "e_phoff      = %ld\n", (long) ehdrp->e_phoff);
1571
  fprintf (stderr, "e_phnum      = %ld\n", (long) ehdrp->e_phnum);
1572
  fprintf (stderr, "e_phentsize  = %ld\n", (long) ehdrp->e_phentsize);
1573
  fprintf (stderr, "e_shoff      = %ld\n", (long) ehdrp->e_shoff);
1574
  fprintf (stderr, "e_shnum      = %ld\n", (long) ehdrp->e_shnum);
1575
  fprintf (stderr, "e_shentsize  = %ld\n", (long) ehdrp->e_shentsize);
1576
}
1577
#endif
1578
 
1579
/* Create a new BFD as if by bfd_openr.  Rather than opening a file,
1580
   reconstruct an ELF file by reading the segments out of remote memory
1581
   based on the ELF file header at EHDR_VMA and the ELF program headers it
1582
   points to.  If not null, *LOADBASEP is filled in with the difference
1583
   between the VMAs from which the segments were read, and the VMAs the
1584
   file headers (and hence BFD's idea of each section's VMA) put them at.
1585
 
1586
   The function TARGET_READ_MEMORY is called to copy LEN bytes from the
1587
   remote memory at target address VMA into the local buffer at MYADDR; it
1588
   should return zero on success or an `errno' code on failure.  TEMPL must
1589
   be a BFD for a target with the word size and byte order found in the
1590
   remote memory.  */
1591
 
1592
bfd *
1593
NAME(_bfd_elf,bfd_from_remote_memory)
1594
  (bfd *templ,
1595
   bfd_vma ehdr_vma,
1596
   bfd_vma *loadbasep,
1597
   int (*target_read_memory) (bfd_vma, bfd_byte *, int))
1598
{
1599
  Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
1600
  Elf_Internal_Ehdr i_ehdr;     /* Elf file header, internal form */
1601
  Elf_External_Phdr *x_phdrs;
1602
  Elf_Internal_Phdr *i_phdrs, *last_phdr;
1603
  bfd *nbfd;
1604
  struct bfd_in_memory *bim;
1605
  int contents_size;
1606
  bfd_byte *contents;
1607
  int err;
1608
  unsigned int i;
1609
  bfd_vma loadbase;
1610
  bfd_boolean loadbase_set;
1611
 
1612
  /* Read in the ELF header in external format.  */
1613
  err = target_read_memory (ehdr_vma, (bfd_byte *) &x_ehdr, sizeof x_ehdr);
1614
  if (err)
1615
    {
1616
      bfd_set_error (bfd_error_system_call);
1617
      errno = err;
1618
      return NULL;
1619
    }
1620
 
1621
  /* Now check to see if we have a valid ELF file, and one that BFD can
1622
     make use of.  The magic number must match, the address size ('class')
1623
     and byte-swapping must match our XVEC entry.  */
1624
 
1625
  if (! elf_file_p (&x_ehdr)
1626
      || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT
1627
      || x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
1628
    {
1629
      bfd_set_error (bfd_error_wrong_format);
1630
      return NULL;
1631
    }
1632
 
1633
  /* Check that file's byte order matches xvec's */
1634
  switch (x_ehdr.e_ident[EI_DATA])
1635
    {
1636
    case ELFDATA2MSB:           /* Big-endian */
1637
      if (! bfd_header_big_endian (templ))
1638
        {
1639
          bfd_set_error (bfd_error_wrong_format);
1640
          return NULL;
1641
        }
1642
      break;
1643
    case ELFDATA2LSB:           /* Little-endian */
1644
      if (! bfd_header_little_endian (templ))
1645
        {
1646
          bfd_set_error (bfd_error_wrong_format);
1647
          return NULL;
1648
        }
1649
      break;
1650
    case ELFDATANONE:           /* No data encoding specified */
1651
    default:                    /* Unknown data encoding specified */
1652
      bfd_set_error (bfd_error_wrong_format);
1653
      return NULL;
1654
    }
1655
 
1656
  elf_swap_ehdr_in (templ, &x_ehdr, &i_ehdr);
1657
 
1658
  /* The file header tells where to find the program headers.
1659
     These are what we use to actually choose what to read.  */
1660
 
1661
  if (i_ehdr.e_phentsize != sizeof (Elf_External_Phdr) || i_ehdr.e_phnum == 0)
1662
    {
1663
      bfd_set_error (bfd_error_wrong_format);
1664
      return NULL;
1665
    }
1666
 
1667
  x_phdrs = bfd_malloc (i_ehdr.e_phnum * (sizeof *x_phdrs + sizeof *i_phdrs));
1668
  if (x_phdrs == NULL)
1669
    {
1670
      bfd_set_error (bfd_error_no_memory);
1671
      return NULL;
1672
    }
1673
  err = target_read_memory (ehdr_vma + i_ehdr.e_phoff, (bfd_byte *) x_phdrs,
1674
                            i_ehdr.e_phnum * sizeof x_phdrs[0]);
1675
  if (err)
1676
    {
1677
      free (x_phdrs);
1678
      bfd_set_error (bfd_error_system_call);
1679
      errno = err;
1680
      return NULL;
1681
    }
1682
  i_phdrs = (Elf_Internal_Phdr *) &x_phdrs[i_ehdr.e_phnum];
1683
 
1684
  contents_size = 0;
1685
  last_phdr = NULL;
1686
  loadbase = ehdr_vma;
1687
  loadbase_set = FALSE;
1688
  for (i = 0; i < i_ehdr.e_phnum; ++i)
1689
    {
1690
      elf_swap_phdr_in (templ, &x_phdrs[i], &i_phdrs[i]);
1691
      if (i_phdrs[i].p_type == PT_LOAD)
1692
        {
1693
          bfd_vma segment_end;
1694
          segment_end = (i_phdrs[i].p_offset + i_phdrs[i].p_filesz
1695
                         + i_phdrs[i].p_align - 1) & -i_phdrs[i].p_align;
1696
          if (segment_end > (bfd_vma) contents_size)
1697
            contents_size = segment_end;
1698
 
1699
          /* LOADADDR is the `Base address' from the gELF specification:
1700
             `lowest p_vaddr value for a PT_LOAD segment' is P_VADDR from the
1701
             first PT_LOAD as PT_LOADs are ordered by P_VADDR.  */
1702
          if (!loadbase_set && (i_phdrs[i].p_offset & -i_phdrs[i].p_align) == 0)
1703
            {
1704
              loadbase = ehdr_vma - (i_phdrs[i].p_vaddr & -i_phdrs[i].p_align);
1705
              loadbase_set = TRUE;
1706
            }
1707
 
1708
          last_phdr = &i_phdrs[i];
1709
        }
1710
    }
1711
  if (last_phdr == NULL)
1712
    {
1713
      /* There were no PT_LOAD segments, so we don't have anything to read.  */
1714
      free (x_phdrs);
1715
      bfd_set_error (bfd_error_wrong_format);
1716
      return NULL;
1717
    }
1718
 
1719
  /* Trim the last segment so we don't bother with zeros in the last page
1720
     that are off the end of the file.  However, if the extra bit in that
1721
     page includes the section headers, keep them.  */
1722
  if ((bfd_vma) contents_size > last_phdr->p_offset + last_phdr->p_filesz
1723
      && (bfd_vma) contents_size >= (i_ehdr.e_shoff
1724
                                     + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1725
    {
1726
      contents_size = last_phdr->p_offset + last_phdr->p_filesz;
1727
      if ((bfd_vma) contents_size < (i_ehdr.e_shoff
1728
                                     + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1729
        contents_size = i_ehdr.e_shoff + i_ehdr.e_shnum * i_ehdr.e_shentsize;
1730
    }
1731
  else
1732
    contents_size = last_phdr->p_offset + last_phdr->p_filesz;
1733
 
1734
  /* Now we know the size of the whole image we want read in.  */
1735
  contents = bfd_zmalloc (contents_size);
1736
  if (contents == NULL)
1737
    {
1738
      free (x_phdrs);
1739
      bfd_set_error (bfd_error_no_memory);
1740
      return NULL;
1741
    }
1742
 
1743
  for (i = 0; i < i_ehdr.e_phnum; ++i)
1744
    if (i_phdrs[i].p_type == PT_LOAD)
1745
      {
1746
        bfd_vma start = i_phdrs[i].p_offset & -i_phdrs[i].p_align;
1747
        bfd_vma end = (i_phdrs[i].p_offset + i_phdrs[i].p_filesz
1748
                       + i_phdrs[i].p_align - 1) & -i_phdrs[i].p_align;
1749
        if (end > (bfd_vma) contents_size)
1750
          end = contents_size;
1751
        err = target_read_memory ((loadbase + i_phdrs[i].p_vaddr)
1752
                                  & -i_phdrs[i].p_align,
1753
                                  contents + start, end - start);
1754
        if (err)
1755
          {
1756
            free (x_phdrs);
1757
            free (contents);
1758
            bfd_set_error (bfd_error_system_call);
1759
            errno = err;
1760
            return NULL;
1761
          }
1762
      }
1763
  free (x_phdrs);
1764
 
1765
  /* If the segments visible in memory didn't include the section headers,
1766
     then clear them from the file header.  */
1767
  if ((bfd_vma) contents_size < (i_ehdr.e_shoff
1768
                                 + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1769
    {
1770
      memset (&x_ehdr.e_shoff, 0, sizeof x_ehdr.e_shoff);
1771
      memset (&x_ehdr.e_shnum, 0, sizeof x_ehdr.e_shnum);
1772
      memset (&x_ehdr.e_shstrndx, 0, sizeof x_ehdr.e_shstrndx);
1773
    }
1774
 
1775
  /* This will normally have been in the first PT_LOAD segment.  But it
1776
     conceivably could be missing, and we might have just changed it.  */
1777
  memcpy (contents, &x_ehdr, sizeof x_ehdr);
1778
 
1779
  /* Now we have a memory image of the ELF file contents.  Make a BFD.  */
1780
  bim = bfd_malloc (sizeof (struct bfd_in_memory));
1781
  if (bim == NULL)
1782
    {
1783
      free (contents);
1784
      bfd_set_error (bfd_error_no_memory);
1785
      return NULL;
1786
    }
1787
  nbfd = _bfd_new_bfd ();
1788
  if (nbfd == NULL)
1789
    {
1790
      free (bim);
1791
      free (contents);
1792
      bfd_set_error (bfd_error_no_memory);
1793
      return NULL;
1794
    }
1795
  nbfd->filename = "<in-memory>";
1796
  nbfd->xvec = templ->xvec;
1797
  bim->size = contents_size;
1798
  bim->buffer = contents;
1799
  nbfd->iostream = bim;
1800
  nbfd->flags = BFD_IN_MEMORY;
1801
  nbfd->direction = read_direction;
1802
  nbfd->mtime = time (NULL);
1803
  nbfd->mtime_set = TRUE;
1804
 
1805
  if (loadbasep)
1806
    *loadbasep = loadbase;
1807
  return nbfd;
1808
}
1809
 
1810
#include "elfcore.h"
1811
 
1812
/* Size-dependent data and functions.  */
1813
const struct elf_size_info NAME(_bfd_elf,size_info) = {
1814
  sizeof (Elf_External_Ehdr),
1815
  sizeof (Elf_External_Phdr),
1816
  sizeof (Elf_External_Shdr),
1817
  sizeof (Elf_External_Rel),
1818
  sizeof (Elf_External_Rela),
1819
  sizeof (Elf_External_Sym),
1820
  sizeof (Elf_External_Dyn),
1821
  sizeof (Elf_External_Note),
1822
  4,
1823
  1,
1824
  ARCH_SIZE, LOG_FILE_ALIGN,
1825
  ELFCLASS, EV_CURRENT,
1826
  elf_write_out_phdrs,
1827
  elf_write_shdrs_and_ehdr,
1828
  elf_checksum_contents,
1829
  elf_write_relocs,
1830
  elf_swap_symbol_in,
1831
  elf_swap_symbol_out,
1832
  elf_slurp_reloc_table,
1833
  elf_slurp_symbol_table,
1834
  elf_swap_dyn_in,
1835
  elf_swap_dyn_out,
1836
  elf_swap_reloc_in,
1837
  elf_swap_reloc_out,
1838
  elf_swap_reloca_in,
1839
  elf_swap_reloca_out
1840
};

powered by: WebSVN 2.1.0

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