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