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