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