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