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