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