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