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