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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [bfd/] [elfcode.h] - Blame information for rev 861

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

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

powered by: WebSVN 2.1.0

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