1/* ELF executable support for BFD. 2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 3 2001, 2002, 2003, 2004 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 H_PUT_16 (abfd, src->e_phnum, dst->e_phnum); 275 H_PUT_16 (abfd, src->e_shentsize, dst->e_shentsize); 276 tmp = src->e_shnum; 277 if (tmp >= SHN_LORESERVE) 278 tmp = SHN_UNDEF; 279 H_PUT_16 (abfd, tmp, dst->e_shnum); 280 tmp = src->e_shstrndx; 281 if (tmp >= SHN_LORESERVE) 282 tmp = SHN_XINDEX; 283 H_PUT_16 (abfd, tmp, dst->e_shstrndx); 284} 285 286/* Translate an ELF section header table entry in external format into an 287 ELF section header table entry in internal format. */ 288 289static void 290elf_swap_shdr_in (bfd *abfd, 291 const Elf_External_Shdr *src, 292 Elf_Internal_Shdr *dst) 293{ 294 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma; 295 296 dst->sh_name = H_GET_32 (abfd, src->sh_name); 297 dst->sh_type = H_GET_32 (abfd, src->sh_type); 298 dst->sh_flags = H_GET_WORD (abfd, src->sh_flags); 299 if (signed_vma) 300 dst->sh_addr = H_GET_SIGNED_WORD (abfd, src->sh_addr); 301 else 302 dst->sh_addr = H_GET_WORD (abfd, src->sh_addr); 303 dst->sh_offset = H_GET_WORD (abfd, src->sh_offset); 304 dst->sh_size = H_GET_WORD (abfd, src->sh_size); 305 dst->sh_link = H_GET_32 (abfd, src->sh_link); 306 dst->sh_info = H_GET_32 (abfd, src->sh_info); 307 dst->sh_addralign = H_GET_WORD (abfd, src->sh_addralign); 308 dst->sh_entsize = H_GET_WORD (abfd, src->sh_entsize); 309 dst->bfd_section = NULL; 310 dst->contents = NULL; 311} 312 313/* Translate an ELF section header table entry in internal format into an 314 ELF section header table entry in external format. */ 315 316static void 317elf_swap_shdr_out (bfd *abfd, 318 const Elf_Internal_Shdr *src, 319 Elf_External_Shdr *dst) 320{ 321 /* note that all elements of dst are *arrays of unsigned char* already... */ 322 H_PUT_32 (abfd, src->sh_name, dst->sh_name); 323 H_PUT_32 (abfd, src->sh_type, dst->sh_type); 324 H_PUT_WORD (abfd, src->sh_flags, dst->sh_flags); 325 H_PUT_WORD (abfd, src->sh_addr, dst->sh_addr); 326 H_PUT_WORD (abfd, src->sh_offset, dst->sh_offset); 327 H_PUT_WORD (abfd, src->sh_size, dst->sh_size); 328 H_PUT_32 (abfd, src->sh_link, dst->sh_link); 329 H_PUT_32 (abfd, src->sh_info, dst->sh_info); 330 H_PUT_WORD (abfd, src->sh_addralign, dst->sh_addralign); 331 H_PUT_WORD (abfd, src->sh_entsize, dst->sh_entsize); 332} 333 334/* Translate an ELF program header table entry in external format into an 335 ELF program header table entry in internal format. */ 336 337void 338elf_swap_phdr_in (bfd *abfd, 339 const Elf_External_Phdr *src, 340 Elf_Internal_Phdr *dst) 341{ 342 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma; 343 344 dst->p_type = H_GET_32 (abfd, src->p_type); 345 dst->p_flags = H_GET_32 (abfd, src->p_flags); 346 dst->p_offset = H_GET_WORD (abfd, src->p_offset); 347 if (signed_vma) 348 { 349 dst->p_vaddr = H_GET_SIGNED_WORD (abfd, src->p_vaddr); 350 dst->p_paddr = H_GET_SIGNED_WORD (abfd, src->p_paddr); 351 } 352 else 353 { 354 dst->p_vaddr = H_GET_WORD (abfd, src->p_vaddr); 355 dst->p_paddr = H_GET_WORD (abfd, src->p_paddr); 356 } 357 dst->p_filesz = H_GET_WORD (abfd, src->p_filesz); 358 dst->p_memsz = H_GET_WORD (abfd, src->p_memsz); 359 dst->p_align = H_GET_WORD (abfd, src->p_align); 360} 361 362void 363elf_swap_phdr_out (bfd *abfd, 364 const Elf_Internal_Phdr *src, 365 Elf_External_Phdr *dst) 366{ 367 /* note that all elements of dst are *arrays of unsigned char* already... */ 368 H_PUT_32 (abfd, src->p_type, dst->p_type); 369 H_PUT_WORD (abfd, src->p_offset, dst->p_offset); 370 H_PUT_WORD (abfd, src->p_vaddr, dst->p_vaddr); 371 H_PUT_WORD (abfd, src->p_paddr, dst->p_paddr); 372 H_PUT_WORD (abfd, src->p_filesz, dst->p_filesz); 373 H_PUT_WORD (abfd, src->p_memsz, dst->p_memsz); 374 H_PUT_32 (abfd, src->p_flags, dst->p_flags); 375 H_PUT_WORD (abfd, src->p_align, dst->p_align); 376} 377 378/* Translate an ELF reloc from external format to internal format. */ 379void 380elf_swap_reloc_in (bfd *abfd, 381 const bfd_byte *s, 382 Elf_Internal_Rela *dst) 383{ 384 const Elf_External_Rel *src = (const Elf_External_Rel *) s; 385 dst->r_offset = H_GET_WORD (abfd, src->r_offset); 386 dst->r_info = H_GET_WORD (abfd, src->r_info); 387 dst->r_addend = 0; 388} 389 390void 391elf_swap_reloca_in (bfd *abfd, 392 const bfd_byte *s, 393 Elf_Internal_Rela *dst) 394{ 395 const Elf_External_Rela *src = (const Elf_External_Rela *) s; 396 dst->r_offset = H_GET_WORD (abfd, src->r_offset); 397 dst->r_info = H_GET_WORD (abfd, src->r_info); 398 dst->r_addend = H_GET_SIGNED_WORD (abfd, src->r_addend); 399} 400 401/* Translate an ELF reloc from internal format to external format. */ 402void 403elf_swap_reloc_out (bfd *abfd, 404 const Elf_Internal_Rela *src, 405 bfd_byte *d) 406{ 407 Elf_External_Rel *dst = (Elf_External_Rel *) d; 408 H_PUT_WORD (abfd, src->r_offset, dst->r_offset); 409 H_PUT_WORD (abfd, src->r_info, dst->r_info); 410} 411 412void 413elf_swap_reloca_out (bfd *abfd, 414 const Elf_Internal_Rela *src, 415 bfd_byte *d) 416{ 417 Elf_External_Rela *dst = (Elf_External_Rela *) d; 418 H_PUT_WORD (abfd, src->r_offset, dst->r_offset); 419 H_PUT_WORD (abfd, src->r_info, dst->r_info); 420 H_PUT_SIGNED_WORD (abfd, src->r_addend, dst->r_addend); 421} 422 423void 424elf_swap_dyn_in (bfd *abfd, 425 const void *p, 426 Elf_Internal_Dyn *dst) 427{ 428 const Elf_External_Dyn *src = p; 429 430 dst->d_tag = H_GET_WORD (abfd, src->d_tag); 431 dst->d_un.d_val = H_GET_WORD (abfd, src->d_un.d_val); 432} 433 434void 435elf_swap_dyn_out (bfd *abfd, 436 const Elf_Internal_Dyn *src, 437 void *p) 438{ 439 Elf_External_Dyn *dst = p; 440 441 H_PUT_WORD (abfd, src->d_tag, dst->d_tag); 442 H_PUT_WORD (abfd, src->d_un.d_val, dst->d_un.d_val); 443} 444 445/* ELF .o/exec file reading */ 446 447/* Begin processing a given object. 448 449 First we validate the file by reading in the ELF header and checking 450 the magic number. */ 451 452static inline bfd_boolean 453elf_file_p (Elf_External_Ehdr *x_ehdrp) 454{ 455 return ((x_ehdrp->e_ident[EI_MAG0] == ELFMAG0) 456 && (x_ehdrp->e_ident[EI_MAG1] == ELFMAG1) 457 && (x_ehdrp->e_ident[EI_MAG2] == ELFMAG2) 458 && (x_ehdrp->e_ident[EI_MAG3] == ELFMAG3)); 459} 460 461/* Check to see if the file associated with ABFD matches the target vector 462 that ABFD points to. 463 464 Note that we may be called several times with the same ABFD, but different 465 target vectors, most of which will not match. We have to avoid leaving 466 any side effects in ABFD, or any data it points to (like tdata), if the 467 file does not match the target vector. */ 468 469const bfd_target * 470elf_object_p (bfd *abfd) 471{ 472 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */ 473 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */ 474 Elf_External_Shdr x_shdr; /* Section header table entry, external form */ 475 Elf_Internal_Shdr i_shdr; 476 Elf_Internal_Shdr *i_shdrp; /* Section header table, internal form */ 477 unsigned int shindex; 478 char *shstrtab; /* Internal copy of section header stringtab */ 479 const struct elf_backend_data *ebd; 480 struct bfd_preserve preserve; 481 asection *s; 482 bfd_size_type amt; 483 484 preserve.marker = NULL; 485 486 /* Read in the ELF header in external format. */ 487 488 if (bfd_bread (&x_ehdr, sizeof (x_ehdr), abfd) != sizeof (x_ehdr)) 489 { 490 if (bfd_get_error () != bfd_error_system_call) 491 goto got_wrong_format_error; 492 else 493 goto got_no_match; 494 } 495 496 /* Now check to see if we have a valid ELF file, and one that BFD can 497 make use of. The magic number must match, the address size ('class') 498 and byte-swapping must match our XVEC entry, and it must have a 499 section header table (FIXME: See comments re sections at top of this 500 file). */ 501 502 if (! elf_file_p (&x_ehdr) 503 || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT 504 || x_ehdr.e_ident[EI_CLASS] != ELFCLASS) 505 goto got_wrong_format_error; 506 507 /* Check that file's byte order matches xvec's */ 508 switch (x_ehdr.e_ident[EI_DATA]) 509 { 510 case ELFDATA2MSB: /* Big-endian */ 511 if (! bfd_header_big_endian (abfd)) 512 goto got_wrong_format_error; 513 break; 514 case ELFDATA2LSB: /* Little-endian */ 515 if (! bfd_header_little_endian (abfd)) 516 goto got_wrong_format_error; 517 break; 518 case ELFDATANONE: /* No data encoding specified */ 519 default: /* Unknown data encoding specified */ 520 goto got_wrong_format_error; 521 } 522 523 if (!bfd_preserve_save (abfd, &preserve)) 524 goto got_no_match; 525 526 /* Allocate an instance of the elf_obj_tdata structure and hook it up to 527 the tdata pointer in the bfd. */ 528 529 if (! (*abfd->xvec->_bfd_set_format[bfd_object]) (abfd)) 530 goto got_no_match; 531 preserve.marker = elf_tdata (abfd); 532 533 /* Now that we know the byte order, swap in the rest of the header */ 534 i_ehdrp = elf_elfheader (abfd); 535 elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp); 536#if DEBUG & 1 537 elf_debug_file (i_ehdrp); 538#endif 539 540 /* Reject ET_CORE (header indicates core file, not object file) */ 541 if (i_ehdrp->e_type == ET_CORE) 542 goto got_wrong_format_error; 543 544 /* If this is a relocatable file and there is no section header 545 table, then we're hosed. */ 546 if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_type == ET_REL) 547 goto got_wrong_format_error; 548 549 /* As a simple sanity check, verify that the what BFD thinks is the 550 size of each section header table entry actually matches the size 551 recorded in the file, but only if there are any sections. */ 552 if (i_ehdrp->e_shentsize != sizeof (x_shdr) && i_ehdrp->e_shnum != 0) 553 goto got_wrong_format_error; 554 555 /* Further sanity check. */ 556 if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_shnum != 0) 557 goto got_wrong_format_error; 558 559 ebd = get_elf_backend_data (abfd); 560 561 /* Check that the ELF e_machine field matches what this particular 562 BFD format expects. */ 563 if (ebd->elf_machine_code != i_ehdrp->e_machine 564 && (ebd->elf_machine_alt1 == 0 565 || i_ehdrp->e_machine != ebd->elf_machine_alt1) 566 && (ebd->elf_machine_alt2 == 0 567 || i_ehdrp->e_machine != ebd->elf_machine_alt2)) 568 { 569 const bfd_target * const *target_ptr; 570 571 if (ebd->elf_machine_code != EM_NONE) 572 goto got_wrong_format_error; 573 574 /* This is the generic ELF target. Let it match any ELF target 575 for which we do not have a specific backend. */ 576 for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++) 577 { 578 const struct elf_backend_data *back; 579 580 if ((*target_ptr)->flavour != bfd_target_elf_flavour) 581 continue; 582 back = (const struct elf_backend_data *) (*target_ptr)->backend_data; 583 if (back->elf_machine_code == i_ehdrp->e_machine 584 || (back->elf_machine_alt1 != 0 585 && back->elf_machine_alt1 == i_ehdrp->e_machine) 586 || (back->elf_machine_alt2 != 0 587 && back->elf_machine_alt2 == i_ehdrp->e_machine)) 588 { 589 /* target_ptr is an ELF backend which matches this 590 object file, so reject the generic ELF target. */ 591 goto got_wrong_format_error; 592 } 593 } 594 } 595 596 if (i_ehdrp->e_type == ET_EXEC) 597 abfd->flags |= EXEC_P; 598 else if (i_ehdrp->e_type == ET_DYN) 599 abfd->flags |= DYNAMIC; 600 601 if (i_ehdrp->e_phnum > 0) 602 abfd->flags |= D_PAGED; 603 604 if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0)) 605 { 606 /* It's OK if this fails for the generic target. */ 607 if (ebd->elf_machine_code != EM_NONE) 608 goto got_no_match; 609 } 610 611 /* Remember the entry point specified in the ELF file header. */ 612 bfd_set_start_address (abfd, i_ehdrp->e_entry); 613 614 if (i_ehdrp->e_shoff != 0) 615 { 616 /* Seek to the section header table in the file. */ 617 if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0) 618 goto got_no_match; 619 620 /* Read the first section header at index 0, and convert to internal 621 form. */ 622 if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr)) 623 goto got_no_match; 624 elf_swap_shdr_in (abfd, &x_shdr, &i_shdr); 625 626 /* If the section count is zero, the actual count is in the first 627 section header. */ 628 if (i_ehdrp->e_shnum == SHN_UNDEF) 629 i_ehdrp->e_shnum = i_shdr.sh_size; 630 631 /* And similarly for the string table index. */ 632 if (i_ehdrp->e_shstrndx == SHN_XINDEX) 633 i_ehdrp->e_shstrndx = i_shdr.sh_link; 634 } 635 636 /* Allocate space for a copy of the section header table in 637 internal form. */ 638 if (i_ehdrp->e_shnum != 0) 639 { 640 Elf_Internal_Shdr *shdrp; 641 unsigned int num_sec; 642 643 amt = sizeof (*i_shdrp) * i_ehdrp->e_shnum; 644 i_shdrp = bfd_alloc (abfd, amt); 645 if (!i_shdrp) 646 goto got_no_match; 647 num_sec = i_ehdrp->e_shnum; 648 if (num_sec > SHN_LORESERVE) 649 num_sec += SHN_HIRESERVE + 1 - SHN_LORESERVE; 650 elf_numsections (abfd) = num_sec; 651 amt = sizeof (i_shdrp) * num_sec; 652 elf_elfsections (abfd) = bfd_alloc (abfd, amt); 653 if (!elf_elfsections (abfd)) 654 goto got_no_match; 655 656 memcpy (i_shdrp, &i_shdr, sizeof (*i_shdrp)); 657 shdrp = i_shdrp; 658 shindex = 0; 659 if (num_sec > SHN_LORESERVE) 660 { 661 for ( ; shindex < SHN_LORESERVE; shindex++) 662 elf_elfsections (abfd)[shindex] = shdrp++; 663 for ( ; shindex < SHN_HIRESERVE + 1; shindex++) 664 elf_elfsections (abfd)[shindex] = i_shdrp; 665 } 666 for ( ; shindex < num_sec; shindex++) 667 elf_elfsections (abfd)[shindex] = shdrp++; 668 669 /* Read in the rest of the section header table and convert it 670 to internal form. */ 671 for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++) 672 { 673 if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr)) 674 goto got_no_match; 675 elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex); 676 677 /* If the section is loaded, but not page aligned, clear 678 D_PAGED. */ 679 if (i_shdrp[shindex].sh_size != 0 680 && (i_shdrp[shindex].sh_flags & SHF_ALLOC) != 0 681 && i_shdrp[shindex].sh_type != SHT_NOBITS 682 && (((i_shdrp[shindex].sh_addr - i_shdrp[shindex].sh_offset) 683 % ebd->maxpagesize) 684 != 0)) 685 abfd->flags &= ~D_PAGED; 686 } 687 } 688 689 if (i_ehdrp->e_shstrndx && i_ehdrp->e_shoff) 690 { 691 if (! bfd_section_from_shdr (abfd, i_ehdrp->e_shstrndx)) 692 goto got_no_match; 693 } 694 695 /* Read in the program headers. */ 696 if (i_ehdrp->e_phnum == 0) 697 elf_tdata (abfd)->phdr = NULL; 698 else 699 { 700 Elf_Internal_Phdr *i_phdr; 701 unsigned int i; 702 703 amt = i_ehdrp->e_phnum * sizeof (Elf_Internal_Phdr); 704 elf_tdata (abfd)->phdr = bfd_alloc (abfd, amt); 705 if (elf_tdata (abfd)->phdr == NULL) 706 goto got_no_match; 707 if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0) 708 goto got_no_match; 709 i_phdr = elf_tdata (abfd)->phdr; 710 for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++) 711 { 712 Elf_External_Phdr x_phdr; 713 714 if (bfd_bread (&x_phdr, sizeof x_phdr, abfd) != sizeof x_phdr) 715 goto got_no_match; 716 elf_swap_phdr_in (abfd, &x_phdr, i_phdr); 717 } 718 } 719 720 /* Read in the string table containing the names of the sections. We 721 will need the base pointer to this table later. */ 722 /* We read this inline now, so that we don't have to go through 723 bfd_section_from_shdr with it (since this particular strtab is 724 used to find all of the ELF section names.) */ 725 726 if (i_ehdrp->e_shstrndx != 0 && i_ehdrp->e_shoff) 727 { 728 unsigned int num_sec; 729 730 shstrtab = bfd_elf_get_str_section (abfd, i_ehdrp->e_shstrndx); 731 if (!shstrtab) 732 goto got_no_match; 733 734 /* Once all of the section headers have been read and converted, we 735 can start processing them. Note that the first section header is 736 a dummy placeholder entry, so we ignore it. */ 737 num_sec = elf_numsections (abfd); 738 for (shindex = 1; shindex < num_sec; shindex++) 739 { 740 if (! bfd_section_from_shdr (abfd, shindex)) 741 goto got_no_match; 742 if (shindex == SHN_LORESERVE - 1) 743 shindex += SHN_HIRESERVE + 1 - SHN_LORESERVE; 744 } 745 746 /* Set up group pointers. */ 747 if (! _bfd_elf_setup_group_pointers (abfd)) 748 goto got_wrong_format_error; 749 } 750 751 /* Let the backend double check the format and override global 752 information. */ 753 if (ebd->elf_backend_object_p) 754 { 755 if (! (*ebd->elf_backend_object_p) (abfd)) 756 goto got_wrong_format_error; 757 } 758 759 /* If we have created any reloc sections that are associated with 760 debugging sections, mark the reloc sections as debugging as well. */ 761 for (s = abfd->sections; s != NULL; s = s->next) 762 { 763 if ((elf_section_data (s)->this_hdr.sh_type == SHT_REL 764 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA) 765 && elf_section_data (s)->this_hdr.sh_info > 0) 766 { 767 unsigned long targ_index; 768 asection *targ_sec; 769 770 targ_index = elf_section_data (s)->this_hdr.sh_info; 771 targ_sec = bfd_section_from_elf_index (abfd, targ_index); 772 if (targ_sec != NULL 773 && (targ_sec->flags & SEC_DEBUGGING) != 0) 774 s->flags |= SEC_DEBUGGING; 775 } 776 } 777 778 bfd_preserve_finish (abfd, &preserve); 779 return abfd->xvec; 780 781 got_wrong_format_error: 782 /* There is way too much undoing of half-known state here. The caller, 783 bfd_check_format_matches, really shouldn't iterate on live bfd's to 784 check match/no-match like it does. We have to rely on that a call to 785 bfd_default_set_arch_mach with the previously known mach, undoes what 786 was done by the first bfd_default_set_arch_mach (with mach 0) here. 787 For this to work, only elf-data and the mach may be changed by the 788 target-specific elf_backend_object_p function. Note that saving the 789 whole bfd here and restoring it would be even worse; the first thing 790 you notice is that the cached bfd file position gets out of sync. */ 791 bfd_set_error (bfd_error_wrong_format); 792 793 got_no_match: 794 if (preserve.marker != NULL) 795 bfd_preserve_restore (abfd, &preserve); 796 return NULL; 797} 798 799/* ELF .o/exec file writing */ 800 801/* Write out the relocs. */ 802 803void 804elf_write_relocs (bfd *abfd, asection *sec, void *data) 805{ 806 bfd_boolean *failedp = data; 807 Elf_Internal_Shdr *rela_hdr; 808 bfd_vma addr_offset; 809 void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *); 810 size_t extsize; 811 bfd_byte *dst_rela; 812 unsigned int idx; 813 asymbol *last_sym; 814 int last_sym_idx; 815 816 /* If we have already failed, don't do anything. */ 817 if (*failedp) 818 return; 819 820 if ((sec->flags & SEC_RELOC) == 0) 821 return; 822 823 /* The linker backend writes the relocs out itself, and sets the 824 reloc_count field to zero to inhibit writing them here. Also, 825 sometimes the SEC_RELOC flag gets set even when there aren't any 826 relocs. */ 827 if (sec->reloc_count == 0) 828 return; 829 830 rela_hdr = &elf_section_data (sec)->rel_hdr; 831 832 rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count; 833 rela_hdr->contents = bfd_alloc (abfd, rela_hdr->sh_size); 834 if (rela_hdr->contents == NULL) 835 { 836 *failedp = TRUE; 837 return; 838 } 839 840 /* Figure out whether the relocations are RELA or REL relocations. */ 841 if (rela_hdr->sh_type == SHT_RELA) 842 { 843 swap_out = elf_swap_reloca_out; 844 extsize = sizeof (Elf_External_Rela); 845 } 846 else if (rela_hdr->sh_type == SHT_REL) 847 { 848 swap_out = elf_swap_reloc_out; 849 extsize = sizeof (Elf_External_Rel); 850 } 851 else 852 /* Every relocation section should be either an SHT_RELA or an 853 SHT_REL section. */ 854 abort (); 855 856 /* The address of an ELF reloc is section relative for an object 857 file, and absolute for an executable file or shared library. 858 The address of a BFD reloc is always section relative. */ 859 addr_offset = 0; 860 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0) 861 addr_offset = sec->vma; 862 863 /* orelocation has the data, reloc_count has the count... */ 864 last_sym = 0; 865 last_sym_idx = 0; 866 dst_rela = rela_hdr->contents; 867 868 for (idx = 0; idx < sec->reloc_count; idx++, dst_rela += extsize) 869 { 870 Elf_Internal_Rela src_rela; 871 arelent *ptr; 872 asymbol *sym; 873 int n; 874 875 ptr = sec->orelocation[idx]; 876 sym = *ptr->sym_ptr_ptr; 877 if (sym == last_sym) 878 n = last_sym_idx; 879 else if (bfd_is_abs_section (sym->section) && sym->value == 0) 880 n = STN_UNDEF; 881 else 882 { 883 last_sym = sym; 884 n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym); 885 if (n < 0) 886 { 887 *failedp = TRUE; 888 return; 889 } 890 last_sym_idx = n; 891 } 892 893 if ((*ptr->sym_ptr_ptr)->the_bfd != NULL 894 && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec 895 && ! _bfd_elf_validate_reloc (abfd, ptr)) 896 { 897 *failedp = TRUE; 898 return; 899 } 900 901 src_rela.r_offset = ptr->address + addr_offset; 902 src_rela.r_info = ELF_R_INFO (n, ptr->howto->type); 903 src_rela.r_addend = ptr->addend; 904 (*swap_out) (abfd, &src_rela, dst_rela); 905 } 906} 907 908/* Write out the program headers. */ 909 910int 911elf_write_out_phdrs (bfd *abfd, 912 const Elf_Internal_Phdr *phdr, 913 unsigned int count) 914{ 915 while (count--) 916 { 917 Elf_External_Phdr extphdr; 918 elf_swap_phdr_out (abfd, phdr, &extphdr); 919 if (bfd_bwrite (&extphdr, sizeof (Elf_External_Phdr), abfd) 920 != sizeof (Elf_External_Phdr)) 921 return -1; 922 phdr++; 923 } 924 return 0; 925} 926 927/* Write out the section headers and the ELF file header. */ 928 929bfd_boolean 930elf_write_shdrs_and_ehdr (bfd *abfd) 931{ 932 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */ 933 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */ 934 Elf_External_Shdr *x_shdrp; /* Section header table, external form */ 935 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */ 936 unsigned int count; 937 bfd_size_type amt; 938 939 i_ehdrp = elf_elfheader (abfd); 940 i_shdrp = elf_elfsections (abfd); 941 942 /* swap the header before spitting it out... */ 943 944#if DEBUG & 1 945 elf_debug_file (i_ehdrp); 946#endif 947 elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr); 948 amt = sizeof (x_ehdr); 949 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0 950 || bfd_bwrite (&x_ehdr, amt, abfd) != amt) 951 return FALSE; 952 953 /* Some fields in the first section header handle overflow of ehdr 954 fields. */ 955 if (i_ehdrp->e_shnum >= SHN_LORESERVE) 956 i_shdrp[0]->sh_size = i_ehdrp->e_shnum; 957 if (i_ehdrp->e_shstrndx >= SHN_LORESERVE) 958 i_shdrp[0]->sh_link = i_ehdrp->e_shstrndx; 959 960 /* at this point we've concocted all the ELF sections... */ 961 amt = i_ehdrp->e_shnum; 962 amt *= sizeof (*x_shdrp); 963 x_shdrp = bfd_alloc (abfd, amt); 964 if (!x_shdrp) 965 return FALSE; 966 967 for (count = 0; count < i_ehdrp->e_shnum; i_shdrp++, count++) 968 { 969#if DEBUG & 2 970 elf_debug_section (count, *i_shdrp); 971#endif 972 elf_swap_shdr_out (abfd, *i_shdrp, x_shdrp + count); 973 974 if (count == SHN_LORESERVE - 1) 975 i_shdrp += SHN_HIRESERVE + 1 - SHN_LORESERVE; 976 } 977 if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0 978 || bfd_bwrite (x_shdrp, amt, abfd) != amt) 979 return FALSE; 980 981 /* need to dump the string table too... */ 982 983 return TRUE; 984} 985 986long 987elf_slurp_symbol_table (bfd *abfd, asymbol **symptrs, bfd_boolean dynamic) 988{ 989 Elf_Internal_Shdr *hdr; 990 Elf_Internal_Shdr *verhdr; 991 unsigned long symcount; /* Number of external ELF symbols */ 992 elf_symbol_type *sym; /* Pointer to current bfd symbol */ 993 elf_symbol_type *symbase; /* Buffer for generated bfd symbols */ 994 Elf_Internal_Sym *isym; 995 Elf_Internal_Sym *isymend; 996 Elf_Internal_Sym *isymbuf = NULL; 997 Elf_External_Versym *xver; 998 Elf_External_Versym *xverbuf = NULL; 999 const struct elf_backend_data *ebd; 1000 bfd_size_type amt; 1001 1002 /* Read each raw ELF symbol, converting from external ELF form to 1003 internal ELF form, and then using the information to create a 1004 canonical bfd symbol table entry. 1005 1006 Note that we allocate the initial bfd canonical symbol buffer 1007 based on a one-to-one mapping of the ELF symbols to canonical 1008 symbols. We actually use all the ELF symbols, so there will be no 1009 space left over at the end. When we have all the symbols, we 1010 build the caller's pointer vector. */ 1011 1012 if (! dynamic) 1013 { 1014 hdr = &elf_tdata (abfd)->symtab_hdr; 1015 verhdr = NULL; 1016 } 1017 else 1018 { 1019 hdr = &elf_tdata (abfd)->dynsymtab_hdr; 1020 if (elf_dynversym (abfd) == 0) 1021 verhdr = NULL; 1022 else 1023 verhdr = &elf_tdata (abfd)->dynversym_hdr; 1024 if ((elf_tdata (abfd)->dynverdef_section != 0 1025 && elf_tdata (abfd)->verdef == NULL) 1026 || (elf_tdata (abfd)->dynverref_section != 0 1027 && elf_tdata (abfd)->verref == NULL)) 1028 { 1029 if (! _bfd_elf_slurp_version_tables (abfd)) 1030 return -1; 1031 } 1032 } 1033 1034 ebd = get_elf_backend_data (abfd); 1035 symcount = hdr->sh_size / sizeof (Elf_External_Sym); 1036 if (symcount == 0) 1037 sym = symbase = NULL; 1038 else 1039 { 1040 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, symcount, 0, 1041 NULL, NULL, NULL); 1042 if (isymbuf == NULL) 1043 return -1; 1044 1045 amt = symcount; 1046 amt *= sizeof (elf_symbol_type); 1047 symbase = bfd_zalloc (abfd, amt); 1048 if (symbase == (elf_symbol_type *) NULL) 1049 goto error_return; 1050 1051 /* Read the raw ELF version symbol information. */ 1052 if (verhdr != NULL 1053 && verhdr->sh_size / sizeof (Elf_External_Versym) != symcount) 1054 { 1055 (*_bfd_error_handler) 1056 (_("%s: version count (%ld) does not match symbol count (%ld)"), 1057 abfd->filename, 1058 (long) (verhdr->sh_size / sizeof (Elf_External_Versym)), 1059 symcount); 1060 1061 /* Slurp in the symbols without the version information, 1062 since that is more helpful than just quitting. */ 1063 verhdr = NULL; 1064 } 1065 1066 if (verhdr != NULL) 1067 { 1068 if (bfd_seek (abfd, verhdr->sh_offset, SEEK_SET) != 0) 1069 goto error_return; 1070 1071 xverbuf = bfd_malloc (verhdr->sh_size); 1072 if (xverbuf == NULL && verhdr->sh_size != 0) 1073 goto error_return; 1074 1075 if (bfd_bread (xverbuf, verhdr->sh_size, abfd) != verhdr->sh_size) 1076 goto error_return; 1077 } 1078 1079 /* Skip first symbol, which is a null dummy. */ 1080 xver = xverbuf; 1081 if (xver != NULL) 1082 ++xver; 1083 isymend = isymbuf + symcount; 1084 for (isym = isymbuf + 1, sym = symbase; isym < isymend; isym++, sym++) 1085 { 1086 memcpy (&sym->internal_elf_sym, isym, sizeof (Elf_Internal_Sym)); 1087 sym->symbol.the_bfd = abfd; 1088 1089 sym->symbol.name = bfd_elf_string_from_elf_section (abfd, 1090 hdr->sh_link, 1091 isym->st_name); 1092 1093 sym->symbol.value = isym->st_value; 1094 1095 if (isym->st_shndx == SHN_UNDEF) 1096 { 1097 sym->symbol.section = bfd_und_section_ptr; 1098 } 1099 else if (isym->st_shndx < SHN_LORESERVE 1100 || isym->st_shndx > SHN_HIRESERVE) 1101 { 1102 sym->symbol.section = bfd_section_from_elf_index (abfd, 1103 isym->st_shndx); 1104 if (sym->symbol.section == NULL) 1105 { 1106 /* This symbol is in a section for which we did not 1107 create a BFD section. Just use bfd_abs_section, 1108 although it is wrong. FIXME. */ 1109 sym->symbol.section = bfd_abs_section_ptr; 1110 } 1111 } 1112 else if (isym->st_shndx == SHN_ABS) 1113 { 1114 sym->symbol.section = bfd_abs_section_ptr; 1115 } 1116 else if (isym->st_shndx == SHN_COMMON) 1117 { 1118 sym->symbol.section = bfd_com_section_ptr; 1119 /* Elf puts the alignment into the `value' field, and 1120 the size into the `size' field. BFD wants to see the 1121 size in the value field, and doesn't care (at the 1122 moment) about the alignment. */ 1123 sym->symbol.value = isym->st_size; 1124 } 1125 else 1126 sym->symbol.section = bfd_abs_section_ptr; 1127 1128 /* If this is a relocatable file, then the symbol value is 1129 already section relative. */ 1130 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0) 1131 sym->symbol.value -= sym->symbol.section->vma; 1132 1133 switch (ELF_ST_BIND (isym->st_info)) 1134 { 1135 case STB_LOCAL: 1136 sym->symbol.flags |= BSF_LOCAL; 1137 break; 1138 case STB_GLOBAL: 1139 if (isym->st_shndx != SHN_UNDEF && isym->st_shndx != SHN_COMMON) 1140 sym->symbol.flags |= BSF_GLOBAL; 1141 break; 1142 case STB_WEAK: 1143 sym->symbol.flags |= BSF_WEAK; 1144 break; 1145 } 1146 1147 switch (ELF_ST_TYPE (isym->st_info)) 1148 { 1149 case STT_SECTION: 1150 sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING; 1151 break; 1152 case STT_FILE: 1153 sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING; 1154 break; 1155 case STT_FUNC: 1156 sym->symbol.flags |= BSF_FUNCTION; 1157 break; 1158 case STT_OBJECT: 1159 sym->symbol.flags |= BSF_OBJECT; 1160 break; 1161 } 1162 1163 if (dynamic) 1164 sym->symbol.flags |= BSF_DYNAMIC; 1165 1166 if (xver != NULL) 1167 { 1168 Elf_Internal_Versym iversym; 1169 1170 _bfd_elf_swap_versym_in (abfd, xver, &iversym); 1171 sym->version = iversym.vs_vers; 1172 xver++; 1173 } 1174 1175 /* Do some backend-specific processing on this symbol. */ 1176 if (ebd->elf_backend_symbol_processing) 1177 (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol); 1178 } 1179 } 1180 1181 /* Do some backend-specific processing on this symbol table. */ 1182 if (ebd->elf_backend_symbol_table_processing) 1183 (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount); 1184 1185 /* We rely on the zalloc to clear out the final symbol entry. */ 1186 1187 symcount = sym - symbase; 1188 1189 /* Fill in the user's symbol pointer vector if needed. */ 1190 if (symptrs) 1191 { 1192 long l = symcount; 1193 1194 sym = symbase; 1195 while (l-- > 0) 1196 { 1197 *symptrs++ = &sym->symbol; 1198 sym++; 1199 } 1200 *symptrs = 0; /* Final null pointer */ 1201 } 1202 1203 if (xverbuf != NULL) 1204 free (xverbuf); 1205 if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf) 1206 free (isymbuf); 1207 return symcount; 1208 1209error_return: 1210 if (xverbuf != NULL) 1211 free (xverbuf); 1212 if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf) 1213 free (isymbuf); 1214 return -1; 1215} 1216 1217/* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of 1218 them. */ 1219 1220static bfd_boolean 1221elf_slurp_reloc_table_from_section (bfd *abfd, 1222 asection *asect, 1223 Elf_Internal_Shdr *rel_hdr, 1224 bfd_size_type reloc_count, 1225 arelent *relents, 1226 asymbol **symbols, 1227 bfd_boolean dynamic) 1228{ 1229 const struct elf_backend_data * const ebd = get_elf_backend_data (abfd); 1230 void *allocated = NULL; 1231 bfd_byte *native_relocs; 1232 arelent *relent; 1233 unsigned int i; 1234 int entsize; 1235 unsigned int symcount; 1236 1237 allocated = bfd_malloc (rel_hdr->sh_size); 1238 if (allocated == NULL) 1239 goto error_return; 1240 1241 if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0 1242 || (bfd_bread (allocated, rel_hdr->sh_size, abfd) 1243 != rel_hdr->sh_size)) 1244 goto error_return; 1245 1246 native_relocs = allocated; 1247 1248 entsize = rel_hdr->sh_entsize; 1249 BFD_ASSERT (entsize == sizeof (Elf_External_Rel) 1250 || entsize == sizeof (Elf_External_Rela)); 1251 1252 if (dynamic) 1253 symcount = bfd_get_dynamic_symcount (abfd); 1254 else 1255 symcount = bfd_get_symcount (abfd); 1256 1257 for (i = 0, relent = relents; 1258 i < reloc_count; 1259 i++, relent++, native_relocs += entsize) 1260 { 1261 Elf_Internal_Rela rela; 1262 1263 if (entsize == sizeof (Elf_External_Rela)) 1264 elf_swap_reloca_in (abfd, native_relocs, &rela); 1265 else 1266 elf_swap_reloc_in (abfd, native_relocs, &rela); 1267 1268 /* The address of an ELF reloc is section relative for an object 1269 file, and absolute for an executable file or shared library. 1270 The address of a normal BFD reloc is always section relative, 1271 and the address of a dynamic reloc is absolute.. */ 1272 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic) 1273 relent->address = rela.r_offset; 1274 else 1275 relent->address = rela.r_offset - asect->vma; 1276 1277 if (ELF_R_SYM (rela.r_info) == 0) 1278 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 1279 else if (ELF_R_SYM (rela.r_info) > symcount) 1280 { 1281 (*_bfd_error_handler) 1282 (_("%s(%s): relocation %d has invalid symbol index %ld"), 1283 abfd->filename, asect->name, i, ELF_R_SYM (rela.r_info)); 1284 relent->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr; 1285 } 1286 else 1287 { 1288 asymbol **ps, *s; 1289 1290 ps = symbols + ELF_R_SYM (rela.r_info) - 1; 1291 s = *ps; 1292 1293 /* Canonicalize ELF section symbols. FIXME: Why? */ 1294 if ((s->flags & BSF_SECTION_SYM) == 0) 1295 relent->sym_ptr_ptr = ps; 1296 else 1297 relent->sym_ptr_ptr = s->section->symbol_ptr_ptr; 1298 } 1299 1300 relent->addend = rela.r_addend; 1301 1302 if ((entsize == sizeof (Elf_External_Rela) 1303 && ebd->elf_info_to_howto != NULL) 1304 || ebd->elf_info_to_howto_rel == NULL) 1305 (*ebd->elf_info_to_howto) (abfd, relent, &rela); 1306 else 1307 (*ebd->elf_info_to_howto_rel) (abfd, relent, &rela); 1308 } 1309 1310 if (allocated != NULL) 1311 free (allocated); 1312 1313 return TRUE; 1314 1315 error_return: 1316 if (allocated != NULL) 1317 free (allocated); 1318 return FALSE; 1319} 1320 1321/* Read in and swap the external relocs. */ 1322 1323bfd_boolean 1324elf_slurp_reloc_table (bfd *abfd, 1325 asection *asect, 1326 asymbol **symbols, 1327 bfd_boolean dynamic) 1328{ 1329 struct bfd_elf_section_data * const d = elf_section_data (asect); 1330 Elf_Internal_Shdr *rel_hdr; 1331 Elf_Internal_Shdr *rel_hdr2; 1332 bfd_size_type reloc_count; 1333 bfd_size_type reloc_count2; 1334 arelent *relents; 1335 bfd_size_type amt; 1336 1337 if (asect->relocation != NULL) 1338 return TRUE; 1339 1340 if (! dynamic) 1341 { 1342 if ((asect->flags & SEC_RELOC) == 0 1343 || asect->reloc_count == 0) 1344 return TRUE; 1345 1346 rel_hdr = &d->rel_hdr; 1347 reloc_count = NUM_SHDR_ENTRIES (rel_hdr); 1348 rel_hdr2 = d->rel_hdr2; 1349 reloc_count2 = (rel_hdr2 ? NUM_SHDR_ENTRIES (rel_hdr2) : 0); 1350 1351 BFD_ASSERT (asect->reloc_count == reloc_count + reloc_count2); 1352 BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset 1353 || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset)); 1354 1355 } 1356 else 1357 { 1358 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this 1359 case because relocations against this section may use the 1360 dynamic symbol table, and in that case bfd_section_from_shdr 1361 in elf.c does not update the RELOC_COUNT. */ 1362 if (asect->size == 0) 1363 return TRUE; 1364 1365 rel_hdr = &d->this_hdr; 1366 reloc_count = NUM_SHDR_ENTRIES (rel_hdr); 1367 rel_hdr2 = NULL; 1368 reloc_count2 = 0; 1369 } 1370 1371 amt = (reloc_count + reloc_count2) * sizeof (arelent); 1372 relents = bfd_alloc (abfd, amt); 1373 if (relents == NULL) 1374 return FALSE; 1375 1376 if (!elf_slurp_reloc_table_from_section (abfd, asect, 1377 rel_hdr, reloc_count, 1378 relents, 1379 symbols, dynamic)) 1380 return FALSE; 1381 1382 if (rel_hdr2 1383 && !elf_slurp_reloc_table_from_section (abfd, asect, 1384 rel_hdr2, reloc_count2, 1385 relents + reloc_count, 1386 symbols, dynamic)) 1387 return FALSE; 1388 1389 asect->relocation = relents; 1390 return TRUE; 1391} 1392 1393#ifdef DEBUG 1394static void 1395elf_debug_section (int num, Elf_Internal_Shdr *hdr) 1396{ 1397 fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num, 1398 hdr->bfd_section != NULL ? hdr->bfd_section->name : "", 1399 (long) hdr); 1400 fprintf (stderr, 1401 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n", 1402 (long) hdr->sh_name, 1403 (long) hdr->sh_type, 1404 (long) hdr->sh_flags); 1405 fprintf (stderr, 1406 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n", 1407 (long) hdr->sh_addr, 1408 (long) hdr->sh_offset, 1409 (long) hdr->sh_size); 1410 fprintf (stderr, 1411 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n", 1412 (long) hdr->sh_link, 1413 (long) hdr->sh_info, 1414 (long) hdr->sh_addralign); 1415 fprintf (stderr, "sh_entsize = %ld\n", 1416 (long) hdr->sh_entsize); 1417 fflush (stderr); 1418} 1419 1420static void 1421elf_debug_file (Elf_Internal_Ehdr *ehdrp) 1422{ 1423 fprintf (stderr, "e_entry = 0x%.8lx\n", (long) ehdrp->e_entry); 1424 fprintf (stderr, "e_phoff = %ld\n", (long) ehdrp->e_phoff); 1425 fprintf (stderr, "e_phnum = %ld\n", (long) ehdrp->e_phnum); 1426 fprintf (stderr, "e_phentsize = %ld\n", (long) ehdrp->e_phentsize); 1427 fprintf (stderr, "e_shoff = %ld\n", (long) ehdrp->e_shoff); 1428 fprintf (stderr, "e_shnum = %ld\n", (long) ehdrp->e_shnum); 1429 fprintf (stderr, "e_shentsize = %ld\n", (long) ehdrp->e_shentsize); 1430} 1431 1432static char * 1433elf_symbol_flags (flagword flags) 1434{ 1435 static char buffer[1024]; 1436 1437 buffer[0] = '\0'; 1438 if (flags & BSF_LOCAL) 1439 strcat (buffer, " local"); 1440 1441 if (flags & BSF_GLOBAL) 1442 strcat (buffer, " global"); 1443 1444 if (flags & BSF_DEBUGGING) 1445 strcat (buffer, " debug"); 1446 1447 if (flags & BSF_FUNCTION) 1448 strcat (buffer, " function"); 1449 1450 if (flags & BSF_KEEP) 1451 strcat (buffer, " keep"); 1452 1453 if (flags & BSF_KEEP_G) 1454 strcat (buffer, " keep_g"); 1455 1456 if (flags & BSF_WEAK) 1457 strcat (buffer, " weak"); 1458 1459 if (flags & BSF_SECTION_SYM) 1460 strcat (buffer, " section-sym"); 1461 1462 if (flags & BSF_OLD_COMMON) 1463 strcat (buffer, " old-common"); 1464 1465 if (flags & BSF_NOT_AT_END) 1466 strcat (buffer, " not-at-end"); 1467 1468 if (flags & BSF_CONSTRUCTOR) 1469 strcat (buffer, " constructor"); 1470 1471 if (flags & BSF_WARNING) 1472 strcat (buffer, " warning"); 1473 1474 if (flags & BSF_INDIRECT) 1475 strcat (buffer, " indirect"); 1476 1477 if (flags & BSF_FILE) 1478 strcat (buffer, " file"); 1479 1480 if (flags & DYNAMIC) 1481 strcat (buffer, " dynamic"); 1482 1483 if (flags & ~(BSF_LOCAL 1484 | BSF_GLOBAL 1485 | BSF_DEBUGGING 1486 | BSF_FUNCTION 1487 | BSF_KEEP 1488 | BSF_KEEP_G 1489 | BSF_WEAK 1490 | BSF_SECTION_SYM 1491 | BSF_OLD_COMMON 1492 | BSF_NOT_AT_END 1493 | BSF_CONSTRUCTOR 1494 | BSF_WARNING 1495 | BSF_INDIRECT 1496 | BSF_FILE 1497 | BSF_DYNAMIC)) 1498 strcat (buffer, " unknown-bits"); 1499 1500 return buffer; 1501} 1502#endif 1503 1504/* Create a new BFD as if by bfd_openr. Rather than opening a file, 1505 reconstruct an ELF file by reading the segments out of remote memory 1506 based on the ELF file header at EHDR_VMA and the ELF program headers it 1507 points to. If not null, *LOADBASEP is filled in with the difference 1508 between the VMAs from which the segments were read, and the VMAs the 1509 file headers (and hence BFD's idea of each section's VMA) put them at. 1510 1511 The function TARGET_READ_MEMORY is called to copy LEN bytes from the 1512 remote memory at target address VMA into the local buffer at MYADDR; it 1513 should return zero on success or an `errno' code on failure. TEMPL must 1514 be a BFD for a target with the word size and byte order found in the 1515 remote memory. */ 1516 1517bfd * 1518NAME(_bfd_elf,bfd_from_remote_memory) 1519 (bfd *templ, 1520 bfd_vma ehdr_vma, 1521 bfd_vma *loadbasep, 1522 int (*target_read_memory) (bfd_vma, char *, int)) 1523{ 1524 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */ 1525 Elf_Internal_Ehdr i_ehdr; /* Elf file header, internal form */ 1526 Elf_External_Phdr *x_phdrs; 1527 Elf_Internal_Phdr *i_phdrs, *last_phdr; 1528 bfd *nbfd; 1529 struct bfd_in_memory *bim; 1530 int contents_size; 1531 char *contents; 1532 int err; 1533 unsigned int i; 1534 bfd_vma loadbase; 1535 1536 /* Read in the ELF header in external format. */ 1537 err = target_read_memory (ehdr_vma, (char *) &x_ehdr, sizeof x_ehdr); 1538 if (err) 1539 { 1540 bfd_set_error (bfd_error_system_call); 1541 errno = err; 1542 return NULL; 1543 } 1544 1545 /* Now check to see if we have a valid ELF file, and one that BFD can 1546 make use of. The magic number must match, the address size ('class') 1547 and byte-swapping must match our XVEC entry. */ 1548 1549 if (! elf_file_p (&x_ehdr) 1550 || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT 1551 || x_ehdr.e_ident[EI_CLASS] != ELFCLASS) 1552 { 1553 bfd_set_error (bfd_error_wrong_format); 1554 return NULL; 1555 } 1556 1557 /* Check that file's byte order matches xvec's */ 1558 switch (x_ehdr.e_ident[EI_DATA]) 1559 { 1560 case ELFDATA2MSB: /* Big-endian */ 1561 if (! bfd_header_big_endian (templ)) 1562 { 1563 bfd_set_error (bfd_error_wrong_format); 1564 return NULL; 1565 } 1566 break; 1567 case ELFDATA2LSB: /* Little-endian */ 1568 if (! bfd_header_little_endian (templ)) 1569 { 1570 bfd_set_error (bfd_error_wrong_format); 1571 return NULL; 1572 } 1573 break; 1574 case ELFDATANONE: /* No data encoding specified */ 1575 default: /* Unknown data encoding specified */ 1576 bfd_set_error (bfd_error_wrong_format); 1577 return NULL; 1578 } 1579 1580 elf_swap_ehdr_in (templ, &x_ehdr, &i_ehdr); 1581 1582 /* The file header tells where to find the program headers. 1583 These are what we use to actually choose what to read. */ 1584 1585 if (i_ehdr.e_phentsize != sizeof (Elf_External_Phdr) || i_ehdr.e_phnum == 0) 1586 { 1587 bfd_set_error (bfd_error_wrong_format); 1588 return NULL; 1589 } 1590 1591 x_phdrs = bfd_malloc (i_ehdr.e_phnum * (sizeof *x_phdrs + sizeof *i_phdrs)); 1592 if (x_phdrs == NULL) 1593 { 1594 bfd_set_error (bfd_error_no_memory); 1595 return NULL; 1596 } 1597 err = target_read_memory (ehdr_vma + i_ehdr.e_phoff, (char *) x_phdrs, 1598 i_ehdr.e_phnum * sizeof x_phdrs[0]); 1599 if (err) 1600 { 1601 free (x_phdrs); 1602 bfd_set_error (bfd_error_system_call); 1603 errno = err; 1604 return NULL; 1605 } 1606 i_phdrs = (Elf_Internal_Phdr *) &x_phdrs[i_ehdr.e_phnum]; 1607 1608 contents_size = 0; 1609 last_phdr = NULL; 1610 loadbase = ehdr_vma; 1611 for (i = 0; i < i_ehdr.e_phnum; ++i) 1612 { 1613 elf_swap_phdr_in (templ, &x_phdrs[i], &i_phdrs[i]); 1614 if (i_phdrs[i].p_type == PT_LOAD) 1615 { 1616 bfd_vma segment_end; 1617 segment_end = (i_phdrs[i].p_offset + i_phdrs[i].p_filesz 1618 + i_phdrs[i].p_align - 1) & -i_phdrs[i].p_align; 1619 if (segment_end > (bfd_vma) contents_size) 1620 contents_size = segment_end; 1621 1622 if ((i_phdrs[i].p_offset & -i_phdrs[i].p_align) == 0) 1623 loadbase = ehdr_vma - (i_phdrs[i].p_vaddr & -i_phdrs[i].p_align); 1624 1625 last_phdr = &i_phdrs[i]; 1626 } 1627 } 1628 if (last_phdr == NULL) 1629 { 1630 /* There were no PT_LOAD segments, so we don't have anything to read. */ 1631 free (x_phdrs); 1632 bfd_set_error (bfd_error_wrong_format); 1633 return NULL; 1634 } 1635 1636 /* Trim the last segment so we don't bother with zeros in the last page 1637 that are off the end of the file. However, if the extra bit in that 1638 page includes the section headers, keep them. */ 1639 if ((bfd_vma) contents_size > last_phdr->p_offset + last_phdr->p_filesz 1640 && (bfd_vma) contents_size >= (i_ehdr.e_shoff 1641 + i_ehdr.e_shnum * i_ehdr.e_shentsize)) 1642 { 1643 contents_size = last_phdr->p_offset + last_phdr->p_filesz; 1644 if ((bfd_vma) contents_size < (i_ehdr.e_shoff 1645 + i_ehdr.e_shnum * i_ehdr.e_shentsize)) 1646 contents_size = i_ehdr.e_shoff + i_ehdr.e_shnum * i_ehdr.e_shentsize; 1647 } 1648 else 1649 contents_size = last_phdr->p_offset + last_phdr->p_filesz; 1650 1651 /* Now we know the size of the whole image we want read in. */ 1652 contents = bfd_zmalloc (contents_size); 1653 if (contents == NULL) 1654 { 1655 free (x_phdrs); 1656 bfd_set_error (bfd_error_no_memory); 1657 return NULL; 1658 } 1659 1660 for (i = 0; i < i_ehdr.e_phnum; ++i) 1661 if (i_phdrs[i].p_type == PT_LOAD) 1662 { 1663 bfd_vma start = i_phdrs[i].p_offset & -i_phdrs[i].p_align; 1664 bfd_vma end = (i_phdrs[i].p_offset + i_phdrs[i].p_filesz 1665 + i_phdrs[i].p_align - 1) & -i_phdrs[i].p_align; 1666 if (end > (bfd_vma) contents_size) 1667 end = contents_size; 1668 err = target_read_memory ((loadbase + i_phdrs[i].p_vaddr) 1669 & -i_phdrs[i].p_align, 1670 contents + start, end - start); 1671 if (err) 1672 { 1673 free (x_phdrs); 1674 free (contents); 1675 bfd_set_error (bfd_error_system_call); 1676 errno = err; 1677 return NULL; 1678 } 1679 } 1680 free (x_phdrs); 1681 1682 /* If the segments visible in memory didn't include the section headers, 1683 then clear them from the file header. */ 1684 if ((bfd_vma) contents_size < (i_ehdr.e_shoff 1685 + i_ehdr.e_shnum * i_ehdr.e_shentsize)) 1686 { 1687 memset (&x_ehdr.e_shoff, 0, sizeof x_ehdr.e_shoff); 1688 memset (&x_ehdr.e_shnum, 0, sizeof x_ehdr.e_shnum); 1689 memset (&x_ehdr.e_shstrndx, 0, sizeof x_ehdr.e_shstrndx); 1690 } 1691 1692 /* This will normally have been in the first PT_LOAD segment. But it 1693 conceivably could be missing, and we might have just changed it. */ 1694 memcpy (contents, &x_ehdr, sizeof x_ehdr); 1695 1696 /* Now we have a memory image of the ELF file contents. Make a BFD. */ 1697 bim = bfd_malloc (sizeof (struct bfd_in_memory)); 1698 if (bim == NULL) 1699 { 1700 free (contents); 1701 bfd_set_error (bfd_error_no_memory); 1702 return NULL; 1703 } 1704 nbfd = _bfd_new_bfd (); 1705 if (nbfd == NULL) 1706 { 1707 free (bim); 1708 free (contents); 1709 bfd_set_error (bfd_error_no_memory); 1710 return NULL; 1711 } 1712 nbfd->filename = "<in-memory>"; 1713 nbfd->xvec = templ->xvec; 1714 bim->size = contents_size; 1715 bim->buffer = contents; 1716 nbfd->iostream = bim; 1717 nbfd->flags = BFD_IN_MEMORY; 1718 nbfd->direction = read_direction; 1719 nbfd->mtime = time (NULL); 1720 nbfd->mtime_set = TRUE; 1721 1722 if (loadbasep) 1723 *loadbasep = loadbase; 1724 return nbfd; 1725} 1726 1727#include "elfcore.h" 1728 1729/* Size-dependent data and functions. */ 1730const struct elf_size_info NAME(_bfd_elf,size_info) = { 1731 sizeof (Elf_External_Ehdr), 1732 sizeof (Elf_External_Phdr), 1733 sizeof (Elf_External_Shdr), 1734 sizeof (Elf_External_Rel), 1735 sizeof (Elf_External_Rela), 1736 sizeof (Elf_External_Sym), 1737 sizeof (Elf_External_Dyn), 1738 sizeof (Elf_External_Note), 1739 4, 1740 1, 1741 ARCH_SIZE, LOG_FILE_ALIGN, 1742 ELFCLASS, EV_CURRENT, 1743 elf_write_out_phdrs, 1744 elf_write_shdrs_and_ehdr, 1745 elf_write_relocs, 1746 elf_swap_symbol_in, 1747 elf_swap_symbol_out, 1748 elf_slurp_reloc_table, 1749 elf_slurp_symbol_table, 1750 elf_swap_dyn_in, 1751 elf_swap_dyn_out, 1752 elf_swap_reloc_in, 1753 elf_swap_reloc_out, 1754 elf_swap_reloca_in, 1755 elf_swap_reloca_out 1756}; 1757