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