1 /* ELF executable support for BFD. 2 Copyright (C) 1991-2020 Free Software Foundation, Inc. 3 4 Written by Fred Fish @ Cygnus Support, from information published 5 in "UNIX System V Release 4, Programmers Guide: ANSI C and 6 Programming Support Tools". Sufficient support for gdb. 7 8 Rewritten by Mark Eichin @ Cygnus Support, from information 9 published in "System V Application Binary Interface", chapters 4 10 and 5, as well as the various "Processor Supplement" documents 11 derived from it. Added support for assembler and other object file 12 utilities. Further work done by Ken Raeburn (Cygnus Support), Michael 13 Meissner (Open Software Foundation), and Peter Hoogenboom (University 14 of Utah) to finish and extend this. 15 16 This file is part of BFD, the Binary File Descriptor library. 17 18 This program is free software; you can redistribute it and/or modify 19 it under the terms of the GNU General Public License as published by 20 the Free Software Foundation; either version 3 of the License, or 21 (at your option) any later version. 22 23 This program is distributed in the hope that it will be useful, 24 but WITHOUT ANY WARRANTY; without even the implied warranty of 25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 26 GNU General Public License for more details. 27 28 You should have received a copy of the GNU General Public License 29 along with this program; if not, write to the Free Software 30 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 31 MA 02110-1301, USA. */ 32 33 34 /* Problems and other issues to resolve. 35 36 (1) BFD expects there to be some fixed number of "sections" in 37 the object file. I.E. there is a "section_count" variable in the 38 bfd structure which contains the number of sections. However, ELF 39 supports multiple "views" of a file. In particular, with current 40 implementations, executable files typically have two tables, a 41 program header table and a section header table, both of which 42 partition the executable. 43 44 In ELF-speak, the "linking view" of the file uses the section header 45 table to access "sections" within the file, and the "execution view" 46 uses the program header table to access "segments" within the file. 47 "Segments" typically may contain all the data from one or more 48 "sections". 49 50 Note that the section header table is optional in ELF executables, 51 but it is this information that is most useful to gdb. If the 52 section header table is missing, then gdb should probably try 53 to make do with the program header table. (FIXME) 54 55 (2) The code in this file is compiled twice, once in 32-bit mode and 56 once in 64-bit mode. More of it should be made size-independent 57 and moved into elf.c. 58 59 (3) ELF section symbols are handled rather sloppily now. This should 60 be cleaned up, and ELF section symbols reconciled with BFD section 61 symbols. 62 63 (4) We need a published spec for 64-bit ELF. We've got some stuff here 64 that we're using for SPARC V9 64-bit chips, but don't assume that 65 it's cast in stone. 66 */ 67 68 #include "sysdep.h" 69 #include "bfd.h" 70 #include "libiberty.h" 71 #include "bfdlink.h" 72 #include "libbfd.h" 73 #include "elf-bfd.h" 74 #include "libiberty.h" 75 76 /* Renaming structures, typedefs, macros and functions to be size-specific. */ 77 #define Elf_External_Ehdr NAME(Elf,External_Ehdr) 78 #define Elf_External_Sym NAME(Elf,External_Sym) 79 #define Elf_External_Shdr NAME(Elf,External_Shdr) 80 #define Elf_External_Phdr NAME(Elf,External_Phdr) 81 #define Elf_External_Rel NAME(Elf,External_Rel) 82 #define Elf_External_Rela NAME(Elf,External_Rela) 83 #define Elf_External_Dyn NAME(Elf,External_Dyn) 84 85 #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command) 86 #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal) 87 #define elf_core_file_matches_executable_p \ 88 NAME(bfd_elf,core_file_matches_executable_p) 89 #define elf_core_file_pid NAME(bfd_elf,core_file_pid) 90 #define elf_object_p NAME(bfd_elf,object_p) 91 #define elf_core_file_p NAME(bfd_elf,core_file_p) 92 #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound) 93 #define elf_get_dynamic_symtab_upper_bound \ 94 NAME(bfd_elf,get_dynamic_symtab_upper_bound) 95 #define elf_swap_reloc_in NAME(bfd_elf,swap_reloc_in) 96 #define elf_swap_reloca_in NAME(bfd_elf,swap_reloca_in) 97 #define elf_swap_reloc_out NAME(bfd_elf,swap_reloc_out) 98 #define elf_swap_reloca_out NAME(bfd_elf,swap_reloca_out) 99 #define elf_swap_symbol_in NAME(bfd_elf,swap_symbol_in) 100 #define elf_swap_symbol_out NAME(bfd_elf,swap_symbol_out) 101 #define elf_swap_phdr_in NAME(bfd_elf,swap_phdr_in) 102 #define elf_swap_phdr_out NAME(bfd_elf,swap_phdr_out) 103 #define elf_swap_dyn_in NAME(bfd_elf,swap_dyn_in) 104 #define elf_swap_dyn_out NAME(bfd_elf,swap_dyn_out) 105 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound) 106 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc) 107 #define elf_slurp_symbol_table NAME(bfd_elf,slurp_symbol_table) 108 #define elf_canonicalize_symtab NAME(bfd_elf,canonicalize_symtab) 109 #define elf_canonicalize_dynamic_symtab \ 110 NAME(bfd_elf,canonicalize_dynamic_symtab) 111 #define elf_get_synthetic_symtab \ 112 NAME(bfd_elf,get_synthetic_symtab) 113 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol) 114 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info) 115 #define elf_get_lineno NAME(bfd_elf,get_lineno) 116 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach) 117 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line) 118 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers) 119 #define elf_set_section_contents NAME(bfd_elf,set_section_contents) 120 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto) 121 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel) 122 #define elf_find_section NAME(bfd_elf,find_section) 123 #define elf_write_shdrs_and_ehdr NAME(bfd_elf,write_shdrs_and_ehdr) 124 #define elf_write_out_phdrs NAME(bfd_elf,write_out_phdrs) 125 #define elf_checksum_contents NAME(bfd_elf,checksum_contents) 126 #define elf_write_relocs NAME(bfd_elf,write_relocs) 127 #define elf_slurp_reloc_table NAME(bfd_elf,slurp_reloc_table) 128 129 #if ARCH_SIZE == 64 130 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y) 131 #define ELF_R_SYM(X) ELF64_R_SYM(X) 132 #define ELF_R_TYPE(X) ELF64_R_TYPE(X) 133 #define ELFCLASS ELFCLASS64 134 #define FILE_ALIGN 8 135 #define LOG_FILE_ALIGN 3 136 #endif 137 #if ARCH_SIZE == 32 138 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y) 139 #define ELF_R_SYM(X) ELF32_R_SYM(X) 140 #define ELF_R_TYPE(X) ELF32_R_TYPE(X) 141 #define ELFCLASS ELFCLASS32 142 #define FILE_ALIGN 4 143 #define LOG_FILE_ALIGN 2 144 #endif 145 146 #if DEBUG & 2 147 static void elf_debug_section (int, Elf_Internal_Shdr *); 148 #endif 149 #if DEBUG & 1 150 static void elf_debug_file (Elf_Internal_Ehdr *); 151 #endif 152 153 /* Structure swapping routines */ 154 155 /* Should perhaps use put_offset, put_word, etc. For now, the two versions 156 can be handled by explicitly specifying 32 bits or "the long type". */ 157 #if ARCH_SIZE == 64 158 #define H_PUT_WORD H_PUT_64 159 #define H_PUT_SIGNED_WORD H_PUT_S64 160 #define H_GET_WORD H_GET_64 161 #define H_GET_SIGNED_WORD H_GET_S64 162 #endif 163 #if ARCH_SIZE == 32 164 #define H_PUT_WORD H_PUT_32 165 #define H_PUT_SIGNED_WORD H_PUT_S32 166 #define H_GET_WORD H_GET_32 167 #define H_GET_SIGNED_WORD H_GET_S32 168 #endif 169 170 /* Translate an ELF symbol in external format into an ELF symbol in internal 171 format. */ 172 173 bfd_boolean 174 elf_swap_symbol_in (bfd *abfd, 175 const void *psrc, 176 const void *pshn, 177 Elf_Internal_Sym *dst) 178 { 179 const Elf_External_Sym *src = (const Elf_External_Sym *) psrc; 180 const Elf_External_Sym_Shndx *shndx = (const Elf_External_Sym_Shndx *) pshn; 181 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma; 182 183 dst->st_name = H_GET_32 (abfd, src->st_name); 184 if (signed_vma) 185 dst->st_value = H_GET_SIGNED_WORD (abfd, src->st_value); 186 else 187 dst->st_value = H_GET_WORD (abfd, src->st_value); 188 dst->st_size = H_GET_WORD (abfd, src->st_size); 189 dst->st_info = H_GET_8 (abfd, src->st_info); 190 dst->st_other = H_GET_8 (abfd, src->st_other); 191 dst->st_shndx = H_GET_16 (abfd, src->st_shndx); 192 if (dst->st_shndx == (SHN_XINDEX & 0xffff)) 193 { 194 if (shndx == NULL) 195 return FALSE; 196 dst->st_shndx = H_GET_32 (abfd, shndx->est_shndx); 197 } 198 else if (dst->st_shndx >= (SHN_LORESERVE & 0xffff)) 199 dst->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff); 200 dst->st_target_internal = 0; 201 return TRUE; 202 } 203 204 /* Translate an ELF symbol in internal format into an ELF symbol in external 205 format. */ 206 207 void 208 elf_swap_symbol_out (bfd *abfd, 209 const Elf_Internal_Sym *src, 210 void *cdst, 211 void *shndx) 212 { 213 unsigned int tmp; 214 Elf_External_Sym *dst = (Elf_External_Sym *) cdst; 215 H_PUT_32 (abfd, src->st_name, dst->st_name); 216 H_PUT_WORD (abfd, src->st_value, dst->st_value); 217 H_PUT_WORD (abfd, src->st_size, dst->st_size); 218 H_PUT_8 (abfd, src->st_info, dst->st_info); 219 H_PUT_8 (abfd, src->st_other, dst->st_other); 220 tmp = src->st_shndx; 221 if (tmp >= (SHN_LORESERVE & 0xffff) && tmp < SHN_LORESERVE) 222 { 223 if (shndx == NULL) 224 abort (); 225 H_PUT_32 (abfd, tmp, shndx); 226 tmp = SHN_XINDEX & 0xffff; 227 } 228 H_PUT_16 (abfd, tmp, dst->st_shndx); 229 } 230 231 /* Translate an ELF file header in external format into an ELF file header in 232 internal format. */ 233 234 static void 235 elf_swap_ehdr_in (bfd *abfd, 236 const Elf_External_Ehdr *src, 237 Elf_Internal_Ehdr *dst) 238 { 239 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma; 240 memcpy (dst->e_ident, src->e_ident, EI_NIDENT); 241 dst->e_type = H_GET_16 (abfd, src->e_type); 242 dst->e_machine = H_GET_16 (abfd, src->e_machine); 243 dst->e_version = H_GET_32 (abfd, src->e_version); 244 if (signed_vma) 245 dst->e_entry = H_GET_SIGNED_WORD (abfd, src->e_entry); 246 else 247 dst->e_entry = H_GET_WORD (abfd, src->e_entry); 248 dst->e_phoff = H_GET_WORD (abfd, src->e_phoff); 249 dst->e_shoff = H_GET_WORD (abfd, src->e_shoff); 250 dst->e_flags = H_GET_32 (abfd, src->e_flags); 251 dst->e_ehsize = H_GET_16 (abfd, src->e_ehsize); 252 dst->e_phentsize = H_GET_16 (abfd, src->e_phentsize); 253 dst->e_phnum = H_GET_16 (abfd, src->e_phnum); 254 dst->e_shentsize = H_GET_16 (abfd, src->e_shentsize); 255 dst->e_shnum = H_GET_16 (abfd, src->e_shnum); 256 dst->e_shstrndx = H_GET_16 (abfd, src->e_shstrndx); 257 } 258 259 /* Translate an ELF file header in internal format into an ELF file header in 260 external format. */ 261 262 static void 263 elf_swap_ehdr_out (bfd *abfd, 264 const Elf_Internal_Ehdr *src, 265 Elf_External_Ehdr *dst) 266 { 267 unsigned int tmp; 268 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma; 269 memcpy (dst->e_ident, src->e_ident, EI_NIDENT); 270 /* note that all elements of dst are *arrays of unsigned char* already... */ 271 H_PUT_16 (abfd, src->e_type, dst->e_type); 272 H_PUT_16 (abfd, src->e_machine, dst->e_machine); 273 H_PUT_32 (abfd, src->e_version, dst->e_version); 274 if (signed_vma) 275 H_PUT_SIGNED_WORD (abfd, src->e_entry, dst->e_entry); 276 else 277 H_PUT_WORD (abfd, src->e_entry, dst->e_entry); 278 H_PUT_WORD (abfd, src->e_phoff, dst->e_phoff); 279 H_PUT_WORD (abfd, src->e_shoff, dst->e_shoff); 280 H_PUT_32 (abfd, src->e_flags, dst->e_flags); 281 H_PUT_16 (abfd, src->e_ehsize, dst->e_ehsize); 282 H_PUT_16 (abfd, src->e_phentsize, dst->e_phentsize); 283 tmp = src->e_phnum; 284 if (tmp > PN_XNUM) 285 tmp = PN_XNUM; 286 H_PUT_16 (abfd, tmp, dst->e_phnum); 287 H_PUT_16 (abfd, src->e_shentsize, dst->e_shentsize); 288 tmp = src->e_shnum; 289 if (tmp >= (SHN_LORESERVE & 0xffff)) 290 tmp = SHN_UNDEF; 291 H_PUT_16 (abfd, tmp, dst->e_shnum); 292 tmp = src->e_shstrndx; 293 if (tmp >= (SHN_LORESERVE & 0xffff)) 294 tmp = SHN_XINDEX & 0xffff; 295 H_PUT_16 (abfd, tmp, dst->e_shstrndx); 296 } 297 298 /* Translate an ELF section header table entry in external format into an 299 ELF section header table entry in internal format. */ 300 301 static void 302 elf_swap_shdr_in (bfd *abfd, 303 const Elf_External_Shdr *src, 304 Elf_Internal_Shdr *dst) 305 { 306 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma; 307 308 dst->sh_name = H_GET_32 (abfd, src->sh_name); 309 dst->sh_type = H_GET_32 (abfd, src->sh_type); 310 dst->sh_flags = H_GET_WORD (abfd, src->sh_flags); 311 if (signed_vma) 312 dst->sh_addr = H_GET_SIGNED_WORD (abfd, src->sh_addr); 313 else 314 dst->sh_addr = H_GET_WORD (abfd, src->sh_addr); 315 dst->sh_offset = H_GET_WORD (abfd, src->sh_offset); 316 dst->sh_size = H_GET_WORD (abfd, src->sh_size); 317 /* PR 23657. Check for invalid section size, in sections with contents. 318 Note - we do not set an error value here because the contents 319 of this particular section might not be needed by the consumer. */ 320 if (dst->sh_type != SHT_NOBITS 321 && dst->sh_size > bfd_get_file_size (abfd)) 322 _bfd_error_handler 323 (_("warning: %pB has a corrupt section with a size (%" BFD_VMA_FMT "x) larger than the file size"), 324 abfd, dst->sh_size); 325 dst->sh_link = H_GET_32 (abfd, src->sh_link); 326 dst->sh_info = H_GET_32 (abfd, src->sh_info); 327 dst->sh_addralign = H_GET_WORD (abfd, src->sh_addralign); 328 dst->sh_entsize = H_GET_WORD (abfd, src->sh_entsize); 329 dst->bfd_section = NULL; 330 dst->contents = NULL; 331 } 332 333 /* Translate an ELF section header table entry in internal format into an 334 ELF section header table entry in external format. */ 335 336 static void 337 elf_swap_shdr_out (bfd *abfd, 338 const Elf_Internal_Shdr *src, 339 Elf_External_Shdr *dst) 340 { 341 /* note that all elements of dst are *arrays of unsigned char* already... */ 342 H_PUT_32 (abfd, src->sh_name, dst->sh_name); 343 H_PUT_32 (abfd, src->sh_type, dst->sh_type); 344 H_PUT_WORD (abfd, src->sh_flags, dst->sh_flags); 345 H_PUT_WORD (abfd, src->sh_addr, dst->sh_addr); 346 H_PUT_WORD (abfd, src->sh_offset, dst->sh_offset); 347 H_PUT_WORD (abfd, src->sh_size, dst->sh_size); 348 H_PUT_32 (abfd, src->sh_link, dst->sh_link); 349 H_PUT_32 (abfd, src->sh_info, dst->sh_info); 350 H_PUT_WORD (abfd, src->sh_addralign, dst->sh_addralign); 351 H_PUT_WORD (abfd, src->sh_entsize, dst->sh_entsize); 352 } 353 354 /* Translate an ELF program header table entry in external format into an 355 ELF program header table entry in internal format. */ 356 357 void 358 elf_swap_phdr_in (bfd *abfd, 359 const Elf_External_Phdr *src, 360 Elf_Internal_Phdr *dst) 361 { 362 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma; 363 364 dst->p_type = H_GET_32 (abfd, src->p_type); 365 dst->p_flags = H_GET_32 (abfd, src->p_flags); 366 dst->p_offset = H_GET_WORD (abfd, src->p_offset); 367 if (signed_vma) 368 { 369 dst->p_vaddr = H_GET_SIGNED_WORD (abfd, src->p_vaddr); 370 dst->p_paddr = H_GET_SIGNED_WORD (abfd, src->p_paddr); 371 } 372 else 373 { 374 dst->p_vaddr = H_GET_WORD (abfd, src->p_vaddr); 375 dst->p_paddr = H_GET_WORD (abfd, src->p_paddr); 376 } 377 dst->p_filesz = H_GET_WORD (abfd, src->p_filesz); 378 dst->p_memsz = H_GET_WORD (abfd, src->p_memsz); 379 dst->p_align = H_GET_WORD (abfd, src->p_align); 380 } 381 382 void 383 elf_swap_phdr_out (bfd *abfd, 384 const Elf_Internal_Phdr *src, 385 Elf_External_Phdr *dst) 386 { 387 const struct elf_backend_data *bed; 388 bfd_vma p_paddr; 389 390 bed = get_elf_backend_data (abfd); 391 p_paddr = bed->want_p_paddr_set_to_zero ? 0 : src->p_paddr; 392 393 /* note that all elements of dst are *arrays of unsigned char* already... */ 394 H_PUT_32 (abfd, src->p_type, dst->p_type); 395 H_PUT_WORD (abfd, src->p_offset, dst->p_offset); 396 H_PUT_WORD (abfd, src->p_vaddr, dst->p_vaddr); 397 H_PUT_WORD (abfd, p_paddr, dst->p_paddr); 398 H_PUT_WORD (abfd, src->p_filesz, dst->p_filesz); 399 H_PUT_WORD (abfd, src->p_memsz, dst->p_memsz); 400 H_PUT_32 (abfd, src->p_flags, dst->p_flags); 401 H_PUT_WORD (abfd, src->p_align, dst->p_align); 402 } 403 404 /* Translate an ELF reloc from external format to internal format. */ 405 void 406 elf_swap_reloc_in (bfd *abfd, 407 const bfd_byte *s, 408 Elf_Internal_Rela *dst) 409 { 410 const Elf_External_Rel *src = (const Elf_External_Rel *) s; 411 dst->r_offset = H_GET_WORD (abfd, src->r_offset); 412 dst->r_info = H_GET_WORD (abfd, src->r_info); 413 dst->r_addend = 0; 414 } 415 416 void 417 elf_swap_reloca_in (bfd *abfd, 418 const bfd_byte *s, 419 Elf_Internal_Rela *dst) 420 { 421 const Elf_External_Rela *src = (const Elf_External_Rela *) s; 422 dst->r_offset = H_GET_WORD (abfd, src->r_offset); 423 dst->r_info = H_GET_WORD (abfd, src->r_info); 424 dst->r_addend = H_GET_SIGNED_WORD (abfd, src->r_addend); 425 } 426 427 /* Translate an ELF reloc from internal format to external format. */ 428 void 429 elf_swap_reloc_out (bfd *abfd, 430 const Elf_Internal_Rela *src, 431 bfd_byte *d) 432 { 433 Elf_External_Rel *dst = (Elf_External_Rel *) d; 434 H_PUT_WORD (abfd, src->r_offset, dst->r_offset); 435 H_PUT_WORD (abfd, src->r_info, dst->r_info); 436 } 437 438 void 439 elf_swap_reloca_out (bfd *abfd, 440 const Elf_Internal_Rela *src, 441 bfd_byte *d) 442 { 443 Elf_External_Rela *dst = (Elf_External_Rela *) d; 444 H_PUT_WORD (abfd, src->r_offset, dst->r_offset); 445 H_PUT_WORD (abfd, src->r_info, dst->r_info); 446 H_PUT_SIGNED_WORD (abfd, src->r_addend, dst->r_addend); 447 } 448 449 void 450 elf_swap_dyn_in (bfd *abfd, 451 const void *p, 452 Elf_Internal_Dyn *dst) 453 { 454 const Elf_External_Dyn *src = (const Elf_External_Dyn *) p; 455 456 dst->d_tag = H_GET_WORD (abfd, src->d_tag); 457 dst->d_un.d_val = H_GET_WORD (abfd, src->d_un.d_val); 458 } 459 460 void 461 elf_swap_dyn_out (bfd *abfd, 462 const Elf_Internal_Dyn *src, 463 void *p) 464 { 465 Elf_External_Dyn *dst = (Elf_External_Dyn *) p; 466 467 H_PUT_WORD (abfd, src->d_tag, dst->d_tag); 468 H_PUT_WORD (abfd, src->d_un.d_val, dst->d_un.d_val); 469 } 470 471 /* ELF .o/exec file reading */ 472 473 /* Begin processing a given object. 474 475 First we validate the file by reading in the ELF header and checking 476 the magic number. */ 477 478 static inline bfd_boolean 479 elf_file_p (Elf_External_Ehdr *x_ehdrp) 480 { 481 return ((x_ehdrp->e_ident[EI_MAG0] == ELFMAG0) 482 && (x_ehdrp->e_ident[EI_MAG1] == ELFMAG1) 483 && (x_ehdrp->e_ident[EI_MAG2] == ELFMAG2) 484 && (x_ehdrp->e_ident[EI_MAG3] == ELFMAG3)); 485 } 486 487 /* Check to see if the file associated with ABFD matches the target vector 488 that ABFD points to. 489 490 Note that we may be called several times with the same ABFD, but different 491 target vectors, most of which will not match. We have to avoid leaving 492 any side effects in ABFD, or any data it points to (like tdata), if the 493 file does not match the target vector. */ 494 495 const bfd_target * 496 elf_object_p (bfd *abfd) 497 { 498 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */ 499 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */ 500 Elf_External_Shdr x_shdr; /* Section header table entry, external form */ 501 Elf_Internal_Shdr i_shdr; 502 Elf_Internal_Shdr *i_shdrp; /* Section header table, internal form */ 503 unsigned int shindex; 504 const struct elf_backend_data *ebd; 505 asection *s; 506 const bfd_target *target; 507 508 /* Read in the ELF header in external format. */ 509 510 if (bfd_bread (&x_ehdr, sizeof (x_ehdr), abfd) != sizeof (x_ehdr)) 511 { 512 if (bfd_get_error () != bfd_error_system_call) 513 goto got_wrong_format_error; 514 else 515 goto got_no_match; 516 } 517 518 /* Now check to see if we have a valid ELF file, and one that BFD can 519 make use of. The magic number must match, the address size ('class') 520 and byte-swapping must match our XVEC entry, and it must have a 521 section header table (FIXME: See comments re sections at top of this 522 file). */ 523 524 if (! elf_file_p (&x_ehdr) 525 || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT 526 || x_ehdr.e_ident[EI_CLASS] != ELFCLASS) 527 goto got_wrong_format_error; 528 529 /* Check that file's byte order matches xvec's */ 530 switch (x_ehdr.e_ident[EI_DATA]) 531 { 532 case ELFDATA2MSB: /* Big-endian */ 533 if (! bfd_header_big_endian (abfd)) 534 goto got_wrong_format_error; 535 break; 536 case ELFDATA2LSB: /* Little-endian */ 537 if (! bfd_header_little_endian (abfd)) 538 goto got_wrong_format_error; 539 break; 540 case ELFDATANONE: /* No data encoding specified */ 541 default: /* Unknown data encoding specified */ 542 goto got_wrong_format_error; 543 } 544 545 target = abfd->xvec; 546 547 /* Allocate an instance of the elf_obj_tdata structure and hook it up to 548 the tdata pointer in the bfd. */ 549 550 if (! (*target->_bfd_set_format[bfd_object]) (abfd)) 551 goto got_no_match; 552 553 /* Now that we know the byte order, swap in the rest of the header */ 554 i_ehdrp = elf_elfheader (abfd); 555 elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp); 556 #if DEBUG & 1 557 elf_debug_file (i_ehdrp); 558 #endif 559 560 /* Reject ET_CORE (header indicates core file, not object file) */ 561 if (i_ehdrp->e_type == ET_CORE) 562 goto got_wrong_format_error; 563 564 /* If this is a relocatable file and there is no section header 565 table, then we're hosed. */ 566 if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_type == ET_REL) 567 goto got_wrong_format_error; 568 569 /* As a simple sanity check, verify that what BFD thinks is the 570 size of each section header table entry actually matches the size 571 recorded in the file, but only if there are any sections. */ 572 if (i_ehdrp->e_shentsize != sizeof (x_shdr) && i_ehdrp->e_shnum != 0) 573 goto got_wrong_format_error; 574 575 /* Further sanity check. */ 576 if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_shnum != 0) 577 goto got_wrong_format_error; 578 579 ebd = get_elf_backend_data (abfd); 580 if (ebd->s->arch_size != ARCH_SIZE) 581 goto got_wrong_format_error; 582 583 /* Check that the ELF e_machine field matches what this particular 584 BFD format expects. */ 585 if (ebd->elf_machine_code != i_ehdrp->e_machine 586 && (ebd->elf_machine_alt1 == 0 587 || i_ehdrp->e_machine != ebd->elf_machine_alt1) 588 && (ebd->elf_machine_alt2 == 0 589 || i_ehdrp->e_machine != ebd->elf_machine_alt2) 590 && ebd->elf_machine_code != EM_NONE) 591 goto got_wrong_format_error; 592 593 if (i_ehdrp->e_type == ET_EXEC) 594 abfd->flags |= EXEC_P; 595 else if (i_ehdrp->e_type == ET_DYN) 596 abfd->flags |= DYNAMIC; 597 598 if (i_ehdrp->e_phnum > 0) 599 abfd->flags |= D_PAGED; 600 601 if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0)) 602 { 603 /* It's OK if this fails for the generic target. */ 604 if (ebd->elf_machine_code != EM_NONE) 605 goto got_no_match; 606 } 607 608 if (ebd->elf_machine_code != EM_NONE 609 && i_ehdrp->e_ident[EI_OSABI] != ebd->elf_osabi 610 && ebd->elf_osabi != ELFOSABI_NONE) 611 goto got_wrong_format_error; 612 613 if (i_ehdrp->e_shoff != 0) 614 { 615 file_ptr where = (file_ptr) i_ehdrp->e_shoff; 616 617 /* Seek to the section header table in the file. */ 618 if (bfd_seek (abfd, where, 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 { 631 i_ehdrp->e_shnum = i_shdr.sh_size; 632 if (i_ehdrp->e_shnum >= SHN_LORESERVE 633 || i_ehdrp->e_shnum != i_shdr.sh_size 634 || i_ehdrp->e_shnum == 0) 635 goto got_wrong_format_error; 636 } 637 638 /* And similarly for the string table index. */ 639 if (i_ehdrp->e_shstrndx == (SHN_XINDEX & 0xffff)) 640 { 641 i_ehdrp->e_shstrndx = i_shdr.sh_link; 642 if (i_ehdrp->e_shstrndx != i_shdr.sh_link) 643 goto got_wrong_format_error; 644 } 645 646 /* And program headers. */ 647 if (i_ehdrp->e_phnum == PN_XNUM && i_shdr.sh_info != 0) 648 { 649 i_ehdrp->e_phnum = i_shdr.sh_info; 650 if (i_ehdrp->e_phnum != i_shdr.sh_info) 651 goto got_wrong_format_error; 652 } 653 654 /* Sanity check that we can read all of the section headers. 655 It ought to be good enough to just read the last one. */ 656 if (i_ehdrp->e_shnum != 1) 657 { 658 /* Check that we don't have a totally silly number of sections. */ 659 if (i_ehdrp->e_shnum > (unsigned int) -1 / sizeof (x_shdr) 660 || i_ehdrp->e_shnum > (unsigned int) -1 / sizeof (i_shdr)) 661 goto got_wrong_format_error; 662 663 where += (i_ehdrp->e_shnum - 1) * sizeof (x_shdr); 664 if ((bfd_size_type) where <= i_ehdrp->e_shoff) 665 goto got_wrong_format_error; 666 667 if (bfd_seek (abfd, where, SEEK_SET) != 0) 668 goto got_no_match; 669 if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr)) 670 goto got_no_match; 671 672 /* Back to where we were. */ 673 where = i_ehdrp->e_shoff + sizeof (x_shdr); 674 if (bfd_seek (abfd, where, SEEK_SET) != 0) 675 goto got_no_match; 676 } 677 } 678 679 /* Allocate space for a copy of the section header table in 680 internal form. */ 681 if (i_ehdrp->e_shnum != 0) 682 { 683 Elf_Internal_Shdr *shdrp; 684 unsigned int num_sec; 685 686 #ifndef BFD64 687 if (i_ehdrp->e_shnum > ((bfd_size_type) -1) / sizeof (*i_shdrp)) 688 goto got_wrong_format_error; 689 #endif 690 i_shdrp = (Elf_Internal_Shdr *) bfd_alloc2 (abfd, i_ehdrp->e_shnum, 691 sizeof (*i_shdrp)); 692 if (!i_shdrp) 693 goto got_no_match; 694 num_sec = i_ehdrp->e_shnum; 695 elf_numsections (abfd) = num_sec; 696 elf_elfsections (abfd) 697 = (Elf_Internal_Shdr **) bfd_alloc2 (abfd, num_sec, sizeof (i_shdrp)); 698 if (!elf_elfsections (abfd)) 699 goto got_no_match; 700 701 memcpy (i_shdrp, &i_shdr, sizeof (*i_shdrp)); 702 for (shdrp = i_shdrp, shindex = 0; shindex < num_sec; shindex++) 703 elf_elfsections (abfd)[shindex] = shdrp++; 704 705 /* Read in the rest of the section header table and convert it 706 to internal form. */ 707 for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++) 708 { 709 if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr)) 710 goto got_no_match; 711 elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex); 712 713 /* Sanity check sh_link and sh_info. */ 714 if (i_shdrp[shindex].sh_link >= num_sec) 715 { 716 /* PR 10478: Accept Solaris binaries with a sh_link 717 field set to SHN_BEFORE or SHN_AFTER. */ 718 switch (ebd->elf_machine_code) 719 { 720 case EM_386: 721 case EM_IAMCU: 722 case EM_X86_64: 723 case EM_OLD_SPARCV9: 724 case EM_SPARC32PLUS: 725 case EM_SPARCV9: 726 case EM_SPARC: 727 if (i_shdrp[shindex].sh_link == (SHN_LORESERVE & 0xffff) /* SHN_BEFORE */ 728 || i_shdrp[shindex].sh_link == ((SHN_LORESERVE + 1) & 0xffff) /* SHN_AFTER */) 729 break; 730 /* Otherwise fall through. */ 731 default: 732 goto got_wrong_format_error; 733 } 734 } 735 736 if (((i_shdrp[shindex].sh_flags & SHF_INFO_LINK) 737 || i_shdrp[shindex].sh_type == SHT_RELA 738 || i_shdrp[shindex].sh_type == SHT_REL) 739 && i_shdrp[shindex].sh_info >= num_sec) 740 goto got_wrong_format_error; 741 742 /* If the section is loaded, but not page aligned, clear 743 D_PAGED. */ 744 if (i_shdrp[shindex].sh_size != 0 745 && (i_shdrp[shindex].sh_flags & SHF_ALLOC) != 0 746 && i_shdrp[shindex].sh_type != SHT_NOBITS 747 && (((i_shdrp[shindex].sh_addr - i_shdrp[shindex].sh_offset) 748 % ebd->minpagesize) 749 != 0)) 750 abfd->flags &= ~D_PAGED; 751 } 752 753 if (i_ehdrp->e_shstrndx >= elf_numsections (abfd) 754 || i_shdrp[i_ehdrp->e_shstrndx].sh_type != SHT_STRTAB) 755 { 756 /* PR 2257: 757 We used to just goto got_wrong_format_error here 758 but there are binaries in existance for which this test 759 will prevent the binutils from working with them at all. 760 So we are kind, and reset the string index value to 0 761 so that at least some processing can be done. */ 762 i_ehdrp->e_shstrndx = SHN_UNDEF; 763 _bfd_error_handler 764 (_("warning: %pB has a corrupt string table index - ignoring"), 765 abfd); 766 } 767 } 768 else if (i_ehdrp->e_shstrndx != SHN_UNDEF) 769 goto got_wrong_format_error; 770 771 /* Read in the program headers. */ 772 if (i_ehdrp->e_phnum == 0) 773 elf_tdata (abfd)->phdr = NULL; 774 else 775 { 776 Elf_Internal_Phdr *i_phdr; 777 unsigned int i; 778 779 #ifndef BFD64 780 if (i_ehdrp->e_phnum > ((bfd_size_type) -1) / sizeof (*i_phdr)) 781 goto got_wrong_format_error; 782 #endif 783 /* Check for a corrupt input file with an impossibly large number 784 of program headers. */ 785 if (bfd_get_file_size (abfd) > 0 786 && i_ehdrp->e_phnum > bfd_get_file_size (abfd)) 787 goto got_no_match; 788 elf_tdata (abfd)->phdr 789 = (Elf_Internal_Phdr *) bfd_alloc2 (abfd, i_ehdrp->e_phnum, 790 sizeof (*i_phdr)); 791 if (elf_tdata (abfd)->phdr == NULL) 792 goto got_no_match; 793 if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0) 794 goto got_no_match; 795 i_phdr = elf_tdata (abfd)->phdr; 796 for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++) 797 { 798 Elf_External_Phdr x_phdr; 799 800 if (bfd_bread (&x_phdr, sizeof x_phdr, abfd) != sizeof x_phdr) 801 goto got_no_match; 802 elf_swap_phdr_in (abfd, &x_phdr, i_phdr); 803 } 804 } 805 806 if (i_ehdrp->e_shstrndx != 0 && i_ehdrp->e_shoff != 0) 807 { 808 unsigned int num_sec; 809 810 /* Once all of the section headers have been read and converted, we 811 can start processing them. Note that the first section header is 812 a dummy placeholder entry, so we ignore it. */ 813 num_sec = elf_numsections (abfd); 814 for (shindex = 1; shindex < num_sec; shindex++) 815 if (!bfd_section_from_shdr (abfd, shindex)) 816 goto got_no_match; 817 818 /* Set up ELF sections for SHF_GROUP and SHF_LINK_ORDER. */ 819 if (! _bfd_elf_setup_sections (abfd)) 820 goto got_wrong_format_error; 821 } 822 823 /* Let the backend double check the format and override global 824 information. */ 825 if (ebd->elf_backend_object_p) 826 { 827 if (! (*ebd->elf_backend_object_p) (abfd)) 828 goto got_wrong_format_error; 829 } 830 831 /* Remember the entry point specified in the ELF file header. */ 832 bfd_set_start_address (abfd, i_ehdrp->e_entry); 833 834 /* If we have created any reloc sections that are associated with 835 debugging sections, mark the reloc sections as debugging as well. */ 836 for (s = abfd->sections; s != NULL; s = s->next) 837 { 838 if ((elf_section_data (s)->this_hdr.sh_type == SHT_REL 839 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA) 840 && elf_section_data (s)->this_hdr.sh_info > 0) 841 { 842 unsigned long targ_index; 843 asection *targ_sec; 844 845 targ_index = elf_section_data (s)->this_hdr.sh_info; 846 targ_sec = bfd_section_from_elf_index (abfd, targ_index); 847 if (targ_sec != NULL 848 && (targ_sec->flags & SEC_DEBUGGING) != 0) 849 s->flags |= SEC_DEBUGGING; 850 } 851 } 852 return target; 853 854 got_wrong_format_error: 855 bfd_set_error (bfd_error_wrong_format); 856 857 got_no_match: 858 return NULL; 859 } 860 861 /* ELF .o/exec file writing */ 862 863 /* Write out the relocs. */ 864 865 void 866 elf_write_relocs (bfd *abfd, asection *sec, void *data) 867 { 868 bfd_boolean *failedp = (bfd_boolean *) data; 869 Elf_Internal_Shdr *rela_hdr; 870 bfd_vma addr_offset; 871 void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *); 872 size_t extsize; 873 bfd_byte *dst_rela; 874 unsigned int idx; 875 asymbol *last_sym; 876 int last_sym_idx; 877 878 /* If we have already failed, don't do anything. */ 879 if (*failedp) 880 return; 881 882 if ((sec->flags & SEC_RELOC) == 0) 883 return; 884 885 /* The linker backend writes the relocs out itself, and sets the 886 reloc_count field to zero to inhibit writing them here. Also, 887 sometimes the SEC_RELOC flag gets set even when there aren't any 888 relocs. */ 889 if (sec->reloc_count == 0) 890 return; 891 892 /* If we have opened an existing file for update, reloc_count may be 893 set even though we are not linking. In that case we have nothing 894 to do. */ 895 if (sec->orelocation == NULL) 896 return; 897 898 rela_hdr = elf_section_data (sec)->rela.hdr; 899 if (rela_hdr == NULL) 900 rela_hdr = elf_section_data (sec)->rel.hdr; 901 902 rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count; 903 rela_hdr->contents = (unsigned char *) bfd_alloc2 (abfd, sec->reloc_count, 904 rela_hdr->sh_entsize); 905 if (rela_hdr->contents == NULL) 906 { 907 *failedp = TRUE; 908 return; 909 } 910 911 /* Figure out whether the relocations are RELA or REL relocations. */ 912 if (rela_hdr->sh_type == SHT_RELA) 913 { 914 swap_out = elf_swap_reloca_out; 915 extsize = sizeof (Elf_External_Rela); 916 } 917 else if (rela_hdr->sh_type == SHT_REL) 918 { 919 swap_out = elf_swap_reloc_out; 920 extsize = sizeof (Elf_External_Rel); 921 } 922 else 923 /* Every relocation section should be either an SHT_RELA or an 924 SHT_REL section. */ 925 abort (); 926 927 /* The address of an ELF reloc is section relative for an object 928 file, and absolute for an executable file or shared library. 929 The address of a BFD reloc is always section relative. */ 930 addr_offset = 0; 931 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0) 932 addr_offset = sec->vma; 933 934 /* orelocation has the data, reloc_count has the count... */ 935 last_sym = 0; 936 last_sym_idx = 0; 937 dst_rela = rela_hdr->contents; 938 939 for (idx = 0; idx < sec->reloc_count; idx++, dst_rela += extsize) 940 { 941 Elf_Internal_Rela src_rela; 942 arelent *ptr; 943 asymbol *sym; 944 int n; 945 946 ptr = sec->orelocation[idx]; 947 sym = *ptr->sym_ptr_ptr; 948 if (sym == last_sym) 949 n = last_sym_idx; 950 else if (bfd_is_abs_section (sym->section) && sym->value == 0) 951 n = STN_UNDEF; 952 else 953 { 954 last_sym = sym; 955 n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym); 956 if (n < 0) 957 { 958 *failedp = TRUE; 959 return; 960 } 961 last_sym_idx = n; 962 } 963 964 if ((*ptr->sym_ptr_ptr)->the_bfd != NULL 965 && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec 966 && ! _bfd_elf_validate_reloc (abfd, ptr)) 967 { 968 *failedp = TRUE; 969 return; 970 } 971 972 if (ptr->howto == NULL) 973 { 974 *failedp = TRUE; 975 return; 976 } 977 978 src_rela.r_offset = ptr->address + addr_offset; 979 src_rela.r_info = ELF_R_INFO (n, ptr->howto->type); 980 src_rela.r_addend = ptr->addend; 981 (*swap_out) (abfd, &src_rela, dst_rela); 982 } 983 } 984 985 /* Write out the program headers. */ 986 987 int 988 elf_write_out_phdrs (bfd *abfd, 989 const Elf_Internal_Phdr *phdr, 990 unsigned int count) 991 { 992 while (count--) 993 { 994 Elf_External_Phdr extphdr; 995 996 elf_swap_phdr_out (abfd, phdr, &extphdr); 997 if (bfd_bwrite (&extphdr, sizeof (Elf_External_Phdr), abfd) 998 != sizeof (Elf_External_Phdr)) 999 return -1; 1000 phdr++; 1001 } 1002 return 0; 1003 } 1004 1005 /* Write out the section headers and the ELF file header. */ 1006 1007 bfd_boolean 1008 elf_write_shdrs_and_ehdr (bfd *abfd) 1009 { 1010 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */ 1011 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */ 1012 Elf_External_Shdr *x_shdrp; /* Section header table, external form */ 1013 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */ 1014 unsigned int count; 1015 bfd_size_type amt; 1016 1017 i_ehdrp = elf_elfheader (abfd); 1018 i_shdrp = elf_elfsections (abfd); 1019 1020 /* swap the header before spitting it out... */ 1021 1022 #if DEBUG & 1 1023 elf_debug_file (i_ehdrp); 1024 #endif 1025 elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr); 1026 amt = sizeof (x_ehdr); 1027 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0 1028 || bfd_bwrite (&x_ehdr, amt, abfd) != amt) 1029 return FALSE; 1030 1031 /* Some fields in the first section header handle overflow of ehdr 1032 fields. */ 1033 if (i_ehdrp->e_phnum >= PN_XNUM) 1034 i_shdrp[0]->sh_info = i_ehdrp->e_phnum; 1035 if (i_ehdrp->e_shnum >= (SHN_LORESERVE & 0xffff)) 1036 i_shdrp[0]->sh_size = i_ehdrp->e_shnum; 1037 if (i_ehdrp->e_shstrndx >= (SHN_LORESERVE & 0xffff)) 1038 i_shdrp[0]->sh_link = i_ehdrp->e_shstrndx; 1039 1040 /* at this point we've concocted all the ELF sections... */ 1041 x_shdrp = (Elf_External_Shdr *) bfd_alloc2 (abfd, i_ehdrp->e_shnum, 1042 sizeof (*x_shdrp)); 1043 if (!x_shdrp) 1044 return FALSE; 1045 1046 for (count = 0; count < i_ehdrp->e_shnum; i_shdrp++, count++) 1047 { 1048 #if DEBUG & 2 1049 elf_debug_section (count, *i_shdrp); 1050 #endif 1051 elf_swap_shdr_out (abfd, *i_shdrp, x_shdrp + count); 1052 } 1053 amt = (bfd_size_type) i_ehdrp->e_shnum * sizeof (*x_shdrp); 1054 if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0 1055 || bfd_bwrite (x_shdrp, amt, abfd) != amt) 1056 return FALSE; 1057 1058 /* need to dump the string table too... */ 1059 1060 return TRUE; 1061 } 1062 1063 bfd_boolean 1064 elf_checksum_contents (bfd *abfd, 1065 void (*process) (const void *, size_t, void *), 1066 void *arg) 1067 { 1068 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd); 1069 Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd); 1070 Elf_Internal_Phdr *i_phdrp = elf_tdata (abfd)->phdr; 1071 unsigned int count, num; 1072 1073 { 1074 Elf_External_Ehdr x_ehdr; 1075 Elf_Internal_Ehdr i_ehdr; 1076 1077 i_ehdr = *i_ehdrp; 1078 i_ehdr.e_phoff = i_ehdr.e_shoff = 0; 1079 elf_swap_ehdr_out (abfd, &i_ehdr, &x_ehdr); 1080 (*process) (&x_ehdr, sizeof x_ehdr, arg); 1081 } 1082 1083 num = i_ehdrp->e_phnum; 1084 for (count = 0; count < num; count++) 1085 { 1086 Elf_External_Phdr x_phdr; 1087 elf_swap_phdr_out (abfd, &i_phdrp[count], &x_phdr); 1088 (*process) (&x_phdr, sizeof x_phdr, arg); 1089 } 1090 1091 num = elf_numsections (abfd); 1092 for (count = 0; count < num; count++) 1093 { 1094 Elf_Internal_Shdr i_shdr; 1095 Elf_External_Shdr x_shdr; 1096 bfd_byte *contents, *free_contents; 1097 1098 i_shdr = *i_shdrp[count]; 1099 i_shdr.sh_offset = 0; 1100 1101 elf_swap_shdr_out (abfd, &i_shdr, &x_shdr); 1102 (*process) (&x_shdr, sizeof x_shdr, arg); 1103 1104 /* Process the section's contents, if it has some. 1105 PR ld/12451: Read them in if necessary. */ 1106 if (i_shdr.sh_type == SHT_NOBITS) 1107 continue; 1108 free_contents = NULL; 1109 contents = i_shdr.contents; 1110 if (contents == NULL) 1111 { 1112 asection *sec; 1113 1114 sec = bfd_section_from_elf_index (abfd, count); 1115 if (sec != NULL) 1116 { 1117 contents = sec->contents; 1118 if (contents == NULL) 1119 { 1120 /* Force rereading from file. */ 1121 sec->flags &= ~SEC_IN_MEMORY; 1122 if (!bfd_malloc_and_get_section (abfd, sec, &free_contents)) 1123 continue; 1124 contents = free_contents; 1125 } 1126 } 1127 } 1128 if (contents != NULL) 1129 { 1130 (*process) (contents, i_shdr.sh_size, arg); 1131 if (free_contents != NULL) 1132 free (free_contents); 1133 } 1134 } 1135 1136 return TRUE; 1137 } 1138 1139 long 1140 elf_slurp_symbol_table (bfd *abfd, asymbol **symptrs, bfd_boolean dynamic) 1141 { 1142 Elf_Internal_Shdr *hdr; 1143 Elf_Internal_Shdr *verhdr; 1144 unsigned long symcount; /* Number of external ELF symbols */ 1145 elf_symbol_type *sym; /* Pointer to current bfd symbol */ 1146 elf_symbol_type *symbase; /* Buffer for generated bfd symbols */ 1147 Elf_Internal_Sym *isym; 1148 Elf_Internal_Sym *isymend; 1149 Elf_Internal_Sym *isymbuf = NULL; 1150 Elf_External_Versym *xver; 1151 Elf_External_Versym *xverbuf = NULL; 1152 const struct elf_backend_data *ebd; 1153 1154 /* Read each raw ELF symbol, converting from external ELF form to 1155 internal ELF form, and then using the information to create a 1156 canonical bfd symbol table entry. 1157 1158 Note that we allocate the initial bfd canonical symbol buffer 1159 based on a one-to-one mapping of the ELF symbols to canonical 1160 symbols. We actually use all the ELF symbols, so there will be no 1161 space left over at the end. When we have all the symbols, we 1162 build the caller's pointer vector. */ 1163 1164 if (! dynamic) 1165 { 1166 hdr = &elf_tdata (abfd)->symtab_hdr; 1167 verhdr = NULL; 1168 } 1169 else 1170 { 1171 hdr = &elf_tdata (abfd)->dynsymtab_hdr; 1172 if (elf_dynversym (abfd) == 0) 1173 verhdr = NULL; 1174 else 1175 verhdr = &elf_tdata (abfd)->dynversym_hdr; 1176 if ((elf_dynverdef (abfd) != 0 1177 && elf_tdata (abfd)->verdef == NULL) 1178 || (elf_dynverref (abfd) != 0 1179 && elf_tdata (abfd)->verref == NULL)) 1180 { 1181 if (!_bfd_elf_slurp_version_tables (abfd, FALSE)) 1182 return -1; 1183 } 1184 } 1185 1186 ebd = get_elf_backend_data (abfd); 1187 symcount = hdr->sh_size / sizeof (Elf_External_Sym); 1188 if (symcount == 0) 1189 sym = symbase = NULL; 1190 else 1191 { 1192 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, symcount, 0, 1193 NULL, NULL, NULL); 1194 if (isymbuf == NULL) 1195 return -1; 1196 1197 symbase = (elf_symbol_type *) bfd_zalloc2 (abfd, symcount, 1198 sizeof (elf_symbol_type)); 1199 if (symbase == (elf_symbol_type *) NULL) 1200 goto error_return; 1201 1202 /* Read the raw ELF version symbol information. */ 1203 if (verhdr != NULL 1204 && verhdr->sh_size / sizeof (Elf_External_Versym) != symcount) 1205 { 1206 _bfd_error_handler 1207 /* xgettext:c-format */ 1208 (_("%pB: version count (%" PRId64 ")" 1209 " does not match symbol count (%ld)"), 1210 abfd, 1211 (int64_t) (verhdr->sh_size / sizeof (Elf_External_Versym)), 1212 symcount); 1213 1214 /* Slurp in the symbols without the version information, 1215 since that is more helpful than just quitting. */ 1216 verhdr = NULL; 1217 } 1218 1219 if (verhdr != NULL) 1220 { 1221 if (bfd_seek (abfd, verhdr->sh_offset, SEEK_SET) != 0) 1222 goto error_return; 1223 1224 xverbuf = (Elf_External_Versym *) bfd_malloc (verhdr->sh_size); 1225 if (xverbuf == NULL && verhdr->sh_size != 0) 1226 goto error_return; 1227 1228 if (bfd_bread (xverbuf, verhdr->sh_size, abfd) != verhdr->sh_size) 1229 goto error_return; 1230 } 1231 1232 /* Skip first symbol, which is a null dummy. */ 1233 xver = xverbuf; 1234 if (xver != NULL) 1235 ++xver; 1236 isymend = isymbuf + symcount; 1237 for (isym = isymbuf + 1, sym = symbase; isym < isymend; isym++, sym++) 1238 { 1239 memcpy (&sym->internal_elf_sym, isym, sizeof (Elf_Internal_Sym)); 1240 1241 sym->symbol.the_bfd = abfd; 1242 sym->symbol.name = bfd_elf_sym_name (abfd, hdr, isym, NULL); 1243 sym->symbol.value = isym->st_value; 1244 1245 if (isym->st_shndx == SHN_UNDEF) 1246 { 1247 sym->symbol.section = bfd_und_section_ptr; 1248 } 1249 else if (isym->st_shndx == SHN_ABS) 1250 { 1251 sym->symbol.section = bfd_abs_section_ptr; 1252 } 1253 else if (isym->st_shndx == SHN_COMMON) 1254 { 1255 sym->symbol.section = bfd_com_section_ptr; 1256 if ((abfd->flags & BFD_PLUGIN) != 0) 1257 { 1258 asection *xc = bfd_get_section_by_name (abfd, "COMMON"); 1259 1260 if (xc == NULL) 1261 { 1262 flagword flags = (SEC_ALLOC | SEC_IS_COMMON | SEC_KEEP 1263 | SEC_EXCLUDE); 1264 xc = bfd_make_section_with_flags (abfd, "COMMON", flags); 1265 if (xc == NULL) 1266 goto error_return; 1267 } 1268 sym->symbol.section = xc; 1269 } 1270 /* Elf puts the alignment into the `value' field, and 1271 the size into the `size' field. BFD wants to see the 1272 size in the value field, and doesn't care (at the 1273 moment) about the alignment. */ 1274 sym->symbol.value = isym->st_size; 1275 } 1276 else 1277 { 1278 sym->symbol.section 1279 = bfd_section_from_elf_index (abfd, isym->st_shndx); 1280 if (sym->symbol.section == NULL) 1281 { 1282 /* This symbol is in a section for which we did not 1283 create a BFD section. Just use bfd_abs_section, 1284 although it is wrong. FIXME. */ 1285 sym->symbol.section = bfd_abs_section_ptr; 1286 } 1287 } 1288 1289 /* If this is a relocatable file, then the symbol value is 1290 already section relative. */ 1291 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0) 1292 sym->symbol.value -= sym->symbol.section->vma; 1293 1294 switch (ELF_ST_BIND (isym->st_info)) 1295 { 1296 case STB_LOCAL: 1297 sym->symbol.flags |= BSF_LOCAL; 1298 break; 1299 case STB_GLOBAL: 1300 if (isym->st_shndx != SHN_UNDEF && isym->st_shndx != SHN_COMMON) 1301 sym->symbol.flags |= BSF_GLOBAL; 1302 break; 1303 case STB_WEAK: 1304 sym->symbol.flags |= BSF_WEAK; 1305 break; 1306 case STB_GNU_UNIQUE: 1307 sym->symbol.flags |= BSF_GNU_UNIQUE; 1308 break; 1309 } 1310 1311 switch (ELF_ST_TYPE (isym->st_info)) 1312 { 1313 case STT_SECTION: 1314 sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING; 1315 break; 1316 case STT_FILE: 1317 sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING; 1318 break; 1319 case STT_FUNC: 1320 sym->symbol.flags |= BSF_FUNCTION; 1321 break; 1322 case STT_COMMON: 1323 /* FIXME: Do we have to put the size field into the value field 1324 as we do with symbols in SHN_COMMON sections (see above) ? */ 1325 sym->symbol.flags |= BSF_ELF_COMMON; 1326 /* Fall through. */ 1327 case STT_OBJECT: 1328 sym->symbol.flags |= BSF_OBJECT; 1329 break; 1330 case STT_TLS: 1331 sym->symbol.flags |= BSF_THREAD_LOCAL; 1332 break; 1333 case STT_RELC: 1334 sym->symbol.flags |= BSF_RELC; 1335 break; 1336 case STT_SRELC: 1337 sym->symbol.flags |= BSF_SRELC; 1338 break; 1339 case STT_GNU_IFUNC: 1340 sym->symbol.flags |= BSF_GNU_INDIRECT_FUNCTION; 1341 break; 1342 } 1343 1344 if (dynamic) 1345 sym->symbol.flags |= BSF_DYNAMIC; 1346 1347 if (xver != NULL) 1348 { 1349 Elf_Internal_Versym iversym; 1350 1351 _bfd_elf_swap_versym_in (abfd, xver, &iversym); 1352 sym->version = iversym.vs_vers; 1353 xver++; 1354 } 1355 1356 /* Do some backend-specific processing on this symbol. */ 1357 if (ebd->elf_backend_symbol_processing) 1358 (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol); 1359 } 1360 } 1361 1362 /* Do some backend-specific processing on this symbol table. */ 1363 if (ebd->elf_backend_symbol_table_processing) 1364 (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount); 1365 1366 /* We rely on the zalloc to clear out the final symbol entry. */ 1367 1368 symcount = sym - symbase; 1369 1370 /* Fill in the user's symbol pointer vector if needed. */ 1371 if (symptrs) 1372 { 1373 long l = symcount; 1374 1375 sym = symbase; 1376 while (l-- > 0) 1377 { 1378 *symptrs++ = &sym->symbol; 1379 sym++; 1380 } 1381 *symptrs = 0; /* Final null pointer */ 1382 } 1383 1384 if (xverbuf != NULL) 1385 free (xverbuf); 1386 if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf) 1387 free (isymbuf); 1388 return symcount; 1389 1390 error_return: 1391 if (xverbuf != NULL) 1392 free (xverbuf); 1393 if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf) 1394 free (isymbuf); 1395 return -1; 1396 } 1397 1398 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of 1399 them. */ 1400 1401 static bfd_boolean 1402 elf_slurp_reloc_table_from_section (bfd *abfd, 1403 asection *asect, 1404 Elf_Internal_Shdr *rel_hdr, 1405 bfd_size_type reloc_count, 1406 arelent *relents, 1407 asymbol **symbols, 1408 bfd_boolean dynamic) 1409 { 1410 const struct elf_backend_data * const ebd = get_elf_backend_data (abfd); 1411 void *allocated = NULL; 1412 bfd_byte *native_relocs; 1413 arelent *relent; 1414 unsigned int i; 1415 int entsize; 1416 unsigned int symcount; 1417 1418 allocated = bfd_malloc (rel_hdr->sh_size); 1419 if (allocated == NULL) 1420 goto error_return; 1421 1422 if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0 1423 || (bfd_bread (allocated, rel_hdr->sh_size, abfd) 1424 != rel_hdr->sh_size)) 1425 goto error_return; 1426 1427 native_relocs = (bfd_byte *) allocated; 1428 1429 entsize = rel_hdr->sh_entsize; 1430 BFD_ASSERT (entsize == sizeof (Elf_External_Rel) 1431 || entsize == sizeof (Elf_External_Rela)); 1432 1433 if (dynamic) 1434 symcount = bfd_get_dynamic_symcount (abfd); 1435 else 1436 symcount = bfd_get_symcount (abfd); 1437 1438 for (i = 0, relent = relents; 1439 i < reloc_count; 1440 i++, relent++, native_relocs += entsize) 1441 { 1442 bfd_boolean res; 1443 Elf_Internal_Rela rela; 1444 1445 if (entsize == sizeof (Elf_External_Rela)) 1446 elf_swap_reloca_in (abfd, native_relocs, &rela); 1447 else 1448 elf_swap_reloc_in (abfd, native_relocs, &rela); 1449 1450 /* The address of an ELF reloc is section relative for an object 1451 file, and absolute for an executable file or shared library. 1452 The address of a normal BFD reloc is always section relative, 1453 and the address of a dynamic reloc is absolute.. */ 1454 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic) 1455 relent->address = rela.r_offset; 1456 else 1457 relent->address = rela.r_offset - asect->vma; 1458 1459 if (ELF_R_SYM (rela.r_info) == STN_UNDEF) 1460 /* FIXME: This and the error case below mean that we have a 1461 symbol on relocs that is not elf_symbol_type. */ 1462 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 1463 else if (ELF_R_SYM (rela.r_info) > symcount) 1464 { 1465 _bfd_error_handler 1466 /* xgettext:c-format */ 1467 (_("%pB(%pA): relocation %d has invalid symbol index %ld"), 1468 abfd, asect, i, (long) ELF_R_SYM (rela.r_info)); 1469 bfd_set_error (bfd_error_bad_value); 1470 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 1471 } 1472 else 1473 { 1474 asymbol **ps; 1475 1476 ps = symbols + ELF_R_SYM (rela.r_info) - 1; 1477 1478 relent->sym_ptr_ptr = ps; 1479 } 1480 1481 relent->addend = rela.r_addend; 1482 1483 if ((entsize == sizeof (Elf_External_Rela) 1484 && ebd->elf_info_to_howto != NULL) 1485 || ebd->elf_info_to_howto_rel == NULL) 1486 res = ebd->elf_info_to_howto (abfd, relent, &rela); 1487 else 1488 res = ebd->elf_info_to_howto_rel (abfd, relent, &rela); 1489 1490 if (! res || relent->howto == NULL) 1491 goto error_return; 1492 } 1493 1494 if (allocated != NULL) 1495 free (allocated); 1496 return TRUE; 1497 1498 error_return: 1499 if (allocated != NULL) 1500 free (allocated); 1501 return FALSE; 1502 } 1503 1504 /* Read in and swap the external relocs. */ 1505 1506 bfd_boolean 1507 elf_slurp_reloc_table (bfd *abfd, 1508 asection *asect, 1509 asymbol **symbols, 1510 bfd_boolean dynamic) 1511 { 1512 struct bfd_elf_section_data * const d = elf_section_data (asect); 1513 Elf_Internal_Shdr *rel_hdr; 1514 Elf_Internal_Shdr *rel_hdr2; 1515 bfd_size_type reloc_count; 1516 bfd_size_type reloc_count2; 1517 arelent *relents; 1518 1519 if (asect->relocation != NULL) 1520 return TRUE; 1521 1522 if (! dynamic) 1523 { 1524 if ((asect->flags & SEC_RELOC) == 0 1525 || asect->reloc_count == 0) 1526 return TRUE; 1527 1528 rel_hdr = d->rel.hdr; 1529 reloc_count = rel_hdr ? NUM_SHDR_ENTRIES (rel_hdr) : 0; 1530 rel_hdr2 = d->rela.hdr; 1531 reloc_count2 = rel_hdr2 ? NUM_SHDR_ENTRIES (rel_hdr2) : 0; 1532 1533 /* PR 17512: file: 0b4f81b7. */ 1534 if (asect->reloc_count != reloc_count + reloc_count2) 1535 return FALSE; 1536 BFD_ASSERT ((rel_hdr && asect->rel_filepos == rel_hdr->sh_offset) 1537 || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset)); 1538 1539 } 1540 else 1541 { 1542 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this 1543 case because relocations against this section may use the 1544 dynamic symbol table, and in that case bfd_section_from_shdr 1545 in elf.c does not update the RELOC_COUNT. */ 1546 if (asect->size == 0) 1547 return TRUE; 1548 1549 rel_hdr = &d->this_hdr; 1550 reloc_count = NUM_SHDR_ENTRIES (rel_hdr); 1551 rel_hdr2 = NULL; 1552 reloc_count2 = 0; 1553 } 1554 1555 relents = (arelent *) bfd_alloc2 (abfd, reloc_count + reloc_count2, 1556 sizeof (arelent)); 1557 if (relents == NULL) 1558 return FALSE; 1559 1560 if (rel_hdr 1561 && !elf_slurp_reloc_table_from_section (abfd, asect, 1562 rel_hdr, reloc_count, 1563 relents, 1564 symbols, dynamic)) 1565 return FALSE; 1566 1567 if (rel_hdr2 1568 && !elf_slurp_reloc_table_from_section (abfd, asect, 1569 rel_hdr2, reloc_count2, 1570 relents + reloc_count, 1571 symbols, dynamic)) 1572 return FALSE; 1573 1574 asect->relocation = relents; 1575 return TRUE; 1576 } 1577 1578 #if DEBUG & 2 1579 static void 1580 elf_debug_section (int num, Elf_Internal_Shdr *hdr) 1581 { 1582 fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num, 1583 hdr->bfd_section != NULL ? hdr->bfd_section->name : "", 1584 (long) hdr); 1585 fprintf (stderr, 1586 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n", 1587 (long) hdr->sh_name, 1588 (long) hdr->sh_type, 1589 (long) hdr->sh_flags); 1590 fprintf (stderr, 1591 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n", 1592 (long) hdr->sh_addr, 1593 (long) hdr->sh_offset, 1594 (long) hdr->sh_size); 1595 fprintf (stderr, 1596 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n", 1597 (long) hdr->sh_link, 1598 (long) hdr->sh_info, 1599 (long) hdr->sh_addralign); 1600 fprintf (stderr, "sh_entsize = %ld\n", 1601 (long) hdr->sh_entsize); 1602 fflush (stderr); 1603 } 1604 #endif 1605 1606 #if DEBUG & 1 1607 static void 1608 elf_debug_file (Elf_Internal_Ehdr *ehdrp) 1609 { 1610 fprintf (stderr, "e_entry = 0x%.8lx\n", (long) ehdrp->e_entry); 1611 fprintf (stderr, "e_phoff = %ld\n", (long) ehdrp->e_phoff); 1612 fprintf (stderr, "e_phnum = %ld\n", (long) ehdrp->e_phnum); 1613 fprintf (stderr, "e_phentsize = %ld\n", (long) ehdrp->e_phentsize); 1614 fprintf (stderr, "e_shoff = %ld\n", (long) ehdrp->e_shoff); 1615 fprintf (stderr, "e_shnum = %ld\n", (long) ehdrp->e_shnum); 1616 fprintf (stderr, "e_shentsize = %ld\n", (long) ehdrp->e_shentsize); 1617 } 1618 #endif 1619 1620 /* Create a new BFD as if by bfd_openr. Rather than opening a file, 1621 reconstruct an ELF file by reading the segments out of remote 1622 memory based on the ELF file header at EHDR_VMA and the ELF program 1623 headers it points to. If non-zero, SIZE is the known extent of the 1624 object. If not null, *LOADBASEP is filled in with the difference 1625 between the VMAs from which the segments were read, and the VMAs 1626 the file headers (and hence BFD's idea of each section's VMA) put 1627 them at. 1628 1629 The function TARGET_READ_MEMORY is called to copy LEN bytes from 1630 the remote memory at target address VMA into the local buffer at 1631 MYADDR; it should return zero on success or an `errno' code on 1632 failure. TEMPL must be a BFD for a target with the word size and 1633 byte order found in the remote memory. */ 1634 1635 bfd * 1636 NAME(_bfd_elf,bfd_from_remote_memory) 1637 (bfd *templ, 1638 bfd_vma ehdr_vma, 1639 bfd_size_type size, 1640 bfd_vma *loadbasep, 1641 int (*target_read_memory) (bfd_vma, bfd_byte *, bfd_size_type)) 1642 { 1643 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */ 1644 Elf_Internal_Ehdr i_ehdr; /* Elf file header, internal form */ 1645 Elf_External_Phdr *x_phdrs; 1646 Elf_Internal_Phdr *i_phdrs, *last_phdr, *first_phdr; 1647 bfd *nbfd; 1648 struct bfd_in_memory *bim; 1649 bfd_byte *contents; 1650 int err; 1651 unsigned int i; 1652 bfd_vma high_offset; 1653 bfd_vma shdr_end; 1654 bfd_vma loadbase; 1655 char *filename; 1656 1657 /* Read in the ELF header in external format. */ 1658 err = target_read_memory (ehdr_vma, (bfd_byte *) &x_ehdr, sizeof x_ehdr); 1659 if (err) 1660 { 1661 bfd_set_error (bfd_error_system_call); 1662 errno = err; 1663 return NULL; 1664 } 1665 1666 /* Now check to see if we have a valid ELF file, and one that BFD can 1667 make use of. The magic number must match, the address size ('class') 1668 and byte-swapping must match our XVEC entry. */ 1669 1670 if (! elf_file_p (&x_ehdr) 1671 || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT 1672 || x_ehdr.e_ident[EI_CLASS] != ELFCLASS) 1673 { 1674 bfd_set_error (bfd_error_wrong_format); 1675 return NULL; 1676 } 1677 1678 /* Check that file's byte order matches xvec's */ 1679 switch (x_ehdr.e_ident[EI_DATA]) 1680 { 1681 case ELFDATA2MSB: /* Big-endian */ 1682 if (! bfd_header_big_endian (templ)) 1683 { 1684 bfd_set_error (bfd_error_wrong_format); 1685 return NULL; 1686 } 1687 break; 1688 case ELFDATA2LSB: /* Little-endian */ 1689 if (! bfd_header_little_endian (templ)) 1690 { 1691 bfd_set_error (bfd_error_wrong_format); 1692 return NULL; 1693 } 1694 break; 1695 case ELFDATANONE: /* No data encoding specified */ 1696 default: /* Unknown data encoding specified */ 1697 bfd_set_error (bfd_error_wrong_format); 1698 return NULL; 1699 } 1700 1701 elf_swap_ehdr_in (templ, &x_ehdr, &i_ehdr); 1702 1703 /* The file header tells where to find the program headers. 1704 These are what we use to actually choose what to read. */ 1705 1706 if (i_ehdr.e_phentsize != sizeof (Elf_External_Phdr) || i_ehdr.e_phnum == 0) 1707 { 1708 bfd_set_error (bfd_error_wrong_format); 1709 return NULL; 1710 } 1711 1712 x_phdrs 1713 = (Elf_External_Phdr *) bfd_malloc2 (i_ehdr.e_phnum, 1714 sizeof (*x_phdrs) + sizeof (*i_phdrs)); 1715 if (x_phdrs == NULL) 1716 return NULL; 1717 err = target_read_memory (ehdr_vma + i_ehdr.e_phoff, (bfd_byte *) x_phdrs, 1718 i_ehdr.e_phnum * sizeof x_phdrs[0]); 1719 if (err) 1720 { 1721 free (x_phdrs); 1722 bfd_set_error (bfd_error_system_call); 1723 errno = err; 1724 return NULL; 1725 } 1726 i_phdrs = (Elf_Internal_Phdr *) &x_phdrs[i_ehdr.e_phnum]; 1727 1728 high_offset = 0; 1729 loadbase = 0; 1730 first_phdr = NULL; 1731 last_phdr = NULL; 1732 for (i = 0; i < i_ehdr.e_phnum; ++i) 1733 { 1734 elf_swap_phdr_in (templ, &x_phdrs[i], &i_phdrs[i]); 1735 if (i_phdrs[i].p_type == PT_LOAD) 1736 { 1737 bfd_vma segment_end = i_phdrs[i].p_offset + i_phdrs[i].p_filesz; 1738 1739 if (segment_end > high_offset) 1740 { 1741 high_offset = segment_end; 1742 last_phdr = &i_phdrs[i]; 1743 } 1744 1745 /* If this program header covers offset zero, where the file 1746 header sits, then we can figure out the loadbase. */ 1747 if (first_phdr == NULL) 1748 { 1749 bfd_vma p_offset = i_phdrs[i].p_offset; 1750 bfd_vma p_vaddr = i_phdrs[i].p_vaddr; 1751 1752 if (i_phdrs[i].p_align > 1) 1753 { 1754 p_offset &= -i_phdrs[i].p_align; 1755 p_vaddr &= -i_phdrs[i].p_align; 1756 } 1757 if (p_offset == 0) 1758 { 1759 loadbase = ehdr_vma - p_vaddr; 1760 first_phdr = &i_phdrs[i]; 1761 } 1762 } 1763 } 1764 } 1765 if (high_offset == 0) 1766 { 1767 /* There were no PT_LOAD segments, so we don't have anything to read. */ 1768 free (x_phdrs); 1769 bfd_set_error (bfd_error_wrong_format); 1770 return NULL; 1771 } 1772 1773 shdr_end = 0; 1774 if (i_ehdr.e_shoff != 0 && i_ehdr.e_shnum != 0 && i_ehdr.e_shentsize != 0) 1775 { 1776 shdr_end = i_ehdr.e_shoff + i_ehdr.e_shnum * i_ehdr.e_shentsize; 1777 1778 if (last_phdr->p_filesz != last_phdr->p_memsz) 1779 { 1780 /* If the last PT_LOAD header has a bss area then ld.so will 1781 have cleared anything past p_filesz, zapping the section 1782 headers. */ 1783 } 1784 else if (size >= shdr_end) 1785 high_offset = size; 1786 else 1787 { 1788 bfd_vma page_size = get_elf_backend_data (templ)->minpagesize; 1789 bfd_vma segment_end = last_phdr->p_offset + last_phdr->p_filesz; 1790 1791 /* Assume we loaded full pages, allowing us to sometimes see 1792 section headers. */ 1793 if (page_size > 1 && shdr_end > segment_end) 1794 { 1795 bfd_vma page_end = (segment_end + page_size - 1) & -page_size; 1796 1797 if (page_end >= shdr_end) 1798 /* Whee, section headers covered. */ 1799 high_offset = shdr_end; 1800 } 1801 } 1802 } 1803 1804 /* Now we know the size of the whole image we want read in. */ 1805 contents = (bfd_byte *) bfd_zmalloc (high_offset); 1806 if (contents == NULL) 1807 { 1808 free (x_phdrs); 1809 return NULL; 1810 } 1811 1812 for (i = 0; i < i_ehdr.e_phnum; ++i) 1813 if (i_phdrs[i].p_type == PT_LOAD) 1814 { 1815 bfd_vma start = i_phdrs[i].p_offset; 1816 bfd_vma end = start + i_phdrs[i].p_filesz; 1817 bfd_vma vaddr = i_phdrs[i].p_vaddr; 1818 1819 /* Extend the beginning of the first pt_load to cover file 1820 header and program headers, if we proved earlier that its 1821 aligned offset is 0. */ 1822 if (first_phdr == &i_phdrs[i]) 1823 { 1824 vaddr -= start; 1825 start = 0; 1826 } 1827 /* Extend the end of the last pt_load to cover section headers. */ 1828 if (last_phdr == &i_phdrs[i]) 1829 end = high_offset; 1830 err = target_read_memory (loadbase + vaddr, 1831 contents + start, end - start); 1832 if (err) 1833 { 1834 free (x_phdrs); 1835 free (contents); 1836 bfd_set_error (bfd_error_system_call); 1837 errno = err; 1838 return NULL; 1839 } 1840 } 1841 free (x_phdrs); 1842 1843 /* If the segments visible in memory didn't include the section headers, 1844 then clear them from the file header. */ 1845 if (high_offset < shdr_end) 1846 { 1847 memset (&x_ehdr.e_shoff, 0, sizeof x_ehdr.e_shoff); 1848 memset (&x_ehdr.e_shnum, 0, sizeof x_ehdr.e_shnum); 1849 memset (&x_ehdr.e_shstrndx, 0, sizeof x_ehdr.e_shstrndx); 1850 } 1851 1852 /* This will normally have been in the first PT_LOAD segment. But it 1853 conceivably could be missing, and we might have just changed it. */ 1854 memcpy (contents, &x_ehdr, sizeof x_ehdr); 1855 1856 /* Now we have a memory image of the ELF file contents. Make a BFD. */ 1857 bim = (struct bfd_in_memory *) bfd_malloc (sizeof (struct bfd_in_memory)); 1858 if (bim == NULL) 1859 { 1860 free (contents); 1861 return NULL; 1862 } 1863 filename = bfd_strdup ("<in-memory>"); 1864 if (filename == NULL) 1865 { 1866 free (bim); 1867 free (contents); 1868 return NULL; 1869 } 1870 nbfd = _bfd_new_bfd (); 1871 if (nbfd == NULL) 1872 { 1873 free (filename); 1874 free (bim); 1875 free (contents); 1876 return NULL; 1877 } 1878 nbfd->filename = filename; 1879 nbfd->xvec = templ->xvec; 1880 bim->size = high_offset; 1881 bim->buffer = contents; 1882 nbfd->iostream = bim; 1883 nbfd->flags = BFD_IN_MEMORY; 1884 nbfd->iovec = &_bfd_memory_iovec; 1885 nbfd->origin = 0; 1886 nbfd->direction = read_direction; 1887 nbfd->mtime = time (NULL); 1888 nbfd->mtime_set = TRUE; 1889 1890 if (loadbasep) 1891 *loadbasep = loadbase; 1892 return nbfd; 1893 } 1894 1895 /* Function for ELF_R_INFO. */ 1896 1897 bfd_vma 1898 NAME(elf,r_info) (bfd_vma sym, bfd_vma type) 1899 { 1900 return ELF_R_INFO (sym, type); 1901 } 1902 1903 /* Function for ELF_R_SYM. */ 1904 1905 bfd_vma 1906 NAME(elf,r_sym) (bfd_vma r_info) 1907 { 1908 return ELF_R_SYM (r_info); 1909 } 1910 1911 #include "elfcore.h" 1912 1913 /* Size-dependent data and functions. */ 1914 const struct elf_size_info NAME(_bfd_elf,size_info) = { 1915 sizeof (Elf_External_Ehdr), 1916 sizeof (Elf_External_Phdr), 1917 sizeof (Elf_External_Shdr), 1918 sizeof (Elf_External_Rel), 1919 sizeof (Elf_External_Rela), 1920 sizeof (Elf_External_Sym), 1921 sizeof (Elf_External_Dyn), 1922 sizeof (Elf_External_Note), 1923 4, 1924 1, 1925 ARCH_SIZE, LOG_FILE_ALIGN, 1926 ELFCLASS, EV_CURRENT, 1927 elf_write_out_phdrs, 1928 elf_write_shdrs_and_ehdr, 1929 elf_checksum_contents, 1930 elf_write_relocs, 1931 elf_swap_symbol_in, 1932 elf_swap_symbol_out, 1933 elf_slurp_reloc_table, 1934 elf_slurp_symbol_table, 1935 elf_swap_dyn_in, 1936 elf_swap_dyn_out, 1937 elf_swap_reloc_in, 1938 elf_swap_reloc_out, 1939 elf_swap_reloca_in, 1940 elf_swap_reloca_out 1941 }; 1942