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