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