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