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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [bfd/] [elfcode.h] - Blame information for rev 14

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

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

powered by: WebSVN 2.1.0

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