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