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