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