1 /* ELF executable support for BFD. 2 3 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 4 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 5 Free Software Foundation, Inc. 6 7 This file is part of BFD, the Binary File Descriptor library. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 22 MA 02110-1301, USA. */ 23 24 25 /* 26 SECTION 27 ELF backends 28 29 BFD support for ELF formats is being worked on. 30 Currently, the best supported back ends are for sparc and i386 31 (running svr4 or Solaris 2). 32 33 Documentation of the internals of the support code still needs 34 to be written. The code is changing quickly enough that we 35 haven't bothered yet. */ 36 37 /* For sparc64-cross-sparc32. */ 38 #define _SYSCALL32 39 #include "sysdep.h" 40 #include "bfd.h" 41 #include "bfdlink.h" 42 #include "libbfd.h" 43 #define ARCH_SIZE 0 44 #include "elf-bfd.h" 45 #include "libiberty.h" 46 #include "safe-ctype.h" 47 48 #ifdef CORE_HEADER 49 #include CORE_HEADER 50 #endif 51 52 static int elf_sort_sections (const void *, const void *); 53 static bfd_boolean assign_file_positions_except_relocs (bfd *, struct bfd_link_info *); 54 static bfd_boolean prep_headers (bfd *); 55 static bfd_boolean swap_out_syms (bfd *, struct bfd_strtab_hash **, int) ; 56 static bfd_boolean elf_read_notes (bfd *, file_ptr, bfd_size_type) ; 57 static bfd_boolean elf_parse_notes (bfd *abfd, char *buf, size_t size, 58 file_ptr offset); 59 60 /* Swap version information in and out. The version information is 61 currently size independent. If that ever changes, this code will 62 need to move into elfcode.h. */ 63 64 /* Swap in a Verdef structure. */ 65 66 void 67 _bfd_elf_swap_verdef_in (bfd *abfd, 68 const Elf_External_Verdef *src, 69 Elf_Internal_Verdef *dst) 70 { 71 dst->vd_version = H_GET_16 (abfd, src->vd_version); 72 dst->vd_flags = H_GET_16 (abfd, src->vd_flags); 73 dst->vd_ndx = H_GET_16 (abfd, src->vd_ndx); 74 dst->vd_cnt = H_GET_16 (abfd, src->vd_cnt); 75 dst->vd_hash = H_GET_32 (abfd, src->vd_hash); 76 dst->vd_aux = H_GET_32 (abfd, src->vd_aux); 77 dst->vd_next = H_GET_32 (abfd, src->vd_next); 78 } 79 80 /* Swap out a Verdef structure. */ 81 82 void 83 _bfd_elf_swap_verdef_out (bfd *abfd, 84 const Elf_Internal_Verdef *src, 85 Elf_External_Verdef *dst) 86 { 87 H_PUT_16 (abfd, src->vd_version, dst->vd_version); 88 H_PUT_16 (abfd, src->vd_flags, dst->vd_flags); 89 H_PUT_16 (abfd, src->vd_ndx, dst->vd_ndx); 90 H_PUT_16 (abfd, src->vd_cnt, dst->vd_cnt); 91 H_PUT_32 (abfd, src->vd_hash, dst->vd_hash); 92 H_PUT_32 (abfd, src->vd_aux, dst->vd_aux); 93 H_PUT_32 (abfd, src->vd_next, dst->vd_next); 94 } 95 96 /* Swap in a Verdaux structure. */ 97 98 void 99 _bfd_elf_swap_verdaux_in (bfd *abfd, 100 const Elf_External_Verdaux *src, 101 Elf_Internal_Verdaux *dst) 102 { 103 dst->vda_name = H_GET_32 (abfd, src->vda_name); 104 dst->vda_next = H_GET_32 (abfd, src->vda_next); 105 } 106 107 /* Swap out a Verdaux structure. */ 108 109 void 110 _bfd_elf_swap_verdaux_out (bfd *abfd, 111 const Elf_Internal_Verdaux *src, 112 Elf_External_Verdaux *dst) 113 { 114 H_PUT_32 (abfd, src->vda_name, dst->vda_name); 115 H_PUT_32 (abfd, src->vda_next, dst->vda_next); 116 } 117 118 /* Swap in a Verneed structure. */ 119 120 void 121 _bfd_elf_swap_verneed_in (bfd *abfd, 122 const Elf_External_Verneed *src, 123 Elf_Internal_Verneed *dst) 124 { 125 dst->vn_version = H_GET_16 (abfd, src->vn_version); 126 dst->vn_cnt = H_GET_16 (abfd, src->vn_cnt); 127 dst->vn_file = H_GET_32 (abfd, src->vn_file); 128 dst->vn_aux = H_GET_32 (abfd, src->vn_aux); 129 dst->vn_next = H_GET_32 (abfd, src->vn_next); 130 } 131 132 /* Swap out a Verneed structure. */ 133 134 void 135 _bfd_elf_swap_verneed_out (bfd *abfd, 136 const Elf_Internal_Verneed *src, 137 Elf_External_Verneed *dst) 138 { 139 H_PUT_16 (abfd, src->vn_version, dst->vn_version); 140 H_PUT_16 (abfd, src->vn_cnt, dst->vn_cnt); 141 H_PUT_32 (abfd, src->vn_file, dst->vn_file); 142 H_PUT_32 (abfd, src->vn_aux, dst->vn_aux); 143 H_PUT_32 (abfd, src->vn_next, dst->vn_next); 144 } 145 146 /* Swap in a Vernaux structure. */ 147 148 void 149 _bfd_elf_swap_vernaux_in (bfd *abfd, 150 const Elf_External_Vernaux *src, 151 Elf_Internal_Vernaux *dst) 152 { 153 dst->vna_hash = H_GET_32 (abfd, src->vna_hash); 154 dst->vna_flags = H_GET_16 (abfd, src->vna_flags); 155 dst->vna_other = H_GET_16 (abfd, src->vna_other); 156 dst->vna_name = H_GET_32 (abfd, src->vna_name); 157 dst->vna_next = H_GET_32 (abfd, src->vna_next); 158 } 159 160 /* Swap out a Vernaux structure. */ 161 162 void 163 _bfd_elf_swap_vernaux_out (bfd *abfd, 164 const Elf_Internal_Vernaux *src, 165 Elf_External_Vernaux *dst) 166 { 167 H_PUT_32 (abfd, src->vna_hash, dst->vna_hash); 168 H_PUT_16 (abfd, src->vna_flags, dst->vna_flags); 169 H_PUT_16 (abfd, src->vna_other, dst->vna_other); 170 H_PUT_32 (abfd, src->vna_name, dst->vna_name); 171 H_PUT_32 (abfd, src->vna_next, dst->vna_next); 172 } 173 174 /* Swap in a Versym structure. */ 175 176 void 177 _bfd_elf_swap_versym_in (bfd *abfd, 178 const Elf_External_Versym *src, 179 Elf_Internal_Versym *dst) 180 { 181 dst->vs_vers = H_GET_16 (abfd, src->vs_vers); 182 } 183 184 /* Swap out a Versym structure. */ 185 186 void 187 _bfd_elf_swap_versym_out (bfd *abfd, 188 const Elf_Internal_Versym *src, 189 Elf_External_Versym *dst) 190 { 191 H_PUT_16 (abfd, src->vs_vers, dst->vs_vers); 192 } 193 194 /* Standard ELF hash function. Do not change this function; you will 195 cause invalid hash tables to be generated. */ 196 197 unsigned long 198 bfd_elf_hash (const char *namearg) 199 { 200 const unsigned char *name = (const unsigned char *) namearg; 201 unsigned long h = 0; 202 unsigned long g; 203 int ch; 204 205 while ((ch = *name++) != '\0') 206 { 207 h = (h << 4) + ch; 208 if ((g = (h & 0xf0000000)) != 0) 209 { 210 h ^= g >> 24; 211 /* The ELF ABI says `h &= ~g', but this is equivalent in 212 this case and on some machines one insn instead of two. */ 213 h ^= g; 214 } 215 } 216 return h & 0xffffffff; 217 } 218 219 /* DT_GNU_HASH hash function. Do not change this function; you will 220 cause invalid hash tables to be generated. */ 221 222 unsigned long 223 bfd_elf_gnu_hash (const char *namearg) 224 { 225 const unsigned char *name = (const unsigned char *) namearg; 226 unsigned long h = 5381; 227 unsigned char ch; 228 229 while ((ch = *name++) != '\0') 230 h = (h << 5) + h + ch; 231 return h & 0xffffffff; 232 } 233 234 /* Create a tdata field OBJECT_SIZE bytes in length, zeroed out and with 235 the object_id field of an elf_obj_tdata field set to OBJECT_ID. */ 236 bfd_boolean 237 bfd_elf_allocate_object (bfd *abfd, 238 size_t object_size, 239 enum elf_target_id object_id) 240 { 241 BFD_ASSERT (object_size >= sizeof (struct elf_obj_tdata)); 242 abfd->tdata.any = bfd_zalloc (abfd, object_size); 243 if (abfd->tdata.any == NULL) 244 return FALSE; 245 246 elf_object_id (abfd) = object_id; 247 elf_program_header_size (abfd) = (bfd_size_type) -1; 248 return TRUE; 249 } 250 251 252 bfd_boolean 253 bfd_elf_make_object (bfd *abfd) 254 { 255 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 256 return bfd_elf_allocate_object (abfd, sizeof (struct elf_obj_tdata), 257 bed->target_id); 258 } 259 260 bfd_boolean 261 bfd_elf_mkcorefile (bfd *abfd) 262 { 263 /* I think this can be done just like an object file. */ 264 return abfd->xvec->_bfd_set_format[(int) bfd_object] (abfd); 265 } 266 267 static char * 268 bfd_elf_get_str_section (bfd *abfd, unsigned int shindex) 269 { 270 Elf_Internal_Shdr **i_shdrp; 271 bfd_byte *shstrtab = NULL; 272 file_ptr offset; 273 bfd_size_type shstrtabsize; 274 275 i_shdrp = elf_elfsections (abfd); 276 if (i_shdrp == 0 277 || shindex >= elf_numsections (abfd) 278 || i_shdrp[shindex] == 0) 279 return NULL; 280 281 shstrtab = i_shdrp[shindex]->contents; 282 if (shstrtab == NULL) 283 { 284 /* No cached one, attempt to read, and cache what we read. */ 285 offset = i_shdrp[shindex]->sh_offset; 286 shstrtabsize = i_shdrp[shindex]->sh_size; 287 288 /* Allocate and clear an extra byte at the end, to prevent crashes 289 in case the string table is not terminated. */ 290 if (shstrtabsize + 1 <= 1 291 || (shstrtab = (bfd_byte *) bfd_alloc (abfd, shstrtabsize + 1)) == NULL 292 || bfd_seek (abfd, offset, SEEK_SET) != 0) 293 shstrtab = NULL; 294 else if (bfd_bread (shstrtab, shstrtabsize, abfd) != shstrtabsize) 295 { 296 if (bfd_get_error () != bfd_error_system_call) 297 bfd_set_error (bfd_error_file_truncated); 298 shstrtab = NULL; 299 /* Once we've failed to read it, make sure we don't keep 300 trying. Otherwise, we'll keep allocating space for 301 the string table over and over. */ 302 i_shdrp[shindex]->sh_size = 0; 303 } 304 else 305 shstrtab[shstrtabsize] = '\0'; 306 i_shdrp[shindex]->contents = shstrtab; 307 } 308 return (char *) shstrtab; 309 } 310 311 char * 312 bfd_elf_string_from_elf_section (bfd *abfd, 313 unsigned int shindex, 314 unsigned int strindex) 315 { 316 Elf_Internal_Shdr *hdr; 317 318 if (strindex == 0) 319 return ""; 320 321 if (elf_elfsections (abfd) == NULL || shindex >= elf_numsections (abfd)) 322 return NULL; 323 324 hdr = elf_elfsections (abfd)[shindex]; 325 326 if (hdr->contents == NULL 327 && bfd_elf_get_str_section (abfd, shindex) == NULL) 328 return NULL; 329 330 if (strindex >= hdr->sh_size) 331 { 332 unsigned int shstrndx = elf_elfheader(abfd)->e_shstrndx; 333 (*_bfd_error_handler) 334 (_("%B: invalid string offset %u >= %lu for section `%s'"), 335 abfd, strindex, (unsigned long) hdr->sh_size, 336 (shindex == shstrndx && strindex == hdr->sh_name 337 ? ".shstrtab" 338 : bfd_elf_string_from_elf_section (abfd, shstrndx, hdr->sh_name))); 339 return NULL; 340 } 341 342 return ((char *) hdr->contents) + strindex; 343 } 344 345 /* Read and convert symbols to internal format. 346 SYMCOUNT specifies the number of symbols to read, starting from 347 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF 348 are non-NULL, they are used to store the internal symbols, external 349 symbols, and symbol section index extensions, respectively. 350 Returns a pointer to the internal symbol buffer (malloced if necessary) 351 or NULL if there were no symbols or some kind of problem. */ 352 353 Elf_Internal_Sym * 354 bfd_elf_get_elf_syms (bfd *ibfd, 355 Elf_Internal_Shdr *symtab_hdr, 356 size_t symcount, 357 size_t symoffset, 358 Elf_Internal_Sym *intsym_buf, 359 void *extsym_buf, 360 Elf_External_Sym_Shndx *extshndx_buf) 361 { 362 Elf_Internal_Shdr *shndx_hdr; 363 void *alloc_ext; 364 const bfd_byte *esym; 365 Elf_External_Sym_Shndx *alloc_extshndx; 366 Elf_External_Sym_Shndx *shndx; 367 Elf_Internal_Sym *alloc_intsym; 368 Elf_Internal_Sym *isym; 369 Elf_Internal_Sym *isymend; 370 const struct elf_backend_data *bed; 371 size_t extsym_size; 372 bfd_size_type amt; 373 file_ptr pos; 374 375 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour) 376 abort (); 377 378 if (symcount == 0) 379 return intsym_buf; 380 381 /* Normal syms might have section extension entries. */ 382 shndx_hdr = NULL; 383 if (symtab_hdr == &elf_tdata (ibfd)->symtab_hdr) 384 shndx_hdr = &elf_tdata (ibfd)->symtab_shndx_hdr; 385 386 /* Read the symbols. */ 387 alloc_ext = NULL; 388 alloc_extshndx = NULL; 389 alloc_intsym = NULL; 390 bed = get_elf_backend_data (ibfd); 391 extsym_size = bed->s->sizeof_sym; 392 amt = symcount * extsym_size; 393 pos = symtab_hdr->sh_offset + symoffset * extsym_size; 394 if (extsym_buf == NULL) 395 { 396 alloc_ext = bfd_malloc2 (symcount, extsym_size); 397 extsym_buf = alloc_ext; 398 } 399 if (extsym_buf == NULL 400 || bfd_seek (ibfd, pos, SEEK_SET) != 0 401 || bfd_bread (extsym_buf, amt, ibfd) != amt) 402 { 403 intsym_buf = NULL; 404 goto out; 405 } 406 407 if (shndx_hdr == NULL || shndx_hdr->sh_size == 0) 408 extshndx_buf = NULL; 409 else 410 { 411 amt = symcount * sizeof (Elf_External_Sym_Shndx); 412 pos = shndx_hdr->sh_offset + symoffset * sizeof (Elf_External_Sym_Shndx); 413 if (extshndx_buf == NULL) 414 { 415 alloc_extshndx = (Elf_External_Sym_Shndx *) 416 bfd_malloc2 (symcount, sizeof (Elf_External_Sym_Shndx)); 417 extshndx_buf = alloc_extshndx; 418 } 419 if (extshndx_buf == NULL 420 || bfd_seek (ibfd, pos, SEEK_SET) != 0 421 || bfd_bread (extshndx_buf, amt, ibfd) != amt) 422 { 423 intsym_buf = NULL; 424 goto out; 425 } 426 } 427 428 if (intsym_buf == NULL) 429 { 430 alloc_intsym = (Elf_Internal_Sym *) 431 bfd_malloc2 (symcount, sizeof (Elf_Internal_Sym)); 432 intsym_buf = alloc_intsym; 433 if (intsym_buf == NULL) 434 goto out; 435 } 436 437 /* Convert the symbols to internal form. */ 438 isymend = intsym_buf + symcount; 439 for (esym = (const bfd_byte *) extsym_buf, isym = intsym_buf, 440 shndx = extshndx_buf; 441 isym < isymend; 442 esym += extsym_size, isym++, shndx = shndx != NULL ? shndx + 1 : NULL) 443 if (!(*bed->s->swap_symbol_in) (ibfd, esym, shndx, isym)) 444 { 445 symoffset += (esym - (bfd_byte *) extsym_buf) / extsym_size; 446 (*_bfd_error_handler) (_("%B symbol number %lu references " 447 "nonexistent SHT_SYMTAB_SHNDX section"), 448 ibfd, (unsigned long) symoffset); 449 if (alloc_intsym != NULL) 450 free (alloc_intsym); 451 intsym_buf = NULL; 452 goto out; 453 } 454 455 out: 456 if (alloc_ext != NULL) 457 free (alloc_ext); 458 if (alloc_extshndx != NULL) 459 free (alloc_extshndx); 460 461 return intsym_buf; 462 } 463 464 /* Look up a symbol name. */ 465 const char * 466 bfd_elf_sym_name (bfd *abfd, 467 Elf_Internal_Shdr *symtab_hdr, 468 Elf_Internal_Sym *isym, 469 asection *sym_sec) 470 { 471 const char *name; 472 unsigned int iname = isym->st_name; 473 unsigned int shindex = symtab_hdr->sh_link; 474 475 if (iname == 0 && ELF_ST_TYPE (isym->st_info) == STT_SECTION 476 /* Check for a bogus st_shndx to avoid crashing. */ 477 && isym->st_shndx < elf_numsections (abfd)) 478 { 479 iname = elf_elfsections (abfd)[isym->st_shndx]->sh_name; 480 shindex = elf_elfheader (abfd)->e_shstrndx; 481 } 482 483 name = bfd_elf_string_from_elf_section (abfd, shindex, iname); 484 if (name == NULL) 485 name = "(null)"; 486 else if (sym_sec && *name == '\0') 487 name = bfd_section_name (abfd, sym_sec); 488 489 return name; 490 } 491 492 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP 493 sections. The first element is the flags, the rest are section 494 pointers. */ 495 496 typedef union elf_internal_group { 497 Elf_Internal_Shdr *shdr; 498 unsigned int flags; 499 } Elf_Internal_Group; 500 501 /* Return the name of the group signature symbol. Why isn't the 502 signature just a string? */ 503 504 static const char * 505 group_signature (bfd *abfd, Elf_Internal_Shdr *ghdr) 506 { 507 Elf_Internal_Shdr *hdr; 508 unsigned char esym[sizeof (Elf64_External_Sym)]; 509 Elf_External_Sym_Shndx eshndx; 510 Elf_Internal_Sym isym; 511 512 /* First we need to ensure the symbol table is available. Make sure 513 that it is a symbol table section. */ 514 if (ghdr->sh_link >= elf_numsections (abfd)) 515 return NULL; 516 hdr = elf_elfsections (abfd) [ghdr->sh_link]; 517 if (hdr->sh_type != SHT_SYMTAB 518 || ! bfd_section_from_shdr (abfd, ghdr->sh_link)) 519 return NULL; 520 521 /* Go read the symbol. */ 522 hdr = &elf_tdata (abfd)->symtab_hdr; 523 if (bfd_elf_get_elf_syms (abfd, hdr, 1, ghdr->sh_info, 524 &isym, esym, &eshndx) == NULL) 525 return NULL; 526 527 return bfd_elf_sym_name (abfd, hdr, &isym, NULL); 528 } 529 530 /* Set next_in_group list pointer, and group name for NEWSECT. */ 531 532 static bfd_boolean 533 setup_group (bfd *abfd, Elf_Internal_Shdr *hdr, asection *newsect) 534 { 535 unsigned int num_group = elf_tdata (abfd)->num_group; 536 537 /* If num_group is zero, read in all SHT_GROUP sections. The count 538 is set to -1 if there are no SHT_GROUP sections. */ 539 if (num_group == 0) 540 { 541 unsigned int i, shnum; 542 543 /* First count the number of groups. If we have a SHT_GROUP 544 section with just a flag word (ie. sh_size is 4), ignore it. */ 545 shnum = elf_numsections (abfd); 546 num_group = 0; 547 548 #define IS_VALID_GROUP_SECTION_HEADER(shdr) \ 549 ( (shdr)->sh_type == SHT_GROUP \ 550 && (shdr)->sh_size >= (2 * GRP_ENTRY_SIZE) \ 551 && (shdr)->sh_entsize == GRP_ENTRY_SIZE \ 552 && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0) 553 554 for (i = 0; i < shnum; i++) 555 { 556 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i]; 557 558 if (IS_VALID_GROUP_SECTION_HEADER (shdr)) 559 num_group += 1; 560 } 561 562 if (num_group == 0) 563 { 564 num_group = (unsigned) -1; 565 elf_tdata (abfd)->num_group = num_group; 566 } 567 else 568 { 569 /* We keep a list of elf section headers for group sections, 570 so we can find them quickly. */ 571 bfd_size_type amt; 572 573 elf_tdata (abfd)->num_group = num_group; 574 elf_tdata (abfd)->group_sect_ptr = (Elf_Internal_Shdr **) 575 bfd_alloc2 (abfd, num_group, sizeof (Elf_Internal_Shdr *)); 576 if (elf_tdata (abfd)->group_sect_ptr == NULL) 577 return FALSE; 578 579 num_group = 0; 580 for (i = 0; i < shnum; i++) 581 { 582 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i]; 583 584 if (IS_VALID_GROUP_SECTION_HEADER (shdr)) 585 { 586 unsigned char *src; 587 Elf_Internal_Group *dest; 588 589 /* Add to list of sections. */ 590 elf_tdata (abfd)->group_sect_ptr[num_group] = shdr; 591 num_group += 1; 592 593 /* Read the raw contents. */ 594 BFD_ASSERT (sizeof (*dest) >= 4); 595 amt = shdr->sh_size * sizeof (*dest) / 4; 596 shdr->contents = (unsigned char *) 597 bfd_alloc2 (abfd, shdr->sh_size, sizeof (*dest) / 4); 598 /* PR binutils/4110: Handle corrupt group headers. */ 599 if (shdr->contents == NULL) 600 { 601 _bfd_error_handler 602 (_("%B: Corrupt size field in group section header: 0x%lx"), abfd, shdr->sh_size); 603 bfd_set_error (bfd_error_bad_value); 604 return FALSE; 605 } 606 607 memset (shdr->contents, 0, amt); 608 609 if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0 610 || (bfd_bread (shdr->contents, shdr->sh_size, abfd) 611 != shdr->sh_size)) 612 return FALSE; 613 614 /* Translate raw contents, a flag word followed by an 615 array of elf section indices all in target byte order, 616 to the flag word followed by an array of elf section 617 pointers. */ 618 src = shdr->contents + shdr->sh_size; 619 dest = (Elf_Internal_Group *) (shdr->contents + amt); 620 while (1) 621 { 622 unsigned int idx; 623 624 src -= 4; 625 --dest; 626 idx = H_GET_32 (abfd, src); 627 if (src == shdr->contents) 628 { 629 dest->flags = idx; 630 if (shdr->bfd_section != NULL && (idx & GRP_COMDAT)) 631 shdr->bfd_section->flags 632 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD; 633 break; 634 } 635 if (idx >= shnum) 636 { 637 ((*_bfd_error_handler) 638 (_("%B: invalid SHT_GROUP entry"), abfd)); 639 idx = 0; 640 } 641 dest->shdr = elf_elfsections (abfd)[idx]; 642 } 643 } 644 } 645 } 646 } 647 648 if (num_group != (unsigned) -1) 649 { 650 unsigned int i; 651 652 for (i = 0; i < num_group; i++) 653 { 654 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i]; 655 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents; 656 unsigned int n_elt = shdr->sh_size / 4; 657 658 /* Look through this group's sections to see if current 659 section is a member. */ 660 while (--n_elt != 0) 661 if ((++idx)->shdr == hdr) 662 { 663 asection *s = NULL; 664 665 /* We are a member of this group. Go looking through 666 other members to see if any others are linked via 667 next_in_group. */ 668 idx = (Elf_Internal_Group *) shdr->contents; 669 n_elt = shdr->sh_size / 4; 670 while (--n_elt != 0) 671 if ((s = (++idx)->shdr->bfd_section) != NULL 672 && elf_next_in_group (s) != NULL) 673 break; 674 if (n_elt != 0) 675 { 676 /* Snarf the group name from other member, and 677 insert current section in circular list. */ 678 elf_group_name (newsect) = elf_group_name (s); 679 elf_next_in_group (newsect) = elf_next_in_group (s); 680 elf_next_in_group (s) = newsect; 681 } 682 else 683 { 684 const char *gname; 685 686 gname = group_signature (abfd, shdr); 687 if (gname == NULL) 688 return FALSE; 689 elf_group_name (newsect) = gname; 690 691 /* Start a circular list with one element. */ 692 elf_next_in_group (newsect) = newsect; 693 } 694 695 /* If the group section has been created, point to the 696 new member. */ 697 if (shdr->bfd_section != NULL) 698 elf_next_in_group (shdr->bfd_section) = newsect; 699 700 i = num_group - 1; 701 break; 702 } 703 } 704 } 705 706 if (elf_group_name (newsect) == NULL) 707 { 708 (*_bfd_error_handler) (_("%B: no group info for section %A"), 709 abfd, newsect); 710 } 711 return TRUE; 712 } 713 714 bfd_boolean 715 _bfd_elf_setup_sections (bfd *abfd) 716 { 717 unsigned int i; 718 unsigned int num_group = elf_tdata (abfd)->num_group; 719 bfd_boolean result = TRUE; 720 asection *s; 721 722 /* Process SHF_LINK_ORDER. */ 723 for (s = abfd->sections; s != NULL; s = s->next) 724 { 725 Elf_Internal_Shdr *this_hdr = &elf_section_data (s)->this_hdr; 726 if ((this_hdr->sh_flags & SHF_LINK_ORDER) != 0) 727 { 728 unsigned int elfsec = this_hdr->sh_link; 729 /* FIXME: The old Intel compiler and old strip/objcopy may 730 not set the sh_link or sh_info fields. Hence we could 731 get the situation where elfsec is 0. */ 732 if (elfsec == 0) 733 { 734 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 735 if (bed->link_order_error_handler) 736 bed->link_order_error_handler 737 (_("%B: warning: sh_link not set for section `%A'"), 738 abfd, s); 739 } 740 else 741 { 742 asection *linksec = NULL; 743 744 if (elfsec < elf_numsections (abfd)) 745 { 746 this_hdr = elf_elfsections (abfd)[elfsec]; 747 linksec = this_hdr->bfd_section; 748 } 749 750 /* PR 1991, 2008: 751 Some strip/objcopy may leave an incorrect value in 752 sh_link. We don't want to proceed. */ 753 if (linksec == NULL) 754 { 755 (*_bfd_error_handler) 756 (_("%B: sh_link [%d] in section `%A' is incorrect"), 757 s->owner, s, elfsec); 758 result = FALSE; 759 } 760 761 elf_linked_to_section (s) = linksec; 762 } 763 } 764 } 765 766 /* Process section groups. */ 767 if (num_group == (unsigned) -1) 768 return result; 769 770 for (i = 0; i < num_group; i++) 771 { 772 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i]; 773 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents; 774 unsigned int n_elt = shdr->sh_size / 4; 775 776 while (--n_elt != 0) 777 if ((++idx)->shdr->bfd_section) 778 elf_sec_group (idx->shdr->bfd_section) = shdr->bfd_section; 779 else if (idx->shdr->sh_type == SHT_RELA 780 || idx->shdr->sh_type == SHT_REL) 781 /* We won't include relocation sections in section groups in 782 output object files. We adjust the group section size here 783 so that relocatable link will work correctly when 784 relocation sections are in section group in input object 785 files. */ 786 shdr->bfd_section->size -= 4; 787 else 788 { 789 /* There are some unknown sections in the group. */ 790 (*_bfd_error_handler) 791 (_("%B: unknown [%d] section `%s' in group [%s]"), 792 abfd, 793 (unsigned int) idx->shdr->sh_type, 794 bfd_elf_string_from_elf_section (abfd, 795 (elf_elfheader (abfd) 796 ->e_shstrndx), 797 idx->shdr->sh_name), 798 shdr->bfd_section->name); 799 result = FALSE; 800 } 801 } 802 return result; 803 } 804 805 bfd_boolean 806 bfd_elf_is_group_section (bfd *abfd ATTRIBUTE_UNUSED, const asection *sec) 807 { 808 return elf_next_in_group (sec) != NULL; 809 } 810 811 /* Make a BFD section from an ELF section. We store a pointer to the 812 BFD section in the bfd_section field of the header. */ 813 814 bfd_boolean 815 _bfd_elf_make_section_from_shdr (bfd *abfd, 816 Elf_Internal_Shdr *hdr, 817 const char *name, 818 int shindex) 819 { 820 asection *newsect; 821 flagword flags; 822 const struct elf_backend_data *bed; 823 824 if (hdr->bfd_section != NULL) 825 return TRUE; 826 827 newsect = bfd_make_section_anyway (abfd, name); 828 if (newsect == NULL) 829 return FALSE; 830 831 hdr->bfd_section = newsect; 832 elf_section_data (newsect)->this_hdr = *hdr; 833 elf_section_data (newsect)->this_idx = shindex; 834 835 /* Always use the real type/flags. */ 836 elf_section_type (newsect) = hdr->sh_type; 837 elf_section_flags (newsect) = hdr->sh_flags; 838 839 newsect->filepos = hdr->sh_offset; 840 841 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr) 842 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size) 843 || ! bfd_set_section_alignment (abfd, newsect, 844 bfd_log2 (hdr->sh_addralign))) 845 return FALSE; 846 847 flags = SEC_NO_FLAGS; 848 if (hdr->sh_type != SHT_NOBITS) 849 flags |= SEC_HAS_CONTENTS; 850 if (hdr->sh_type == SHT_GROUP) 851 flags |= SEC_GROUP | SEC_EXCLUDE; 852 if ((hdr->sh_flags & SHF_ALLOC) != 0) 853 { 854 flags |= SEC_ALLOC; 855 if (hdr->sh_type != SHT_NOBITS) 856 flags |= SEC_LOAD; 857 } 858 if ((hdr->sh_flags & SHF_WRITE) == 0) 859 flags |= SEC_READONLY; 860 if ((hdr->sh_flags & SHF_EXECINSTR) != 0) 861 flags |= SEC_CODE; 862 else if ((flags & SEC_LOAD) != 0) 863 flags |= SEC_DATA; 864 if ((hdr->sh_flags & SHF_MERGE) != 0) 865 { 866 flags |= SEC_MERGE; 867 newsect->entsize = hdr->sh_entsize; 868 if ((hdr->sh_flags & SHF_STRINGS) != 0) 869 flags |= SEC_STRINGS; 870 } 871 if (hdr->sh_flags & SHF_GROUP) 872 if (!setup_group (abfd, hdr, newsect)) 873 return FALSE; 874 if ((hdr->sh_flags & SHF_TLS) != 0) 875 flags |= SEC_THREAD_LOCAL; 876 if ((hdr->sh_flags & SHF_EXCLUDE) != 0) 877 flags |= SEC_EXCLUDE; 878 879 if ((flags & SEC_ALLOC) == 0) 880 { 881 /* The debugging sections appear to be recognized only by name, 882 not any sort of flag. Their SEC_ALLOC bits are cleared. */ 883 static const struct 884 { 885 const char *name; 886 int len; 887 } debug_sections [] = 888 { 889 { STRING_COMMA_LEN ("debug") }, /* 'd' */ 890 { NULL, 0 }, /* 'e' */ 891 { NULL, 0 }, /* 'f' */ 892 { STRING_COMMA_LEN ("gnu.linkonce.wi.") }, /* 'g' */ 893 { NULL, 0 }, /* 'h' */ 894 { NULL, 0 }, /* 'i' */ 895 { NULL, 0 }, /* 'j' */ 896 { NULL, 0 }, /* 'k' */ 897 { STRING_COMMA_LEN ("line") }, /* 'l' */ 898 { NULL, 0 }, /* 'm' */ 899 { NULL, 0 }, /* 'n' */ 900 { NULL, 0 }, /* 'o' */ 901 { NULL, 0 }, /* 'p' */ 902 { NULL, 0 }, /* 'q' */ 903 { NULL, 0 }, /* 'r' */ 904 { STRING_COMMA_LEN ("stab") }, /* 's' */ 905 { NULL, 0 }, /* 't' */ 906 { NULL, 0 }, /* 'u' */ 907 { NULL, 0 }, /* 'v' */ 908 { NULL, 0 }, /* 'w' */ 909 { NULL, 0 }, /* 'x' */ 910 { NULL, 0 }, /* 'y' */ 911 { STRING_COMMA_LEN ("zdebug") } /* 'z' */ 912 }; 913 914 if (name [0] == '.') 915 { 916 int i = name [1] - 'd'; 917 if (i >= 0 918 && i < (int) ARRAY_SIZE (debug_sections) 919 && debug_sections [i].name != NULL 920 && strncmp (&name [1], debug_sections [i].name, 921 debug_sections [i].len) == 0) 922 flags |= SEC_DEBUGGING; 923 } 924 } 925 926 /* As a GNU extension, if the name begins with .gnu.linkonce, we 927 only link a single copy of the section. This is used to support 928 g++. g++ will emit each template expansion in its own section. 929 The symbols will be defined as weak, so that multiple definitions 930 are permitted. The GNU linker extension is to actually discard 931 all but one of the sections. */ 932 if (CONST_STRNEQ (name, ".gnu.linkonce") 933 && elf_next_in_group (newsect) == NULL) 934 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD; 935 936 bed = get_elf_backend_data (abfd); 937 if (bed->elf_backend_section_flags) 938 if (! bed->elf_backend_section_flags (&flags, hdr)) 939 return FALSE; 940 941 if (! bfd_set_section_flags (abfd, newsect, flags)) 942 return FALSE; 943 944 /* We do not parse the PT_NOTE segments as we are interested even in the 945 separate debug info files which may have the segments offsets corrupted. 946 PT_NOTEs from the core files are currently not parsed using BFD. */ 947 if (hdr->sh_type == SHT_NOTE) 948 { 949 bfd_byte *contents; 950 951 if (!bfd_malloc_and_get_section (abfd, newsect, &contents)) 952 return FALSE; 953 954 elf_parse_notes (abfd, (char *) contents, hdr->sh_size, -1); 955 free (contents); 956 } 957 958 if ((flags & SEC_ALLOC) != 0) 959 { 960 Elf_Internal_Phdr *phdr; 961 unsigned int i, nload; 962 963 /* Some ELF linkers produce binaries with all the program header 964 p_paddr fields zero. If we have such a binary with more than 965 one PT_LOAD header, then leave the section lma equal to vma 966 so that we don't create sections with overlapping lma. */ 967 phdr = elf_tdata (abfd)->phdr; 968 for (nload = 0, i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++) 969 if (phdr->p_paddr != 0) 970 break; 971 else if (phdr->p_type == PT_LOAD && phdr->p_memsz != 0) 972 ++nload; 973 if (i >= elf_elfheader (abfd)->e_phnum && nload > 1) 974 return TRUE; 975 976 phdr = elf_tdata (abfd)->phdr; 977 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++) 978 { 979 if (((phdr->p_type == PT_LOAD 980 && (hdr->sh_flags & SHF_TLS) == 0) 981 || phdr->p_type == PT_TLS) 982 && ELF_SECTION_IN_SEGMENT (hdr, phdr)) 983 { 984 if ((flags & SEC_LOAD) == 0) 985 newsect->lma = (phdr->p_paddr 986 + hdr->sh_addr - phdr->p_vaddr); 987 else 988 /* We used to use the same adjustment for SEC_LOAD 989 sections, but that doesn't work if the segment 990 is packed with code from multiple VMAs. 991 Instead we calculate the section LMA based on 992 the segment LMA. It is assumed that the 993 segment will contain sections with contiguous 994 LMAs, even if the VMAs are not. */ 995 newsect->lma = (phdr->p_paddr 996 + hdr->sh_offset - phdr->p_offset); 997 998 /* With contiguous segments, we can't tell from file 999 offsets whether a section with zero size should 1000 be placed at the end of one segment or the 1001 beginning of the next. Decide based on vaddr. */ 1002 if (hdr->sh_addr >= phdr->p_vaddr 1003 && (hdr->sh_addr + hdr->sh_size 1004 <= phdr->p_vaddr + phdr->p_memsz)) 1005 break; 1006 } 1007 } 1008 } 1009 1010 /* Compress/decompress DWARF debug sections with names: .debug_* and 1011 .zdebug_*, after the section flags is set. */ 1012 if ((flags & SEC_DEBUGGING) 1013 && ((name[1] == 'd' && name[6] == '_') 1014 || (name[1] == 'z' && name[7] == '_'))) 1015 { 1016 enum { nothing, compress, decompress } action = nothing; 1017 char *new_name; 1018 1019 if (bfd_is_section_compressed (abfd, newsect)) 1020 { 1021 /* Compressed section. Check if we should decompress. */ 1022 if ((abfd->flags & BFD_DECOMPRESS)) 1023 action = decompress; 1024 } 1025 else 1026 { 1027 /* Normal section. Check if we should compress. */ 1028 if ((abfd->flags & BFD_COMPRESS)) 1029 action = compress; 1030 } 1031 1032 new_name = NULL; 1033 switch (action) 1034 { 1035 case nothing: 1036 break; 1037 case compress: 1038 if (!bfd_init_section_compress_status (abfd, newsect)) 1039 { 1040 (*_bfd_error_handler) 1041 (_("%B: unable to initialize commpress status for section %s"), 1042 abfd, name); 1043 return FALSE; 1044 } 1045 if (name[1] != 'z') 1046 { 1047 unsigned int len = strlen (name); 1048 1049 new_name = bfd_alloc (abfd, len + 2); 1050 if (new_name == NULL) 1051 return FALSE; 1052 new_name[0] = '.'; 1053 new_name[1] = 'z'; 1054 memcpy (new_name + 2, name + 1, len); 1055 } 1056 break; 1057 case decompress: 1058 if (!bfd_init_section_decompress_status (abfd, newsect)) 1059 { 1060 (*_bfd_error_handler) 1061 (_("%B: unable to initialize decommpress status for section %s"), 1062 abfd, name); 1063 return FALSE; 1064 } 1065 if (name[1] == 'z') 1066 { 1067 unsigned int len = strlen (name); 1068 1069 new_name = bfd_alloc (abfd, len); 1070 if (new_name == NULL) 1071 return FALSE; 1072 new_name[0] = '.'; 1073 memcpy (new_name + 1, name + 2, len - 1); 1074 } 1075 break; 1076 } 1077 if (new_name != NULL) 1078 bfd_rename_section (abfd, newsect, new_name); 1079 } 1080 1081 return TRUE; 1082 } 1083 1084 const char *const bfd_elf_section_type_names[] = { 1085 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB", 1086 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE", 1087 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM", 1088 }; 1089 1090 /* ELF relocs are against symbols. If we are producing relocatable 1091 output, and the reloc is against an external symbol, and nothing 1092 has given us any additional addend, the resulting reloc will also 1093 be against the same symbol. In such a case, we don't want to 1094 change anything about the way the reloc is handled, since it will 1095 all be done at final link time. Rather than put special case code 1096 into bfd_perform_relocation, all the reloc types use this howto 1097 function. It just short circuits the reloc if producing 1098 relocatable output against an external symbol. */ 1099 1100 bfd_reloc_status_type 1101 bfd_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED, 1102 arelent *reloc_entry, 1103 asymbol *symbol, 1104 void *data ATTRIBUTE_UNUSED, 1105 asection *input_section, 1106 bfd *output_bfd, 1107 char **error_message ATTRIBUTE_UNUSED) 1108 { 1109 if (output_bfd != NULL 1110 && (symbol->flags & BSF_SECTION_SYM) == 0 1111 && (! reloc_entry->howto->partial_inplace 1112 || reloc_entry->addend == 0)) 1113 { 1114 reloc_entry->address += input_section->output_offset; 1115 return bfd_reloc_ok; 1116 } 1117 1118 return bfd_reloc_continue; 1119 } 1120 1121 /* Copy the program header and other data from one object module to 1122 another. */ 1123 1124 bfd_boolean 1125 _bfd_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd) 1126 { 1127 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 1128 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 1129 return TRUE; 1130 1131 BFD_ASSERT (!elf_flags_init (obfd) 1132 || (elf_elfheader (obfd)->e_flags 1133 == elf_elfheader (ibfd)->e_flags)); 1134 1135 elf_gp (obfd) = elf_gp (ibfd); 1136 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags; 1137 elf_flags_init (obfd) = TRUE; 1138 1139 /* Copy object attributes. */ 1140 _bfd_elf_copy_obj_attributes (ibfd, obfd); 1141 return TRUE; 1142 } 1143 1144 static const char * 1145 get_segment_type (unsigned int p_type) 1146 { 1147 const char *pt; 1148 switch (p_type) 1149 { 1150 case PT_NULL: pt = "NULL"; break; 1151 case PT_LOAD: pt = "LOAD"; break; 1152 case PT_DYNAMIC: pt = "DYNAMIC"; break; 1153 case PT_INTERP: pt = "INTERP"; break; 1154 case PT_NOTE: pt = "NOTE"; break; 1155 case PT_SHLIB: pt = "SHLIB"; break; 1156 case PT_PHDR: pt = "PHDR"; break; 1157 case PT_TLS: pt = "TLS"; break; 1158 case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break; 1159 case PT_GNU_STACK: pt = "STACK"; break; 1160 case PT_GNU_RELRO: pt = "RELRO"; break; 1161 default: pt = NULL; break; 1162 } 1163 return pt; 1164 } 1165 1166 /* Print out the program headers. */ 1167 1168 bfd_boolean 1169 _bfd_elf_print_private_bfd_data (bfd *abfd, void *farg) 1170 { 1171 FILE *f = (FILE *) farg; 1172 Elf_Internal_Phdr *p; 1173 asection *s; 1174 bfd_byte *dynbuf = NULL; 1175 1176 p = elf_tdata (abfd)->phdr; 1177 if (p != NULL) 1178 { 1179 unsigned int i, c; 1180 1181 fprintf (f, _("\nProgram Header:\n")); 1182 c = elf_elfheader (abfd)->e_phnum; 1183 for (i = 0; i < c; i++, p++) 1184 { 1185 const char *pt = get_segment_type (p->p_type); 1186 char buf[20]; 1187 1188 if (pt == NULL) 1189 { 1190 sprintf (buf, "0x%lx", p->p_type); 1191 pt = buf; 1192 } 1193 fprintf (f, "%8s off 0x", pt); 1194 bfd_fprintf_vma (abfd, f, p->p_offset); 1195 fprintf (f, " vaddr 0x"); 1196 bfd_fprintf_vma (abfd, f, p->p_vaddr); 1197 fprintf (f, " paddr 0x"); 1198 bfd_fprintf_vma (abfd, f, p->p_paddr); 1199 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align)); 1200 fprintf (f, " filesz 0x"); 1201 bfd_fprintf_vma (abfd, f, p->p_filesz); 1202 fprintf (f, " memsz 0x"); 1203 bfd_fprintf_vma (abfd, f, p->p_memsz); 1204 fprintf (f, " flags %c%c%c", 1205 (p->p_flags & PF_R) != 0 ? 'r' : '-', 1206 (p->p_flags & PF_W) != 0 ? 'w' : '-', 1207 (p->p_flags & PF_X) != 0 ? 'x' : '-'); 1208 if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0) 1209 fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)); 1210 fprintf (f, "\n"); 1211 } 1212 } 1213 1214 s = bfd_get_section_by_name (abfd, ".dynamic"); 1215 if (s != NULL) 1216 { 1217 unsigned int elfsec; 1218 unsigned long shlink; 1219 bfd_byte *extdyn, *extdynend; 1220 size_t extdynsize; 1221 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *); 1222 1223 fprintf (f, _("\nDynamic Section:\n")); 1224 1225 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf)) 1226 goto error_return; 1227 1228 elfsec = _bfd_elf_section_from_bfd_section (abfd, s); 1229 if (elfsec == SHN_BAD) 1230 goto error_return; 1231 shlink = elf_elfsections (abfd)[elfsec]->sh_link; 1232 1233 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn; 1234 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in; 1235 1236 extdyn = dynbuf; 1237 extdynend = extdyn + s->size; 1238 for (; extdyn < extdynend; extdyn += extdynsize) 1239 { 1240 Elf_Internal_Dyn dyn; 1241 const char *name = ""; 1242 char ab[20]; 1243 bfd_boolean stringp; 1244 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 1245 1246 (*swap_dyn_in) (abfd, extdyn, &dyn); 1247 1248 if (dyn.d_tag == DT_NULL) 1249 break; 1250 1251 stringp = FALSE; 1252 switch (dyn.d_tag) 1253 { 1254 default: 1255 if (bed->elf_backend_get_target_dtag) 1256 name = (*bed->elf_backend_get_target_dtag) (dyn.d_tag); 1257 1258 if (!strcmp (name, "")) 1259 { 1260 sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag); 1261 name = ab; 1262 } 1263 break; 1264 1265 case DT_NEEDED: name = "NEEDED"; stringp = TRUE; break; 1266 case DT_PLTRELSZ: name = "PLTRELSZ"; break; 1267 case DT_PLTGOT: name = "PLTGOT"; break; 1268 case DT_HASH: name = "HASH"; break; 1269 case DT_STRTAB: name = "STRTAB"; break; 1270 case DT_SYMTAB: name = "SYMTAB"; break; 1271 case DT_RELA: name = "RELA"; break; 1272 case DT_RELASZ: name = "RELASZ"; break; 1273 case DT_RELAENT: name = "RELAENT"; break; 1274 case DT_STRSZ: name = "STRSZ"; break; 1275 case DT_SYMENT: name = "SYMENT"; break; 1276 case DT_INIT: name = "INIT"; break; 1277 case DT_FINI: name = "FINI"; break; 1278 case DT_SONAME: name = "SONAME"; stringp = TRUE; break; 1279 case DT_RPATH: name = "RPATH"; stringp = TRUE; break; 1280 case DT_SYMBOLIC: name = "SYMBOLIC"; break; 1281 case DT_REL: name = "REL"; break; 1282 case DT_RELSZ: name = "RELSZ"; break; 1283 case DT_RELENT: name = "RELENT"; break; 1284 case DT_PLTREL: name = "PLTREL"; break; 1285 case DT_DEBUG: name = "DEBUG"; break; 1286 case DT_TEXTREL: name = "TEXTREL"; break; 1287 case DT_JMPREL: name = "JMPREL"; break; 1288 case DT_BIND_NOW: name = "BIND_NOW"; break; 1289 case DT_INIT_ARRAY: name = "INIT_ARRAY"; break; 1290 case DT_FINI_ARRAY: name = "FINI_ARRAY"; break; 1291 case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break; 1292 case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break; 1293 case DT_RUNPATH: name = "RUNPATH"; stringp = TRUE; break; 1294 case DT_FLAGS: name = "FLAGS"; break; 1295 case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break; 1296 case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break; 1297 case DT_CHECKSUM: name = "CHECKSUM"; break; 1298 case DT_PLTPADSZ: name = "PLTPADSZ"; break; 1299 case DT_MOVEENT: name = "MOVEENT"; break; 1300 case DT_MOVESZ: name = "MOVESZ"; break; 1301 case DT_FEATURE: name = "FEATURE"; break; 1302 case DT_POSFLAG_1: name = "POSFLAG_1"; break; 1303 case DT_SYMINSZ: name = "SYMINSZ"; break; 1304 case DT_SYMINENT: name = "SYMINENT"; break; 1305 case DT_CONFIG: name = "CONFIG"; stringp = TRUE; break; 1306 case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = TRUE; break; 1307 case DT_AUDIT: name = "AUDIT"; stringp = TRUE; break; 1308 case DT_PLTPAD: name = "PLTPAD"; break; 1309 case DT_MOVETAB: name = "MOVETAB"; break; 1310 case DT_SYMINFO: name = "SYMINFO"; break; 1311 case DT_RELACOUNT: name = "RELACOUNT"; break; 1312 case DT_RELCOUNT: name = "RELCOUNT"; break; 1313 case DT_FLAGS_1: name = "FLAGS_1"; break; 1314 case DT_VERSYM: name = "VERSYM"; break; 1315 case DT_VERDEF: name = "VERDEF"; break; 1316 case DT_VERDEFNUM: name = "VERDEFNUM"; break; 1317 case DT_VERNEED: name = "VERNEED"; break; 1318 case DT_VERNEEDNUM: name = "VERNEEDNUM"; break; 1319 case DT_AUXILIARY: name = "AUXILIARY"; stringp = TRUE; break; 1320 case DT_USED: name = "USED"; break; 1321 case DT_FILTER: name = "FILTER"; stringp = TRUE; break; 1322 case DT_GNU_HASH: name = "GNU_HASH"; break; 1323 } 1324 1325 fprintf (f, " %-20s ", name); 1326 if (! stringp) 1327 { 1328 fprintf (f, "0x"); 1329 bfd_fprintf_vma (abfd, f, dyn.d_un.d_val); 1330 } 1331 else 1332 { 1333 const char *string; 1334 unsigned int tagv = dyn.d_un.d_val; 1335 1336 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv); 1337 if (string == NULL) 1338 goto error_return; 1339 fprintf (f, "%s", string); 1340 } 1341 fprintf (f, "\n"); 1342 } 1343 1344 free (dynbuf); 1345 dynbuf = NULL; 1346 } 1347 1348 if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL) 1349 || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL)) 1350 { 1351 if (! _bfd_elf_slurp_version_tables (abfd, FALSE)) 1352 return FALSE; 1353 } 1354 1355 if (elf_dynverdef (abfd) != 0) 1356 { 1357 Elf_Internal_Verdef *t; 1358 1359 fprintf (f, _("\nVersion definitions:\n")); 1360 for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef) 1361 { 1362 fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx, 1363 t->vd_flags, t->vd_hash, 1364 t->vd_nodename ? t->vd_nodename : "<corrupt>"); 1365 if (t->vd_auxptr != NULL && t->vd_auxptr->vda_nextptr != NULL) 1366 { 1367 Elf_Internal_Verdaux *a; 1368 1369 fprintf (f, "\t"); 1370 for (a = t->vd_auxptr->vda_nextptr; 1371 a != NULL; 1372 a = a->vda_nextptr) 1373 fprintf (f, "%s ", 1374 a->vda_nodename ? a->vda_nodename : "<corrupt>"); 1375 fprintf (f, "\n"); 1376 } 1377 } 1378 } 1379 1380 if (elf_dynverref (abfd) != 0) 1381 { 1382 Elf_Internal_Verneed *t; 1383 1384 fprintf (f, _("\nVersion References:\n")); 1385 for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref) 1386 { 1387 Elf_Internal_Vernaux *a; 1388 1389 fprintf (f, _(" required from %s:\n"), 1390 t->vn_filename ? t->vn_filename : "<corrupt>"); 1391 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr) 1392 fprintf (f, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash, 1393 a->vna_flags, a->vna_other, 1394 a->vna_nodename ? a->vna_nodename : "<corrupt>"); 1395 } 1396 } 1397 1398 return TRUE; 1399 1400 error_return: 1401 if (dynbuf != NULL) 1402 free (dynbuf); 1403 return FALSE; 1404 } 1405 1406 /* Display ELF-specific fields of a symbol. */ 1407 1408 void 1409 bfd_elf_print_symbol (bfd *abfd, 1410 void *filep, 1411 asymbol *symbol, 1412 bfd_print_symbol_type how) 1413 { 1414 FILE *file = (FILE *) filep; 1415 switch (how) 1416 { 1417 case bfd_print_symbol_name: 1418 fprintf (file, "%s", symbol->name); 1419 break; 1420 case bfd_print_symbol_more: 1421 fprintf (file, "elf "); 1422 bfd_fprintf_vma (abfd, file, symbol->value); 1423 fprintf (file, " %lx", (unsigned long) symbol->flags); 1424 break; 1425 case bfd_print_symbol_all: 1426 { 1427 const char *section_name; 1428 const char *name = NULL; 1429 const struct elf_backend_data *bed; 1430 unsigned char st_other; 1431 bfd_vma val; 1432 1433 section_name = symbol->section ? symbol->section->name : "(*none*)"; 1434 1435 bed = get_elf_backend_data (abfd); 1436 if (bed->elf_backend_print_symbol_all) 1437 name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol); 1438 1439 if (name == NULL) 1440 { 1441 name = symbol->name; 1442 bfd_print_symbol_vandf (abfd, file, symbol); 1443 } 1444 1445 fprintf (file, " %s\t", section_name); 1446 /* Print the "other" value for a symbol. For common symbols, 1447 we've already printed the size; now print the alignment. 1448 For other symbols, we have no specified alignment, and 1449 we've printed the address; now print the size. */ 1450 if (symbol->section && bfd_is_com_section (symbol->section)) 1451 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value; 1452 else 1453 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size; 1454 bfd_fprintf_vma (abfd, file, val); 1455 1456 /* If we have version information, print it. */ 1457 if (elf_tdata (abfd)->dynversym_section != 0 1458 && (elf_tdata (abfd)->dynverdef_section != 0 1459 || elf_tdata (abfd)->dynverref_section != 0)) 1460 { 1461 unsigned int vernum; 1462 const char *version_string; 1463 1464 vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION; 1465 1466 if (vernum == 0) 1467 version_string = ""; 1468 else if (vernum == 1) 1469 version_string = "Base"; 1470 else if (vernum <= elf_tdata (abfd)->cverdefs) 1471 version_string = 1472 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename; 1473 else 1474 { 1475 Elf_Internal_Verneed *t; 1476 1477 version_string = ""; 1478 for (t = elf_tdata (abfd)->verref; 1479 t != NULL; 1480 t = t->vn_nextref) 1481 { 1482 Elf_Internal_Vernaux *a; 1483 1484 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr) 1485 { 1486 if (a->vna_other == vernum) 1487 { 1488 version_string = a->vna_nodename; 1489 break; 1490 } 1491 } 1492 } 1493 } 1494 1495 if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0) 1496 fprintf (file, " %-11s", version_string); 1497 else 1498 { 1499 int i; 1500 1501 fprintf (file, " (%s)", version_string); 1502 for (i = 10 - strlen (version_string); i > 0; --i) 1503 putc (' ', file); 1504 } 1505 } 1506 1507 /* If the st_other field is not zero, print it. */ 1508 st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other; 1509 1510 switch (st_other) 1511 { 1512 case 0: break; 1513 case STV_INTERNAL: fprintf (file, " .internal"); break; 1514 case STV_HIDDEN: fprintf (file, " .hidden"); break; 1515 case STV_PROTECTED: fprintf (file, " .protected"); break; 1516 default: 1517 /* Some other non-defined flags are also present, so print 1518 everything hex. */ 1519 fprintf (file, " 0x%02x", (unsigned int) st_other); 1520 } 1521 1522 fprintf (file, " %s", name); 1523 } 1524 break; 1525 } 1526 } 1527 1528 /* Allocate an ELF string table--force the first byte to be zero. */ 1529 1530 struct bfd_strtab_hash * 1531 _bfd_elf_stringtab_init (void) 1532 { 1533 struct bfd_strtab_hash *ret; 1534 1535 ret = _bfd_stringtab_init (); 1536 if (ret != NULL) 1537 { 1538 bfd_size_type loc; 1539 1540 loc = _bfd_stringtab_add (ret, "", TRUE, FALSE); 1541 BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1); 1542 if (loc == (bfd_size_type) -1) 1543 { 1544 _bfd_stringtab_free (ret); 1545 ret = NULL; 1546 } 1547 } 1548 return ret; 1549 } 1550 1551 /* ELF .o/exec file reading */ 1552 1553 /* Create a new bfd section from an ELF section header. */ 1554 1555 bfd_boolean 1556 bfd_section_from_shdr (bfd *abfd, unsigned int shindex) 1557 { 1558 Elf_Internal_Shdr *hdr; 1559 Elf_Internal_Ehdr *ehdr; 1560 const struct elf_backend_data *bed; 1561 const char *name; 1562 1563 if (shindex >= elf_numsections (abfd)) 1564 return FALSE; 1565 1566 hdr = elf_elfsections (abfd)[shindex]; 1567 ehdr = elf_elfheader (abfd); 1568 name = bfd_elf_string_from_elf_section (abfd, ehdr->e_shstrndx, 1569 hdr->sh_name); 1570 if (name == NULL) 1571 return FALSE; 1572 1573 bed = get_elf_backend_data (abfd); 1574 switch (hdr->sh_type) 1575 { 1576 case SHT_NULL: 1577 /* Inactive section. Throw it away. */ 1578 return TRUE; 1579 1580 case SHT_PROGBITS: /* Normal section with contents. */ 1581 case SHT_NOBITS: /* .bss section. */ 1582 case SHT_HASH: /* .hash section. */ 1583 case SHT_NOTE: /* .note section. */ 1584 case SHT_INIT_ARRAY: /* .init_array section. */ 1585 case SHT_FINI_ARRAY: /* .fini_array section. */ 1586 case SHT_PREINIT_ARRAY: /* .preinit_array section. */ 1587 case SHT_GNU_LIBLIST: /* .gnu.liblist section. */ 1588 case SHT_GNU_HASH: /* .gnu.hash section. */ 1589 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex); 1590 1591 case SHT_DYNAMIC: /* Dynamic linking information. */ 1592 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex)) 1593 return FALSE; 1594 if (hdr->sh_link > elf_numsections (abfd)) 1595 { 1596 /* PR 10478: Accept Solaris binaries with a sh_link 1597 field set to SHN_BEFORE or SHN_AFTER. */ 1598 switch (bfd_get_arch (abfd)) 1599 { 1600 case bfd_arch_i386: 1601 case bfd_arch_sparc: 1602 if (hdr->sh_link == (SHN_LORESERVE & 0xffff) /* SHN_BEFORE */ 1603 || hdr->sh_link == ((SHN_LORESERVE + 1) & 0xffff) /* SHN_AFTER */) 1604 break; 1605 /* Otherwise fall through. */ 1606 default: 1607 return FALSE; 1608 } 1609 } 1610 else if (elf_elfsections (abfd)[hdr->sh_link] == NULL) 1611 return FALSE; 1612 else if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_STRTAB) 1613 { 1614 Elf_Internal_Shdr *dynsymhdr; 1615 1616 /* The shared libraries distributed with hpux11 have a bogus 1617 sh_link field for the ".dynamic" section. Find the 1618 string table for the ".dynsym" section instead. */ 1619 if (elf_dynsymtab (abfd) != 0) 1620 { 1621 dynsymhdr = elf_elfsections (abfd)[elf_dynsymtab (abfd)]; 1622 hdr->sh_link = dynsymhdr->sh_link; 1623 } 1624 else 1625 { 1626 unsigned int i, num_sec; 1627 1628 num_sec = elf_numsections (abfd); 1629 for (i = 1; i < num_sec; i++) 1630 { 1631 dynsymhdr = elf_elfsections (abfd)[i]; 1632 if (dynsymhdr->sh_type == SHT_DYNSYM) 1633 { 1634 hdr->sh_link = dynsymhdr->sh_link; 1635 break; 1636 } 1637 } 1638 } 1639 } 1640 break; 1641 1642 case SHT_SYMTAB: /* A symbol table */ 1643 if (elf_onesymtab (abfd) == shindex) 1644 return TRUE; 1645 1646 if (hdr->sh_entsize != bed->s->sizeof_sym) 1647 return FALSE; 1648 if (hdr->sh_info * hdr->sh_entsize > hdr->sh_size) 1649 return FALSE; 1650 BFD_ASSERT (elf_onesymtab (abfd) == 0); 1651 elf_onesymtab (abfd) = shindex; 1652 elf_tdata (abfd)->symtab_hdr = *hdr; 1653 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr; 1654 abfd->flags |= HAS_SYMS; 1655 1656 /* Sometimes a shared object will map in the symbol table. If 1657 SHF_ALLOC is set, and this is a shared object, then we also 1658 treat this section as a BFD section. We can not base the 1659 decision purely on SHF_ALLOC, because that flag is sometimes 1660 set in a relocatable object file, which would confuse the 1661 linker. */ 1662 if ((hdr->sh_flags & SHF_ALLOC) != 0 1663 && (abfd->flags & DYNAMIC) != 0 1664 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name, 1665 shindex)) 1666 return FALSE; 1667 1668 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we 1669 can't read symbols without that section loaded as well. It 1670 is most likely specified by the next section header. */ 1671 if (elf_elfsections (abfd)[elf_symtab_shndx (abfd)]->sh_link != shindex) 1672 { 1673 unsigned int i, num_sec; 1674 1675 num_sec = elf_numsections (abfd); 1676 for (i = shindex + 1; i < num_sec; i++) 1677 { 1678 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i]; 1679 if (hdr2->sh_type == SHT_SYMTAB_SHNDX 1680 && hdr2->sh_link == shindex) 1681 break; 1682 } 1683 if (i == num_sec) 1684 for (i = 1; i < shindex; i++) 1685 { 1686 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i]; 1687 if (hdr2->sh_type == SHT_SYMTAB_SHNDX 1688 && hdr2->sh_link == shindex) 1689 break; 1690 } 1691 if (i != shindex) 1692 return bfd_section_from_shdr (abfd, i); 1693 } 1694 return TRUE; 1695 1696 case SHT_DYNSYM: /* A dynamic symbol table */ 1697 if (elf_dynsymtab (abfd) == shindex) 1698 return TRUE; 1699 1700 if (hdr->sh_entsize != bed->s->sizeof_sym) 1701 return FALSE; 1702 BFD_ASSERT (elf_dynsymtab (abfd) == 0); 1703 elf_dynsymtab (abfd) = shindex; 1704 elf_tdata (abfd)->dynsymtab_hdr = *hdr; 1705 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr; 1706 abfd->flags |= HAS_SYMS; 1707 1708 /* Besides being a symbol table, we also treat this as a regular 1709 section, so that objcopy can handle it. */ 1710 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex); 1711 1712 case SHT_SYMTAB_SHNDX: /* Symbol section indices when >64k sections */ 1713 if (elf_symtab_shndx (abfd) == shindex) 1714 return TRUE; 1715 1716 BFD_ASSERT (elf_symtab_shndx (abfd) == 0); 1717 elf_symtab_shndx (abfd) = shindex; 1718 elf_tdata (abfd)->symtab_shndx_hdr = *hdr; 1719 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->symtab_shndx_hdr; 1720 return TRUE; 1721 1722 case SHT_STRTAB: /* A string table */ 1723 if (hdr->bfd_section != NULL) 1724 return TRUE; 1725 if (ehdr->e_shstrndx == shindex) 1726 { 1727 elf_tdata (abfd)->shstrtab_hdr = *hdr; 1728 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr; 1729 return TRUE; 1730 } 1731 if (elf_elfsections (abfd)[elf_onesymtab (abfd)]->sh_link == shindex) 1732 { 1733 symtab_strtab: 1734 elf_tdata (abfd)->strtab_hdr = *hdr; 1735 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->strtab_hdr; 1736 return TRUE; 1737 } 1738 if (elf_elfsections (abfd)[elf_dynsymtab (abfd)]->sh_link == shindex) 1739 { 1740 dynsymtab_strtab: 1741 elf_tdata (abfd)->dynstrtab_hdr = *hdr; 1742 hdr = &elf_tdata (abfd)->dynstrtab_hdr; 1743 elf_elfsections (abfd)[shindex] = hdr; 1744 /* We also treat this as a regular section, so that objcopy 1745 can handle it. */ 1746 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, 1747 shindex); 1748 } 1749 1750 /* If the string table isn't one of the above, then treat it as a 1751 regular section. We need to scan all the headers to be sure, 1752 just in case this strtab section appeared before the above. */ 1753 if (elf_onesymtab (abfd) == 0 || elf_dynsymtab (abfd) == 0) 1754 { 1755 unsigned int i, num_sec; 1756 1757 num_sec = elf_numsections (abfd); 1758 for (i = 1; i < num_sec; i++) 1759 { 1760 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i]; 1761 if (hdr2->sh_link == shindex) 1762 { 1763 /* Prevent endless recursion on broken objects. */ 1764 if (i == shindex) 1765 return FALSE; 1766 if (! bfd_section_from_shdr (abfd, i)) 1767 return FALSE; 1768 if (elf_onesymtab (abfd) == i) 1769 goto symtab_strtab; 1770 if (elf_dynsymtab (abfd) == i) 1771 goto dynsymtab_strtab; 1772 } 1773 } 1774 } 1775 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex); 1776 1777 case SHT_REL: 1778 case SHT_RELA: 1779 /* *These* do a lot of work -- but build no sections! */ 1780 { 1781 asection *target_sect; 1782 Elf_Internal_Shdr *hdr2, **p_hdr; 1783 unsigned int num_sec = elf_numsections (abfd); 1784 struct bfd_elf_section_data *esdt; 1785 bfd_size_type amt; 1786 1787 if (hdr->sh_entsize 1788 != (bfd_size_type) (hdr->sh_type == SHT_REL 1789 ? bed->s->sizeof_rel : bed->s->sizeof_rela)) 1790 return FALSE; 1791 1792 /* Check for a bogus link to avoid crashing. */ 1793 if (hdr->sh_link >= num_sec) 1794 { 1795 ((*_bfd_error_handler) 1796 (_("%B: invalid link %lu for reloc section %s (index %u)"), 1797 abfd, hdr->sh_link, name, shindex)); 1798 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, 1799 shindex); 1800 } 1801 1802 /* For some incomprehensible reason Oracle distributes 1803 libraries for Solaris in which some of the objects have 1804 bogus sh_link fields. It would be nice if we could just 1805 reject them, but, unfortunately, some people need to use 1806 them. We scan through the section headers; if we find only 1807 one suitable symbol table, we clobber the sh_link to point 1808 to it. I hope this doesn't break anything. 1809 1810 Don't do it on executable nor shared library. */ 1811 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0 1812 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB 1813 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM) 1814 { 1815 unsigned int scan; 1816 int found; 1817 1818 found = 0; 1819 for (scan = 1; scan < num_sec; scan++) 1820 { 1821 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB 1822 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM) 1823 { 1824 if (found != 0) 1825 { 1826 found = 0; 1827 break; 1828 } 1829 found = scan; 1830 } 1831 } 1832 if (found != 0) 1833 hdr->sh_link = found; 1834 } 1835 1836 /* Get the symbol table. */ 1837 if ((elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB 1838 || elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_DYNSYM) 1839 && ! bfd_section_from_shdr (abfd, hdr->sh_link)) 1840 return FALSE; 1841 1842 /* If this reloc section does not use the main symbol table we 1843 don't treat it as a reloc section. BFD can't adequately 1844 represent such a section, so at least for now, we don't 1845 try. We just present it as a normal section. We also 1846 can't use it as a reloc section if it points to the null 1847 section, an invalid section, another reloc section, or its 1848 sh_link points to the null section. */ 1849 if (hdr->sh_link != elf_onesymtab (abfd) 1850 || hdr->sh_link == SHN_UNDEF 1851 || hdr->sh_info == SHN_UNDEF 1852 || hdr->sh_info >= num_sec 1853 || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_REL 1854 || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_RELA) 1855 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, 1856 shindex); 1857 1858 if (! bfd_section_from_shdr (abfd, hdr->sh_info)) 1859 return FALSE; 1860 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info); 1861 if (target_sect == NULL) 1862 return FALSE; 1863 1864 esdt = elf_section_data (target_sect); 1865 if (hdr->sh_type == SHT_RELA) 1866 p_hdr = &esdt->rela.hdr; 1867 else 1868 p_hdr = &esdt->rel.hdr; 1869 1870 BFD_ASSERT (*p_hdr == NULL); 1871 amt = sizeof (*hdr2); 1872 hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt); 1873 if (hdr2 == NULL) 1874 return FALSE; 1875 *hdr2 = *hdr; 1876 *p_hdr = hdr2; 1877 elf_elfsections (abfd)[shindex] = hdr2; 1878 target_sect->reloc_count += NUM_SHDR_ENTRIES (hdr); 1879 target_sect->flags |= SEC_RELOC; 1880 target_sect->relocation = NULL; 1881 target_sect->rel_filepos = hdr->sh_offset; 1882 /* In the section to which the relocations apply, mark whether 1883 its relocations are of the REL or RELA variety. */ 1884 if (hdr->sh_size != 0) 1885 { 1886 if (hdr->sh_type == SHT_RELA) 1887 target_sect->use_rela_p = 1; 1888 } 1889 abfd->flags |= HAS_RELOC; 1890 return TRUE; 1891 } 1892 1893 case SHT_GNU_verdef: 1894 elf_dynverdef (abfd) = shindex; 1895 elf_tdata (abfd)->dynverdef_hdr = *hdr; 1896 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex); 1897 1898 case SHT_GNU_versym: 1899 if (hdr->sh_entsize != sizeof (Elf_External_Versym)) 1900 return FALSE; 1901 elf_dynversym (abfd) = shindex; 1902 elf_tdata (abfd)->dynversym_hdr = *hdr; 1903 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex); 1904 1905 case SHT_GNU_verneed: 1906 elf_dynverref (abfd) = shindex; 1907 elf_tdata (abfd)->dynverref_hdr = *hdr; 1908 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex); 1909 1910 case SHT_SHLIB: 1911 return TRUE; 1912 1913 case SHT_GROUP: 1914 if (! IS_VALID_GROUP_SECTION_HEADER (hdr)) 1915 return FALSE; 1916 if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex)) 1917 return FALSE; 1918 if (hdr->contents != NULL) 1919 { 1920 Elf_Internal_Group *idx = (Elf_Internal_Group *) hdr->contents; 1921 unsigned int n_elt = hdr->sh_size / GRP_ENTRY_SIZE; 1922 asection *s; 1923 1924 if (idx->flags & GRP_COMDAT) 1925 hdr->bfd_section->flags 1926 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD; 1927 1928 /* We try to keep the same section order as it comes in. */ 1929 idx += n_elt; 1930 while (--n_elt != 0) 1931 { 1932 --idx; 1933 1934 if (idx->shdr != NULL 1935 && (s = idx->shdr->bfd_section) != NULL 1936 && elf_next_in_group (s) != NULL) 1937 { 1938 elf_next_in_group (hdr->bfd_section) = s; 1939 break; 1940 } 1941 } 1942 } 1943 break; 1944 1945 default: 1946 /* Possibly an attributes section. */ 1947 if (hdr->sh_type == SHT_GNU_ATTRIBUTES 1948 || hdr->sh_type == bed->obj_attrs_section_type) 1949 { 1950 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex)) 1951 return FALSE; 1952 _bfd_elf_parse_attributes (abfd, hdr); 1953 return TRUE; 1954 } 1955 1956 /* Check for any processor-specific section types. */ 1957 if (bed->elf_backend_section_from_shdr (abfd, hdr, name, shindex)) 1958 return TRUE; 1959 1960 if (hdr->sh_type >= SHT_LOUSER && hdr->sh_type <= SHT_HIUSER) 1961 { 1962 if ((hdr->sh_flags & SHF_ALLOC) != 0) 1963 /* FIXME: How to properly handle allocated section reserved 1964 for applications? */ 1965 (*_bfd_error_handler) 1966 (_("%B: don't know how to handle allocated, application " 1967 "specific section `%s' [0x%8x]"), 1968 abfd, name, hdr->sh_type); 1969 else 1970 /* Allow sections reserved for applications. */ 1971 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, 1972 shindex); 1973 } 1974 else if (hdr->sh_type >= SHT_LOPROC 1975 && hdr->sh_type <= SHT_HIPROC) 1976 /* FIXME: We should handle this section. */ 1977 (*_bfd_error_handler) 1978 (_("%B: don't know how to handle processor specific section " 1979 "`%s' [0x%8x]"), 1980 abfd, name, hdr->sh_type); 1981 else if (hdr->sh_type >= SHT_LOOS && hdr->sh_type <= SHT_HIOS) 1982 { 1983 /* Unrecognised OS-specific sections. */ 1984 if ((hdr->sh_flags & SHF_OS_NONCONFORMING) != 0) 1985 /* SHF_OS_NONCONFORMING indicates that special knowledge is 1986 required to correctly process the section and the file should 1987 be rejected with an error message. */ 1988 (*_bfd_error_handler) 1989 (_("%B: don't know how to handle OS specific section " 1990 "`%s' [0x%8x]"), 1991 abfd, name, hdr->sh_type); 1992 else 1993 /* Otherwise it should be processed. */ 1994 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex); 1995 } 1996 else 1997 /* FIXME: We should handle this section. */ 1998 (*_bfd_error_handler) 1999 (_("%B: don't know how to handle section `%s' [0x%8x]"), 2000 abfd, name, hdr->sh_type); 2001 2002 return FALSE; 2003 } 2004 2005 return TRUE; 2006 } 2007 2008 /* Return the local symbol specified by ABFD, R_SYMNDX. */ 2009 2010 Elf_Internal_Sym * 2011 bfd_sym_from_r_symndx (struct sym_cache *cache, 2012 bfd *abfd, 2013 unsigned long r_symndx) 2014 { 2015 unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE; 2016 2017 if (cache->abfd != abfd || cache->indx[ent] != r_symndx) 2018 { 2019 Elf_Internal_Shdr *symtab_hdr; 2020 unsigned char esym[sizeof (Elf64_External_Sym)]; 2021 Elf_External_Sym_Shndx eshndx; 2022 2023 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 2024 if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx, 2025 &cache->sym[ent], esym, &eshndx) == NULL) 2026 return NULL; 2027 2028 if (cache->abfd != abfd) 2029 { 2030 memset (cache->indx, -1, sizeof (cache->indx)); 2031 cache->abfd = abfd; 2032 } 2033 cache->indx[ent] = r_symndx; 2034 } 2035 2036 return &cache->sym[ent]; 2037 } 2038 2039 /* Given an ELF section number, retrieve the corresponding BFD 2040 section. */ 2041 2042 asection * 2043 bfd_section_from_elf_index (bfd *abfd, unsigned int sec_index) 2044 { 2045 if (sec_index >= elf_numsections (abfd)) 2046 return NULL; 2047 return elf_elfsections (abfd)[sec_index]->bfd_section; 2048 } 2049 2050 static const struct bfd_elf_special_section special_sections_b[] = 2051 { 2052 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE }, 2053 { NULL, 0, 0, 0, 0 } 2054 }; 2055 2056 static const struct bfd_elf_special_section special_sections_c[] = 2057 { 2058 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS, 0 }, 2059 { NULL, 0, 0, 0, 0 } 2060 }; 2061 2062 static const struct bfd_elf_special_section special_sections_d[] = 2063 { 2064 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE }, 2065 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE }, 2066 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS, 0 }, 2067 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS, 0 }, 2068 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS, 0 }, 2069 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS, 0 }, 2070 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS, 0 }, 2071 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC, SHF_ALLOC }, 2072 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB, SHF_ALLOC }, 2073 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM, SHF_ALLOC }, 2074 { NULL, 0, 0, 0, 0 } 2075 }; 2076 2077 static const struct bfd_elf_special_section special_sections_f[] = 2078 { 2079 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR }, 2080 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE }, 2081 { NULL, 0, 0, 0, 0 } 2082 }; 2083 2084 static const struct bfd_elf_special_section special_sections_g[] = 2085 { 2086 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE }, 2087 { STRING_COMMA_LEN (".gnu.lto_"), -1, SHT_PROGBITS, SHF_EXCLUDE }, 2088 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE }, 2089 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym, 0 }, 2090 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef, 0 }, 2091 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed, 0 }, 2092 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST, SHF_ALLOC }, 2093 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA, SHF_ALLOC }, 2094 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH, SHF_ALLOC }, 2095 { NULL, 0, 0, 0, 0 } 2096 }; 2097 2098 static const struct bfd_elf_special_section special_sections_h[] = 2099 { 2100 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH, SHF_ALLOC }, 2101 { NULL, 0, 0, 0, 0 } 2102 }; 2103 2104 static const struct bfd_elf_special_section special_sections_i[] = 2105 { 2106 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR }, 2107 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE }, 2108 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS, 0 }, 2109 { NULL, 0, 0, 0, 0 } 2110 }; 2111 2112 static const struct bfd_elf_special_section special_sections_l[] = 2113 { 2114 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS, 0 }, 2115 { NULL, 0, 0, 0, 0 } 2116 }; 2117 2118 static const struct bfd_elf_special_section special_sections_n[] = 2119 { 2120 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS, 0 }, 2121 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE, 0 }, 2122 { NULL, 0, 0, 0, 0 } 2123 }; 2124 2125 static const struct bfd_elf_special_section special_sections_p[] = 2126 { 2127 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE }, 2128 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR }, 2129 { NULL, 0, 0, 0, 0 } 2130 }; 2131 2132 static const struct bfd_elf_special_section special_sections_r[] = 2133 { 2134 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS, SHF_ALLOC }, 2135 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS, SHF_ALLOC }, 2136 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA, 0 }, 2137 { STRING_COMMA_LEN (".rel"), -1, SHT_REL, 0 }, 2138 { NULL, 0, 0, 0, 0 } 2139 }; 2140 2141 static const struct bfd_elf_special_section special_sections_s[] = 2142 { 2143 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB, 0 }, 2144 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB, 0 }, 2145 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB, 0 }, 2146 /* See struct bfd_elf_special_section declaration for the semantics of 2147 this special case where .prefix_length != strlen (.prefix). */ 2148 { ".stabstr", 5, 3, SHT_STRTAB, 0 }, 2149 { NULL, 0, 0, 0, 0 } 2150 }; 2151 2152 static const struct bfd_elf_special_section special_sections_t[] = 2153 { 2154 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR }, 2155 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS }, 2156 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS }, 2157 { NULL, 0, 0, 0, 0 } 2158 }; 2159 2160 static const struct bfd_elf_special_section special_sections_z[] = 2161 { 2162 { STRING_COMMA_LEN (".zdebug_line"), 0, SHT_PROGBITS, 0 }, 2163 { STRING_COMMA_LEN (".zdebug_info"), 0, SHT_PROGBITS, 0 }, 2164 { STRING_COMMA_LEN (".zdebug_abbrev"), 0, SHT_PROGBITS, 0 }, 2165 { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS, 0 }, 2166 { NULL, 0, 0, 0, 0 } 2167 }; 2168 2169 static const struct bfd_elf_special_section * const special_sections[] = 2170 { 2171 special_sections_b, /* 'b' */ 2172 special_sections_c, /* 'c' */ 2173 special_sections_d, /* 'd' */ 2174 NULL, /* 'e' */ 2175 special_sections_f, /* 'f' */ 2176 special_sections_g, /* 'g' */ 2177 special_sections_h, /* 'h' */ 2178 special_sections_i, /* 'i' */ 2179 NULL, /* 'j' */ 2180 NULL, /* 'k' */ 2181 special_sections_l, /* 'l' */ 2182 NULL, /* 'm' */ 2183 special_sections_n, /* 'n' */ 2184 NULL, /* 'o' */ 2185 special_sections_p, /* 'p' */ 2186 NULL, /* 'q' */ 2187 special_sections_r, /* 'r' */ 2188 special_sections_s, /* 's' */ 2189 special_sections_t, /* 't' */ 2190 NULL, /* 'u' */ 2191 NULL, /* 'v' */ 2192 NULL, /* 'w' */ 2193 NULL, /* 'x' */ 2194 NULL, /* 'y' */ 2195 special_sections_z /* 'z' */ 2196 }; 2197 2198 const struct bfd_elf_special_section * 2199 _bfd_elf_get_special_section (const char *name, 2200 const struct bfd_elf_special_section *spec, 2201 unsigned int rela) 2202 { 2203 int i; 2204 int len; 2205 2206 len = strlen (name); 2207 2208 for (i = 0; spec[i].prefix != NULL; i++) 2209 { 2210 int suffix_len; 2211 int prefix_len = spec[i].prefix_length; 2212 2213 if (len < prefix_len) 2214 continue; 2215 if (memcmp (name, spec[i].prefix, prefix_len) != 0) 2216 continue; 2217 2218 suffix_len = spec[i].suffix_length; 2219 if (suffix_len <= 0) 2220 { 2221 if (name[prefix_len] != 0) 2222 { 2223 if (suffix_len == 0) 2224 continue; 2225 if (name[prefix_len] != '.' 2226 && (suffix_len == -2 2227 || (rela && spec[i].type == SHT_REL))) 2228 continue; 2229 } 2230 } 2231 else 2232 { 2233 if (len < prefix_len + suffix_len) 2234 continue; 2235 if (memcmp (name + len - suffix_len, 2236 spec[i].prefix + prefix_len, 2237 suffix_len) != 0) 2238 continue; 2239 } 2240 return &spec[i]; 2241 } 2242 2243 return NULL; 2244 } 2245 2246 const struct bfd_elf_special_section * 2247 _bfd_elf_get_sec_type_attr (bfd *abfd, asection *sec) 2248 { 2249 int i; 2250 const struct bfd_elf_special_section *spec; 2251 const struct elf_backend_data *bed; 2252 2253 /* See if this is one of the special sections. */ 2254 if (sec->name == NULL) 2255 return NULL; 2256 2257 bed = get_elf_backend_data (abfd); 2258 spec = bed->special_sections; 2259 if (spec) 2260 { 2261 spec = _bfd_elf_get_special_section (sec->name, 2262 bed->special_sections, 2263 sec->use_rela_p); 2264 if (spec != NULL) 2265 return spec; 2266 } 2267 2268 if (sec->name[0] != '.') 2269 return NULL; 2270 2271 i = sec->name[1] - 'b'; 2272 if (i < 0 || i > 'z' - 'b') 2273 return NULL; 2274 2275 spec = special_sections[i]; 2276 2277 if (spec == NULL) 2278 return NULL; 2279 2280 return _bfd_elf_get_special_section (sec->name, spec, sec->use_rela_p); 2281 } 2282 2283 bfd_boolean 2284 _bfd_elf_new_section_hook (bfd *abfd, asection *sec) 2285 { 2286 struct bfd_elf_section_data *sdata; 2287 const struct elf_backend_data *bed; 2288 const struct bfd_elf_special_section *ssect; 2289 2290 sdata = (struct bfd_elf_section_data *) sec->used_by_bfd; 2291 if (sdata == NULL) 2292 { 2293 sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd, 2294 sizeof (*sdata)); 2295 if (sdata == NULL) 2296 return FALSE; 2297 sec->used_by_bfd = sdata; 2298 } 2299 2300 /* Indicate whether or not this section should use RELA relocations. */ 2301 bed = get_elf_backend_data (abfd); 2302 sec->use_rela_p = bed->default_use_rela_p; 2303 2304 /* When we read a file, we don't need to set ELF section type and 2305 flags. They will be overridden in _bfd_elf_make_section_from_shdr 2306 anyway. We will set ELF section type and flags for all linker 2307 created sections. If user specifies BFD section flags, we will 2308 set ELF section type and flags based on BFD section flags in 2309 elf_fake_sections. Special handling for .init_array/.fini_array 2310 output sections since they may contain .ctors/.dtors input 2311 sections. We don't want _bfd_elf_init_private_section_data to 2312 copy ELF section type from .ctors/.dtors input sections. */ 2313 if (abfd->direction != read_direction 2314 || (sec->flags & SEC_LINKER_CREATED) != 0) 2315 { 2316 ssect = (*bed->get_sec_type_attr) (abfd, sec); 2317 if (ssect != NULL 2318 && (!sec->flags 2319 || (sec->flags & SEC_LINKER_CREATED) != 0 2320 || ssect->type == SHT_INIT_ARRAY 2321 || ssect->type == SHT_FINI_ARRAY)) 2322 { 2323 elf_section_type (sec) = ssect->type; 2324 elf_section_flags (sec) = ssect->attr; 2325 } 2326 } 2327 2328 return _bfd_generic_new_section_hook (abfd, sec); 2329 } 2330 2331 /* Create a new bfd section from an ELF program header. 2332 2333 Since program segments have no names, we generate a synthetic name 2334 of the form segment<NUM>, where NUM is generally the index in the 2335 program header table. For segments that are split (see below) we 2336 generate the names segment<NUM>a and segment<NUM>b. 2337 2338 Note that some program segments may have a file size that is different than 2339 (less than) the memory size. All this means is that at execution the 2340 system must allocate the amount of memory specified by the memory size, 2341 but only initialize it with the first "file size" bytes read from the 2342 file. This would occur for example, with program segments consisting 2343 of combined data+bss. 2344 2345 To handle the above situation, this routine generates TWO bfd sections 2346 for the single program segment. The first has the length specified by 2347 the file size of the segment, and the second has the length specified 2348 by the difference between the two sizes. In effect, the segment is split 2349 into its initialized and uninitialized parts. 2350 2351 */ 2352 2353 bfd_boolean 2354 _bfd_elf_make_section_from_phdr (bfd *abfd, 2355 Elf_Internal_Phdr *hdr, 2356 int hdr_index, 2357 const char *type_name) 2358 { 2359 asection *newsect; 2360 char *name; 2361 char namebuf[64]; 2362 size_t len; 2363 int split; 2364 2365 split = ((hdr->p_memsz > 0) 2366 && (hdr->p_filesz > 0) 2367 && (hdr->p_memsz > hdr->p_filesz)); 2368 2369 if (hdr->p_filesz > 0) 2370 { 2371 sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "a" : ""); 2372 len = strlen (namebuf) + 1; 2373 name = (char *) bfd_alloc (abfd, len); 2374 if (!name) 2375 return FALSE; 2376 memcpy (name, namebuf, len); 2377 newsect = bfd_make_section (abfd, name); 2378 if (newsect == NULL) 2379 return FALSE; 2380 newsect->vma = hdr->p_vaddr; 2381 newsect->lma = hdr->p_paddr; 2382 newsect->size = hdr->p_filesz; 2383 newsect->filepos = hdr->p_offset; 2384 newsect->flags |= SEC_HAS_CONTENTS; 2385 newsect->alignment_power = bfd_log2 (hdr->p_align); 2386 if (hdr->p_type == PT_LOAD) 2387 { 2388 newsect->flags |= SEC_ALLOC; 2389 newsect->flags |= SEC_LOAD; 2390 if (hdr->p_flags & PF_X) 2391 { 2392 /* FIXME: all we known is that it has execute PERMISSION, 2393 may be data. */ 2394 newsect->flags |= SEC_CODE; 2395 } 2396 } 2397 if (!(hdr->p_flags & PF_W)) 2398 { 2399 newsect->flags |= SEC_READONLY; 2400 } 2401 } 2402 2403 if (hdr->p_memsz > hdr->p_filesz) 2404 { 2405 bfd_vma align; 2406 2407 sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "b" : ""); 2408 len = strlen (namebuf) + 1; 2409 name = (char *) bfd_alloc (abfd, len); 2410 if (!name) 2411 return FALSE; 2412 memcpy (name, namebuf, len); 2413 newsect = bfd_make_section (abfd, name); 2414 if (newsect == NULL) 2415 return FALSE; 2416 newsect->vma = hdr->p_vaddr + hdr->p_filesz; 2417 newsect->lma = hdr->p_paddr + hdr->p_filesz; 2418 newsect->size = hdr->p_memsz - hdr->p_filesz; 2419 newsect->filepos = hdr->p_offset + hdr->p_filesz; 2420 align = newsect->vma & -newsect->vma; 2421 if (align == 0 || align > hdr->p_align) 2422 align = hdr->p_align; 2423 newsect->alignment_power = bfd_log2 (align); 2424 if (hdr->p_type == PT_LOAD) 2425 { 2426 /* Hack for gdb. Segments that have not been modified do 2427 not have their contents written to a core file, on the 2428 assumption that a debugger can find the contents in the 2429 executable. We flag this case by setting the fake 2430 section size to zero. Note that "real" bss sections will 2431 always have their contents dumped to the core file. */ 2432 if (bfd_get_format (abfd) == bfd_core) 2433 newsect->size = 0; 2434 newsect->flags |= SEC_ALLOC; 2435 if (hdr->p_flags & PF_X) 2436 newsect->flags |= SEC_CODE; 2437 } 2438 if (!(hdr->p_flags & PF_W)) 2439 newsect->flags |= SEC_READONLY; 2440 } 2441 2442 return TRUE; 2443 } 2444 2445 bfd_boolean 2446 bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int hdr_index) 2447 { 2448 const struct elf_backend_data *bed; 2449 2450 switch (hdr->p_type) 2451 { 2452 case PT_NULL: 2453 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "null"); 2454 2455 case PT_LOAD: 2456 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "load"); 2457 2458 case PT_DYNAMIC: 2459 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "dynamic"); 2460 2461 case PT_INTERP: 2462 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "interp"); 2463 2464 case PT_NOTE: 2465 if (! _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "note")) 2466 return FALSE; 2467 if (! elf_read_notes (abfd, hdr->p_offset, hdr->p_filesz)) 2468 return FALSE; 2469 return TRUE; 2470 2471 case PT_SHLIB: 2472 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "shlib"); 2473 2474 case PT_PHDR: 2475 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "phdr"); 2476 2477 case PT_GNU_EH_FRAME: 2478 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, 2479 "eh_frame_hdr"); 2480 2481 case PT_GNU_STACK: 2482 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "stack"); 2483 2484 case PT_GNU_RELRO: 2485 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "relro"); 2486 2487 default: 2488 /* Check for any processor-specific program segment types. */ 2489 bed = get_elf_backend_data (abfd); 2490 return bed->elf_backend_section_from_phdr (abfd, hdr, hdr_index, "proc"); 2491 } 2492 } 2493 2494 /* Return the REL_HDR for SEC, assuming there is only a single one, either 2495 REL or RELA. */ 2496 2497 Elf_Internal_Shdr * 2498 _bfd_elf_single_rel_hdr (asection *sec) 2499 { 2500 if (elf_section_data (sec)->rel.hdr) 2501 { 2502 BFD_ASSERT (elf_section_data (sec)->rela.hdr == NULL); 2503 return elf_section_data (sec)->rel.hdr; 2504 } 2505 else 2506 return elf_section_data (sec)->rela.hdr; 2507 } 2508 2509 /* Allocate and initialize a section-header for a new reloc section, 2510 containing relocations against ASECT. It is stored in RELDATA. If 2511 USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL 2512 relocations. */ 2513 2514 bfd_boolean 2515 _bfd_elf_init_reloc_shdr (bfd *abfd, 2516 struct bfd_elf_section_reloc_data *reldata, 2517 asection *asect, 2518 bfd_boolean use_rela_p) 2519 { 2520 Elf_Internal_Shdr *rel_hdr; 2521 char *name; 2522 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 2523 bfd_size_type amt; 2524 2525 amt = sizeof (Elf_Internal_Shdr); 2526 BFD_ASSERT (reldata->hdr == NULL); 2527 rel_hdr = bfd_zalloc (abfd, amt); 2528 reldata->hdr = rel_hdr; 2529 2530 amt = sizeof ".rela" + strlen (asect->name); 2531 name = (char *) bfd_alloc (abfd, amt); 2532 if (name == NULL) 2533 return FALSE; 2534 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name); 2535 rel_hdr->sh_name = 2536 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name, 2537 FALSE); 2538 if (rel_hdr->sh_name == (unsigned int) -1) 2539 return FALSE; 2540 rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL; 2541 rel_hdr->sh_entsize = (use_rela_p 2542 ? bed->s->sizeof_rela 2543 : bed->s->sizeof_rel); 2544 rel_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align; 2545 rel_hdr->sh_flags = 0; 2546 rel_hdr->sh_addr = 0; 2547 rel_hdr->sh_size = 0; 2548 rel_hdr->sh_offset = 0; 2549 2550 return TRUE; 2551 } 2552 2553 /* Return the default section type based on the passed in section flags. */ 2554 2555 int 2556 bfd_elf_get_default_section_type (flagword flags) 2557 { 2558 if ((flags & SEC_ALLOC) != 0 2559 && (flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0) 2560 return SHT_NOBITS; 2561 return SHT_PROGBITS; 2562 } 2563 2564 struct fake_section_arg 2565 { 2566 struct bfd_link_info *link_info; 2567 bfd_boolean failed; 2568 }; 2569 2570 /* Set up an ELF internal section header for a section. */ 2571 2572 static void 2573 elf_fake_sections (bfd *abfd, asection *asect, void *fsarg) 2574 { 2575 struct fake_section_arg *arg = (struct fake_section_arg *)fsarg; 2576 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 2577 struct bfd_elf_section_data *esd = elf_section_data (asect); 2578 Elf_Internal_Shdr *this_hdr; 2579 unsigned int sh_type; 2580 2581 if (arg->failed) 2582 { 2583 /* We already failed; just get out of the bfd_map_over_sections 2584 loop. */ 2585 return; 2586 } 2587 2588 this_hdr = &esd->this_hdr; 2589 2590 this_hdr->sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), 2591 asect->name, FALSE); 2592 if (this_hdr->sh_name == (unsigned int) -1) 2593 { 2594 arg->failed = TRUE; 2595 return; 2596 } 2597 2598 /* Don't clear sh_flags. Assembler may set additional bits. */ 2599 2600 if ((asect->flags & SEC_ALLOC) != 0 2601 || asect->user_set_vma) 2602 this_hdr->sh_addr = asect->vma; 2603 else 2604 this_hdr->sh_addr = 0; 2605 2606 this_hdr->sh_offset = 0; 2607 this_hdr->sh_size = asect->size; 2608 this_hdr->sh_link = 0; 2609 this_hdr->sh_addralign = (bfd_vma) 1 << asect->alignment_power; 2610 /* The sh_entsize and sh_info fields may have been set already by 2611 copy_private_section_data. */ 2612 2613 this_hdr->bfd_section = asect; 2614 this_hdr->contents = NULL; 2615 2616 /* If the section type is unspecified, we set it based on 2617 asect->flags. */ 2618 if ((asect->flags & SEC_GROUP) != 0) 2619 sh_type = SHT_GROUP; 2620 else 2621 sh_type = bfd_elf_get_default_section_type (asect->flags); 2622 2623 if (this_hdr->sh_type == SHT_NULL) 2624 this_hdr->sh_type = sh_type; 2625 else if (this_hdr->sh_type == SHT_NOBITS 2626 && sh_type == SHT_PROGBITS 2627 && (asect->flags & SEC_ALLOC) != 0) 2628 { 2629 /* Warn if we are changing a NOBITS section to PROGBITS, but 2630 allow the link to proceed. This can happen when users link 2631 non-bss input sections to bss output sections, or emit data 2632 to a bss output section via a linker script. */ 2633 (*_bfd_error_handler) 2634 (_("warning: section `%A' type changed to PROGBITS"), asect); 2635 this_hdr->sh_type = sh_type; 2636 } 2637 2638 switch (this_hdr->sh_type) 2639 { 2640 default: 2641 break; 2642 2643 case SHT_STRTAB: 2644 case SHT_INIT_ARRAY: 2645 case SHT_FINI_ARRAY: 2646 case SHT_PREINIT_ARRAY: 2647 case SHT_NOTE: 2648 case SHT_NOBITS: 2649 case SHT_PROGBITS: 2650 break; 2651 2652 case SHT_HASH: 2653 this_hdr->sh_entsize = bed->s->sizeof_hash_entry; 2654 break; 2655 2656 case SHT_DYNSYM: 2657 this_hdr->sh_entsize = bed->s->sizeof_sym; 2658 break; 2659 2660 case SHT_DYNAMIC: 2661 this_hdr->sh_entsize = bed->s->sizeof_dyn; 2662 break; 2663 2664 case SHT_RELA: 2665 if (get_elf_backend_data (abfd)->may_use_rela_p) 2666 this_hdr->sh_entsize = bed->s->sizeof_rela; 2667 break; 2668 2669 case SHT_REL: 2670 if (get_elf_backend_data (abfd)->may_use_rel_p) 2671 this_hdr->sh_entsize = bed->s->sizeof_rel; 2672 break; 2673 2674 case SHT_GNU_versym: 2675 this_hdr->sh_entsize = sizeof (Elf_External_Versym); 2676 break; 2677 2678 case SHT_GNU_verdef: 2679 this_hdr->sh_entsize = 0; 2680 /* objcopy or strip will copy over sh_info, but may not set 2681 cverdefs. The linker will set cverdefs, but sh_info will be 2682 zero. */ 2683 if (this_hdr->sh_info == 0) 2684 this_hdr->sh_info = elf_tdata (abfd)->cverdefs; 2685 else 2686 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0 2687 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs); 2688 break; 2689 2690 case SHT_GNU_verneed: 2691 this_hdr->sh_entsize = 0; 2692 /* objcopy or strip will copy over sh_info, but may not set 2693 cverrefs. The linker will set cverrefs, but sh_info will be 2694 zero. */ 2695 if (this_hdr->sh_info == 0) 2696 this_hdr->sh_info = elf_tdata (abfd)->cverrefs; 2697 else 2698 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0 2699 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs); 2700 break; 2701 2702 case SHT_GROUP: 2703 this_hdr->sh_entsize = GRP_ENTRY_SIZE; 2704 break; 2705 2706 case SHT_GNU_HASH: 2707 this_hdr->sh_entsize = bed->s->arch_size == 64 ? 0 : 4; 2708 break; 2709 } 2710 2711 if ((asect->flags & SEC_ALLOC) != 0) 2712 this_hdr->sh_flags |= SHF_ALLOC; 2713 if ((asect->flags & SEC_READONLY) == 0) 2714 this_hdr->sh_flags |= SHF_WRITE; 2715 if ((asect->flags & SEC_CODE) != 0) 2716 this_hdr->sh_flags |= SHF_EXECINSTR; 2717 if ((asect->flags & SEC_MERGE) != 0) 2718 { 2719 this_hdr->sh_flags |= SHF_MERGE; 2720 this_hdr->sh_entsize = asect->entsize; 2721 if ((asect->flags & SEC_STRINGS) != 0) 2722 this_hdr->sh_flags |= SHF_STRINGS; 2723 } 2724 if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL) 2725 this_hdr->sh_flags |= SHF_GROUP; 2726 if ((asect->flags & SEC_THREAD_LOCAL) != 0) 2727 { 2728 this_hdr->sh_flags |= SHF_TLS; 2729 if (asect->size == 0 2730 && (asect->flags & SEC_HAS_CONTENTS) == 0) 2731 { 2732 struct bfd_link_order *o = asect->map_tail.link_order; 2733 2734 this_hdr->sh_size = 0; 2735 if (o != NULL) 2736 { 2737 this_hdr->sh_size = o->offset + o->size; 2738 if (this_hdr->sh_size != 0) 2739 this_hdr->sh_type = SHT_NOBITS; 2740 } 2741 } 2742 } 2743 if ((asect->flags & (SEC_GROUP | SEC_EXCLUDE)) == SEC_EXCLUDE) 2744 this_hdr->sh_flags |= SHF_EXCLUDE; 2745 2746 /* If the section has relocs, set up a section header for the 2747 SHT_REL[A] section. If two relocation sections are required for 2748 this section, it is up to the processor-specific back-end to 2749 create the other. */ 2750 if ((asect->flags & SEC_RELOC) != 0) 2751 { 2752 /* When doing a relocatable link, create both REL and RELA sections if 2753 needed. */ 2754 if (arg->link_info 2755 /* Do the normal setup if we wouldn't create any sections here. */ 2756 && esd->rel.count + esd->rela.count > 0 2757 && (arg->link_info->relocatable || arg->link_info->emitrelocations)) 2758 { 2759 if (esd->rel.count && esd->rel.hdr == NULL 2760 && !_bfd_elf_init_reloc_shdr (abfd, &esd->rel, asect, FALSE)) 2761 { 2762 arg->failed = TRUE; 2763 return; 2764 } 2765 if (esd->rela.count && esd->rela.hdr == NULL 2766 && !_bfd_elf_init_reloc_shdr (abfd, &esd->rela, asect, TRUE)) 2767 { 2768 arg->failed = TRUE; 2769 return; 2770 } 2771 } 2772 else if (!_bfd_elf_init_reloc_shdr (abfd, 2773 (asect->use_rela_p 2774 ? &esd->rela : &esd->rel), 2775 asect, 2776 asect->use_rela_p)) 2777 arg->failed = TRUE; 2778 } 2779 2780 /* Check for processor-specific section types. */ 2781 sh_type = this_hdr->sh_type; 2782 if (bed->elf_backend_fake_sections 2783 && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect)) 2784 arg->failed = TRUE; 2785 2786 if (sh_type == SHT_NOBITS && asect->size != 0) 2787 { 2788 /* Don't change the header type from NOBITS if we are being 2789 called for objcopy --only-keep-debug. */ 2790 this_hdr->sh_type = sh_type; 2791 } 2792 } 2793 2794 /* Fill in the contents of a SHT_GROUP section. Called from 2795 _bfd_elf_compute_section_file_positions for gas, objcopy, and 2796 when ELF targets use the generic linker, ld. Called for ld -r 2797 from bfd_elf_final_link. */ 2798 2799 void 2800 bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg) 2801 { 2802 bfd_boolean *failedptr = (bfd_boolean *) failedptrarg; 2803 asection *elt, *first; 2804 unsigned char *loc; 2805 bfd_boolean gas; 2806 2807 /* Ignore linker created group section. See elfNN_ia64_object_p in 2808 elfxx-ia64.c. */ 2809 if (((sec->flags & (SEC_GROUP | SEC_LINKER_CREATED)) != SEC_GROUP) 2810 || *failedptr) 2811 return; 2812 2813 if (elf_section_data (sec)->this_hdr.sh_info == 0) 2814 { 2815 unsigned long symindx = 0; 2816 2817 /* elf_group_id will have been set up by objcopy and the 2818 generic linker. */ 2819 if (elf_group_id (sec) != NULL) 2820 symindx = elf_group_id (sec)->udata.i; 2821 2822 if (symindx == 0) 2823 { 2824 /* If called from the assembler, swap_out_syms will have set up 2825 elf_section_syms. */ 2826 BFD_ASSERT (elf_section_syms (abfd) != NULL); 2827 symindx = elf_section_syms (abfd)[sec->index]->udata.i; 2828 } 2829 elf_section_data (sec)->this_hdr.sh_info = symindx; 2830 } 2831 else if (elf_section_data (sec)->this_hdr.sh_info == (unsigned int) -2) 2832 { 2833 /* The ELF backend linker sets sh_info to -2 when the group 2834 signature symbol is global, and thus the index can't be 2835 set until all local symbols are output. */ 2836 asection *igroup = elf_sec_group (elf_next_in_group (sec)); 2837 struct bfd_elf_section_data *sec_data = elf_section_data (igroup); 2838 unsigned long symndx = sec_data->this_hdr.sh_info; 2839 unsigned long extsymoff = 0; 2840 struct elf_link_hash_entry *h; 2841 2842 if (!elf_bad_symtab (igroup->owner)) 2843 { 2844 Elf_Internal_Shdr *symtab_hdr; 2845 2846 symtab_hdr = &elf_tdata (igroup->owner)->symtab_hdr; 2847 extsymoff = symtab_hdr->sh_info; 2848 } 2849 h = elf_sym_hashes (igroup->owner)[symndx - extsymoff]; 2850 while (h->root.type == bfd_link_hash_indirect 2851 || h->root.type == bfd_link_hash_warning) 2852 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2853 2854 elf_section_data (sec)->this_hdr.sh_info = h->indx; 2855 } 2856 2857 /* The contents won't be allocated for "ld -r" or objcopy. */ 2858 gas = TRUE; 2859 if (sec->contents == NULL) 2860 { 2861 gas = FALSE; 2862 sec->contents = (unsigned char *) bfd_alloc (abfd, sec->size); 2863 2864 /* Arrange for the section to be written out. */ 2865 elf_section_data (sec)->this_hdr.contents = sec->contents; 2866 if (sec->contents == NULL) 2867 { 2868 *failedptr = TRUE; 2869 return; 2870 } 2871 } 2872 2873 loc = sec->contents + sec->size; 2874 2875 /* Get the pointer to the first section in the group that gas 2876 squirreled away here. objcopy arranges for this to be set to the 2877 start of the input section group. */ 2878 first = elt = elf_next_in_group (sec); 2879 2880 /* First element is a flag word. Rest of section is elf section 2881 indices for all the sections of the group. Write them backwards 2882 just to keep the group in the same order as given in .section 2883 directives, not that it matters. */ 2884 while (elt != NULL) 2885 { 2886 asection *s; 2887 2888 s = elt; 2889 if (!gas) 2890 s = s->output_section; 2891 if (s != NULL 2892 && !bfd_is_abs_section (s)) 2893 { 2894 unsigned int idx = elf_section_data (s)->this_idx; 2895 2896 loc -= 4; 2897 H_PUT_32 (abfd, idx, loc); 2898 } 2899 elt = elf_next_in_group (elt); 2900 if (elt == first) 2901 break; 2902 } 2903 2904 if ((loc -= 4) != sec->contents) 2905 abort (); 2906 2907 H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc); 2908 } 2909 2910 /* Assign all ELF section numbers. The dummy first section is handled here 2911 too. The link/info pointers for the standard section types are filled 2912 in here too, while we're at it. */ 2913 2914 static bfd_boolean 2915 assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info) 2916 { 2917 struct elf_obj_tdata *t = elf_tdata (abfd); 2918 asection *sec; 2919 unsigned int section_number, secn; 2920 Elf_Internal_Shdr **i_shdrp; 2921 struct bfd_elf_section_data *d; 2922 bfd_boolean need_symtab; 2923 2924 section_number = 1; 2925 2926 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd)); 2927 2928 /* SHT_GROUP sections are in relocatable files only. */ 2929 if (link_info == NULL || link_info->relocatable) 2930 { 2931 /* Put SHT_GROUP sections first. */ 2932 for (sec = abfd->sections; sec != NULL; sec = sec->next) 2933 { 2934 d = elf_section_data (sec); 2935 2936 if (d->this_hdr.sh_type == SHT_GROUP) 2937 { 2938 if (sec->flags & SEC_LINKER_CREATED) 2939 { 2940 /* Remove the linker created SHT_GROUP sections. */ 2941 bfd_section_list_remove (abfd, sec); 2942 abfd->section_count--; 2943 } 2944 else 2945 d->this_idx = section_number++; 2946 } 2947 } 2948 } 2949 2950 for (sec = abfd->sections; sec; sec = sec->next) 2951 { 2952 d = elf_section_data (sec); 2953 2954 if (d->this_hdr.sh_type != SHT_GROUP) 2955 d->this_idx = section_number++; 2956 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name); 2957 if (d->rel.hdr) 2958 { 2959 d->rel.idx = section_number++; 2960 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel.hdr->sh_name); 2961 } 2962 else 2963 d->rel.idx = 0; 2964 2965 if (d->rela.hdr) 2966 { 2967 d->rela.idx = section_number++; 2968 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rela.hdr->sh_name); 2969 } 2970 else 2971 d->rela.idx = 0; 2972 } 2973 2974 t->shstrtab_section = section_number++; 2975 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name); 2976 elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section; 2977 2978 need_symtab = (bfd_get_symcount (abfd) > 0 2979 || (link_info == NULL 2980 && ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC)) 2981 == HAS_RELOC))); 2982 if (need_symtab) 2983 { 2984 t->symtab_section = section_number++; 2985 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name); 2986 if (section_number > ((SHN_LORESERVE - 2) & 0xFFFF)) 2987 { 2988 t->symtab_shndx_section = section_number++; 2989 t->symtab_shndx_hdr.sh_name 2990 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), 2991 ".symtab_shndx", FALSE); 2992 if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1) 2993 return FALSE; 2994 } 2995 t->strtab_section = section_number++; 2996 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name); 2997 } 2998 2999 _bfd_elf_strtab_finalize (elf_shstrtab (abfd)); 3000 t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd)); 3001 3002 elf_numsections (abfd) = section_number; 3003 elf_elfheader (abfd)->e_shnum = section_number; 3004 3005 /* Set up the list of section header pointers, in agreement with the 3006 indices. */ 3007 i_shdrp = (Elf_Internal_Shdr **) bfd_zalloc2 (abfd, section_number, 3008 sizeof (Elf_Internal_Shdr *)); 3009 if (i_shdrp == NULL) 3010 return FALSE; 3011 3012 i_shdrp[0] = (Elf_Internal_Shdr *) bfd_zalloc (abfd, 3013 sizeof (Elf_Internal_Shdr)); 3014 if (i_shdrp[0] == NULL) 3015 { 3016 bfd_release (abfd, i_shdrp); 3017 return FALSE; 3018 } 3019 3020 elf_elfsections (abfd) = i_shdrp; 3021 3022 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr; 3023 if (need_symtab) 3024 { 3025 i_shdrp[t->symtab_section] = &t->symtab_hdr; 3026 if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF)) 3027 { 3028 i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr; 3029 t->symtab_shndx_hdr.sh_link = t->symtab_section; 3030 } 3031 i_shdrp[t->strtab_section] = &t->strtab_hdr; 3032 t->symtab_hdr.sh_link = t->strtab_section; 3033 } 3034 3035 for (sec = abfd->sections; sec; sec = sec->next) 3036 { 3037 asection *s; 3038 const char *name; 3039 3040 d = elf_section_data (sec); 3041 3042 i_shdrp[d->this_idx] = &d->this_hdr; 3043 if (d->rel.idx != 0) 3044 i_shdrp[d->rel.idx] = d->rel.hdr; 3045 if (d->rela.idx != 0) 3046 i_shdrp[d->rela.idx] = d->rela.hdr; 3047 3048 /* Fill in the sh_link and sh_info fields while we're at it. */ 3049 3050 /* sh_link of a reloc section is the section index of the symbol 3051 table. sh_info is the section index of the section to which 3052 the relocation entries apply. */ 3053 if (d->rel.idx != 0) 3054 { 3055 d->rel.hdr->sh_link = t->symtab_section; 3056 d->rel.hdr->sh_info = d->this_idx; 3057 } 3058 if (d->rela.idx != 0) 3059 { 3060 d->rela.hdr->sh_link = t->symtab_section; 3061 d->rela.hdr->sh_info = d->this_idx; 3062 } 3063 3064 /* We need to set up sh_link for SHF_LINK_ORDER. */ 3065 if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0) 3066 { 3067 s = elf_linked_to_section (sec); 3068 if (s) 3069 { 3070 /* elf_linked_to_section points to the input section. */ 3071 if (link_info != NULL) 3072 { 3073 /* Check discarded linkonce section. */ 3074 if (elf_discarded_section (s)) 3075 { 3076 asection *kept; 3077 (*_bfd_error_handler) 3078 (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"), 3079 abfd, d->this_hdr.bfd_section, 3080 s, s->owner); 3081 /* Point to the kept section if it has the same 3082 size as the discarded one. */ 3083 kept = _bfd_elf_check_kept_section (s, link_info); 3084 if (kept == NULL) 3085 { 3086 bfd_set_error (bfd_error_bad_value); 3087 return FALSE; 3088 } 3089 s = kept; 3090 } 3091 3092 s = s->output_section; 3093 BFD_ASSERT (s != NULL); 3094 } 3095 else 3096 { 3097 /* Handle objcopy. */ 3098 if (s->output_section == NULL) 3099 { 3100 (*_bfd_error_handler) 3101 (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"), 3102 abfd, d->this_hdr.bfd_section, s, s->owner); 3103 bfd_set_error (bfd_error_bad_value); 3104 return FALSE; 3105 } 3106 s = s->output_section; 3107 } 3108 d->this_hdr.sh_link = elf_section_data (s)->this_idx; 3109 } 3110 else 3111 { 3112 /* PR 290: 3113 The Intel C compiler generates SHT_IA_64_UNWIND with 3114 SHF_LINK_ORDER. But it doesn't set the sh_link or 3115 sh_info fields. Hence we could get the situation 3116 where s is NULL. */ 3117 const struct elf_backend_data *bed 3118 = get_elf_backend_data (abfd); 3119 if (bed->link_order_error_handler) 3120 bed->link_order_error_handler 3121 (_("%B: warning: sh_link not set for section `%A'"), 3122 abfd, sec); 3123 } 3124 } 3125 3126 switch (d->this_hdr.sh_type) 3127 { 3128 case SHT_REL: 3129 case SHT_RELA: 3130 /* A reloc section which we are treating as a normal BFD 3131 section. sh_link is the section index of the symbol 3132 table. sh_info is the section index of the section to 3133 which the relocation entries apply. We assume that an 3134 allocated reloc section uses the dynamic symbol table. 3135 FIXME: How can we be sure? */ 3136 s = bfd_get_section_by_name (abfd, ".dynsym"); 3137 if (s != NULL) 3138 d->this_hdr.sh_link = elf_section_data (s)->this_idx; 3139 3140 /* We look up the section the relocs apply to by name. */ 3141 name = sec->name; 3142 if (d->this_hdr.sh_type == SHT_REL) 3143 name += 4; 3144 else 3145 name += 5; 3146 s = bfd_get_section_by_name (abfd, name); 3147 if (s != NULL) 3148 d->this_hdr.sh_info = elf_section_data (s)->this_idx; 3149 break; 3150 3151 case SHT_STRTAB: 3152 /* We assume that a section named .stab*str is a stabs 3153 string section. We look for a section with the same name 3154 but without the trailing ``str'', and set its sh_link 3155 field to point to this section. */ 3156 if (CONST_STRNEQ (sec->name, ".stab") 3157 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0) 3158 { 3159 size_t len; 3160 char *alc; 3161 3162 len = strlen (sec->name); 3163 alc = (char *) bfd_malloc (len - 2); 3164 if (alc == NULL) 3165 return FALSE; 3166 memcpy (alc, sec->name, len - 3); 3167 alc[len - 3] = '\0'; 3168 s = bfd_get_section_by_name (abfd, alc); 3169 free (alc); 3170 if (s != NULL) 3171 { 3172 elf_section_data (s)->this_hdr.sh_link = d->this_idx; 3173 3174 /* This is a .stab section. */ 3175 if (elf_section_data (s)->this_hdr.sh_entsize == 0) 3176 elf_section_data (s)->this_hdr.sh_entsize 3177 = 4 + 2 * bfd_get_arch_size (abfd) / 8; 3178 } 3179 } 3180 break; 3181 3182 case SHT_DYNAMIC: 3183 case SHT_DYNSYM: 3184 case SHT_GNU_verneed: 3185 case SHT_GNU_verdef: 3186 /* sh_link is the section header index of the string table 3187 used for the dynamic entries, or the symbol table, or the 3188 version strings. */ 3189 s = bfd_get_section_by_name (abfd, ".dynstr"); 3190 if (s != NULL) 3191 d->this_hdr.sh_link = elf_section_data (s)->this_idx; 3192 break; 3193 3194 case SHT_GNU_LIBLIST: 3195 /* sh_link is the section header index of the prelink library 3196 list used for the dynamic entries, or the symbol table, or 3197 the version strings. */ 3198 s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC) 3199 ? ".dynstr" : ".gnu.libstr"); 3200 if (s != NULL) 3201 d->this_hdr.sh_link = elf_section_data (s)->this_idx; 3202 break; 3203 3204 case SHT_HASH: 3205 case SHT_GNU_HASH: 3206 case SHT_GNU_versym: 3207 /* sh_link is the section header index of the symbol table 3208 this hash table or version table is for. */ 3209 s = bfd_get_section_by_name (abfd, ".dynsym"); 3210 if (s != NULL) 3211 d->this_hdr.sh_link = elf_section_data (s)->this_idx; 3212 break; 3213 3214 case SHT_GROUP: 3215 d->this_hdr.sh_link = t->symtab_section; 3216 } 3217 } 3218 3219 for (secn = 1; secn < section_number; ++secn) 3220 if (i_shdrp[secn] == NULL) 3221 i_shdrp[secn] = i_shdrp[0]; 3222 else 3223 i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd), 3224 i_shdrp[secn]->sh_name); 3225 return TRUE; 3226 } 3227 3228 /* Map symbol from it's internal number to the external number, moving 3229 all local symbols to be at the head of the list. */ 3230 3231 static bfd_boolean 3232 sym_is_global (bfd *abfd, asymbol *sym) 3233 { 3234 /* If the backend has a special mapping, use it. */ 3235 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 3236 if (bed->elf_backend_sym_is_global) 3237 return (*bed->elf_backend_sym_is_global) (abfd, sym); 3238 3239 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE)) != 0 3240 || bfd_is_und_section (bfd_get_section (sym)) 3241 || bfd_is_com_section (bfd_get_section (sym))); 3242 } 3243 3244 /* Don't output section symbols for sections that are not going to be 3245 output. */ 3246 3247 static bfd_boolean 3248 ignore_section_sym (bfd *abfd, asymbol *sym) 3249 { 3250 return ((sym->flags & BSF_SECTION_SYM) != 0 3251 && !(sym->section->owner == abfd 3252 || (sym->section->output_section->owner == abfd 3253 && sym->section->output_offset == 0))); 3254 } 3255 3256 static bfd_boolean 3257 elf_map_symbols (bfd *abfd) 3258 { 3259 unsigned int symcount = bfd_get_symcount (abfd); 3260 asymbol **syms = bfd_get_outsymbols (abfd); 3261 asymbol **sect_syms; 3262 unsigned int num_locals = 0; 3263 unsigned int num_globals = 0; 3264 unsigned int num_locals2 = 0; 3265 unsigned int num_globals2 = 0; 3266 int max_index = 0; 3267 unsigned int idx; 3268 asection *asect; 3269 asymbol **new_syms; 3270 3271 #ifdef DEBUG 3272 fprintf (stderr, "elf_map_symbols\n"); 3273 fflush (stderr); 3274 #endif 3275 3276 for (asect = abfd->sections; asect; asect = asect->next) 3277 { 3278 if (max_index < asect->index) 3279 max_index = asect->index; 3280 } 3281 3282 max_index++; 3283 sect_syms = (asymbol **) bfd_zalloc2 (abfd, max_index, sizeof (asymbol *)); 3284 if (sect_syms == NULL) 3285 return FALSE; 3286 elf_section_syms (abfd) = sect_syms; 3287 elf_num_section_syms (abfd) = max_index; 3288 3289 /* Init sect_syms entries for any section symbols we have already 3290 decided to output. */ 3291 for (idx = 0; idx < symcount; idx++) 3292 { 3293 asymbol *sym = syms[idx]; 3294 3295 if ((sym->flags & BSF_SECTION_SYM) != 0 3296 && sym->value == 0 3297 && !ignore_section_sym (abfd, sym)) 3298 { 3299 asection *sec = sym->section; 3300 3301 if (sec->owner != abfd) 3302 sec = sec->output_section; 3303 3304 sect_syms[sec->index] = syms[idx]; 3305 } 3306 } 3307 3308 /* Classify all of the symbols. */ 3309 for (idx = 0; idx < symcount; idx++) 3310 { 3311 if (ignore_section_sym (abfd, syms[idx])) 3312 continue; 3313 if (!sym_is_global (abfd, syms[idx])) 3314 num_locals++; 3315 else 3316 num_globals++; 3317 } 3318 3319 /* We will be adding a section symbol for each normal BFD section. Most 3320 sections will already have a section symbol in outsymbols, but 3321 eg. SHT_GROUP sections will not, and we need the section symbol mapped 3322 at least in that case. */ 3323 for (asect = abfd->sections; asect; asect = asect->next) 3324 { 3325 if (sect_syms[asect->index] == NULL) 3326 { 3327 if (!sym_is_global (abfd, asect->symbol)) 3328 num_locals++; 3329 else 3330 num_globals++; 3331 } 3332 } 3333 3334 /* Now sort the symbols so the local symbols are first. */ 3335 new_syms = (asymbol **) bfd_alloc2 (abfd, num_locals + num_globals, 3336 sizeof (asymbol *)); 3337 3338 if (new_syms == NULL) 3339 return FALSE; 3340 3341 for (idx = 0; idx < symcount; idx++) 3342 { 3343 asymbol *sym = syms[idx]; 3344 unsigned int i; 3345 3346 if (ignore_section_sym (abfd, sym)) 3347 continue; 3348 if (!sym_is_global (abfd, sym)) 3349 i = num_locals2++; 3350 else 3351 i = num_locals + num_globals2++; 3352 new_syms[i] = sym; 3353 sym->udata.i = i + 1; 3354 } 3355 for (asect = abfd->sections; asect; asect = asect->next) 3356 { 3357 if (sect_syms[asect->index] == NULL) 3358 { 3359 asymbol *sym = asect->symbol; 3360 unsigned int i; 3361 3362 sect_syms[asect->index] = sym; 3363 if (!sym_is_global (abfd, sym)) 3364 i = num_locals2++; 3365 else 3366 i = num_locals + num_globals2++; 3367 new_syms[i] = sym; 3368 sym->udata.i = i + 1; 3369 } 3370 } 3371 3372 bfd_set_symtab (abfd, new_syms, num_locals + num_globals); 3373 3374 elf_num_locals (abfd) = num_locals; 3375 elf_num_globals (abfd) = num_globals; 3376 return TRUE; 3377 } 3378 3379 /* Align to the maximum file alignment that could be required for any 3380 ELF data structure. */ 3381 3382 static inline file_ptr 3383 align_file_position (file_ptr off, int align) 3384 { 3385 return (off + align - 1) & ~(align - 1); 3386 } 3387 3388 /* Assign a file position to a section, optionally aligning to the 3389 required section alignment. */ 3390 3391 file_ptr 3392 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp, 3393 file_ptr offset, 3394 bfd_boolean align) 3395 { 3396 if (align && i_shdrp->sh_addralign > 1) 3397 offset = BFD_ALIGN (offset, i_shdrp->sh_addralign); 3398 i_shdrp->sh_offset = offset; 3399 if (i_shdrp->bfd_section != NULL) 3400 i_shdrp->bfd_section->filepos = offset; 3401 if (i_shdrp->sh_type != SHT_NOBITS) 3402 offset += i_shdrp->sh_size; 3403 return offset; 3404 } 3405 3406 /* Compute the file positions we are going to put the sections at, and 3407 otherwise prepare to begin writing out the ELF file. If LINK_INFO 3408 is not NULL, this is being called by the ELF backend linker. */ 3409 3410 bfd_boolean 3411 _bfd_elf_compute_section_file_positions (bfd *abfd, 3412 struct bfd_link_info *link_info) 3413 { 3414 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 3415 struct fake_section_arg fsargs; 3416 bfd_boolean failed; 3417 struct bfd_strtab_hash *strtab = NULL; 3418 Elf_Internal_Shdr *shstrtab_hdr; 3419 bfd_boolean need_symtab; 3420 3421 if (abfd->output_has_begun) 3422 return TRUE; 3423 3424 /* Do any elf backend specific processing first. */ 3425 if (bed->elf_backend_begin_write_processing) 3426 (*bed->elf_backend_begin_write_processing) (abfd, link_info); 3427 3428 if (! prep_headers (abfd)) 3429 return FALSE; 3430 3431 /* Post process the headers if necessary. */ 3432 if (bed->elf_backend_post_process_headers) 3433 (*bed->elf_backend_post_process_headers) (abfd, link_info); 3434 3435 fsargs.failed = FALSE; 3436 fsargs.link_info = link_info; 3437 bfd_map_over_sections (abfd, elf_fake_sections, &fsargs); 3438 if (fsargs.failed) 3439 return FALSE; 3440 3441 if (!assign_section_numbers (abfd, link_info)) 3442 return FALSE; 3443 3444 /* The backend linker builds symbol table information itself. */ 3445 need_symtab = (link_info == NULL 3446 && (bfd_get_symcount (abfd) > 0 3447 || ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC)) 3448 == HAS_RELOC))); 3449 if (need_symtab) 3450 { 3451 /* Non-zero if doing a relocatable link. */ 3452 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC)); 3453 3454 if (! swap_out_syms (abfd, &strtab, relocatable_p)) 3455 return FALSE; 3456 } 3457 3458 failed = FALSE; 3459 if (link_info == NULL) 3460 { 3461 bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed); 3462 if (failed) 3463 return FALSE; 3464 } 3465 3466 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr; 3467 /* sh_name was set in prep_headers. */ 3468 shstrtab_hdr->sh_type = SHT_STRTAB; 3469 shstrtab_hdr->sh_flags = 0; 3470 shstrtab_hdr->sh_addr = 0; 3471 shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd)); 3472 shstrtab_hdr->sh_entsize = 0; 3473 shstrtab_hdr->sh_link = 0; 3474 shstrtab_hdr->sh_info = 0; 3475 /* sh_offset is set in assign_file_positions_except_relocs. */ 3476 shstrtab_hdr->sh_addralign = 1; 3477 3478 if (!assign_file_positions_except_relocs (abfd, link_info)) 3479 return FALSE; 3480 3481 if (need_symtab) 3482 { 3483 file_ptr off; 3484 Elf_Internal_Shdr *hdr; 3485 3486 off = elf_tdata (abfd)->next_file_pos; 3487 3488 hdr = &elf_tdata (abfd)->symtab_hdr; 3489 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE); 3490 3491 hdr = &elf_tdata (abfd)->symtab_shndx_hdr; 3492 if (hdr->sh_size != 0) 3493 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE); 3494 3495 hdr = &elf_tdata (abfd)->strtab_hdr; 3496 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE); 3497 3498 elf_tdata (abfd)->next_file_pos = off; 3499 3500 /* Now that we know where the .strtab section goes, write it 3501 out. */ 3502 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0 3503 || ! _bfd_stringtab_emit (abfd, strtab)) 3504 return FALSE; 3505 _bfd_stringtab_free (strtab); 3506 } 3507 3508 abfd->output_has_begun = TRUE; 3509 3510 return TRUE; 3511 } 3512 3513 /* Make an initial estimate of the size of the program header. If we 3514 get the number wrong here, we'll redo section placement. */ 3515 3516 static bfd_size_type 3517 get_program_header_size (bfd *abfd, struct bfd_link_info *info) 3518 { 3519 size_t segs; 3520 asection *s; 3521 const struct elf_backend_data *bed; 3522 3523 /* Assume we will need exactly two PT_LOAD segments: one for text 3524 and one for data. */ 3525 segs = 2; 3526 3527 s = bfd_get_section_by_name (abfd, ".interp"); 3528 if (s != NULL && (s->flags & SEC_LOAD) != 0) 3529 { 3530 /* If we have a loadable interpreter section, we need a 3531 PT_INTERP segment. In this case, assume we also need a 3532 PT_PHDR segment, although that may not be true for all 3533 targets. */ 3534 segs += 2; 3535 } 3536 3537 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL) 3538 { 3539 /* We need a PT_DYNAMIC segment. */ 3540 ++segs; 3541 } 3542 3543 if (info != NULL && info->relro) 3544 { 3545 /* We need a PT_GNU_RELRO segment. */ 3546 ++segs; 3547 } 3548 3549 if (elf_tdata (abfd)->eh_frame_hdr) 3550 { 3551 /* We need a PT_GNU_EH_FRAME segment. */ 3552 ++segs; 3553 } 3554 3555 if (elf_tdata (abfd)->stack_flags) 3556 { 3557 /* We need a PT_GNU_STACK segment. */ 3558 ++segs; 3559 } 3560 3561 for (s = abfd->sections; s != NULL; s = s->next) 3562 { 3563 if ((s->flags & SEC_LOAD) != 0 3564 && CONST_STRNEQ (s->name, ".note")) 3565 { 3566 /* We need a PT_NOTE segment. */ 3567 ++segs; 3568 /* Try to create just one PT_NOTE segment 3569 for all adjacent loadable .note* sections. 3570 gABI requires that within a PT_NOTE segment 3571 (and also inside of each SHT_NOTE section) 3572 each note is padded to a multiple of 4 size, 3573 so we check whether the sections are correctly 3574 aligned. */ 3575 if (s->alignment_power == 2) 3576 while (s->next != NULL 3577 && s->next->alignment_power == 2 3578 && (s->next->flags & SEC_LOAD) != 0 3579 && CONST_STRNEQ (s->next->name, ".note")) 3580 s = s->next; 3581 } 3582 } 3583 3584 for (s = abfd->sections; s != NULL; s = s->next) 3585 { 3586 if (s->flags & SEC_THREAD_LOCAL) 3587 { 3588 /* We need a PT_TLS segment. */ 3589 ++segs; 3590 break; 3591 } 3592 } 3593 3594 /* Let the backend count up any program headers it might need. */ 3595 bed = get_elf_backend_data (abfd); 3596 if (bed->elf_backend_additional_program_headers) 3597 { 3598 int a; 3599 3600 a = (*bed->elf_backend_additional_program_headers) (abfd, info); 3601 if (a == -1) 3602 abort (); 3603 segs += a; 3604 } 3605 3606 return segs * bed->s->sizeof_phdr; 3607 } 3608 3609 /* Find the segment that contains the output_section of section. */ 3610 3611 Elf_Internal_Phdr * 3612 _bfd_elf_find_segment_containing_section (bfd * abfd, asection * section) 3613 { 3614 struct elf_segment_map *m; 3615 Elf_Internal_Phdr *p; 3616 3617 for (m = elf_tdata (abfd)->segment_map, 3618 p = elf_tdata (abfd)->phdr; 3619 m != NULL; 3620 m = m->next, p++) 3621 { 3622 int i; 3623 3624 for (i = m->count - 1; i >= 0; i--) 3625 if (m->sections[i] == section) 3626 return p; 3627 } 3628 3629 return NULL; 3630 } 3631 3632 /* Create a mapping from a set of sections to a program segment. */ 3633 3634 static struct elf_segment_map * 3635 make_mapping (bfd *abfd, 3636 asection **sections, 3637 unsigned int from, 3638 unsigned int to, 3639 bfd_boolean phdr) 3640 { 3641 struct elf_segment_map *m; 3642 unsigned int i; 3643 asection **hdrpp; 3644 bfd_size_type amt; 3645 3646 amt = sizeof (struct elf_segment_map); 3647 amt += (to - from - 1) * sizeof (asection *); 3648 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt); 3649 if (m == NULL) 3650 return NULL; 3651 m->next = NULL; 3652 m->p_type = PT_LOAD; 3653 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++) 3654 m->sections[i - from] = *hdrpp; 3655 m->count = to - from; 3656 3657 if (from == 0 && phdr) 3658 { 3659 /* Include the headers in the first PT_LOAD segment. */ 3660 m->includes_filehdr = 1; 3661 m->includes_phdrs = 1; 3662 } 3663 3664 return m; 3665 } 3666 3667 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL 3668 on failure. */ 3669 3670 struct elf_segment_map * 3671 _bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec) 3672 { 3673 struct elf_segment_map *m; 3674 3675 m = (struct elf_segment_map *) bfd_zalloc (abfd, 3676 sizeof (struct elf_segment_map)); 3677 if (m == NULL) 3678 return NULL; 3679 m->next = NULL; 3680 m->p_type = PT_DYNAMIC; 3681 m->count = 1; 3682 m->sections[0] = dynsec; 3683 3684 return m; 3685 } 3686 3687 /* Possibly add or remove segments from the segment map. */ 3688 3689 static bfd_boolean 3690 elf_modify_segment_map (bfd *abfd, 3691 struct bfd_link_info *info, 3692 bfd_boolean remove_empty_load) 3693 { 3694 struct elf_segment_map **m; 3695 const struct elf_backend_data *bed; 3696 3697 /* The placement algorithm assumes that non allocated sections are 3698 not in PT_LOAD segments. We ensure this here by removing such 3699 sections from the segment map. We also remove excluded 3700 sections. Finally, any PT_LOAD segment without sections is 3701 removed. */ 3702 m = &elf_tdata (abfd)->segment_map; 3703 while (*m) 3704 { 3705 unsigned int i, new_count; 3706 3707 for (new_count = 0, i = 0; i < (*m)->count; i++) 3708 { 3709 if (((*m)->sections[i]->flags & SEC_EXCLUDE) == 0 3710 && (((*m)->sections[i]->flags & SEC_ALLOC) != 0 3711 || (*m)->p_type != PT_LOAD)) 3712 { 3713 (*m)->sections[new_count] = (*m)->sections[i]; 3714 new_count++; 3715 } 3716 } 3717 (*m)->count = new_count; 3718 3719 if (remove_empty_load && (*m)->p_type == PT_LOAD && (*m)->count == 0) 3720 *m = (*m)->next; 3721 else 3722 m = &(*m)->next; 3723 } 3724 3725 bed = get_elf_backend_data (abfd); 3726 if (bed->elf_backend_modify_segment_map != NULL) 3727 { 3728 if (!(*bed->elf_backend_modify_segment_map) (abfd, info)) 3729 return FALSE; 3730 } 3731 3732 return TRUE; 3733 } 3734 3735 /* Set up a mapping from BFD sections to program segments. */ 3736 3737 bfd_boolean 3738 _bfd_elf_map_sections_to_segments (bfd *abfd, struct bfd_link_info *info) 3739 { 3740 unsigned int count; 3741 struct elf_segment_map *m; 3742 asection **sections = NULL; 3743 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 3744 bfd_boolean no_user_phdrs; 3745 3746 no_user_phdrs = elf_tdata (abfd)->segment_map == NULL; 3747 if (no_user_phdrs && bfd_count_sections (abfd) != 0) 3748 { 3749 asection *s; 3750 unsigned int i; 3751 struct elf_segment_map *mfirst; 3752 struct elf_segment_map **pm; 3753 asection *last_hdr; 3754 bfd_vma last_size; 3755 unsigned int phdr_index; 3756 bfd_vma maxpagesize; 3757 asection **hdrpp; 3758 bfd_boolean phdr_in_segment = TRUE; 3759 bfd_boolean writable; 3760 int tls_count = 0; 3761 asection *first_tls = NULL; 3762 asection *dynsec, *eh_frame_hdr; 3763 bfd_size_type amt; 3764 bfd_vma addr_mask, wrap_to = 0; 3765 3766 /* Select the allocated sections, and sort them. */ 3767 3768 sections = (asection **) bfd_malloc2 (bfd_count_sections (abfd), 3769 sizeof (asection *)); 3770 if (sections == NULL) 3771 goto error_return; 3772 3773 /* Calculate top address, avoiding undefined behaviour of shift 3774 left operator when shift count is equal to size of type 3775 being shifted. */ 3776 addr_mask = ((bfd_vma) 1 << (bfd_arch_bits_per_address (abfd) - 1)) - 1; 3777 addr_mask = (addr_mask << 1) + 1; 3778 3779 i = 0; 3780 for (s = abfd->sections; s != NULL; s = s->next) 3781 { 3782 if ((s->flags & SEC_ALLOC) != 0) 3783 { 3784 sections[i] = s; 3785 ++i; 3786 /* A wrapping section potentially clashes with header. */ 3787 if (((s->lma + s->size) & addr_mask) < (s->lma & addr_mask)) 3788 wrap_to = (s->lma + s->size) & addr_mask; 3789 } 3790 } 3791 BFD_ASSERT (i <= bfd_count_sections (abfd)); 3792 count = i; 3793 3794 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections); 3795 3796 /* Build the mapping. */ 3797 3798 mfirst = NULL; 3799 pm = &mfirst; 3800 3801 /* If we have a .interp section, then create a PT_PHDR segment for 3802 the program headers and a PT_INTERP segment for the .interp 3803 section. */ 3804 s = bfd_get_section_by_name (abfd, ".interp"); 3805 if (s != NULL && (s->flags & SEC_LOAD) != 0) 3806 { 3807 amt = sizeof (struct elf_segment_map); 3808 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt); 3809 if (m == NULL) 3810 goto error_return; 3811 m->next = NULL; 3812 m->p_type = PT_PHDR; 3813 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */ 3814 m->p_flags = PF_R | PF_X; 3815 m->p_flags_valid = 1; 3816 m->includes_phdrs = 1; 3817 3818 *pm = m; 3819 pm = &m->next; 3820 3821 amt = sizeof (struct elf_segment_map); 3822 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt); 3823 if (m == NULL) 3824 goto error_return; 3825 m->next = NULL; 3826 m->p_type = PT_INTERP; 3827 m->count = 1; 3828 m->sections[0] = s; 3829 3830 *pm = m; 3831 pm = &m->next; 3832 } 3833 3834 /* Look through the sections. We put sections in the same program 3835 segment when the start of the second section can be placed within 3836 a few bytes of the end of the first section. */ 3837 last_hdr = NULL; 3838 last_size = 0; 3839 phdr_index = 0; 3840 maxpagesize = bed->maxpagesize; 3841 writable = FALSE; 3842 dynsec = bfd_get_section_by_name (abfd, ".dynamic"); 3843 if (dynsec != NULL 3844 && (dynsec->flags & SEC_LOAD) == 0) 3845 dynsec = NULL; 3846 3847 /* Deal with -Ttext or something similar such that the first section 3848 is not adjacent to the program headers. This is an 3849 approximation, since at this point we don't know exactly how many 3850 program headers we will need. */ 3851 if (count > 0) 3852 { 3853 bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size; 3854 3855 if (phdr_size == (bfd_size_type) -1) 3856 phdr_size = get_program_header_size (abfd, info); 3857 if ((abfd->flags & D_PAGED) == 0 3858 || (sections[0]->lma & addr_mask) < phdr_size 3859 || ((sections[0]->lma & addr_mask) % maxpagesize 3860 < phdr_size % maxpagesize) 3861 || (sections[0]->lma & addr_mask & -maxpagesize) < wrap_to) 3862 phdr_in_segment = FALSE; 3863 } 3864 3865 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++) 3866 { 3867 asection *hdr; 3868 bfd_boolean new_segment; 3869 3870 hdr = *hdrpp; 3871 3872 /* See if this section and the last one will fit in the same 3873 segment. */ 3874 3875 if (last_hdr == NULL) 3876 { 3877 /* If we don't have a segment yet, then we don't need a new 3878 one (we build the last one after this loop). */ 3879 new_segment = FALSE; 3880 } 3881 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma) 3882 { 3883 /* If this section has a different relation between the 3884 virtual address and the load address, then we need a new 3885 segment. */ 3886 new_segment = TRUE; 3887 } 3888 else if (hdr->lma < last_hdr->lma + last_size 3889 || last_hdr->lma + last_size < last_hdr->lma) 3890 { 3891 /* If this section has a load address that makes it overlap 3892 the previous section, then we need a new segment. */ 3893 new_segment = TRUE; 3894 } 3895 /* In the next test we have to be careful when last_hdr->lma is close 3896 to the end of the address space. If the aligned address wraps 3897 around to the start of the address space, then there are no more 3898 pages left in memory and it is OK to assume that the current 3899 section can be included in the current segment. */ 3900 else if ((BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize 3901 > last_hdr->lma) 3902 && (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize 3903 <= hdr->lma)) 3904 { 3905 /* If putting this section in this segment would force us to 3906 skip a page in the segment, then we need a new segment. */ 3907 new_segment = TRUE; 3908 } 3909 else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0 3910 && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0) 3911 { 3912 /* We don't want to put a loadable section after a 3913 nonloadable section in the same segment. 3914 Consider .tbss sections as loadable for this purpose. */ 3915 new_segment = TRUE; 3916 } 3917 else if ((abfd->flags & D_PAGED) == 0) 3918 { 3919 /* If the file is not demand paged, which means that we 3920 don't require the sections to be correctly aligned in the 3921 file, then there is no other reason for a new segment. */ 3922 new_segment = FALSE; 3923 } 3924 else if (! writable 3925 && (hdr->flags & SEC_READONLY) == 0 3926 && (((last_hdr->lma + last_size - 1) & -maxpagesize) 3927 != (hdr->lma & -maxpagesize))) 3928 { 3929 /* We don't want to put a writable section in a read only 3930 segment, unless they are on the same page in memory 3931 anyhow. We already know that the last section does not 3932 bring us past the current section on the page, so the 3933 only case in which the new section is not on the same 3934 page as the previous section is when the previous section 3935 ends precisely on a page boundary. */ 3936 new_segment = TRUE; 3937 } 3938 else 3939 { 3940 /* Otherwise, we can use the same segment. */ 3941 new_segment = FALSE; 3942 } 3943 3944 /* Allow interested parties a chance to override our decision. */ 3945 if (last_hdr != NULL 3946 && info != NULL 3947 && info->callbacks->override_segment_assignment != NULL) 3948 new_segment 3949 = info->callbacks->override_segment_assignment (info, abfd, hdr, 3950 last_hdr, 3951 new_segment); 3952 3953 if (! new_segment) 3954 { 3955 if ((hdr->flags & SEC_READONLY) == 0) 3956 writable = TRUE; 3957 last_hdr = hdr; 3958 /* .tbss sections effectively have zero size. */ 3959 if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) 3960 != SEC_THREAD_LOCAL) 3961 last_size = hdr->size; 3962 else 3963 last_size = 0; 3964 continue; 3965 } 3966 3967 /* We need a new program segment. We must create a new program 3968 header holding all the sections from phdr_index until hdr. */ 3969 3970 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment); 3971 if (m == NULL) 3972 goto error_return; 3973 3974 *pm = m; 3975 pm = &m->next; 3976 3977 if ((hdr->flags & SEC_READONLY) == 0) 3978 writable = TRUE; 3979 else 3980 writable = FALSE; 3981 3982 last_hdr = hdr; 3983 /* .tbss sections effectively have zero size. */ 3984 if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL) 3985 last_size = hdr->size; 3986 else 3987 last_size = 0; 3988 phdr_index = i; 3989 phdr_in_segment = FALSE; 3990 } 3991 3992 /* Create a final PT_LOAD program segment, but not if it's just 3993 for .tbss. */ 3994 if (last_hdr != NULL 3995 && (i - phdr_index != 1 3996 || ((last_hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) 3997 != SEC_THREAD_LOCAL))) 3998 { 3999 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment); 4000 if (m == NULL) 4001 goto error_return; 4002 4003 *pm = m; 4004 pm = &m->next; 4005 } 4006 4007 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */ 4008 if (dynsec != NULL) 4009 { 4010 m = _bfd_elf_make_dynamic_segment (abfd, dynsec); 4011 if (m == NULL) 4012 goto error_return; 4013 *pm = m; 4014 pm = &m->next; 4015 } 4016 4017 /* For each batch of consecutive loadable .note sections, 4018 add a PT_NOTE segment. We don't use bfd_get_section_by_name, 4019 because if we link together nonloadable .note sections and 4020 loadable .note sections, we will generate two .note sections 4021 in the output file. FIXME: Using names for section types is 4022 bogus anyhow. */ 4023 for (s = abfd->sections; s != NULL; s = s->next) 4024 { 4025 if ((s->flags & SEC_LOAD) != 0 4026 && CONST_STRNEQ (s->name, ".note")) 4027 { 4028 asection *s2; 4029 4030 count = 1; 4031 amt = sizeof (struct elf_segment_map); 4032 if (s->alignment_power == 2) 4033 for (s2 = s; s2->next != NULL; s2 = s2->next) 4034 { 4035 if (s2->next->alignment_power == 2 4036 && (s2->next->flags & SEC_LOAD) != 0 4037 && CONST_STRNEQ (s2->next->name, ".note") 4038 && align_power (s2->lma + s2->size, 2) 4039 == s2->next->lma) 4040 count++; 4041 else 4042 break; 4043 } 4044 amt += (count - 1) * sizeof (asection *); 4045 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt); 4046 if (m == NULL) 4047 goto error_return; 4048 m->next = NULL; 4049 m->p_type = PT_NOTE; 4050 m->count = count; 4051 while (count > 1) 4052 { 4053 m->sections[m->count - count--] = s; 4054 BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0); 4055 s = s->next; 4056 } 4057 m->sections[m->count - 1] = s; 4058 BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0); 4059 *pm = m; 4060 pm = &m->next; 4061 } 4062 if (s->flags & SEC_THREAD_LOCAL) 4063 { 4064 if (! tls_count) 4065 first_tls = s; 4066 tls_count++; 4067 } 4068 } 4069 4070 /* If there are any SHF_TLS output sections, add PT_TLS segment. */ 4071 if (tls_count > 0) 4072 { 4073 amt = sizeof (struct elf_segment_map); 4074 amt += (tls_count - 1) * sizeof (asection *); 4075 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt); 4076 if (m == NULL) 4077 goto error_return; 4078 m->next = NULL; 4079 m->p_type = PT_TLS; 4080 m->count = tls_count; 4081 /* Mandated PF_R. */ 4082 m->p_flags = PF_R; 4083 m->p_flags_valid = 1; 4084 for (i = 0; i < (unsigned int) tls_count; ++i) 4085 { 4086 BFD_ASSERT (first_tls->flags & SEC_THREAD_LOCAL); 4087 m->sections[i] = first_tls; 4088 first_tls = first_tls->next; 4089 } 4090 4091 *pm = m; 4092 pm = &m->next; 4093 } 4094 4095 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME 4096 segment. */ 4097 eh_frame_hdr = elf_tdata (abfd)->eh_frame_hdr; 4098 if (eh_frame_hdr != NULL 4099 && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0) 4100 { 4101 amt = sizeof (struct elf_segment_map); 4102 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt); 4103 if (m == NULL) 4104 goto error_return; 4105 m->next = NULL; 4106 m->p_type = PT_GNU_EH_FRAME; 4107 m->count = 1; 4108 m->sections[0] = eh_frame_hdr->output_section; 4109 4110 *pm = m; 4111 pm = &m->next; 4112 } 4113 4114 if (elf_tdata (abfd)->stack_flags) 4115 { 4116 amt = sizeof (struct elf_segment_map); 4117 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt); 4118 if (m == NULL) 4119 goto error_return; 4120 m->next = NULL; 4121 m->p_type = PT_GNU_STACK; 4122 m->p_flags = elf_tdata (abfd)->stack_flags; 4123 m->p_flags_valid = 1; 4124 4125 *pm = m; 4126 pm = &m->next; 4127 } 4128 4129 if (info != NULL && info->relro) 4130 { 4131 for (m = mfirst; m != NULL; m = m->next) 4132 { 4133 if (m->p_type == PT_LOAD) 4134 { 4135 asection *last = m->sections[m->count - 1]; 4136 bfd_vma vaddr = m->sections[0]->vma; 4137 bfd_vma filesz = last->vma - vaddr + last->size; 4138 4139 if (vaddr < info->relro_end 4140 && vaddr >= info->relro_start 4141 && (vaddr + filesz) >= info->relro_end) 4142 break; 4143 } 4144 } 4145 4146 /* Make a PT_GNU_RELRO segment only when it isn't empty. */ 4147 if (m != NULL) 4148 { 4149 amt = sizeof (struct elf_segment_map); 4150 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt); 4151 if (m == NULL) 4152 goto error_return; 4153 m->next = NULL; 4154 m->p_type = PT_GNU_RELRO; 4155 m->p_flags = PF_R; 4156 m->p_flags_valid = 1; 4157 4158 *pm = m; 4159 pm = &m->next; 4160 } 4161 } 4162 4163 free (sections); 4164 elf_tdata (abfd)->segment_map = mfirst; 4165 } 4166 4167 if (!elf_modify_segment_map (abfd, info, no_user_phdrs)) 4168 return FALSE; 4169 4170 for (count = 0, m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next) 4171 ++count; 4172 elf_tdata (abfd)->program_header_size = count * bed->s->sizeof_phdr; 4173 4174 return TRUE; 4175 4176 error_return: 4177 if (sections != NULL) 4178 free (sections); 4179 return FALSE; 4180 } 4181 4182 /* Sort sections by address. */ 4183 4184 static int 4185 elf_sort_sections (const void *arg1, const void *arg2) 4186 { 4187 const asection *sec1 = *(const asection **) arg1; 4188 const asection *sec2 = *(const asection **) arg2; 4189 bfd_size_type size1, size2; 4190 4191 /* Sort by LMA first, since this is the address used to 4192 place the section into a segment. */ 4193 if (sec1->lma < sec2->lma) 4194 return -1; 4195 else if (sec1->lma > sec2->lma) 4196 return 1; 4197 4198 /* Then sort by VMA. Normally the LMA and the VMA will be 4199 the same, and this will do nothing. */ 4200 if (sec1->vma < sec2->vma) 4201 return -1; 4202 else if (sec1->vma > sec2->vma) 4203 return 1; 4204 4205 /* Put !SEC_LOAD sections after SEC_LOAD ones. */ 4206 4207 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0) 4208 4209 if (TOEND (sec1)) 4210 { 4211 if (TOEND (sec2)) 4212 { 4213 /* If the indicies are the same, do not return 0 4214 here, but continue to try the next comparison. */ 4215 if (sec1->target_index - sec2->target_index != 0) 4216 return sec1->target_index - sec2->target_index; 4217 } 4218 else 4219 return 1; 4220 } 4221 else if (TOEND (sec2)) 4222 return -1; 4223 4224 #undef TOEND 4225 4226 /* Sort by size, to put zero sized sections 4227 before others at the same address. */ 4228 4229 size1 = (sec1->flags & SEC_LOAD) ? sec1->size : 0; 4230 size2 = (sec2->flags & SEC_LOAD) ? sec2->size : 0; 4231 4232 if (size1 < size2) 4233 return -1; 4234 if (size1 > size2) 4235 return 1; 4236 4237 return sec1->target_index - sec2->target_index; 4238 } 4239 4240 /* Ian Lance Taylor writes: 4241 4242 We shouldn't be using % with a negative signed number. That's just 4243 not good. We have to make sure either that the number is not 4244 negative, or that the number has an unsigned type. When the types 4245 are all the same size they wind up as unsigned. When file_ptr is a 4246 larger signed type, the arithmetic winds up as signed long long, 4247 which is wrong. 4248 4249 What we're trying to say here is something like ``increase OFF by 4250 the least amount that will cause it to be equal to the VMA modulo 4251 the page size.'' */ 4252 /* In other words, something like: 4253 4254 vma_offset = m->sections[0]->vma % bed->maxpagesize; 4255 off_offset = off % bed->maxpagesize; 4256 if (vma_offset < off_offset) 4257 adjustment = vma_offset + bed->maxpagesize - off_offset; 4258 else 4259 adjustment = vma_offset - off_offset; 4260 4261 which can can be collapsed into the expression below. */ 4262 4263 static file_ptr 4264 vma_page_aligned_bias (bfd_vma vma, ufile_ptr off, bfd_vma maxpagesize) 4265 { 4266 return ((vma - off) % maxpagesize); 4267 } 4268 4269 static void 4270 print_segment_map (const struct elf_segment_map *m) 4271 { 4272 unsigned int j; 4273 const char *pt = get_segment_type (m->p_type); 4274 char buf[32]; 4275 4276 if (pt == NULL) 4277 { 4278 if (m->p_type >= PT_LOPROC && m->p_type <= PT_HIPROC) 4279 sprintf (buf, "LOPROC+%7.7x", 4280 (unsigned int) (m->p_type - PT_LOPROC)); 4281 else if (m->p_type >= PT_LOOS && m->p_type <= PT_HIOS) 4282 sprintf (buf, "LOOS+%7.7x", 4283 (unsigned int) (m->p_type - PT_LOOS)); 4284 else 4285 snprintf (buf, sizeof (buf), "%8.8x", 4286 (unsigned int) m->p_type); 4287 pt = buf; 4288 } 4289 fflush (stdout); 4290 fprintf (stderr, "%s:", pt); 4291 for (j = 0; j < m->count; j++) 4292 fprintf (stderr, " %s", m->sections [j]->name); 4293 putc ('\n',stderr); 4294 fflush (stderr); 4295 } 4296 4297 static bfd_boolean 4298 write_zeros (bfd *abfd, file_ptr pos, bfd_size_type len) 4299 { 4300 void *buf; 4301 bfd_boolean ret; 4302 4303 if (bfd_seek (abfd, pos, SEEK_SET) != 0) 4304 return FALSE; 4305 buf = bfd_zmalloc (len); 4306 if (buf == NULL) 4307 return FALSE; 4308 ret = bfd_bwrite (buf, len, abfd) == len; 4309 free (buf); 4310 return ret; 4311 } 4312 4313 /* Assign file positions to the sections based on the mapping from 4314 sections to segments. This function also sets up some fields in 4315 the file header. */ 4316 4317 static bfd_boolean 4318 assign_file_positions_for_load_sections (bfd *abfd, 4319 struct bfd_link_info *link_info) 4320 { 4321 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 4322 struct elf_segment_map *m; 4323 Elf_Internal_Phdr *phdrs; 4324 Elf_Internal_Phdr *p; 4325 file_ptr off; 4326 bfd_size_type maxpagesize; 4327 unsigned int alloc; 4328 unsigned int i, j; 4329 bfd_vma header_pad = 0; 4330 4331 if (link_info == NULL 4332 && !_bfd_elf_map_sections_to_segments (abfd, link_info)) 4333 return FALSE; 4334 4335 alloc = 0; 4336 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next) 4337 { 4338 ++alloc; 4339 if (m->header_size) 4340 header_pad = m->header_size; 4341 } 4342 4343 if (alloc) 4344 { 4345 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr; 4346 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr; 4347 } 4348 else 4349 { 4350 /* PR binutils/12467. */ 4351 elf_elfheader (abfd)->e_phoff = 0; 4352 elf_elfheader (abfd)->e_phentsize = 0; 4353 } 4354 4355 elf_elfheader (abfd)->e_phnum = alloc; 4356 4357 if (elf_tdata (abfd)->program_header_size == (bfd_size_type) -1) 4358 elf_tdata (abfd)->program_header_size = alloc * bed->s->sizeof_phdr; 4359 else 4360 BFD_ASSERT (elf_tdata (abfd)->program_header_size 4361 >= alloc * bed->s->sizeof_phdr); 4362 4363 if (alloc == 0) 4364 { 4365 elf_tdata (abfd)->next_file_pos = bed->s->sizeof_ehdr; 4366 return TRUE; 4367 } 4368 4369 /* We're writing the size in elf_tdata (abfd)->program_header_size, 4370 see assign_file_positions_except_relocs, so make sure we have 4371 that amount allocated, with trailing space cleared. 4372 The variable alloc contains the computed need, while elf_tdata 4373 (abfd)->program_header_size contains the size used for the 4374 layout. 4375 See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments 4376 where the layout is forced to according to a larger size in the 4377 last iterations for the testcase ld-elf/header. */ 4378 BFD_ASSERT (elf_tdata (abfd)->program_header_size % bed->s->sizeof_phdr 4379 == 0); 4380 phdrs = (Elf_Internal_Phdr *) 4381 bfd_zalloc2 (abfd, 4382 (elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr), 4383 sizeof (Elf_Internal_Phdr)); 4384 elf_tdata (abfd)->phdr = phdrs; 4385 if (phdrs == NULL) 4386 return FALSE; 4387 4388 maxpagesize = 1; 4389 if ((abfd->flags & D_PAGED) != 0) 4390 maxpagesize = bed->maxpagesize; 4391 4392 off = bed->s->sizeof_ehdr; 4393 off += alloc * bed->s->sizeof_phdr; 4394 if (header_pad < (bfd_vma) off) 4395 header_pad = 0; 4396 else 4397 header_pad -= off; 4398 off += header_pad; 4399 4400 for (m = elf_tdata (abfd)->segment_map, p = phdrs, j = 0; 4401 m != NULL; 4402 m = m->next, p++, j++) 4403 { 4404 asection **secpp; 4405 bfd_vma off_adjust; 4406 bfd_boolean no_contents; 4407 4408 /* If elf_segment_map is not from map_sections_to_segments, the 4409 sections may not be correctly ordered. NOTE: sorting should 4410 not be done to the PT_NOTE section of a corefile, which may 4411 contain several pseudo-sections artificially created by bfd. 4412 Sorting these pseudo-sections breaks things badly. */ 4413 if (m->count > 1 4414 && !(elf_elfheader (abfd)->e_type == ET_CORE 4415 && m->p_type == PT_NOTE)) 4416 qsort (m->sections, (size_t) m->count, sizeof (asection *), 4417 elf_sort_sections); 4418 4419 /* An ELF segment (described by Elf_Internal_Phdr) may contain a 4420 number of sections with contents contributing to both p_filesz 4421 and p_memsz, followed by a number of sections with no contents 4422 that just contribute to p_memsz. In this loop, OFF tracks next 4423 available file offset for PT_LOAD and PT_NOTE segments. */ 4424 p->p_type = m->p_type; 4425 p->p_flags = m->p_flags; 4426 4427 if (m->count == 0) 4428 p->p_vaddr = 0; 4429 else 4430 p->p_vaddr = m->sections[0]->vma - m->p_vaddr_offset; 4431 4432 if (m->p_paddr_valid) 4433 p->p_paddr = m->p_paddr; 4434 else if (m->count == 0) 4435 p->p_paddr = 0; 4436 else 4437 p->p_paddr = m->sections[0]->lma - m->p_vaddr_offset; 4438 4439 if (p->p_type == PT_LOAD 4440 && (abfd->flags & D_PAGED) != 0) 4441 { 4442 /* p_align in demand paged PT_LOAD segments effectively stores 4443 the maximum page size. When copying an executable with 4444 objcopy, we set m->p_align from the input file. Use this 4445 value for maxpagesize rather than bed->maxpagesize, which 4446 may be different. Note that we use maxpagesize for PT_TLS 4447 segment alignment later in this function, so we are relying 4448 on at least one PT_LOAD segment appearing before a PT_TLS 4449 segment. */ 4450 if (m->p_align_valid) 4451 maxpagesize = m->p_align; 4452 4453 p->p_align = maxpagesize; 4454 } 4455 else if (m->p_align_valid) 4456 p->p_align = m->p_align; 4457 else if (m->count == 0) 4458 p->p_align = 1 << bed->s->log_file_align; 4459 else 4460 p->p_align = 0; 4461 4462 no_contents = FALSE; 4463 off_adjust = 0; 4464 if (p->p_type == PT_LOAD 4465 && m->count > 0) 4466 { 4467 bfd_size_type align; 4468 unsigned int align_power = 0; 4469 4470 if (m->p_align_valid) 4471 align = p->p_align; 4472 else 4473 { 4474 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++) 4475 { 4476 unsigned int secalign; 4477 4478 secalign = bfd_get_section_alignment (abfd, *secpp); 4479 if (secalign > align_power) 4480 align_power = secalign; 4481 } 4482 align = (bfd_size_type) 1 << align_power; 4483 if (align < maxpagesize) 4484 align = maxpagesize; 4485 } 4486 4487 for (i = 0; i < m->count; i++) 4488 if ((m->sections[i]->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0) 4489 /* If we aren't making room for this section, then 4490 it must be SHT_NOBITS regardless of what we've 4491 set via struct bfd_elf_special_section. */ 4492 elf_section_type (m->sections[i]) = SHT_NOBITS; 4493 4494 /* Find out whether this segment contains any loadable 4495 sections. */ 4496 no_contents = TRUE; 4497 for (i = 0; i < m->count; i++) 4498 if (elf_section_type (m->sections[i]) != SHT_NOBITS) 4499 { 4500 no_contents = FALSE; 4501 break; 4502 } 4503 4504 off_adjust = vma_page_aligned_bias (p->p_vaddr, off, align); 4505 off += off_adjust; 4506 if (no_contents) 4507 { 4508 /* We shouldn't need to align the segment on disk since 4509 the segment doesn't need file space, but the gABI 4510 arguably requires the alignment and glibc ld.so 4511 checks it. So to comply with the alignment 4512 requirement but not waste file space, we adjust 4513 p_offset for just this segment. (OFF_ADJUST is 4514 subtracted from OFF later.) This may put p_offset 4515 past the end of file, but that shouldn't matter. */ 4516 } 4517 else 4518 off_adjust = 0; 4519 } 4520 /* Make sure the .dynamic section is the first section in the 4521 PT_DYNAMIC segment. */ 4522 else if (p->p_type == PT_DYNAMIC 4523 && m->count > 1 4524 && strcmp (m->sections[0]->name, ".dynamic") != 0) 4525 { 4526 _bfd_error_handler 4527 (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"), 4528 abfd); 4529 bfd_set_error (bfd_error_bad_value); 4530 return FALSE; 4531 } 4532 /* Set the note section type to SHT_NOTE. */ 4533 else if (p->p_type == PT_NOTE) 4534 for (i = 0; i < m->count; i++) 4535 elf_section_type (m->sections[i]) = SHT_NOTE; 4536 4537 p->p_offset = 0; 4538 p->p_filesz = 0; 4539 p->p_memsz = 0; 4540 4541 if (m->includes_filehdr) 4542 { 4543 if (!m->p_flags_valid) 4544 p->p_flags |= PF_R; 4545 p->p_filesz = bed->s->sizeof_ehdr; 4546 p->p_memsz = bed->s->sizeof_ehdr; 4547 if (m->count > 0) 4548 { 4549 BFD_ASSERT (p->p_type == PT_LOAD); 4550 4551 if (p->p_vaddr < (bfd_vma) off) 4552 { 4553 (*_bfd_error_handler) 4554 (_("%B: Not enough room for program headers, try linking with -N"), 4555 abfd); 4556 bfd_set_error (bfd_error_bad_value); 4557 return FALSE; 4558 } 4559 4560 p->p_vaddr -= off; 4561 if (!m->p_paddr_valid) 4562 p->p_paddr -= off; 4563 } 4564 } 4565 4566 if (m->includes_phdrs) 4567 { 4568 if (!m->p_flags_valid) 4569 p->p_flags |= PF_R; 4570 4571 if (!m->includes_filehdr) 4572 { 4573 p->p_offset = bed->s->sizeof_ehdr; 4574 4575 if (m->count > 0) 4576 { 4577 BFD_ASSERT (p->p_type == PT_LOAD); 4578 p->p_vaddr -= off - p->p_offset; 4579 if (!m->p_paddr_valid) 4580 p->p_paddr -= off - p->p_offset; 4581 } 4582 } 4583 4584 p->p_filesz += alloc * bed->s->sizeof_phdr; 4585 p->p_memsz += alloc * bed->s->sizeof_phdr; 4586 if (m->count) 4587 { 4588 p->p_filesz += header_pad; 4589 p->p_memsz += header_pad; 4590 } 4591 } 4592 4593 if (p->p_type == PT_LOAD 4594 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)) 4595 { 4596 if (!m->includes_filehdr && !m->includes_phdrs) 4597 p->p_offset = off; 4598 else 4599 { 4600 file_ptr adjust; 4601 4602 adjust = off - (p->p_offset + p->p_filesz); 4603 if (!no_contents) 4604 p->p_filesz += adjust; 4605 p->p_memsz += adjust; 4606 } 4607 } 4608 4609 /* Set up p_filesz, p_memsz, p_align and p_flags from the section 4610 maps. Set filepos for sections in PT_LOAD segments, and in 4611 core files, for sections in PT_NOTE segments. 4612 assign_file_positions_for_non_load_sections will set filepos 4613 for other sections and update p_filesz for other segments. */ 4614 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++) 4615 { 4616 asection *sec; 4617 bfd_size_type align; 4618 Elf_Internal_Shdr *this_hdr; 4619 4620 sec = *secpp; 4621 this_hdr = &elf_section_data (sec)->this_hdr; 4622 align = (bfd_size_type) 1 << bfd_get_section_alignment (abfd, sec); 4623 4624 if ((p->p_type == PT_LOAD 4625 || p->p_type == PT_TLS) 4626 && (this_hdr->sh_type != SHT_NOBITS 4627 || ((this_hdr->sh_flags & SHF_ALLOC) != 0 4628 && ((this_hdr->sh_flags & SHF_TLS) == 0 4629 || p->p_type == PT_TLS)))) 4630 { 4631 bfd_vma p_start = p->p_paddr; 4632 bfd_vma p_end = p_start + p->p_memsz; 4633 bfd_vma s_start = sec->lma; 4634 bfd_vma adjust = s_start - p_end; 4635 4636 if (adjust != 0 4637 && (s_start < p_end 4638 || p_end < p_start)) 4639 { 4640 (*_bfd_error_handler) 4641 (_("%B: section %A lma %#lx adjusted to %#lx"), abfd, sec, 4642 (unsigned long) s_start, (unsigned long) p_end); 4643 adjust = 0; 4644 sec->lma = p_end; 4645 } 4646 p->p_memsz += adjust; 4647 4648 if (this_hdr->sh_type != SHT_NOBITS) 4649 { 4650 if (p->p_filesz + adjust < p->p_memsz) 4651 { 4652 /* We have a PROGBITS section following NOBITS ones. 4653 Allocate file space for the NOBITS section(s) and 4654 zero it. */ 4655 adjust = p->p_memsz - p->p_filesz; 4656 if (!write_zeros (abfd, off, adjust)) 4657 return FALSE; 4658 } 4659 off += adjust; 4660 p->p_filesz += adjust; 4661 } 4662 } 4663 4664 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core) 4665 { 4666 /* The section at i == 0 is the one that actually contains 4667 everything. */ 4668 if (i == 0) 4669 { 4670 this_hdr->sh_offset = sec->filepos = off; 4671 off += this_hdr->sh_size; 4672 p->p_filesz = this_hdr->sh_size; 4673 p->p_memsz = 0; 4674 p->p_align = 1; 4675 } 4676 else 4677 { 4678 /* The rest are fake sections that shouldn't be written. */ 4679 sec->filepos = 0; 4680 sec->size = 0; 4681 sec->flags = 0; 4682 continue; 4683 } 4684 } 4685 else 4686 { 4687 if (p->p_type == PT_LOAD) 4688 { 4689 this_hdr->sh_offset = sec->filepos = off; 4690 if (this_hdr->sh_type != SHT_NOBITS) 4691 off += this_hdr->sh_size; 4692 } 4693 else if (this_hdr->sh_type == SHT_NOBITS 4694 && (this_hdr->sh_flags & SHF_TLS) != 0 4695 && this_hdr->sh_offset == 0) 4696 { 4697 /* This is a .tbss section that didn't get a PT_LOAD. 4698 (See _bfd_elf_map_sections_to_segments "Create a 4699 final PT_LOAD".) Set sh_offset to the value it 4700 would have if we had created a zero p_filesz and 4701 p_memsz PT_LOAD header for the section. This 4702 also makes the PT_TLS header have the same 4703 p_offset value. */ 4704 bfd_vma adjust = vma_page_aligned_bias (this_hdr->sh_addr, 4705 off, align); 4706 this_hdr->sh_offset = sec->filepos = off + adjust; 4707 } 4708 4709 if (this_hdr->sh_type != SHT_NOBITS) 4710 { 4711 p->p_filesz += this_hdr->sh_size; 4712 /* A load section without SHF_ALLOC is something like 4713 a note section in a PT_NOTE segment. These take 4714 file space but are not loaded into memory. */ 4715 if ((this_hdr->sh_flags & SHF_ALLOC) != 0) 4716 p->p_memsz += this_hdr->sh_size; 4717 } 4718 else if ((this_hdr->sh_flags & SHF_ALLOC) != 0) 4719 { 4720 if (p->p_type == PT_TLS) 4721 p->p_memsz += this_hdr->sh_size; 4722 4723 /* .tbss is special. It doesn't contribute to p_memsz of 4724 normal segments. */ 4725 else if ((this_hdr->sh_flags & SHF_TLS) == 0) 4726 p->p_memsz += this_hdr->sh_size; 4727 } 4728 4729 if (align > p->p_align 4730 && !m->p_align_valid 4731 && (p->p_type != PT_LOAD 4732 || (abfd->flags & D_PAGED) == 0)) 4733 p->p_align = align; 4734 } 4735 4736 if (!m->p_flags_valid) 4737 { 4738 p->p_flags |= PF_R; 4739 if ((this_hdr->sh_flags & SHF_EXECINSTR) != 0) 4740 p->p_flags |= PF_X; 4741 if ((this_hdr->sh_flags & SHF_WRITE) != 0) 4742 p->p_flags |= PF_W; 4743 } 4744 } 4745 off -= off_adjust; 4746 4747 /* Check that all sections are in a PT_LOAD segment. 4748 Don't check funky gdb generated core files. */ 4749 if (p->p_type == PT_LOAD && bfd_get_format (abfd) != bfd_core) 4750 { 4751 bfd_boolean check_vma = TRUE; 4752 4753 for (i = 1; i < m->count; i++) 4754 if (m->sections[i]->vma == m->sections[i - 1]->vma 4755 && ELF_SECTION_SIZE (&(elf_section_data (m->sections[i]) 4756 ->this_hdr), p) != 0 4757 && ELF_SECTION_SIZE (&(elf_section_data (m->sections[i - 1]) 4758 ->this_hdr), p) != 0) 4759 { 4760 /* Looks like we have overlays packed into the segment. */ 4761 check_vma = FALSE; 4762 break; 4763 } 4764 4765 for (i = 0; i < m->count; i++) 4766 { 4767 Elf_Internal_Shdr *this_hdr; 4768 asection *sec; 4769 4770 sec = m->sections[i]; 4771 this_hdr = &(elf_section_data(sec)->this_hdr); 4772 if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr, p, check_vma, 0) 4773 && !ELF_TBSS_SPECIAL (this_hdr, p)) 4774 { 4775 (*_bfd_error_handler) 4776 (_("%B: section `%A' can't be allocated in segment %d"), 4777 abfd, sec, j); 4778 print_segment_map (m); 4779 } 4780 } 4781 } 4782 } 4783 4784 elf_tdata (abfd)->next_file_pos = off; 4785 return TRUE; 4786 } 4787 4788 /* Assign file positions for the other sections. */ 4789 4790 static bfd_boolean 4791 assign_file_positions_for_non_load_sections (bfd *abfd, 4792 struct bfd_link_info *link_info) 4793 { 4794 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 4795 Elf_Internal_Shdr **i_shdrpp; 4796 Elf_Internal_Shdr **hdrpp; 4797 Elf_Internal_Phdr *phdrs; 4798 Elf_Internal_Phdr *p; 4799 struct elf_segment_map *m; 4800 bfd_vma filehdr_vaddr, filehdr_paddr; 4801 bfd_vma phdrs_vaddr, phdrs_paddr; 4802 file_ptr off; 4803 unsigned int num_sec; 4804 unsigned int i; 4805 unsigned int count; 4806 4807 i_shdrpp = elf_elfsections (abfd); 4808 num_sec = elf_numsections (abfd); 4809 off = elf_tdata (abfd)->next_file_pos; 4810 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++) 4811 { 4812 struct elf_obj_tdata *tdata = elf_tdata (abfd); 4813 Elf_Internal_Shdr *hdr; 4814 4815 hdr = *hdrpp; 4816 if (hdr->bfd_section != NULL 4817 && (hdr->bfd_section->filepos != 0 4818 || (hdr->sh_type == SHT_NOBITS 4819 && hdr->contents == NULL))) 4820 BFD_ASSERT (hdr->sh_offset == hdr->bfd_section->filepos); 4821 else if ((hdr->sh_flags & SHF_ALLOC) != 0) 4822 { 4823 (*_bfd_error_handler) 4824 (_("%B: warning: allocated section `%s' not in segment"), 4825 abfd, 4826 (hdr->bfd_section == NULL 4827 ? "*unknown*" 4828 : hdr->bfd_section->name)); 4829 /* We don't need to page align empty sections. */ 4830 if ((abfd->flags & D_PAGED) != 0 && hdr->sh_size != 0) 4831 off += vma_page_aligned_bias (hdr->sh_addr, off, 4832 bed->maxpagesize); 4833 else 4834 off += vma_page_aligned_bias (hdr->sh_addr, off, 4835 hdr->sh_addralign); 4836 off = _bfd_elf_assign_file_position_for_section (hdr, off, 4837 FALSE); 4838 } 4839 else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA) 4840 && hdr->bfd_section == NULL) 4841 || hdr == i_shdrpp[tdata->symtab_section] 4842 || hdr == i_shdrpp[tdata->symtab_shndx_section] 4843 || hdr == i_shdrpp[tdata->strtab_section]) 4844 hdr->sh_offset = -1; 4845 else 4846 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE); 4847 } 4848 4849 /* Now that we have set the section file positions, we can set up 4850 the file positions for the non PT_LOAD segments. */ 4851 count = 0; 4852 filehdr_vaddr = 0; 4853 filehdr_paddr = 0; 4854 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr; 4855 phdrs_paddr = 0; 4856 phdrs = elf_tdata (abfd)->phdr; 4857 for (m = elf_tdata (abfd)->segment_map, p = phdrs; 4858 m != NULL; 4859 m = m->next, p++) 4860 { 4861 ++count; 4862 if (p->p_type != PT_LOAD) 4863 continue; 4864 4865 if (m->includes_filehdr) 4866 { 4867 filehdr_vaddr = p->p_vaddr; 4868 filehdr_paddr = p->p_paddr; 4869 } 4870 if (m->includes_phdrs) 4871 { 4872 phdrs_vaddr = p->p_vaddr; 4873 phdrs_paddr = p->p_paddr; 4874 if (m->includes_filehdr) 4875 { 4876 phdrs_vaddr += bed->s->sizeof_ehdr; 4877 phdrs_paddr += bed->s->sizeof_ehdr; 4878 } 4879 } 4880 } 4881 4882 for (m = elf_tdata (abfd)->segment_map, p = phdrs; 4883 m != NULL; 4884 m = m->next, p++) 4885 { 4886 if (p->p_type == PT_GNU_RELRO) 4887 { 4888 const Elf_Internal_Phdr *lp; 4889 4890 BFD_ASSERT (!m->includes_filehdr && !m->includes_phdrs); 4891 4892 if (link_info != NULL) 4893 { 4894 /* During linking the range of the RELRO segment is passed 4895 in link_info. */ 4896 for (lp = phdrs; lp < phdrs + count; ++lp) 4897 { 4898 if (lp->p_type == PT_LOAD 4899 && lp->p_vaddr >= link_info->relro_start 4900 && lp->p_vaddr < link_info->relro_end 4901 && lp->p_vaddr + lp->p_filesz >= link_info->relro_end) 4902 break; 4903 } 4904 } 4905 else 4906 { 4907 /* Otherwise we are copying an executable or shared 4908 library, but we need to use the same linker logic. */ 4909 for (lp = phdrs; lp < phdrs + count; ++lp) 4910 { 4911 if (lp->p_type == PT_LOAD 4912 && lp->p_paddr == p->p_paddr) 4913 break; 4914 } 4915 } 4916 4917 if (lp < phdrs + count) 4918 { 4919 p->p_vaddr = lp->p_vaddr; 4920 p->p_paddr = lp->p_paddr; 4921 p->p_offset = lp->p_offset; 4922 if (link_info != NULL) 4923 p->p_filesz = link_info->relro_end - lp->p_vaddr; 4924 else if (m->p_size_valid) 4925 p->p_filesz = m->p_size; 4926 else 4927 abort (); 4928 p->p_memsz = p->p_filesz; 4929 p->p_align = 1; 4930 p->p_flags = (lp->p_flags & ~PF_W); 4931 } 4932 else 4933 { 4934 memset (p, 0, sizeof *p); 4935 p->p_type = PT_NULL; 4936 } 4937 } 4938 else if (m->count != 0) 4939 { 4940 if (p->p_type != PT_LOAD 4941 && (p->p_type != PT_NOTE 4942 || bfd_get_format (abfd) != bfd_core)) 4943 { 4944 BFD_ASSERT (!m->includes_filehdr && !m->includes_phdrs); 4945 4946 p->p_filesz = 0; 4947 p->p_offset = m->sections[0]->filepos; 4948 for (i = m->count; i-- != 0;) 4949 { 4950 asection *sect = m->sections[i]; 4951 Elf_Internal_Shdr *hdr = &elf_section_data (sect)->this_hdr; 4952 if (hdr->sh_type != SHT_NOBITS) 4953 { 4954 p->p_filesz = (sect->filepos - m->sections[0]->filepos 4955 + hdr->sh_size); 4956 break; 4957 } 4958 } 4959 } 4960 } 4961 else if (m->includes_filehdr) 4962 { 4963 p->p_vaddr = filehdr_vaddr; 4964 if (! m->p_paddr_valid) 4965 p->p_paddr = filehdr_paddr; 4966 } 4967 else if (m->includes_phdrs) 4968 { 4969 p->p_vaddr = phdrs_vaddr; 4970 if (! m->p_paddr_valid) 4971 p->p_paddr = phdrs_paddr; 4972 } 4973 } 4974 4975 elf_tdata (abfd)->next_file_pos = off; 4976 4977 return TRUE; 4978 } 4979 4980 /* Work out the file positions of all the sections. This is called by 4981 _bfd_elf_compute_section_file_positions. All the section sizes and 4982 VMAs must be known before this is called. 4983 4984 Reloc sections come in two flavours: Those processed specially as 4985 "side-channel" data attached to a section to which they apply, and 4986 those that bfd doesn't process as relocations. The latter sort are 4987 stored in a normal bfd section by bfd_section_from_shdr. We don't 4988 consider the former sort here, unless they form part of the loadable 4989 image. Reloc sections not assigned here will be handled later by 4990 assign_file_positions_for_relocs. 4991 4992 We also don't set the positions of the .symtab and .strtab here. */ 4993 4994 static bfd_boolean 4995 assign_file_positions_except_relocs (bfd *abfd, 4996 struct bfd_link_info *link_info) 4997 { 4998 struct elf_obj_tdata *tdata = elf_tdata (abfd); 4999 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd); 5000 file_ptr off; 5001 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 5002 5003 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 5004 && bfd_get_format (abfd) != bfd_core) 5005 { 5006 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd); 5007 unsigned int num_sec = elf_numsections (abfd); 5008 Elf_Internal_Shdr **hdrpp; 5009 unsigned int i; 5010 5011 /* Start after the ELF header. */ 5012 off = i_ehdrp->e_ehsize; 5013 5014 /* We are not creating an executable, which means that we are 5015 not creating a program header, and that the actual order of 5016 the sections in the file is unimportant. */ 5017 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++) 5018 { 5019 Elf_Internal_Shdr *hdr; 5020 5021 hdr = *hdrpp; 5022 if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA) 5023 && hdr->bfd_section == NULL) 5024 || i == tdata->symtab_section 5025 || i == tdata->symtab_shndx_section 5026 || i == tdata->strtab_section) 5027 { 5028 hdr->sh_offset = -1; 5029 } 5030 else 5031 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE); 5032 } 5033 } 5034 else 5035 { 5036 unsigned int alloc; 5037 5038 /* Assign file positions for the loaded sections based on the 5039 assignment of sections to segments. */ 5040 if (!assign_file_positions_for_load_sections (abfd, link_info)) 5041 return FALSE; 5042 5043 /* And for non-load sections. */ 5044 if (!assign_file_positions_for_non_load_sections (abfd, link_info)) 5045 return FALSE; 5046 5047 if (bed->elf_backend_modify_program_headers != NULL) 5048 { 5049 if (!(*bed->elf_backend_modify_program_headers) (abfd, link_info)) 5050 return FALSE; 5051 } 5052 5053 /* Write out the program headers. */ 5054 alloc = tdata->program_header_size / bed->s->sizeof_phdr; 5055 if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0 5056 || bed->s->write_out_phdrs (abfd, tdata->phdr, alloc) != 0) 5057 return FALSE; 5058 5059 off = tdata->next_file_pos; 5060 } 5061 5062 /* Place the section headers. */ 5063 off = align_file_position (off, 1 << bed->s->log_file_align); 5064 i_ehdrp->e_shoff = off; 5065 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize; 5066 5067 tdata->next_file_pos = off; 5068 5069 return TRUE; 5070 } 5071 5072 static bfd_boolean 5073 prep_headers (bfd *abfd) 5074 { 5075 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form. */ 5076 struct elf_strtab_hash *shstrtab; 5077 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 5078 5079 i_ehdrp = elf_elfheader (abfd); 5080 5081 shstrtab = _bfd_elf_strtab_init (); 5082 if (shstrtab == NULL) 5083 return FALSE; 5084 5085 elf_shstrtab (abfd) = shstrtab; 5086 5087 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0; 5088 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1; 5089 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2; 5090 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3; 5091 5092 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass; 5093 i_ehdrp->e_ident[EI_DATA] = 5094 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB; 5095 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current; 5096 5097 if ((abfd->flags & DYNAMIC) != 0) 5098 i_ehdrp->e_type = ET_DYN; 5099 else if ((abfd->flags & EXEC_P) != 0) 5100 i_ehdrp->e_type = ET_EXEC; 5101 else if (bfd_get_format (abfd) == bfd_core) 5102 i_ehdrp->e_type = ET_CORE; 5103 else 5104 i_ehdrp->e_type = ET_REL; 5105 5106 switch (bfd_get_arch (abfd)) 5107 { 5108 case bfd_arch_unknown: 5109 i_ehdrp->e_machine = EM_NONE; 5110 break; 5111 5112 /* There used to be a long list of cases here, each one setting 5113 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE 5114 in the corresponding bfd definition. To avoid duplication, 5115 the switch was removed. Machines that need special handling 5116 can generally do it in elf_backend_final_write_processing(), 5117 unless they need the information earlier than the final write. 5118 Such need can generally be supplied by replacing the tests for 5119 e_machine with the conditions used to determine it. */ 5120 default: 5121 i_ehdrp->e_machine = bed->elf_machine_code; 5122 } 5123 5124 i_ehdrp->e_version = bed->s->ev_current; 5125 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr; 5126 5127 /* No program header, for now. */ 5128 i_ehdrp->e_phoff = 0; 5129 i_ehdrp->e_phentsize = 0; 5130 i_ehdrp->e_phnum = 0; 5131 5132 /* Each bfd section is section header entry. */ 5133 i_ehdrp->e_entry = bfd_get_start_address (abfd); 5134 i_ehdrp->e_shentsize = bed->s->sizeof_shdr; 5135 5136 /* If we're building an executable, we'll need a program header table. */ 5137 if (abfd->flags & EXEC_P) 5138 /* It all happens later. */ 5139 ; 5140 else 5141 { 5142 i_ehdrp->e_phentsize = 0; 5143 i_ehdrp->e_phoff = 0; 5144 } 5145 5146 elf_tdata (abfd)->symtab_hdr.sh_name = 5147 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE); 5148 elf_tdata (abfd)->strtab_hdr.sh_name = 5149 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE); 5150 elf_tdata (abfd)->shstrtab_hdr.sh_name = 5151 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE); 5152 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1 5153 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1 5154 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1) 5155 return FALSE; 5156 5157 return TRUE; 5158 } 5159 5160 /* Assign file positions for all the reloc sections which are not part 5161 of the loadable file image. */ 5162 5163 void 5164 _bfd_elf_assign_file_positions_for_relocs (bfd *abfd) 5165 { 5166 file_ptr off; 5167 unsigned int i, num_sec; 5168 Elf_Internal_Shdr **shdrpp; 5169 5170 off = elf_tdata (abfd)->next_file_pos; 5171 5172 num_sec = elf_numsections (abfd); 5173 for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++) 5174 { 5175 Elf_Internal_Shdr *shdrp; 5176 5177 shdrp = *shdrpp; 5178 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA) 5179 && shdrp->sh_offset == -1) 5180 off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE); 5181 } 5182 5183 elf_tdata (abfd)->next_file_pos = off; 5184 } 5185 5186 bfd_boolean 5187 _bfd_elf_write_object_contents (bfd *abfd) 5188 { 5189 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 5190 Elf_Internal_Shdr **i_shdrp; 5191 bfd_boolean failed; 5192 unsigned int count, num_sec; 5193 5194 if (! abfd->output_has_begun 5195 && ! _bfd_elf_compute_section_file_positions (abfd, NULL)) 5196 return FALSE; 5197 5198 i_shdrp = elf_elfsections (abfd); 5199 5200 failed = FALSE; 5201 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed); 5202 if (failed) 5203 return FALSE; 5204 5205 _bfd_elf_assign_file_positions_for_relocs (abfd); 5206 5207 /* After writing the headers, we need to write the sections too... */ 5208 num_sec = elf_numsections (abfd); 5209 for (count = 1; count < num_sec; count++) 5210 { 5211 if (bed->elf_backend_section_processing) 5212 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]); 5213 if (i_shdrp[count]->contents) 5214 { 5215 bfd_size_type amt = i_shdrp[count]->sh_size; 5216 5217 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0 5218 || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt) 5219 return FALSE; 5220 } 5221 } 5222 5223 /* Write out the section header names. */ 5224 if (elf_shstrtab (abfd) != NULL 5225 && (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0 5226 || !_bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd)))) 5227 return FALSE; 5228 5229 if (bed->elf_backend_final_write_processing) 5230 (*bed->elf_backend_final_write_processing) (abfd, 5231 elf_tdata (abfd)->linker); 5232 5233 if (!bed->s->write_shdrs_and_ehdr (abfd)) 5234 return FALSE; 5235 5236 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */ 5237 if (elf_tdata (abfd)->after_write_object_contents) 5238 return (*elf_tdata (abfd)->after_write_object_contents) (abfd); 5239 5240 return TRUE; 5241 } 5242 5243 bfd_boolean 5244 _bfd_elf_write_corefile_contents (bfd *abfd) 5245 { 5246 /* Hopefully this can be done just like an object file. */ 5247 return _bfd_elf_write_object_contents (abfd); 5248 } 5249 5250 /* Given a section, search the header to find them. */ 5251 5252 unsigned int 5253 _bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect) 5254 { 5255 const struct elf_backend_data *bed; 5256 unsigned int sec_index; 5257 5258 if (elf_section_data (asect) != NULL 5259 && elf_section_data (asect)->this_idx != 0) 5260 return elf_section_data (asect)->this_idx; 5261 5262 if (bfd_is_abs_section (asect)) 5263 sec_index = SHN_ABS; 5264 else if (bfd_is_com_section (asect)) 5265 sec_index = SHN_COMMON; 5266 else if (bfd_is_und_section (asect)) 5267 sec_index = SHN_UNDEF; 5268 else 5269 sec_index = SHN_BAD; 5270 5271 bed = get_elf_backend_data (abfd); 5272 if (bed->elf_backend_section_from_bfd_section) 5273 { 5274 int retval = sec_index; 5275 5276 if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval)) 5277 return retval; 5278 } 5279 5280 if (sec_index == SHN_BAD) 5281 bfd_set_error (bfd_error_nonrepresentable_section); 5282 5283 return sec_index; 5284 } 5285 5286 /* Given a BFD symbol, return the index in the ELF symbol table, or -1 5287 on error. */ 5288 5289 int 5290 _bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr) 5291 { 5292 asymbol *asym_ptr = *asym_ptr_ptr; 5293 int idx; 5294 flagword flags = asym_ptr->flags; 5295 5296 /* When gas creates relocations against local labels, it creates its 5297 own symbol for the section, but does put the symbol into the 5298 symbol chain, so udata is 0. When the linker is generating 5299 relocatable output, this section symbol may be for one of the 5300 input sections rather than the output section. */ 5301 if (asym_ptr->udata.i == 0 5302 && (flags & BSF_SECTION_SYM) 5303 && asym_ptr->section) 5304 { 5305 asection *sec; 5306 int indx; 5307 5308 sec = asym_ptr->section; 5309 if (sec->owner != abfd && sec->output_section != NULL) 5310 sec = sec->output_section; 5311 if (sec->owner == abfd 5312 && (indx = sec->index) < elf_num_section_syms (abfd) 5313 && elf_section_syms (abfd)[indx] != NULL) 5314 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i; 5315 } 5316 5317 idx = asym_ptr->udata.i; 5318 5319 if (idx == 0) 5320 { 5321 /* This case can occur when using --strip-symbol on a symbol 5322 which is used in a relocation entry. */ 5323 (*_bfd_error_handler) 5324 (_("%B: symbol `%s' required but not present"), 5325 abfd, bfd_asymbol_name (asym_ptr)); 5326 bfd_set_error (bfd_error_no_symbols); 5327 return -1; 5328 } 5329 5330 #if DEBUG & 4 5331 { 5332 fprintf (stderr, 5333 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx\n", 5334 (long) asym_ptr, asym_ptr->name, idx, (long) flags); 5335 fflush (stderr); 5336 } 5337 #endif 5338 5339 return idx; 5340 } 5341 5342 /* Rewrite program header information. */ 5343 5344 static bfd_boolean 5345 rewrite_elf_program_header (bfd *ibfd, bfd *obfd) 5346 { 5347 Elf_Internal_Ehdr *iehdr; 5348 struct elf_segment_map *map; 5349 struct elf_segment_map *map_first; 5350 struct elf_segment_map **pointer_to_map; 5351 Elf_Internal_Phdr *segment; 5352 asection *section; 5353 unsigned int i; 5354 unsigned int num_segments; 5355 bfd_boolean phdr_included = FALSE; 5356 bfd_boolean p_paddr_valid; 5357 bfd_vma maxpagesize; 5358 struct elf_segment_map *phdr_adjust_seg = NULL; 5359 unsigned int phdr_adjust_num = 0; 5360 const struct elf_backend_data *bed; 5361 5362 bed = get_elf_backend_data (ibfd); 5363 iehdr = elf_elfheader (ibfd); 5364 5365 map_first = NULL; 5366 pointer_to_map = &map_first; 5367 5368 num_segments = elf_elfheader (ibfd)->e_phnum; 5369 maxpagesize = get_elf_backend_data (obfd)->maxpagesize; 5370 5371 /* Returns the end address of the segment + 1. */ 5372 #define SEGMENT_END(segment, start) \ 5373 (start + (segment->p_memsz > segment->p_filesz \ 5374 ? segment->p_memsz : segment->p_filesz)) 5375 5376 #define SECTION_SIZE(section, segment) \ 5377 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \ 5378 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \ 5379 ? section->size : 0) 5380 5381 /* Returns TRUE if the given section is contained within 5382 the given segment. VMA addresses are compared. */ 5383 #define IS_CONTAINED_BY_VMA(section, segment) \ 5384 (section->vma >= segment->p_vaddr \ 5385 && (section->vma + SECTION_SIZE (section, segment) \ 5386 <= (SEGMENT_END (segment, segment->p_vaddr)))) 5387 5388 /* Returns TRUE if the given section is contained within 5389 the given segment. LMA addresses are compared. */ 5390 #define IS_CONTAINED_BY_LMA(section, segment, base) \ 5391 (section->lma >= base \ 5392 && (section->lma + SECTION_SIZE (section, segment) \ 5393 <= SEGMENT_END (segment, base))) 5394 5395 /* Handle PT_NOTE segment. */ 5396 #define IS_NOTE(p, s) \ 5397 (p->p_type == PT_NOTE \ 5398 && elf_section_type (s) == SHT_NOTE \ 5399 && (bfd_vma) s->filepos >= p->p_offset \ 5400 && ((bfd_vma) s->filepos + s->size \ 5401 <= p->p_offset + p->p_filesz)) 5402 5403 /* Special case: corefile "NOTE" section containing regs, prpsinfo 5404 etc. */ 5405 #define IS_COREFILE_NOTE(p, s) \ 5406 (IS_NOTE (p, s) \ 5407 && bfd_get_format (ibfd) == bfd_core \ 5408 && s->vma == 0 \ 5409 && s->lma == 0) 5410 5411 /* The complicated case when p_vaddr is 0 is to handle the Solaris 5412 linker, which generates a PT_INTERP section with p_vaddr and 5413 p_memsz set to 0. */ 5414 #define IS_SOLARIS_PT_INTERP(p, s) \ 5415 (p->p_vaddr == 0 \ 5416 && p->p_paddr == 0 \ 5417 && p->p_memsz == 0 \ 5418 && p->p_filesz > 0 \ 5419 && (s->flags & SEC_HAS_CONTENTS) != 0 \ 5420 && s->size > 0 \ 5421 && (bfd_vma) s->filepos >= p->p_offset \ 5422 && ((bfd_vma) s->filepos + s->size \ 5423 <= p->p_offset + p->p_filesz)) 5424 5425 /* Decide if the given section should be included in the given segment. 5426 A section will be included if: 5427 1. It is within the address space of the segment -- we use the LMA 5428 if that is set for the segment and the VMA otherwise, 5429 2. It is an allocated section or a NOTE section in a PT_NOTE 5430 segment. 5431 3. There is an output section associated with it, 5432 4. The section has not already been allocated to a previous segment. 5433 5. PT_GNU_STACK segments do not include any sections. 5434 6. PT_TLS segment includes only SHF_TLS sections. 5435 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments. 5436 8. PT_DYNAMIC should not contain empty sections at the beginning 5437 (with the possible exception of .dynamic). */ 5438 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \ 5439 ((((segment->p_paddr \ 5440 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \ 5441 : IS_CONTAINED_BY_VMA (section, segment)) \ 5442 && (section->flags & SEC_ALLOC) != 0) \ 5443 || IS_NOTE (segment, section)) \ 5444 && segment->p_type != PT_GNU_STACK \ 5445 && (segment->p_type != PT_TLS \ 5446 || (section->flags & SEC_THREAD_LOCAL)) \ 5447 && (segment->p_type == PT_LOAD \ 5448 || segment->p_type == PT_TLS \ 5449 || (section->flags & SEC_THREAD_LOCAL) == 0) \ 5450 && (segment->p_type != PT_DYNAMIC \ 5451 || SECTION_SIZE (section, segment) > 0 \ 5452 || (segment->p_paddr \ 5453 ? segment->p_paddr != section->lma \ 5454 : segment->p_vaddr != section->vma) \ 5455 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \ 5456 == 0)) \ 5457 && !section->segment_mark) 5458 5459 /* If the output section of a section in the input segment is NULL, 5460 it is removed from the corresponding output segment. */ 5461 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \ 5462 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \ 5463 && section->output_section != NULL) 5464 5465 /* Returns TRUE iff seg1 starts after the end of seg2. */ 5466 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \ 5467 (seg1->field >= SEGMENT_END (seg2, seg2->field)) 5468 5469 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both 5470 their VMA address ranges and their LMA address ranges overlap. 5471 It is possible to have overlapping VMA ranges without overlapping LMA 5472 ranges. RedBoot images for example can have both .data and .bss mapped 5473 to the same VMA range, but with the .data section mapped to a different 5474 LMA. */ 5475 #define SEGMENT_OVERLAPS(seg1, seg2) \ 5476 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \ 5477 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \ 5478 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \ 5479 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr))) 5480 5481 /* Initialise the segment mark field. */ 5482 for (section = ibfd->sections; section != NULL; section = section->next) 5483 section->segment_mark = FALSE; 5484 5485 /* The Solaris linker creates program headers in which all the 5486 p_paddr fields are zero. When we try to objcopy or strip such a 5487 file, we get confused. Check for this case, and if we find it 5488 don't set the p_paddr_valid fields. */ 5489 p_paddr_valid = FALSE; 5490 for (i = 0, segment = elf_tdata (ibfd)->phdr; 5491 i < num_segments; 5492 i++, segment++) 5493 if (segment->p_paddr != 0) 5494 { 5495 p_paddr_valid = TRUE; 5496 break; 5497 } 5498 5499 /* Scan through the segments specified in the program header 5500 of the input BFD. For this first scan we look for overlaps 5501 in the loadable segments. These can be created by weird 5502 parameters to objcopy. Also, fix some solaris weirdness. */ 5503 for (i = 0, segment = elf_tdata (ibfd)->phdr; 5504 i < num_segments; 5505 i++, segment++) 5506 { 5507 unsigned int j; 5508 Elf_Internal_Phdr *segment2; 5509 5510 if (segment->p_type == PT_INTERP) 5511 for (section = ibfd->sections; section; section = section->next) 5512 if (IS_SOLARIS_PT_INTERP (segment, section)) 5513 { 5514 /* Mininal change so that the normal section to segment 5515 assignment code will work. */ 5516 segment->p_vaddr = section->vma; 5517 break; 5518 } 5519 5520 if (segment->p_type != PT_LOAD) 5521 { 5522 /* Remove PT_GNU_RELRO segment. */ 5523 if (segment->p_type == PT_GNU_RELRO) 5524 segment->p_type = PT_NULL; 5525 continue; 5526 } 5527 5528 /* Determine if this segment overlaps any previous segments. */ 5529 for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2++) 5530 { 5531 bfd_signed_vma extra_length; 5532 5533 if (segment2->p_type != PT_LOAD 5534 || !SEGMENT_OVERLAPS (segment, segment2)) 5535 continue; 5536 5537 /* Merge the two segments together. */ 5538 if (segment2->p_vaddr < segment->p_vaddr) 5539 { 5540 /* Extend SEGMENT2 to include SEGMENT and then delete 5541 SEGMENT. */ 5542 extra_length = (SEGMENT_END (segment, segment->p_vaddr) 5543 - SEGMENT_END (segment2, segment2->p_vaddr)); 5544 5545 if (extra_length > 0) 5546 { 5547 segment2->p_memsz += extra_length; 5548 segment2->p_filesz += extra_length; 5549 } 5550 5551 segment->p_type = PT_NULL; 5552 5553 /* Since we have deleted P we must restart the outer loop. */ 5554 i = 0; 5555 segment = elf_tdata (ibfd)->phdr; 5556 break; 5557 } 5558 else 5559 { 5560 /* Extend SEGMENT to include SEGMENT2 and then delete 5561 SEGMENT2. */ 5562 extra_length = (SEGMENT_END (segment2, segment2->p_vaddr) 5563 - SEGMENT_END (segment, segment->p_vaddr)); 5564 5565 if (extra_length > 0) 5566 { 5567 segment->p_memsz += extra_length; 5568 segment->p_filesz += extra_length; 5569 } 5570 5571 segment2->p_type = PT_NULL; 5572 } 5573 } 5574 } 5575 5576 /* The second scan attempts to assign sections to segments. */ 5577 for (i = 0, segment = elf_tdata (ibfd)->phdr; 5578 i < num_segments; 5579 i++, segment++) 5580 { 5581 unsigned int section_count; 5582 asection **sections; 5583 asection *output_section; 5584 unsigned int isec; 5585 bfd_vma matching_lma; 5586 bfd_vma suggested_lma; 5587 unsigned int j; 5588 bfd_size_type amt; 5589 asection *first_section; 5590 bfd_boolean first_matching_lma; 5591 bfd_boolean first_suggested_lma; 5592 5593 if (segment->p_type == PT_NULL) 5594 continue; 5595 5596 first_section = NULL; 5597 /* Compute how many sections might be placed into this segment. */ 5598 for (section = ibfd->sections, section_count = 0; 5599 section != NULL; 5600 section = section->next) 5601 { 5602 /* Find the first section in the input segment, which may be 5603 removed from the corresponding output segment. */ 5604 if (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed)) 5605 { 5606 if (first_section == NULL) 5607 first_section = section; 5608 if (section->output_section != NULL) 5609 ++section_count; 5610 } 5611 } 5612 5613 /* Allocate a segment map big enough to contain 5614 all of the sections we have selected. */ 5615 amt = sizeof (struct elf_segment_map); 5616 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *); 5617 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt); 5618 if (map == NULL) 5619 return FALSE; 5620 5621 /* Initialise the fields of the segment map. Default to 5622 using the physical address of the segment in the input BFD. */ 5623 map->next = NULL; 5624 map->p_type = segment->p_type; 5625 map->p_flags = segment->p_flags; 5626 map->p_flags_valid = 1; 5627 5628 /* If the first section in the input segment is removed, there is 5629 no need to preserve segment physical address in the corresponding 5630 output segment. */ 5631 if (!first_section || first_section->output_section != NULL) 5632 { 5633 map->p_paddr = segment->p_paddr; 5634 map->p_paddr_valid = p_paddr_valid; 5635 } 5636 5637 /* Determine if this segment contains the ELF file header 5638 and if it contains the program headers themselves. */ 5639 map->includes_filehdr = (segment->p_offset == 0 5640 && segment->p_filesz >= iehdr->e_ehsize); 5641 map->includes_phdrs = 0; 5642 5643 if (!phdr_included || segment->p_type != PT_LOAD) 5644 { 5645 map->includes_phdrs = 5646 (segment->p_offset <= (bfd_vma) iehdr->e_phoff 5647 && (segment->p_offset + segment->p_filesz 5648 >= ((bfd_vma) iehdr->e_phoff 5649 + iehdr->e_phnum * iehdr->e_phentsize))); 5650 5651 if (segment->p_type == PT_LOAD && map->includes_phdrs) 5652 phdr_included = TRUE; 5653 } 5654 5655 if (section_count == 0) 5656 { 5657 /* Special segments, such as the PT_PHDR segment, may contain 5658 no sections, but ordinary, loadable segments should contain 5659 something. They are allowed by the ELF spec however, so only 5660 a warning is produced. */ 5661 if (segment->p_type == PT_LOAD) 5662 (*_bfd_error_handler) (_("%B: warning: Empty loadable segment" 5663 " detected, is this intentional ?\n"), 5664 ibfd); 5665 5666 map->count = 0; 5667 *pointer_to_map = map; 5668 pointer_to_map = &map->next; 5669 5670 continue; 5671 } 5672 5673 /* Now scan the sections in the input BFD again and attempt 5674 to add their corresponding output sections to the segment map. 5675 The problem here is how to handle an output section which has 5676 been moved (ie had its LMA changed). There are four possibilities: 5677 5678 1. None of the sections have been moved. 5679 In this case we can continue to use the segment LMA from the 5680 input BFD. 5681 5682 2. All of the sections have been moved by the same amount. 5683 In this case we can change the segment's LMA to match the LMA 5684 of the first section. 5685 5686 3. Some of the sections have been moved, others have not. 5687 In this case those sections which have not been moved can be 5688 placed in the current segment which will have to have its size, 5689 and possibly its LMA changed, and a new segment or segments will 5690 have to be created to contain the other sections. 5691 5692 4. The sections have been moved, but not by the same amount. 5693 In this case we can change the segment's LMA to match the LMA 5694 of the first section and we will have to create a new segment 5695 or segments to contain the other sections. 5696 5697 In order to save time, we allocate an array to hold the section 5698 pointers that we are interested in. As these sections get assigned 5699 to a segment, they are removed from this array. */ 5700 5701 sections = (asection **) bfd_malloc2 (section_count, sizeof (asection *)); 5702 if (sections == NULL) 5703 return FALSE; 5704 5705 /* Step One: Scan for segment vs section LMA conflicts. 5706 Also add the sections to the section array allocated above. 5707 Also add the sections to the current segment. In the common 5708 case, where the sections have not been moved, this means that 5709 we have completely filled the segment, and there is nothing 5710 more to do. */ 5711 isec = 0; 5712 matching_lma = 0; 5713 suggested_lma = 0; 5714 first_matching_lma = TRUE; 5715 first_suggested_lma = TRUE; 5716 5717 for (section = ibfd->sections; 5718 section != NULL; 5719 section = section->next) 5720 if (section == first_section) 5721 break; 5722 5723 for (j = 0; section != NULL; section = section->next) 5724 { 5725 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed)) 5726 { 5727 output_section = section->output_section; 5728 5729 sections[j++] = section; 5730 5731 /* The Solaris native linker always sets p_paddr to 0. 5732 We try to catch that case here, and set it to the 5733 correct value. Note - some backends require that 5734 p_paddr be left as zero. */ 5735 if (!p_paddr_valid 5736 && segment->p_vaddr != 0 5737 && !bed->want_p_paddr_set_to_zero 5738 && isec == 0 5739 && output_section->lma != 0 5740 && output_section->vma == (segment->p_vaddr 5741 + (map->includes_filehdr 5742 ? iehdr->e_ehsize 5743 : 0) 5744 + (map->includes_phdrs 5745 ? (iehdr->e_phnum 5746 * iehdr->e_phentsize) 5747 : 0))) 5748 map->p_paddr = segment->p_vaddr; 5749 5750 /* Match up the physical address of the segment with the 5751 LMA address of the output section. */ 5752 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr) 5753 || IS_COREFILE_NOTE (segment, section) 5754 || (bed->want_p_paddr_set_to_zero 5755 && IS_CONTAINED_BY_VMA (output_section, segment))) 5756 { 5757 if (first_matching_lma || output_section->lma < matching_lma) 5758 { 5759 matching_lma = output_section->lma; 5760 first_matching_lma = FALSE; 5761 } 5762 5763 /* We assume that if the section fits within the segment 5764 then it does not overlap any other section within that 5765 segment. */ 5766 map->sections[isec++] = output_section; 5767 } 5768 else if (first_suggested_lma) 5769 { 5770 suggested_lma = output_section->lma; 5771 first_suggested_lma = FALSE; 5772 } 5773 5774 if (j == section_count) 5775 break; 5776 } 5777 } 5778 5779 BFD_ASSERT (j == section_count); 5780 5781 /* Step Two: Adjust the physical address of the current segment, 5782 if necessary. */ 5783 if (isec == section_count) 5784 { 5785 /* All of the sections fitted within the segment as currently 5786 specified. This is the default case. Add the segment to 5787 the list of built segments and carry on to process the next 5788 program header in the input BFD. */ 5789 map->count = section_count; 5790 *pointer_to_map = map; 5791 pointer_to_map = &map->next; 5792 5793 if (p_paddr_valid 5794 && !bed->want_p_paddr_set_to_zero 5795 && matching_lma != map->p_paddr 5796 && !map->includes_filehdr 5797 && !map->includes_phdrs) 5798 /* There is some padding before the first section in the 5799 segment. So, we must account for that in the output 5800 segment's vma. */ 5801 map->p_vaddr_offset = matching_lma - map->p_paddr; 5802 5803 free (sections); 5804 continue; 5805 } 5806 else 5807 { 5808 if (!first_matching_lma) 5809 { 5810 /* At least one section fits inside the current segment. 5811 Keep it, but modify its physical address to match the 5812 LMA of the first section that fitted. */ 5813 map->p_paddr = matching_lma; 5814 } 5815 else 5816 { 5817 /* None of the sections fitted inside the current segment. 5818 Change the current segment's physical address to match 5819 the LMA of the first section. */ 5820 map->p_paddr = suggested_lma; 5821 } 5822 5823 /* Offset the segment physical address from the lma 5824 to allow for space taken up by elf headers. */ 5825 if (map->includes_filehdr) 5826 { 5827 if (map->p_paddr >= iehdr->e_ehsize) 5828 map->p_paddr -= iehdr->e_ehsize; 5829 else 5830 { 5831 map->includes_filehdr = FALSE; 5832 map->includes_phdrs = FALSE; 5833 } 5834 } 5835 5836 if (map->includes_phdrs) 5837 { 5838 if (map->p_paddr >= iehdr->e_phnum * iehdr->e_phentsize) 5839 { 5840 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize; 5841 5842 /* iehdr->e_phnum is just an estimate of the number 5843 of program headers that we will need. Make a note 5844 here of the number we used and the segment we chose 5845 to hold these headers, so that we can adjust the 5846 offset when we know the correct value. */ 5847 phdr_adjust_num = iehdr->e_phnum; 5848 phdr_adjust_seg = map; 5849 } 5850 else 5851 map->includes_phdrs = FALSE; 5852 } 5853 } 5854 5855 /* Step Three: Loop over the sections again, this time assigning 5856 those that fit to the current segment and removing them from the 5857 sections array; but making sure not to leave large gaps. Once all 5858 possible sections have been assigned to the current segment it is 5859 added to the list of built segments and if sections still remain 5860 to be assigned, a new segment is constructed before repeating 5861 the loop. */ 5862 isec = 0; 5863 do 5864 { 5865 map->count = 0; 5866 suggested_lma = 0; 5867 first_suggested_lma = TRUE; 5868 5869 /* Fill the current segment with sections that fit. */ 5870 for (j = 0; j < section_count; j++) 5871 { 5872 section = sections[j]; 5873 5874 if (section == NULL) 5875 continue; 5876 5877 output_section = section->output_section; 5878 5879 BFD_ASSERT (output_section != NULL); 5880 5881 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr) 5882 || IS_COREFILE_NOTE (segment, section)) 5883 { 5884 if (map->count == 0) 5885 { 5886 /* If the first section in a segment does not start at 5887 the beginning of the segment, then something is 5888 wrong. */ 5889 if (output_section->lma 5890 != (map->p_paddr 5891 + (map->includes_filehdr ? iehdr->e_ehsize : 0) 5892 + (map->includes_phdrs 5893 ? iehdr->e_phnum * iehdr->e_phentsize 5894 : 0))) 5895 abort (); 5896 } 5897 else 5898 { 5899 asection *prev_sec; 5900 5901 prev_sec = map->sections[map->count - 1]; 5902 5903 /* If the gap between the end of the previous section 5904 and the start of this section is more than 5905 maxpagesize then we need to start a new segment. */ 5906 if ((BFD_ALIGN (prev_sec->lma + prev_sec->size, 5907 maxpagesize) 5908 < BFD_ALIGN (output_section->lma, maxpagesize)) 5909 || (prev_sec->lma + prev_sec->size 5910 > output_section->lma)) 5911 { 5912 if (first_suggested_lma) 5913 { 5914 suggested_lma = output_section->lma; 5915 first_suggested_lma = FALSE; 5916 } 5917 5918 continue; 5919 } 5920 } 5921 5922 map->sections[map->count++] = output_section; 5923 ++isec; 5924 sections[j] = NULL; 5925 section->segment_mark = TRUE; 5926 } 5927 else if (first_suggested_lma) 5928 { 5929 suggested_lma = output_section->lma; 5930 first_suggested_lma = FALSE; 5931 } 5932 } 5933 5934 BFD_ASSERT (map->count > 0); 5935 5936 /* Add the current segment to the list of built segments. */ 5937 *pointer_to_map = map; 5938 pointer_to_map = &map->next; 5939 5940 if (isec < section_count) 5941 { 5942 /* We still have not allocated all of the sections to 5943 segments. Create a new segment here, initialise it 5944 and carry on looping. */ 5945 amt = sizeof (struct elf_segment_map); 5946 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *); 5947 map = (struct elf_segment_map *) bfd_alloc (obfd, amt); 5948 if (map == NULL) 5949 { 5950 free (sections); 5951 return FALSE; 5952 } 5953 5954 /* Initialise the fields of the segment map. Set the physical 5955 physical address to the LMA of the first section that has 5956 not yet been assigned. */ 5957 map->next = NULL; 5958 map->p_type = segment->p_type; 5959 map->p_flags = segment->p_flags; 5960 map->p_flags_valid = 1; 5961 map->p_paddr = suggested_lma; 5962 map->p_paddr_valid = p_paddr_valid; 5963 map->includes_filehdr = 0; 5964 map->includes_phdrs = 0; 5965 } 5966 } 5967 while (isec < section_count); 5968 5969 free (sections); 5970 } 5971 5972 elf_tdata (obfd)->segment_map = map_first; 5973 5974 /* If we had to estimate the number of program headers that were 5975 going to be needed, then check our estimate now and adjust 5976 the offset if necessary. */ 5977 if (phdr_adjust_seg != NULL) 5978 { 5979 unsigned int count; 5980 5981 for (count = 0, map = map_first; map != NULL; map = map->next) 5982 count++; 5983 5984 if (count > phdr_adjust_num) 5985 phdr_adjust_seg->p_paddr 5986 -= (count - phdr_adjust_num) * iehdr->e_phentsize; 5987 } 5988 5989 #undef SEGMENT_END 5990 #undef SECTION_SIZE 5991 #undef IS_CONTAINED_BY_VMA 5992 #undef IS_CONTAINED_BY_LMA 5993 #undef IS_NOTE 5994 #undef IS_COREFILE_NOTE 5995 #undef IS_SOLARIS_PT_INTERP 5996 #undef IS_SECTION_IN_INPUT_SEGMENT 5997 #undef INCLUDE_SECTION_IN_SEGMENT 5998 #undef SEGMENT_AFTER_SEGMENT 5999 #undef SEGMENT_OVERLAPS 6000 return TRUE; 6001 } 6002 6003 /* Copy ELF program header information. */ 6004 6005 static bfd_boolean 6006 copy_elf_program_header (bfd *ibfd, bfd *obfd) 6007 { 6008 Elf_Internal_Ehdr *iehdr; 6009 struct elf_segment_map *map; 6010 struct elf_segment_map *map_first; 6011 struct elf_segment_map **pointer_to_map; 6012 Elf_Internal_Phdr *segment; 6013 unsigned int i; 6014 unsigned int num_segments; 6015 bfd_boolean phdr_included = FALSE; 6016 bfd_boolean p_paddr_valid; 6017 6018 iehdr = elf_elfheader (ibfd); 6019 6020 map_first = NULL; 6021 pointer_to_map = &map_first; 6022 6023 /* If all the segment p_paddr fields are zero, don't set 6024 map->p_paddr_valid. */ 6025 p_paddr_valid = FALSE; 6026 num_segments = elf_elfheader (ibfd)->e_phnum; 6027 for (i = 0, segment = elf_tdata (ibfd)->phdr; 6028 i < num_segments; 6029 i++, segment++) 6030 if (segment->p_paddr != 0) 6031 { 6032 p_paddr_valid = TRUE; 6033 break; 6034 } 6035 6036 for (i = 0, segment = elf_tdata (ibfd)->phdr; 6037 i < num_segments; 6038 i++, segment++) 6039 { 6040 asection *section; 6041 unsigned int section_count; 6042 bfd_size_type amt; 6043 Elf_Internal_Shdr *this_hdr; 6044 asection *first_section = NULL; 6045 asection *lowest_section; 6046 6047 /* Compute how many sections are in this segment. */ 6048 for (section = ibfd->sections, section_count = 0; 6049 section != NULL; 6050 section = section->next) 6051 { 6052 this_hdr = &(elf_section_data(section)->this_hdr); 6053 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment)) 6054 { 6055 if (first_section == NULL) 6056 first_section = section; 6057 section_count++; 6058 } 6059 } 6060 6061 /* Allocate a segment map big enough to contain 6062 all of the sections we have selected. */ 6063 amt = sizeof (struct elf_segment_map); 6064 if (section_count != 0) 6065 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *); 6066 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt); 6067 if (map == NULL) 6068 return FALSE; 6069 6070 /* Initialize the fields of the output segment map with the 6071 input segment. */ 6072 map->next = NULL; 6073 map->p_type = segment->p_type; 6074 map->p_flags = segment->p_flags; 6075 map->p_flags_valid = 1; 6076 map->p_paddr = segment->p_paddr; 6077 map->p_paddr_valid = p_paddr_valid; 6078 map->p_align = segment->p_align; 6079 map->p_align_valid = 1; 6080 map->p_vaddr_offset = 0; 6081 6082 if (map->p_type == PT_GNU_RELRO) 6083 { 6084 /* The PT_GNU_RELRO segment may contain the first a few 6085 bytes in the .got.plt section even if the whole .got.plt 6086 section isn't in the PT_GNU_RELRO segment. We won't 6087 change the size of the PT_GNU_RELRO segment. */ 6088 map->p_size = segment->p_memsz; 6089 map->p_size_valid = 1; 6090 } 6091 6092 /* Determine if this segment contains the ELF file header 6093 and if it contains the program headers themselves. */ 6094 map->includes_filehdr = (segment->p_offset == 0 6095 && segment->p_filesz >= iehdr->e_ehsize); 6096 6097 map->includes_phdrs = 0; 6098 if (! phdr_included || segment->p_type != PT_LOAD) 6099 { 6100 map->includes_phdrs = 6101 (segment->p_offset <= (bfd_vma) iehdr->e_phoff 6102 && (segment->p_offset + segment->p_filesz 6103 >= ((bfd_vma) iehdr->e_phoff 6104 + iehdr->e_phnum * iehdr->e_phentsize))); 6105 6106 if (segment->p_type == PT_LOAD && map->includes_phdrs) 6107 phdr_included = TRUE; 6108 } 6109 6110 lowest_section = first_section; 6111 if (section_count != 0) 6112 { 6113 unsigned int isec = 0; 6114 6115 for (section = first_section; 6116 section != NULL; 6117 section = section->next) 6118 { 6119 this_hdr = &(elf_section_data(section)->this_hdr); 6120 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment)) 6121 { 6122 map->sections[isec++] = section->output_section; 6123 if (section->lma < lowest_section->lma) 6124 lowest_section = section; 6125 if ((section->flags & SEC_ALLOC) != 0) 6126 { 6127 bfd_vma seg_off; 6128 6129 /* Section lmas are set up from PT_LOAD header 6130 p_paddr in _bfd_elf_make_section_from_shdr. 6131 If this header has a p_paddr that disagrees 6132 with the section lma, flag the p_paddr as 6133 invalid. */ 6134 if ((section->flags & SEC_LOAD) != 0) 6135 seg_off = this_hdr->sh_offset - segment->p_offset; 6136 else 6137 seg_off = this_hdr->sh_addr - segment->p_vaddr; 6138 if (section->lma - segment->p_paddr != seg_off) 6139 map->p_paddr_valid = FALSE; 6140 } 6141 if (isec == section_count) 6142 break; 6143 } 6144 } 6145 } 6146 6147 if (map->includes_filehdr && lowest_section != NULL) 6148 /* We need to keep the space used by the headers fixed. */ 6149 map->header_size = lowest_section->vma - segment->p_vaddr; 6150 6151 if (!map->includes_phdrs 6152 && !map->includes_filehdr 6153 && map->p_paddr_valid) 6154 /* There is some other padding before the first section. */ 6155 map->p_vaddr_offset = ((lowest_section ? lowest_section->lma : 0) 6156 - segment->p_paddr); 6157 6158 map->count = section_count; 6159 *pointer_to_map = map; 6160 pointer_to_map = &map->next; 6161 } 6162 6163 elf_tdata (obfd)->segment_map = map_first; 6164 return TRUE; 6165 } 6166 6167 /* Copy private BFD data. This copies or rewrites ELF program header 6168 information. */ 6169 6170 static bfd_boolean 6171 copy_private_bfd_data (bfd *ibfd, bfd *obfd) 6172 { 6173 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 6174 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 6175 return TRUE; 6176 6177 if (elf_tdata (ibfd)->phdr == NULL) 6178 return TRUE; 6179 6180 if (ibfd->xvec == obfd->xvec) 6181 { 6182 /* Check to see if any sections in the input BFD 6183 covered by ELF program header have changed. */ 6184 Elf_Internal_Phdr *segment; 6185 asection *section, *osec; 6186 unsigned int i, num_segments; 6187 Elf_Internal_Shdr *this_hdr; 6188 const struct elf_backend_data *bed; 6189 6190 bed = get_elf_backend_data (ibfd); 6191 6192 /* Regenerate the segment map if p_paddr is set to 0. */ 6193 if (bed->want_p_paddr_set_to_zero) 6194 goto rewrite; 6195 6196 /* Initialize the segment mark field. */ 6197 for (section = obfd->sections; section != NULL; 6198 section = section->next) 6199 section->segment_mark = FALSE; 6200 6201 num_segments = elf_elfheader (ibfd)->e_phnum; 6202 for (i = 0, segment = elf_tdata (ibfd)->phdr; 6203 i < num_segments; 6204 i++, segment++) 6205 { 6206 /* PR binutils/3535. The Solaris linker always sets the p_paddr 6207 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0 6208 which severly confuses things, so always regenerate the segment 6209 map in this case. */ 6210 if (segment->p_paddr == 0 6211 && segment->p_memsz == 0 6212 && (segment->p_type == PT_INTERP || segment->p_type == PT_DYNAMIC)) 6213 goto rewrite; 6214 6215 for (section = ibfd->sections; 6216 section != NULL; section = section->next) 6217 { 6218 /* We mark the output section so that we know it comes 6219 from the input BFD. */ 6220 osec = section->output_section; 6221 if (osec) 6222 osec->segment_mark = TRUE; 6223 6224 /* Check if this section is covered by the segment. */ 6225 this_hdr = &(elf_section_data(section)->this_hdr); 6226 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment)) 6227 { 6228 /* FIXME: Check if its output section is changed or 6229 removed. What else do we need to check? */ 6230 if (osec == NULL 6231 || section->flags != osec->flags 6232 || section->lma != osec->lma 6233 || section->vma != osec->vma 6234 || section->size != osec->size 6235 || section->rawsize != osec->rawsize 6236 || section->alignment_power != osec->alignment_power) 6237 goto rewrite; 6238 } 6239 } 6240 } 6241 6242 /* Check to see if any output section do not come from the 6243 input BFD. */ 6244 for (section = obfd->sections; section != NULL; 6245 section = section->next) 6246 { 6247 if (section->segment_mark == FALSE) 6248 goto rewrite; 6249 else 6250 section->segment_mark = FALSE; 6251 } 6252 6253 return copy_elf_program_header (ibfd, obfd); 6254 } 6255 6256 rewrite: 6257 return rewrite_elf_program_header (ibfd, obfd); 6258 } 6259 6260 /* Initialize private output section information from input section. */ 6261 6262 bfd_boolean 6263 _bfd_elf_init_private_section_data (bfd *ibfd, 6264 asection *isec, 6265 bfd *obfd, 6266 asection *osec, 6267 struct bfd_link_info *link_info) 6268 6269 { 6270 Elf_Internal_Shdr *ihdr, *ohdr; 6271 bfd_boolean final_link = link_info != NULL && !link_info->relocatable; 6272 6273 if (ibfd->xvec->flavour != bfd_target_elf_flavour 6274 || obfd->xvec->flavour != bfd_target_elf_flavour) 6275 return TRUE; 6276 6277 BFD_ASSERT (elf_section_data (osec) != NULL); 6278 6279 /* For objcopy and relocatable link, don't copy the output ELF 6280 section type from input if the output BFD section flags have been 6281 set to something different. For a final link allow some flags 6282 that the linker clears to differ. */ 6283 if (elf_section_type (osec) == SHT_NULL 6284 && (osec->flags == isec->flags 6285 || (final_link 6286 && ((osec->flags ^ isec->flags) 6287 & ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC)) == 0))) 6288 elf_section_type (osec) = elf_section_type (isec); 6289 6290 /* FIXME: Is this correct for all OS/PROC specific flags? */ 6291 elf_section_flags (osec) |= (elf_section_flags (isec) 6292 & (SHF_MASKOS | SHF_MASKPROC)); 6293 6294 /* Set things up for objcopy and relocatable link. The output 6295 SHT_GROUP section will have its elf_next_in_group pointing back 6296 to the input group members. Ignore linker created group section. 6297 See elfNN_ia64_object_p in elfxx-ia64.c. */ 6298 if (!final_link) 6299 { 6300 if (elf_sec_group (isec) == NULL 6301 || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0) 6302 { 6303 if (elf_section_flags (isec) & SHF_GROUP) 6304 elf_section_flags (osec) |= SHF_GROUP; 6305 elf_next_in_group (osec) = elf_next_in_group (isec); 6306 elf_section_data (osec)->group = elf_section_data (isec)->group; 6307 } 6308 } 6309 6310 ihdr = &elf_section_data (isec)->this_hdr; 6311 6312 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We 6313 don't use the output section of the linked-to section since it 6314 may be NULL at this point. */ 6315 if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0) 6316 { 6317 ohdr = &elf_section_data (osec)->this_hdr; 6318 ohdr->sh_flags |= SHF_LINK_ORDER; 6319 elf_linked_to_section (osec) = elf_linked_to_section (isec); 6320 } 6321 6322 osec->use_rela_p = isec->use_rela_p; 6323 6324 return TRUE; 6325 } 6326 6327 /* Copy private section information. This copies over the entsize 6328 field, and sometimes the info field. */ 6329 6330 bfd_boolean 6331 _bfd_elf_copy_private_section_data (bfd *ibfd, 6332 asection *isec, 6333 bfd *obfd, 6334 asection *osec) 6335 { 6336 Elf_Internal_Shdr *ihdr, *ohdr; 6337 6338 if (ibfd->xvec->flavour != bfd_target_elf_flavour 6339 || obfd->xvec->flavour != bfd_target_elf_flavour) 6340 return TRUE; 6341 6342 ihdr = &elf_section_data (isec)->this_hdr; 6343 ohdr = &elf_section_data (osec)->this_hdr; 6344 6345 ohdr->sh_entsize = ihdr->sh_entsize; 6346 6347 if (ihdr->sh_type == SHT_SYMTAB 6348 || ihdr->sh_type == SHT_DYNSYM 6349 || ihdr->sh_type == SHT_GNU_verneed 6350 || ihdr->sh_type == SHT_GNU_verdef) 6351 ohdr->sh_info = ihdr->sh_info; 6352 6353 return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec, 6354 NULL); 6355 } 6356 6357 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments 6358 necessary if we are removing either the SHT_GROUP section or any of 6359 the group member sections. DISCARDED is the value that a section's 6360 output_section has if the section will be discarded, NULL when this 6361 function is called from objcopy, bfd_abs_section_ptr when called 6362 from the linker. */ 6363 6364 bfd_boolean 6365 _bfd_elf_fixup_group_sections (bfd *ibfd, asection *discarded) 6366 { 6367 asection *isec; 6368 6369 for (isec = ibfd->sections; isec != NULL; isec = isec->next) 6370 if (elf_section_type (isec) == SHT_GROUP) 6371 { 6372 asection *first = elf_next_in_group (isec); 6373 asection *s = first; 6374 bfd_size_type removed = 0; 6375 6376 while (s != NULL) 6377 { 6378 /* If this member section is being output but the 6379 SHT_GROUP section is not, then clear the group info 6380 set up by _bfd_elf_copy_private_section_data. */ 6381 if (s->output_section != discarded 6382 && isec->output_section == discarded) 6383 { 6384 elf_section_flags (s->output_section) &= ~SHF_GROUP; 6385 elf_group_name (s->output_section) = NULL; 6386 } 6387 /* Conversely, if the member section is not being output 6388 but the SHT_GROUP section is, then adjust its size. */ 6389 else if (s->output_section == discarded 6390 && isec->output_section != discarded) 6391 removed += 4; 6392 s = elf_next_in_group (s); 6393 if (s == first) 6394 break; 6395 } 6396 if (removed != 0) 6397 { 6398 if (discarded != NULL) 6399 { 6400 /* If we've been called for ld -r, then we need to 6401 adjust the input section size. This function may 6402 be called multiple times, so save the original 6403 size. */ 6404 if (isec->rawsize == 0) 6405 isec->rawsize = isec->size; 6406 isec->size = isec->rawsize - removed; 6407 } 6408 else 6409 { 6410 /* Adjust the output section size when called from 6411 objcopy. */ 6412 isec->output_section->size -= removed; 6413 } 6414 } 6415 } 6416 6417 return TRUE; 6418 } 6419 6420 /* Copy private header information. */ 6421 6422 bfd_boolean 6423 _bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd) 6424 { 6425 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 6426 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 6427 return TRUE; 6428 6429 /* Copy over private BFD data if it has not already been copied. 6430 This must be done here, rather than in the copy_private_bfd_data 6431 entry point, because the latter is called after the section 6432 contents have been set, which means that the program headers have 6433 already been worked out. */ 6434 if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL) 6435 { 6436 if (! copy_private_bfd_data (ibfd, obfd)) 6437 return FALSE; 6438 } 6439 6440 return _bfd_elf_fixup_group_sections (ibfd, NULL); 6441 } 6442 6443 /* Copy private symbol information. If this symbol is in a section 6444 which we did not map into a BFD section, try to map the section 6445 index correctly. We use special macro definitions for the mapped 6446 section indices; these definitions are interpreted by the 6447 swap_out_syms function. */ 6448 6449 #define MAP_ONESYMTAB (SHN_HIOS + 1) 6450 #define MAP_DYNSYMTAB (SHN_HIOS + 2) 6451 #define MAP_STRTAB (SHN_HIOS + 3) 6452 #define MAP_SHSTRTAB (SHN_HIOS + 4) 6453 #define MAP_SYM_SHNDX (SHN_HIOS + 5) 6454 6455 bfd_boolean 6456 _bfd_elf_copy_private_symbol_data (bfd *ibfd, 6457 asymbol *isymarg, 6458 bfd *obfd, 6459 asymbol *osymarg) 6460 { 6461 elf_symbol_type *isym, *osym; 6462 6463 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 6464 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 6465 return TRUE; 6466 6467 isym = elf_symbol_from (ibfd, isymarg); 6468 osym = elf_symbol_from (obfd, osymarg); 6469 6470 if (isym != NULL 6471 && isym->internal_elf_sym.st_shndx != 0 6472 && osym != NULL 6473 && bfd_is_abs_section (isym->symbol.section)) 6474 { 6475 unsigned int shndx; 6476 6477 shndx = isym->internal_elf_sym.st_shndx; 6478 if (shndx == elf_onesymtab (ibfd)) 6479 shndx = MAP_ONESYMTAB; 6480 else if (shndx == elf_dynsymtab (ibfd)) 6481 shndx = MAP_DYNSYMTAB; 6482 else if (shndx == elf_tdata (ibfd)->strtab_section) 6483 shndx = MAP_STRTAB; 6484 else if (shndx == elf_tdata (ibfd)->shstrtab_section) 6485 shndx = MAP_SHSTRTAB; 6486 else if (shndx == elf_tdata (ibfd)->symtab_shndx_section) 6487 shndx = MAP_SYM_SHNDX; 6488 osym->internal_elf_sym.st_shndx = shndx; 6489 } 6490 6491 return TRUE; 6492 } 6493 6494 /* Swap out the symbols. */ 6495 6496 static bfd_boolean 6497 swap_out_syms (bfd *abfd, 6498 struct bfd_strtab_hash **sttp, 6499 int relocatable_p) 6500 { 6501 const struct elf_backend_data *bed; 6502 int symcount; 6503 asymbol **syms; 6504 struct bfd_strtab_hash *stt; 6505 Elf_Internal_Shdr *symtab_hdr; 6506 Elf_Internal_Shdr *symtab_shndx_hdr; 6507 Elf_Internal_Shdr *symstrtab_hdr; 6508 bfd_byte *outbound_syms; 6509 bfd_byte *outbound_shndx; 6510 int idx; 6511 bfd_size_type amt; 6512 bfd_boolean name_local_sections; 6513 6514 if (!elf_map_symbols (abfd)) 6515 return FALSE; 6516 6517 /* Dump out the symtabs. */ 6518 stt = _bfd_elf_stringtab_init (); 6519 if (stt == NULL) 6520 return FALSE; 6521 6522 bed = get_elf_backend_data (abfd); 6523 symcount = bfd_get_symcount (abfd); 6524 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 6525 symtab_hdr->sh_type = SHT_SYMTAB; 6526 symtab_hdr->sh_entsize = bed->s->sizeof_sym; 6527 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1); 6528 symtab_hdr->sh_info = elf_num_locals (abfd) + 1; 6529 symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align; 6530 6531 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr; 6532 symstrtab_hdr->sh_type = SHT_STRTAB; 6533 6534 outbound_syms = (bfd_byte *) bfd_alloc2 (abfd, 1 + symcount, 6535 bed->s->sizeof_sym); 6536 if (outbound_syms == NULL) 6537 { 6538 _bfd_stringtab_free (stt); 6539 return FALSE; 6540 } 6541 symtab_hdr->contents = outbound_syms; 6542 6543 outbound_shndx = NULL; 6544 symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr; 6545 if (symtab_shndx_hdr->sh_name != 0) 6546 { 6547 amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx); 6548 outbound_shndx = (bfd_byte *) 6549 bfd_zalloc2 (abfd, 1 + symcount, sizeof (Elf_External_Sym_Shndx)); 6550 if (outbound_shndx == NULL) 6551 { 6552 _bfd_stringtab_free (stt); 6553 return FALSE; 6554 } 6555 6556 symtab_shndx_hdr->contents = outbound_shndx; 6557 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX; 6558 symtab_shndx_hdr->sh_size = amt; 6559 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx); 6560 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx); 6561 } 6562 6563 /* Now generate the data (for "contents"). */ 6564 { 6565 /* Fill in zeroth symbol and swap it out. */ 6566 Elf_Internal_Sym sym; 6567 sym.st_name = 0; 6568 sym.st_value = 0; 6569 sym.st_size = 0; 6570 sym.st_info = 0; 6571 sym.st_other = 0; 6572 sym.st_shndx = SHN_UNDEF; 6573 sym.st_target_internal = 0; 6574 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx); 6575 outbound_syms += bed->s->sizeof_sym; 6576 if (outbound_shndx != NULL) 6577 outbound_shndx += sizeof (Elf_External_Sym_Shndx); 6578 } 6579 6580 name_local_sections 6581 = (bed->elf_backend_name_local_section_symbols 6582 && bed->elf_backend_name_local_section_symbols (abfd)); 6583 6584 syms = bfd_get_outsymbols (abfd); 6585 for (idx = 0; idx < symcount; idx++) 6586 { 6587 Elf_Internal_Sym sym; 6588 bfd_vma value = syms[idx]->value; 6589 elf_symbol_type *type_ptr; 6590 flagword flags = syms[idx]->flags; 6591 int type; 6592 6593 if (!name_local_sections 6594 && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM) 6595 { 6596 /* Local section symbols have no name. */ 6597 sym.st_name = 0; 6598 } 6599 else 6600 { 6601 sym.st_name = (unsigned long) _bfd_stringtab_add (stt, 6602 syms[idx]->name, 6603 TRUE, FALSE); 6604 if (sym.st_name == (unsigned long) -1) 6605 { 6606 _bfd_stringtab_free (stt); 6607 return FALSE; 6608 } 6609 } 6610 6611 type_ptr = elf_symbol_from (abfd, syms[idx]); 6612 6613 if ((flags & BSF_SECTION_SYM) == 0 6614 && bfd_is_com_section (syms[idx]->section)) 6615 { 6616 /* ELF common symbols put the alignment into the `value' field, 6617 and the size into the `size' field. This is backwards from 6618 how BFD handles it, so reverse it here. */ 6619 sym.st_size = value; 6620 if (type_ptr == NULL 6621 || type_ptr->internal_elf_sym.st_value == 0) 6622 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value)); 6623 else 6624 sym.st_value = type_ptr->internal_elf_sym.st_value; 6625 sym.st_shndx = _bfd_elf_section_from_bfd_section 6626 (abfd, syms[idx]->section); 6627 } 6628 else 6629 { 6630 asection *sec = syms[idx]->section; 6631 unsigned int shndx; 6632 6633 if (sec->output_section) 6634 { 6635 value += sec->output_offset; 6636 sec = sec->output_section; 6637 } 6638 6639 /* Don't add in the section vma for relocatable output. */ 6640 if (! relocatable_p) 6641 value += sec->vma; 6642 sym.st_value = value; 6643 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0; 6644 6645 if (bfd_is_abs_section (sec) 6646 && type_ptr != NULL 6647 && type_ptr->internal_elf_sym.st_shndx != 0) 6648 { 6649 /* This symbol is in a real ELF section which we did 6650 not create as a BFD section. Undo the mapping done 6651 by copy_private_symbol_data. */ 6652 shndx = type_ptr->internal_elf_sym.st_shndx; 6653 switch (shndx) 6654 { 6655 case MAP_ONESYMTAB: 6656 shndx = elf_onesymtab (abfd); 6657 break; 6658 case MAP_DYNSYMTAB: 6659 shndx = elf_dynsymtab (abfd); 6660 break; 6661 case MAP_STRTAB: 6662 shndx = elf_tdata (abfd)->strtab_section; 6663 break; 6664 case MAP_SHSTRTAB: 6665 shndx = elf_tdata (abfd)->shstrtab_section; 6666 break; 6667 case MAP_SYM_SHNDX: 6668 shndx = elf_tdata (abfd)->symtab_shndx_section; 6669 break; 6670 default: 6671 break; 6672 } 6673 } 6674 else 6675 { 6676 shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 6677 6678 if (shndx == SHN_BAD) 6679 { 6680 asection *sec2; 6681 6682 /* Writing this would be a hell of a lot easier if 6683 we had some decent documentation on bfd, and 6684 knew what to expect of the library, and what to 6685 demand of applications. For example, it 6686 appears that `objcopy' might not set the 6687 section of a symbol to be a section that is 6688 actually in the output file. */ 6689 sec2 = bfd_get_section_by_name (abfd, sec->name); 6690 if (sec2 == NULL) 6691 { 6692 _bfd_error_handler (_("\ 6693 Unable to find equivalent output section for symbol '%s' from section '%s'"), 6694 syms[idx]->name ? syms[idx]->name : "<Local sym>", 6695 sec->name); 6696 bfd_set_error (bfd_error_invalid_operation); 6697 _bfd_stringtab_free (stt); 6698 return FALSE; 6699 } 6700 6701 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2); 6702 BFD_ASSERT (shndx != SHN_BAD); 6703 } 6704 } 6705 6706 sym.st_shndx = shndx; 6707 } 6708 6709 if ((flags & BSF_THREAD_LOCAL) != 0) 6710 type = STT_TLS; 6711 else if ((flags & BSF_GNU_INDIRECT_FUNCTION) != 0) 6712 type = STT_GNU_IFUNC; 6713 else if ((flags & BSF_FUNCTION) != 0) 6714 type = STT_FUNC; 6715 else if ((flags & BSF_OBJECT) != 0) 6716 type = STT_OBJECT; 6717 else if ((flags & BSF_RELC) != 0) 6718 type = STT_RELC; 6719 else if ((flags & BSF_SRELC) != 0) 6720 type = STT_SRELC; 6721 else 6722 type = STT_NOTYPE; 6723 6724 if (syms[idx]->section->flags & SEC_THREAD_LOCAL) 6725 type = STT_TLS; 6726 6727 /* Processor-specific types. */ 6728 if (type_ptr != NULL 6729 && bed->elf_backend_get_symbol_type) 6730 type = ((*bed->elf_backend_get_symbol_type) 6731 (&type_ptr->internal_elf_sym, type)); 6732 6733 if (flags & BSF_SECTION_SYM) 6734 { 6735 if (flags & BSF_GLOBAL) 6736 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION); 6737 else 6738 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION); 6739 } 6740 else if (bfd_is_com_section (syms[idx]->section)) 6741 { 6742 #ifdef USE_STT_COMMON 6743 if (type == STT_OBJECT) 6744 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_COMMON); 6745 else 6746 #endif 6747 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type); 6748 } 6749 else if (bfd_is_und_section (syms[idx]->section)) 6750 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK) 6751 ? STB_WEAK 6752 : STB_GLOBAL), 6753 type); 6754 else if (flags & BSF_FILE) 6755 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE); 6756 else 6757 { 6758 int bind = STB_LOCAL; 6759 6760 if (flags & BSF_LOCAL) 6761 bind = STB_LOCAL; 6762 else if (flags & BSF_GNU_UNIQUE) 6763 bind = STB_GNU_UNIQUE; 6764 else if (flags & BSF_WEAK) 6765 bind = STB_WEAK; 6766 else if (flags & BSF_GLOBAL) 6767 bind = STB_GLOBAL; 6768 6769 sym.st_info = ELF_ST_INFO (bind, type); 6770 } 6771 6772 if (type_ptr != NULL) 6773 { 6774 sym.st_other = type_ptr->internal_elf_sym.st_other; 6775 sym.st_target_internal 6776 = type_ptr->internal_elf_sym.st_target_internal; 6777 } 6778 else 6779 { 6780 sym.st_other = 0; 6781 sym.st_target_internal = 0; 6782 } 6783 6784 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx); 6785 outbound_syms += bed->s->sizeof_sym; 6786 if (outbound_shndx != NULL) 6787 outbound_shndx += sizeof (Elf_External_Sym_Shndx); 6788 } 6789 6790 *sttp = stt; 6791 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt); 6792 symstrtab_hdr->sh_type = SHT_STRTAB; 6793 6794 symstrtab_hdr->sh_flags = 0; 6795 symstrtab_hdr->sh_addr = 0; 6796 symstrtab_hdr->sh_entsize = 0; 6797 symstrtab_hdr->sh_link = 0; 6798 symstrtab_hdr->sh_info = 0; 6799 symstrtab_hdr->sh_addralign = 1; 6800 6801 return TRUE; 6802 } 6803 6804 /* Return the number of bytes required to hold the symtab vector. 6805 6806 Note that we base it on the count plus 1, since we will null terminate 6807 the vector allocated based on this size. However, the ELF symbol table 6808 always has a dummy entry as symbol #0, so it ends up even. */ 6809 6810 long 6811 _bfd_elf_get_symtab_upper_bound (bfd *abfd) 6812 { 6813 long symcount; 6814 long symtab_size; 6815 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr; 6816 6817 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym; 6818 symtab_size = (symcount + 1) * (sizeof (asymbol *)); 6819 if (symcount > 0) 6820 symtab_size -= sizeof (asymbol *); 6821 6822 return symtab_size; 6823 } 6824 6825 long 6826 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd) 6827 { 6828 long symcount; 6829 long symtab_size; 6830 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr; 6831 6832 if (elf_dynsymtab (abfd) == 0) 6833 { 6834 bfd_set_error (bfd_error_invalid_operation); 6835 return -1; 6836 } 6837 6838 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym; 6839 symtab_size = (symcount + 1) * (sizeof (asymbol *)); 6840 if (symcount > 0) 6841 symtab_size -= sizeof (asymbol *); 6842 6843 return symtab_size; 6844 } 6845 6846 long 6847 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, 6848 sec_ptr asect) 6849 { 6850 return (asect->reloc_count + 1) * sizeof (arelent *); 6851 } 6852 6853 /* Canonicalize the relocs. */ 6854 6855 long 6856 _bfd_elf_canonicalize_reloc (bfd *abfd, 6857 sec_ptr section, 6858 arelent **relptr, 6859 asymbol **symbols) 6860 { 6861 arelent *tblptr; 6862 unsigned int i; 6863 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 6864 6865 if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE)) 6866 return -1; 6867 6868 tblptr = section->relocation; 6869 for (i = 0; i < section->reloc_count; i++) 6870 *relptr++ = tblptr++; 6871 6872 *relptr = NULL; 6873 6874 return section->reloc_count; 6875 } 6876 6877 long 6878 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation) 6879 { 6880 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 6881 long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE); 6882 6883 if (symcount >= 0) 6884 bfd_get_symcount (abfd) = symcount; 6885 return symcount; 6886 } 6887 6888 long 6889 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd, 6890 asymbol **allocation) 6891 { 6892 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 6893 long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE); 6894 6895 if (symcount >= 0) 6896 bfd_get_dynamic_symcount (abfd) = symcount; 6897 return symcount; 6898 } 6899 6900 /* Return the size required for the dynamic reloc entries. Any loadable 6901 section that was actually installed in the BFD, and has type SHT_REL 6902 or SHT_RELA, and uses the dynamic symbol table, is considered to be a 6903 dynamic reloc section. */ 6904 6905 long 6906 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd) 6907 { 6908 long ret; 6909 asection *s; 6910 6911 if (elf_dynsymtab (abfd) == 0) 6912 { 6913 bfd_set_error (bfd_error_invalid_operation); 6914 return -1; 6915 } 6916 6917 ret = sizeof (arelent *); 6918 for (s = abfd->sections; s != NULL; s = s->next) 6919 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd) 6920 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL 6921 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)) 6922 ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize) 6923 * sizeof (arelent *)); 6924 6925 return ret; 6926 } 6927 6928 /* Canonicalize the dynamic relocation entries. Note that we return the 6929 dynamic relocations as a single block, although they are actually 6930 associated with particular sections; the interface, which was 6931 designed for SunOS style shared libraries, expects that there is only 6932 one set of dynamic relocs. Any loadable section that was actually 6933 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the 6934 dynamic symbol table, is considered to be a dynamic reloc section. */ 6935 6936 long 6937 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd, 6938 arelent **storage, 6939 asymbol **syms) 6940 { 6941 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean); 6942 asection *s; 6943 long ret; 6944 6945 if (elf_dynsymtab (abfd) == 0) 6946 { 6947 bfd_set_error (bfd_error_invalid_operation); 6948 return -1; 6949 } 6950 6951 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table; 6952 ret = 0; 6953 for (s = abfd->sections; s != NULL; s = s->next) 6954 { 6955 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd) 6956 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL 6957 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)) 6958 { 6959 arelent *p; 6960 long count, i; 6961 6962 if (! (*slurp_relocs) (abfd, s, syms, TRUE)) 6963 return -1; 6964 count = s->size / elf_section_data (s)->this_hdr.sh_entsize; 6965 p = s->relocation; 6966 for (i = 0; i < count; i++) 6967 *storage++ = p++; 6968 ret += count; 6969 } 6970 } 6971 6972 *storage = NULL; 6973 6974 return ret; 6975 } 6976 6977 /* Read in the version information. */ 6978 6979 bfd_boolean 6980 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver) 6981 { 6982 bfd_byte *contents = NULL; 6983 unsigned int freeidx = 0; 6984 6985 if (elf_dynverref (abfd) != 0) 6986 { 6987 Elf_Internal_Shdr *hdr; 6988 Elf_External_Verneed *everneed; 6989 Elf_Internal_Verneed *iverneed; 6990 unsigned int i; 6991 bfd_byte *contents_end; 6992 6993 hdr = &elf_tdata (abfd)->dynverref_hdr; 6994 6995 elf_tdata (abfd)->verref = (Elf_Internal_Verneed *) 6996 bfd_zalloc2 (abfd, hdr->sh_info, sizeof (Elf_Internal_Verneed)); 6997 if (elf_tdata (abfd)->verref == NULL) 6998 goto error_return; 6999 7000 elf_tdata (abfd)->cverrefs = hdr->sh_info; 7001 7002 contents = (bfd_byte *) bfd_malloc (hdr->sh_size); 7003 if (contents == NULL) 7004 { 7005 error_return_verref: 7006 elf_tdata (abfd)->verref = NULL; 7007 elf_tdata (abfd)->cverrefs = 0; 7008 goto error_return; 7009 } 7010 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0 7011 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size) 7012 goto error_return_verref; 7013 7014 if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verneed)) 7015 goto error_return_verref; 7016 7017 BFD_ASSERT (sizeof (Elf_External_Verneed) 7018 == sizeof (Elf_External_Vernaux)); 7019 contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed); 7020 everneed = (Elf_External_Verneed *) contents; 7021 iverneed = elf_tdata (abfd)->verref; 7022 for (i = 0; i < hdr->sh_info; i++, iverneed++) 7023 { 7024 Elf_External_Vernaux *evernaux; 7025 Elf_Internal_Vernaux *ivernaux; 7026 unsigned int j; 7027 7028 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed); 7029 7030 iverneed->vn_bfd = abfd; 7031 7032 iverneed->vn_filename = 7033 bfd_elf_string_from_elf_section (abfd, hdr->sh_link, 7034 iverneed->vn_file); 7035 if (iverneed->vn_filename == NULL) 7036 goto error_return_verref; 7037 7038 if (iverneed->vn_cnt == 0) 7039 iverneed->vn_auxptr = NULL; 7040 else 7041 { 7042 iverneed->vn_auxptr = (struct elf_internal_vernaux *) 7043 bfd_alloc2 (abfd, iverneed->vn_cnt, 7044 sizeof (Elf_Internal_Vernaux)); 7045 if (iverneed->vn_auxptr == NULL) 7046 goto error_return_verref; 7047 } 7048 7049 if (iverneed->vn_aux 7050 > (size_t) (contents_end - (bfd_byte *) everneed)) 7051 goto error_return_verref; 7052 7053 evernaux = ((Elf_External_Vernaux *) 7054 ((bfd_byte *) everneed + iverneed->vn_aux)); 7055 ivernaux = iverneed->vn_auxptr; 7056 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++) 7057 { 7058 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux); 7059 7060 ivernaux->vna_nodename = 7061 bfd_elf_string_from_elf_section (abfd, hdr->sh_link, 7062 ivernaux->vna_name); 7063 if (ivernaux->vna_nodename == NULL) 7064 goto error_return_verref; 7065 7066 if (j + 1 < iverneed->vn_cnt) 7067 ivernaux->vna_nextptr = ivernaux + 1; 7068 else 7069 ivernaux->vna_nextptr = NULL; 7070 7071 if (ivernaux->vna_next 7072 > (size_t) (contents_end - (bfd_byte *) evernaux)) 7073 goto error_return_verref; 7074 7075 evernaux = ((Elf_External_Vernaux *) 7076 ((bfd_byte *) evernaux + ivernaux->vna_next)); 7077 7078 if (ivernaux->vna_other > freeidx) 7079 freeidx = ivernaux->vna_other; 7080 } 7081 7082 if (i + 1 < hdr->sh_info) 7083 iverneed->vn_nextref = iverneed + 1; 7084 else 7085 iverneed->vn_nextref = NULL; 7086 7087 if (iverneed->vn_next 7088 > (size_t) (contents_end - (bfd_byte *) everneed)) 7089 goto error_return_verref; 7090 7091 everneed = ((Elf_External_Verneed *) 7092 ((bfd_byte *) everneed + iverneed->vn_next)); 7093 } 7094 7095 free (contents); 7096 contents = NULL; 7097 } 7098 7099 if (elf_dynverdef (abfd) != 0) 7100 { 7101 Elf_Internal_Shdr *hdr; 7102 Elf_External_Verdef *everdef; 7103 Elf_Internal_Verdef *iverdef; 7104 Elf_Internal_Verdef *iverdefarr; 7105 Elf_Internal_Verdef iverdefmem; 7106 unsigned int i; 7107 unsigned int maxidx; 7108 bfd_byte *contents_end_def, *contents_end_aux; 7109 7110 hdr = &elf_tdata (abfd)->dynverdef_hdr; 7111 7112 contents = (bfd_byte *) bfd_malloc (hdr->sh_size); 7113 if (contents == NULL) 7114 goto error_return; 7115 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0 7116 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size) 7117 goto error_return; 7118 7119 if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verdef)) 7120 goto error_return; 7121 7122 BFD_ASSERT (sizeof (Elf_External_Verdef) 7123 >= sizeof (Elf_External_Verdaux)); 7124 contents_end_def = contents + hdr->sh_size 7125 - sizeof (Elf_External_Verdef); 7126 contents_end_aux = contents + hdr->sh_size 7127 - sizeof (Elf_External_Verdaux); 7128 7129 /* We know the number of entries in the section but not the maximum 7130 index. Therefore we have to run through all entries and find 7131 the maximum. */ 7132 everdef = (Elf_External_Verdef *) contents; 7133 maxidx = 0; 7134 for (i = 0; i < hdr->sh_info; ++i) 7135 { 7136 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem); 7137 7138 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx) 7139 maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION); 7140 7141 if (iverdefmem.vd_next 7142 > (size_t) (contents_end_def - (bfd_byte *) everdef)) 7143 goto error_return; 7144 7145 everdef = ((Elf_External_Verdef *) 7146 ((bfd_byte *) everdef + iverdefmem.vd_next)); 7147 } 7148 7149 if (default_imported_symver) 7150 { 7151 if (freeidx > maxidx) 7152 maxidx = ++freeidx; 7153 else 7154 freeidx = ++maxidx; 7155 } 7156 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *) 7157 bfd_zalloc2 (abfd, maxidx, sizeof (Elf_Internal_Verdef)); 7158 if (elf_tdata (abfd)->verdef == NULL) 7159 goto error_return; 7160 7161 elf_tdata (abfd)->cverdefs = maxidx; 7162 7163 everdef = (Elf_External_Verdef *) contents; 7164 iverdefarr = elf_tdata (abfd)->verdef; 7165 for (i = 0; i < hdr->sh_info; i++) 7166 { 7167 Elf_External_Verdaux *everdaux; 7168 Elf_Internal_Verdaux *iverdaux; 7169 unsigned int j; 7170 7171 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem); 7172 7173 if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0) 7174 { 7175 error_return_verdef: 7176 elf_tdata (abfd)->verdef = NULL; 7177 elf_tdata (abfd)->cverdefs = 0; 7178 goto error_return; 7179 } 7180 7181 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1]; 7182 memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef)); 7183 7184 iverdef->vd_bfd = abfd; 7185 7186 if (iverdef->vd_cnt == 0) 7187 iverdef->vd_auxptr = NULL; 7188 else 7189 { 7190 iverdef->vd_auxptr = (struct elf_internal_verdaux *) 7191 bfd_alloc2 (abfd, iverdef->vd_cnt, 7192 sizeof (Elf_Internal_Verdaux)); 7193 if (iverdef->vd_auxptr == NULL) 7194 goto error_return_verdef; 7195 } 7196 7197 if (iverdef->vd_aux 7198 > (size_t) (contents_end_aux - (bfd_byte *) everdef)) 7199 goto error_return_verdef; 7200 7201 everdaux = ((Elf_External_Verdaux *) 7202 ((bfd_byte *) everdef + iverdef->vd_aux)); 7203 iverdaux = iverdef->vd_auxptr; 7204 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++) 7205 { 7206 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux); 7207 7208 iverdaux->vda_nodename = 7209 bfd_elf_string_from_elf_section (abfd, hdr->sh_link, 7210 iverdaux->vda_name); 7211 if (iverdaux->vda_nodename == NULL) 7212 goto error_return_verdef; 7213 7214 if (j + 1 < iverdef->vd_cnt) 7215 iverdaux->vda_nextptr = iverdaux + 1; 7216 else 7217 iverdaux->vda_nextptr = NULL; 7218 7219 if (iverdaux->vda_next 7220 > (size_t) (contents_end_aux - (bfd_byte *) everdaux)) 7221 goto error_return_verdef; 7222 7223 everdaux = ((Elf_External_Verdaux *) 7224 ((bfd_byte *) everdaux + iverdaux->vda_next)); 7225 } 7226 7227 if (iverdef->vd_cnt) 7228 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename; 7229 7230 if ((size_t) (iverdef - iverdefarr) + 1 < maxidx) 7231 iverdef->vd_nextdef = iverdef + 1; 7232 else 7233 iverdef->vd_nextdef = NULL; 7234 7235 everdef = ((Elf_External_Verdef *) 7236 ((bfd_byte *) everdef + iverdef->vd_next)); 7237 } 7238 7239 free (contents); 7240 contents = NULL; 7241 } 7242 else if (default_imported_symver) 7243 { 7244 if (freeidx < 3) 7245 freeidx = 3; 7246 else 7247 freeidx++; 7248 7249 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *) 7250 bfd_zalloc2 (abfd, freeidx, sizeof (Elf_Internal_Verdef)); 7251 if (elf_tdata (abfd)->verdef == NULL) 7252 goto error_return; 7253 7254 elf_tdata (abfd)->cverdefs = freeidx; 7255 } 7256 7257 /* Create a default version based on the soname. */ 7258 if (default_imported_symver) 7259 { 7260 Elf_Internal_Verdef *iverdef; 7261 Elf_Internal_Verdaux *iverdaux; 7262 7263 iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];; 7264 7265 iverdef->vd_version = VER_DEF_CURRENT; 7266 iverdef->vd_flags = 0; 7267 iverdef->vd_ndx = freeidx; 7268 iverdef->vd_cnt = 1; 7269 7270 iverdef->vd_bfd = abfd; 7271 7272 iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd); 7273 if (iverdef->vd_nodename == NULL) 7274 goto error_return_verdef; 7275 iverdef->vd_nextdef = NULL; 7276 iverdef->vd_auxptr = (struct elf_internal_verdaux *) 7277 bfd_alloc (abfd, sizeof (Elf_Internal_Verdaux)); 7278 if (iverdef->vd_auxptr == NULL) 7279 goto error_return_verdef; 7280 7281 iverdaux = iverdef->vd_auxptr; 7282 iverdaux->vda_nodename = iverdef->vd_nodename; 7283 iverdaux->vda_nextptr = NULL; 7284 } 7285 7286 return TRUE; 7287 7288 error_return: 7289 if (contents != NULL) 7290 free (contents); 7291 return FALSE; 7292 } 7293 7294 asymbol * 7295 _bfd_elf_make_empty_symbol (bfd *abfd) 7296 { 7297 elf_symbol_type *newsym; 7298 bfd_size_type amt = sizeof (elf_symbol_type); 7299 7300 newsym = (elf_symbol_type *) bfd_zalloc (abfd, amt); 7301 if (!newsym) 7302 return NULL; 7303 else 7304 { 7305 newsym->symbol.the_bfd = abfd; 7306 return &newsym->symbol; 7307 } 7308 } 7309 7310 void 7311 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED, 7312 asymbol *symbol, 7313 symbol_info *ret) 7314 { 7315 bfd_symbol_info (symbol, ret); 7316 } 7317 7318 /* Return whether a symbol name implies a local symbol. Most targets 7319 use this function for the is_local_label_name entry point, but some 7320 override it. */ 7321 7322 bfd_boolean 7323 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, 7324 const char *name) 7325 { 7326 /* Normal local symbols start with ``.L''. */ 7327 if (name[0] == '.' && name[1] == 'L') 7328 return TRUE; 7329 7330 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate 7331 DWARF debugging symbols starting with ``..''. */ 7332 if (name[0] == '.' && name[1] == '.') 7333 return TRUE; 7334 7335 /* gcc will sometimes generate symbols beginning with ``_.L_'' when 7336 emitting DWARF debugging output. I suspect this is actually a 7337 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call 7338 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading 7339 underscore to be emitted on some ELF targets). For ease of use, 7340 we treat such symbols as local. */ 7341 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_') 7342 return TRUE; 7343 7344 return FALSE; 7345 } 7346 7347 alent * 7348 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED, 7349 asymbol *symbol ATTRIBUTE_UNUSED) 7350 { 7351 abort (); 7352 return NULL; 7353 } 7354 7355 bfd_boolean 7356 _bfd_elf_set_arch_mach (bfd *abfd, 7357 enum bfd_architecture arch, 7358 unsigned long machine) 7359 { 7360 /* If this isn't the right architecture for this backend, and this 7361 isn't the generic backend, fail. */ 7362 if (arch != get_elf_backend_data (abfd)->arch 7363 && arch != bfd_arch_unknown 7364 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown) 7365 return FALSE; 7366 7367 return bfd_default_set_arch_mach (abfd, arch, machine); 7368 } 7369 7370 /* Find the function to a particular section and offset, 7371 for error reporting. */ 7372 7373 static bfd_boolean 7374 elf_find_function (bfd *abfd, 7375 asection *section, 7376 asymbol **symbols, 7377 bfd_vma offset, 7378 const char **filename_ptr, 7379 const char **functionname_ptr) 7380 { 7381 const char *filename; 7382 asymbol *func, *file; 7383 bfd_vma low_func; 7384 asymbol **p; 7385 /* ??? Given multiple file symbols, it is impossible to reliably 7386 choose the right file name for global symbols. File symbols are 7387 local symbols, and thus all file symbols must sort before any 7388 global symbols. The ELF spec may be interpreted to say that a 7389 file symbol must sort before other local symbols, but currently 7390 ld -r doesn't do this. So, for ld -r output, it is possible to 7391 make a better choice of file name for local symbols by ignoring 7392 file symbols appearing after a given local symbol. */ 7393 enum { nothing_seen, symbol_seen, file_after_symbol_seen } state; 7394 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 7395 7396 if (symbols == NULL) 7397 return FALSE; 7398 7399 filename = NULL; 7400 func = NULL; 7401 file = NULL; 7402 low_func = 0; 7403 state = nothing_seen; 7404 7405 for (p = symbols; *p != NULL; p++) 7406 { 7407 elf_symbol_type *q; 7408 unsigned int type; 7409 7410 q = (elf_symbol_type *) *p; 7411 7412 type = ELF_ST_TYPE (q->internal_elf_sym.st_info); 7413 switch (type) 7414 { 7415 case STT_FILE: 7416 file = &q->symbol; 7417 if (state == symbol_seen) 7418 state = file_after_symbol_seen; 7419 continue; 7420 default: 7421 if (!bed->is_function_type (type)) 7422 break; 7423 case STT_NOTYPE: 7424 if (bfd_get_section (&q->symbol) == section 7425 && q->symbol.value >= low_func 7426 && q->symbol.value <= offset) 7427 { 7428 func = (asymbol *) q; 7429 low_func = q->symbol.value; 7430 filename = NULL; 7431 if (file != NULL 7432 && (ELF_ST_BIND (q->internal_elf_sym.st_info) == STB_LOCAL 7433 || state != file_after_symbol_seen)) 7434 filename = bfd_asymbol_name (file); 7435 } 7436 break; 7437 } 7438 if (state == nothing_seen) 7439 state = symbol_seen; 7440 } 7441 7442 if (func == NULL) 7443 return FALSE; 7444 7445 if (filename_ptr) 7446 *filename_ptr = filename; 7447 if (functionname_ptr) 7448 *functionname_ptr = bfd_asymbol_name (func); 7449 7450 return TRUE; 7451 } 7452 7453 /* Find the nearest line to a particular section and offset, 7454 for error reporting. */ 7455 7456 bfd_boolean 7457 _bfd_elf_find_nearest_line (bfd *abfd, 7458 asection *section, 7459 asymbol **symbols, 7460 bfd_vma offset, 7461 const char **filename_ptr, 7462 const char **functionname_ptr, 7463 unsigned int *line_ptr) 7464 { 7465 bfd_boolean found; 7466 7467 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset, 7468 filename_ptr, functionname_ptr, 7469 line_ptr)) 7470 { 7471 if (!*functionname_ptr) 7472 elf_find_function (abfd, section, symbols, offset, 7473 *filename_ptr ? NULL : filename_ptr, 7474 functionname_ptr); 7475 7476 return TRUE; 7477 } 7478 7479 if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections, 7480 section, symbols, offset, 7481 filename_ptr, functionname_ptr, 7482 line_ptr, 0, 7483 &elf_tdata (abfd)->dwarf2_find_line_info)) 7484 { 7485 if (!*functionname_ptr) 7486 elf_find_function (abfd, section, symbols, offset, 7487 *filename_ptr ? NULL : filename_ptr, 7488 functionname_ptr); 7489 7490 return TRUE; 7491 } 7492 7493 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, 7494 &found, filename_ptr, 7495 functionname_ptr, line_ptr, 7496 &elf_tdata (abfd)->line_info)) 7497 return FALSE; 7498 if (found && (*functionname_ptr || *line_ptr)) 7499 return TRUE; 7500 7501 if (symbols == NULL) 7502 return FALSE; 7503 7504 if (! elf_find_function (abfd, section, symbols, offset, 7505 filename_ptr, functionname_ptr)) 7506 return FALSE; 7507 7508 *line_ptr = 0; 7509 return TRUE; 7510 } 7511 7512 /* Find the line for a symbol. */ 7513 7514 bfd_boolean 7515 _bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol, 7516 const char **filename_ptr, unsigned int *line_ptr) 7517 { 7518 return _bfd_dwarf2_find_line (abfd, symbols, symbol, 7519 filename_ptr, line_ptr, 0, 7520 &elf_tdata (abfd)->dwarf2_find_line_info); 7521 } 7522 7523 /* After a call to bfd_find_nearest_line, successive calls to 7524 bfd_find_inliner_info can be used to get source information about 7525 each level of function inlining that terminated at the address 7526 passed to bfd_find_nearest_line. Currently this is only supported 7527 for DWARF2 with appropriate DWARF3 extensions. */ 7528 7529 bfd_boolean 7530 _bfd_elf_find_inliner_info (bfd *abfd, 7531 const char **filename_ptr, 7532 const char **functionname_ptr, 7533 unsigned int *line_ptr) 7534 { 7535 bfd_boolean found; 7536 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr, 7537 functionname_ptr, line_ptr, 7538 & elf_tdata (abfd)->dwarf2_find_line_info); 7539 return found; 7540 } 7541 7542 int 7543 _bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info) 7544 { 7545 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 7546 int ret = bed->s->sizeof_ehdr; 7547 7548 if (!info->relocatable) 7549 { 7550 bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size; 7551 7552 if (phdr_size == (bfd_size_type) -1) 7553 { 7554 struct elf_segment_map *m; 7555 7556 phdr_size = 0; 7557 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next) 7558 phdr_size += bed->s->sizeof_phdr; 7559 7560 if (phdr_size == 0) 7561 phdr_size = get_program_header_size (abfd, info); 7562 } 7563 7564 elf_tdata (abfd)->program_header_size = phdr_size; 7565 ret += phdr_size; 7566 } 7567 7568 return ret; 7569 } 7570 7571 bfd_boolean 7572 _bfd_elf_set_section_contents (bfd *abfd, 7573 sec_ptr section, 7574 const void *location, 7575 file_ptr offset, 7576 bfd_size_type count) 7577 { 7578 Elf_Internal_Shdr *hdr; 7579 bfd_signed_vma pos; 7580 7581 if (! abfd->output_has_begun 7582 && ! _bfd_elf_compute_section_file_positions (abfd, NULL)) 7583 return FALSE; 7584 7585 hdr = &elf_section_data (section)->this_hdr; 7586 pos = hdr->sh_offset + offset; 7587 if (bfd_seek (abfd, pos, SEEK_SET) != 0 7588 || bfd_bwrite (location, count, abfd) != count) 7589 return FALSE; 7590 7591 return TRUE; 7592 } 7593 7594 void 7595 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, 7596 arelent *cache_ptr ATTRIBUTE_UNUSED, 7597 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED) 7598 { 7599 abort (); 7600 } 7601 7602 /* Try to convert a non-ELF reloc into an ELF one. */ 7603 7604 bfd_boolean 7605 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc) 7606 { 7607 /* Check whether we really have an ELF howto. */ 7608 7609 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec) 7610 { 7611 bfd_reloc_code_real_type code; 7612 reloc_howto_type *howto; 7613 7614 /* Alien reloc: Try to determine its type to replace it with an 7615 equivalent ELF reloc. */ 7616 7617 if (areloc->howto->pc_relative) 7618 { 7619 switch (areloc->howto->bitsize) 7620 { 7621 case 8: 7622 code = BFD_RELOC_8_PCREL; 7623 break; 7624 case 12: 7625 code = BFD_RELOC_12_PCREL; 7626 break; 7627 case 16: 7628 code = BFD_RELOC_16_PCREL; 7629 break; 7630 case 24: 7631 code = BFD_RELOC_24_PCREL; 7632 break; 7633 case 32: 7634 code = BFD_RELOC_32_PCREL; 7635 break; 7636 case 64: 7637 code = BFD_RELOC_64_PCREL; 7638 break; 7639 default: 7640 goto fail; 7641 } 7642 7643 howto = bfd_reloc_type_lookup (abfd, code); 7644 7645 if (areloc->howto->pcrel_offset != howto->pcrel_offset) 7646 { 7647 if (howto->pcrel_offset) 7648 areloc->addend += areloc->address; 7649 else 7650 areloc->addend -= areloc->address; /* addend is unsigned!! */ 7651 } 7652 } 7653 else 7654 { 7655 switch (areloc->howto->bitsize) 7656 { 7657 case 8: 7658 code = BFD_RELOC_8; 7659 break; 7660 case 14: 7661 code = BFD_RELOC_14; 7662 break; 7663 case 16: 7664 code = BFD_RELOC_16; 7665 break; 7666 case 26: 7667 code = BFD_RELOC_26; 7668 break; 7669 case 32: 7670 code = BFD_RELOC_32; 7671 break; 7672 case 64: 7673 code = BFD_RELOC_64; 7674 break; 7675 default: 7676 goto fail; 7677 } 7678 7679 howto = bfd_reloc_type_lookup (abfd, code); 7680 } 7681 7682 if (howto) 7683 areloc->howto = howto; 7684 else 7685 goto fail; 7686 } 7687 7688 return TRUE; 7689 7690 fail: 7691 (*_bfd_error_handler) 7692 (_("%B: unsupported relocation type %s"), 7693 abfd, areloc->howto->name); 7694 bfd_set_error (bfd_error_bad_value); 7695 return FALSE; 7696 } 7697 7698 bfd_boolean 7699 _bfd_elf_close_and_cleanup (bfd *abfd) 7700 { 7701 if (bfd_get_format (abfd) == bfd_object) 7702 { 7703 if (elf_tdata (abfd) != NULL && elf_shstrtab (abfd) != NULL) 7704 _bfd_elf_strtab_free (elf_shstrtab (abfd)); 7705 _bfd_dwarf2_cleanup_debug_info (abfd); 7706 } 7707 7708 return _bfd_generic_close_and_cleanup (abfd); 7709 } 7710 7711 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY 7712 in the relocation's offset. Thus we cannot allow any sort of sanity 7713 range-checking to interfere. There is nothing else to do in processing 7714 this reloc. */ 7715 7716 bfd_reloc_status_type 7717 _bfd_elf_rel_vtable_reloc_fn 7718 (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED, 7719 struct bfd_symbol *symbol ATTRIBUTE_UNUSED, 7720 void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED, 7721 bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED) 7722 { 7723 return bfd_reloc_ok; 7724 } 7725 7726 /* Elf core file support. Much of this only works on native 7727 toolchains, since we rely on knowing the 7728 machine-dependent procfs structure in order to pick 7729 out details about the corefile. */ 7730 7731 #ifdef HAVE_SYS_PROCFS_H 7732 /* Needed for new procfs interface on sparc-solaris. */ 7733 # define _STRUCTURED_PROC 1 7734 # include <sys/procfs.h> 7735 #endif 7736 7737 /* Return a PID that identifies a "thread" for threaded cores, or the 7738 PID of the main process for non-threaded cores. */ 7739 7740 static int 7741 elfcore_make_pid (bfd *abfd) 7742 { 7743 int pid; 7744 7745 pid = elf_tdata (abfd)->core_lwpid; 7746 if (pid == 0) 7747 pid = elf_tdata (abfd)->core_pid; 7748 7749 return pid; 7750 } 7751 7752 /* If there isn't a section called NAME, make one, using 7753 data from SECT. Note, this function will generate a 7754 reference to NAME, so you shouldn't deallocate or 7755 overwrite it. */ 7756 7757 static bfd_boolean 7758 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect) 7759 { 7760 asection *sect2; 7761 7762 if (bfd_get_section_by_name (abfd, name) != NULL) 7763 return TRUE; 7764 7765 sect2 = bfd_make_section_with_flags (abfd, name, sect->flags); 7766 if (sect2 == NULL) 7767 return FALSE; 7768 7769 sect2->size = sect->size; 7770 sect2->filepos = sect->filepos; 7771 sect2->alignment_power = sect->alignment_power; 7772 return TRUE; 7773 } 7774 7775 /* Create a pseudosection containing SIZE bytes at FILEPOS. This 7776 actually creates up to two pseudosections: 7777 - For the single-threaded case, a section named NAME, unless 7778 such a section already exists. 7779 - For the multi-threaded case, a section named "NAME/PID", where 7780 PID is elfcore_make_pid (abfd). 7781 Both pseudosections have identical contents. */ 7782 bfd_boolean 7783 _bfd_elfcore_make_pseudosection (bfd *abfd, 7784 char *name, 7785 size_t size, 7786 ufile_ptr filepos) 7787 { 7788 char buf[100]; 7789 char *threaded_name; 7790 size_t len; 7791 asection *sect; 7792 7793 /* Build the section name. */ 7794 7795 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd)); 7796 len = strlen (buf) + 1; 7797 threaded_name = (char *) bfd_alloc (abfd, len); 7798 if (threaded_name == NULL) 7799 return FALSE; 7800 memcpy (threaded_name, buf, len); 7801 7802 sect = bfd_make_section_anyway_with_flags (abfd, threaded_name, 7803 SEC_HAS_CONTENTS); 7804 if (sect == NULL) 7805 return FALSE; 7806 sect->size = size; 7807 sect->filepos = filepos; 7808 sect->alignment_power = 2; 7809 7810 return elfcore_maybe_make_sect (abfd, name, sect); 7811 } 7812 7813 /* prstatus_t exists on: 7814 solaris 2.5+ 7815 linux 2.[01] + glibc 7816 unixware 4.2 7817 */ 7818 7819 #if defined (HAVE_PRSTATUS_T) 7820 7821 static bfd_boolean 7822 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) 7823 { 7824 size_t size; 7825 int offset; 7826 7827 if (note->descsz == sizeof (prstatus_t)) 7828 { 7829 prstatus_t prstat; 7830 7831 size = sizeof (prstat.pr_reg); 7832 offset = offsetof (prstatus_t, pr_reg); 7833 memcpy (&prstat, note->descdata, sizeof (prstat)); 7834 7835 /* Do not overwrite the core signal if it 7836 has already been set by another thread. */ 7837 if (elf_tdata (abfd)->core_signal == 0) 7838 elf_tdata (abfd)->core_signal = prstat.pr_cursig; 7839 if (elf_tdata (abfd)->core_pid == 0) 7840 elf_tdata (abfd)->core_pid = prstat.pr_pid; 7841 7842 /* pr_who exists on: 7843 solaris 2.5+ 7844 unixware 4.2 7845 pr_who doesn't exist on: 7846 linux 2.[01] 7847 */ 7848 #if defined (HAVE_PRSTATUS_T_PR_WHO) 7849 elf_tdata (abfd)->core_lwpid = prstat.pr_who; 7850 #else 7851 elf_tdata (abfd)->core_lwpid = prstat.pr_pid; 7852 #endif 7853 } 7854 #if defined (HAVE_PRSTATUS32_T) 7855 else if (note->descsz == sizeof (prstatus32_t)) 7856 { 7857 /* 64-bit host, 32-bit corefile */ 7858 prstatus32_t prstat; 7859 7860 size = sizeof (prstat.pr_reg); 7861 offset = offsetof (prstatus32_t, pr_reg); 7862 memcpy (&prstat, note->descdata, sizeof (prstat)); 7863 7864 /* Do not overwrite the core signal if it 7865 has already been set by another thread. */ 7866 if (elf_tdata (abfd)->core_signal == 0) 7867 elf_tdata (abfd)->core_signal = prstat.pr_cursig; 7868 if (elf_tdata (abfd)->core_pid == 0) 7869 elf_tdata (abfd)->core_pid = prstat.pr_pid; 7870 7871 /* pr_who exists on: 7872 solaris 2.5+ 7873 unixware 4.2 7874 pr_who doesn't exist on: 7875 linux 2.[01] 7876 */ 7877 #if defined (HAVE_PRSTATUS32_T_PR_WHO) 7878 elf_tdata (abfd)->core_lwpid = prstat.pr_who; 7879 #else 7880 elf_tdata (abfd)->core_lwpid = prstat.pr_pid; 7881 #endif 7882 } 7883 #endif /* HAVE_PRSTATUS32_T */ 7884 else 7885 { 7886 /* Fail - we don't know how to handle any other 7887 note size (ie. data object type). */ 7888 return TRUE; 7889 } 7890 7891 /* Make a ".reg/999" section and a ".reg" section. */ 7892 return _bfd_elfcore_make_pseudosection (abfd, ".reg", 7893 size, note->descpos + offset); 7894 } 7895 #endif /* defined (HAVE_PRSTATUS_T) */ 7896 7897 /* Create a pseudosection containing the exact contents of NOTE. */ 7898 static bfd_boolean 7899 elfcore_make_note_pseudosection (bfd *abfd, 7900 char *name, 7901 Elf_Internal_Note *note) 7902 { 7903 return _bfd_elfcore_make_pseudosection (abfd, name, 7904 note->descsz, note->descpos); 7905 } 7906 7907 /* There isn't a consistent prfpregset_t across platforms, 7908 but it doesn't matter, because we don't have to pick this 7909 data structure apart. */ 7910 7911 static bfd_boolean 7912 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note) 7913 { 7914 return elfcore_make_note_pseudosection (abfd, ".reg2", note); 7915 } 7916 7917 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note 7918 type of NT_PRXFPREG. Just include the whole note's contents 7919 literally. */ 7920 7921 static bfd_boolean 7922 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note) 7923 { 7924 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note); 7925 } 7926 7927 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX" 7928 with a note type of NT_X86_XSTATE. Just include the whole note's 7929 contents literally. */ 7930 7931 static bfd_boolean 7932 elfcore_grok_xstatereg (bfd *abfd, Elf_Internal_Note *note) 7933 { 7934 return elfcore_make_note_pseudosection (abfd, ".reg-xstate", note); 7935 } 7936 7937 static bfd_boolean 7938 elfcore_grok_ppc_vmx (bfd *abfd, Elf_Internal_Note *note) 7939 { 7940 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vmx", note); 7941 } 7942 7943 static bfd_boolean 7944 elfcore_grok_ppc_vsx (bfd *abfd, Elf_Internal_Note *note) 7945 { 7946 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vsx", note); 7947 } 7948 7949 static bfd_boolean 7950 elfcore_grok_s390_high_gprs (bfd *abfd, Elf_Internal_Note *note) 7951 { 7952 return elfcore_make_note_pseudosection (abfd, ".reg-s390-high-gprs", note); 7953 } 7954 7955 static bfd_boolean 7956 elfcore_grok_s390_timer (bfd *abfd, Elf_Internal_Note *note) 7957 { 7958 return elfcore_make_note_pseudosection (abfd, ".reg-s390-timer", note); 7959 } 7960 7961 static bfd_boolean 7962 elfcore_grok_s390_todcmp (bfd *abfd, Elf_Internal_Note *note) 7963 { 7964 return elfcore_make_note_pseudosection (abfd, ".reg-s390-todcmp", note); 7965 } 7966 7967 static bfd_boolean 7968 elfcore_grok_s390_todpreg (bfd *abfd, Elf_Internal_Note *note) 7969 { 7970 return elfcore_make_note_pseudosection (abfd, ".reg-s390-todpreg", note); 7971 } 7972 7973 static bfd_boolean 7974 elfcore_grok_s390_ctrs (bfd *abfd, Elf_Internal_Note *note) 7975 { 7976 return elfcore_make_note_pseudosection (abfd, ".reg-s390-ctrs", note); 7977 } 7978 7979 static bfd_boolean 7980 elfcore_grok_s390_prefix (bfd *abfd, Elf_Internal_Note *note) 7981 { 7982 return elfcore_make_note_pseudosection (abfd, ".reg-s390-prefix", note); 7983 } 7984 7985 static bfd_boolean 7986 elfcore_grok_s390_last_break (bfd *abfd, Elf_Internal_Note *note) 7987 { 7988 return elfcore_make_note_pseudosection (abfd, ".reg-s390-last-break", note); 7989 } 7990 7991 static bfd_boolean 7992 elfcore_grok_s390_system_call (bfd *abfd, Elf_Internal_Note *note) 7993 { 7994 return elfcore_make_note_pseudosection (abfd, ".reg-s390-system-call", note); 7995 } 7996 7997 static bfd_boolean 7998 elfcore_grok_arm_vfp (bfd *abfd, Elf_Internal_Note *note) 7999 { 8000 return elfcore_make_note_pseudosection (abfd, ".reg-arm-vfp", note); 8001 } 8002 8003 #if defined (HAVE_PRPSINFO_T) 8004 typedef prpsinfo_t elfcore_psinfo_t; 8005 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */ 8006 typedef prpsinfo32_t elfcore_psinfo32_t; 8007 #endif 8008 #endif 8009 8010 #if defined (HAVE_PSINFO_T) 8011 typedef psinfo_t elfcore_psinfo_t; 8012 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */ 8013 typedef psinfo32_t elfcore_psinfo32_t; 8014 #endif 8015 #endif 8016 8017 /* return a malloc'ed copy of a string at START which is at 8018 most MAX bytes long, possibly without a terminating '\0'. 8019 the copy will always have a terminating '\0'. */ 8020 8021 char * 8022 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max) 8023 { 8024 char *dups; 8025 char *end = (char *) memchr (start, '\0', max); 8026 size_t len; 8027 8028 if (end == NULL) 8029 len = max; 8030 else 8031 len = end - start; 8032 8033 dups = (char *) bfd_alloc (abfd, len + 1); 8034 if (dups == NULL) 8035 return NULL; 8036 8037 memcpy (dups, start, len); 8038 dups[len] = '\0'; 8039 8040 return dups; 8041 } 8042 8043 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) 8044 static bfd_boolean 8045 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) 8046 { 8047 if (note->descsz == sizeof (elfcore_psinfo_t)) 8048 { 8049 elfcore_psinfo_t psinfo; 8050 8051 memcpy (&psinfo, note->descdata, sizeof (psinfo)); 8052 8053 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID) 8054 elf_tdata (abfd)->core_pid = psinfo.pr_pid; 8055 #endif 8056 elf_tdata (abfd)->core_program 8057 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname, 8058 sizeof (psinfo.pr_fname)); 8059 8060 elf_tdata (abfd)->core_command 8061 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs, 8062 sizeof (psinfo.pr_psargs)); 8063 } 8064 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T) 8065 else if (note->descsz == sizeof (elfcore_psinfo32_t)) 8066 { 8067 /* 64-bit host, 32-bit corefile */ 8068 elfcore_psinfo32_t psinfo; 8069 8070 memcpy (&psinfo, note->descdata, sizeof (psinfo)); 8071 8072 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID) 8073 elf_tdata (abfd)->core_pid = psinfo.pr_pid; 8074 #endif 8075 elf_tdata (abfd)->core_program 8076 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname, 8077 sizeof (psinfo.pr_fname)); 8078 8079 elf_tdata (abfd)->core_command 8080 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs, 8081 sizeof (psinfo.pr_psargs)); 8082 } 8083 #endif 8084 8085 else 8086 { 8087 /* Fail - we don't know how to handle any other 8088 note size (ie. data object type). */ 8089 return TRUE; 8090 } 8091 8092 /* Note that for some reason, a spurious space is tacked 8093 onto the end of the args in some (at least one anyway) 8094 implementations, so strip it off if it exists. */ 8095 8096 { 8097 char *command = elf_tdata (abfd)->core_command; 8098 int n = strlen (command); 8099 8100 if (0 < n && command[n - 1] == ' ') 8101 command[n - 1] = '\0'; 8102 } 8103 8104 return TRUE; 8105 } 8106 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */ 8107 8108 #if defined (HAVE_PSTATUS_T) 8109 static bfd_boolean 8110 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note) 8111 { 8112 if (note->descsz == sizeof (pstatus_t) 8113 #if defined (HAVE_PXSTATUS_T) 8114 || note->descsz == sizeof (pxstatus_t) 8115 #endif 8116 ) 8117 { 8118 pstatus_t pstat; 8119 8120 memcpy (&pstat, note->descdata, sizeof (pstat)); 8121 8122 elf_tdata (abfd)->core_pid = pstat.pr_pid; 8123 } 8124 #if defined (HAVE_PSTATUS32_T) 8125 else if (note->descsz == sizeof (pstatus32_t)) 8126 { 8127 /* 64-bit host, 32-bit corefile */ 8128 pstatus32_t pstat; 8129 8130 memcpy (&pstat, note->descdata, sizeof (pstat)); 8131 8132 elf_tdata (abfd)->core_pid = pstat.pr_pid; 8133 } 8134 #endif 8135 /* Could grab some more details from the "representative" 8136 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an 8137 NT_LWPSTATUS note, presumably. */ 8138 8139 return TRUE; 8140 } 8141 #endif /* defined (HAVE_PSTATUS_T) */ 8142 8143 #if defined (HAVE_LWPSTATUS_T) 8144 static bfd_boolean 8145 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note) 8146 { 8147 lwpstatus_t lwpstat; 8148 char buf[100]; 8149 char *name; 8150 size_t len; 8151 asection *sect; 8152 8153 if (note->descsz != sizeof (lwpstat) 8154 #if defined (HAVE_LWPXSTATUS_T) 8155 && note->descsz != sizeof (lwpxstatus_t) 8156 #endif 8157 ) 8158 return TRUE; 8159 8160 memcpy (&lwpstat, note->descdata, sizeof (lwpstat)); 8161 8162 elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid; 8163 /* Do not overwrite the core signal if it has already been set by 8164 another thread. */ 8165 if (elf_tdata (abfd)->core_signal == 0) 8166 elf_tdata (abfd)->core_signal = lwpstat.pr_cursig; 8167 8168 /* Make a ".reg/999" section. */ 8169 8170 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd)); 8171 len = strlen (buf) + 1; 8172 name = bfd_alloc (abfd, len); 8173 if (name == NULL) 8174 return FALSE; 8175 memcpy (name, buf, len); 8176 8177 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS); 8178 if (sect == NULL) 8179 return FALSE; 8180 8181 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT) 8182 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs); 8183 sect->filepos = note->descpos 8184 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs); 8185 #endif 8186 8187 #if defined (HAVE_LWPSTATUS_T_PR_REG) 8188 sect->size = sizeof (lwpstat.pr_reg); 8189 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg); 8190 #endif 8191 8192 sect->alignment_power = 2; 8193 8194 if (!elfcore_maybe_make_sect (abfd, ".reg", sect)) 8195 return FALSE; 8196 8197 /* Make a ".reg2/999" section */ 8198 8199 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd)); 8200 len = strlen (buf) + 1; 8201 name = bfd_alloc (abfd, len); 8202 if (name == NULL) 8203 return FALSE; 8204 memcpy (name, buf, len); 8205 8206 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS); 8207 if (sect == NULL) 8208 return FALSE; 8209 8210 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT) 8211 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs); 8212 sect->filepos = note->descpos 8213 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs); 8214 #endif 8215 8216 #if defined (HAVE_LWPSTATUS_T_PR_FPREG) 8217 sect->size = sizeof (lwpstat.pr_fpreg); 8218 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg); 8219 #endif 8220 8221 sect->alignment_power = 2; 8222 8223 return elfcore_maybe_make_sect (abfd, ".reg2", sect); 8224 } 8225 #endif /* defined (HAVE_LWPSTATUS_T) */ 8226 8227 static bfd_boolean 8228 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note) 8229 { 8230 char buf[30]; 8231 char *name; 8232 size_t len; 8233 asection *sect; 8234 int type; 8235 int is_active_thread; 8236 bfd_vma base_addr; 8237 8238 if (note->descsz < 728) 8239 return TRUE; 8240 8241 if (! CONST_STRNEQ (note->namedata, "win32")) 8242 return TRUE; 8243 8244 type = bfd_get_32 (abfd, note->descdata); 8245 8246 switch (type) 8247 { 8248 case 1 /* NOTE_INFO_PROCESS */: 8249 /* FIXME: need to add ->core_command. */ 8250 /* process_info.pid */ 8251 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 8); 8252 /* process_info.signal */ 8253 elf_tdata (abfd)->core_signal = bfd_get_32 (abfd, note->descdata + 12); 8254 break; 8255 8256 case 2 /* NOTE_INFO_THREAD */: 8257 /* Make a ".reg/999" section. */ 8258 /* thread_info.tid */ 8259 sprintf (buf, ".reg/%ld", (long) bfd_get_32 (abfd, note->descdata + 8)); 8260 8261 len = strlen (buf) + 1; 8262 name = (char *) bfd_alloc (abfd, len); 8263 if (name == NULL) 8264 return FALSE; 8265 8266 memcpy (name, buf, len); 8267 8268 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS); 8269 if (sect == NULL) 8270 return FALSE; 8271 8272 /* sizeof (thread_info.thread_context) */ 8273 sect->size = 716; 8274 /* offsetof (thread_info.thread_context) */ 8275 sect->filepos = note->descpos + 12; 8276 sect->alignment_power = 2; 8277 8278 /* thread_info.is_active_thread */ 8279 is_active_thread = bfd_get_32 (abfd, note->descdata + 8); 8280 8281 if (is_active_thread) 8282 if (! elfcore_maybe_make_sect (abfd, ".reg", sect)) 8283 return FALSE; 8284 break; 8285 8286 case 3 /* NOTE_INFO_MODULE */: 8287 /* Make a ".module/xxxxxxxx" section. */ 8288 /* module_info.base_address */ 8289 base_addr = bfd_get_32 (abfd, note->descdata + 4); 8290 sprintf (buf, ".module/%08lx", (unsigned long) base_addr); 8291 8292 len = strlen (buf) + 1; 8293 name = (char *) bfd_alloc (abfd, len); 8294 if (name == NULL) 8295 return FALSE; 8296 8297 memcpy (name, buf, len); 8298 8299 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS); 8300 8301 if (sect == NULL) 8302 return FALSE; 8303 8304 sect->size = note->descsz; 8305 sect->filepos = note->descpos; 8306 sect->alignment_power = 2; 8307 break; 8308 8309 default: 8310 return TRUE; 8311 } 8312 8313 return TRUE; 8314 } 8315 8316 static bfd_boolean 8317 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note) 8318 { 8319 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 8320 8321 switch (note->type) 8322 { 8323 default: 8324 return TRUE; 8325 8326 case NT_PRSTATUS: 8327 if (bed->elf_backend_grok_prstatus) 8328 if ((*bed->elf_backend_grok_prstatus) (abfd, note)) 8329 return TRUE; 8330 #if defined (HAVE_PRSTATUS_T) 8331 return elfcore_grok_prstatus (abfd, note); 8332 #else 8333 return TRUE; 8334 #endif 8335 8336 #if defined (HAVE_PSTATUS_T) 8337 case NT_PSTATUS: 8338 return elfcore_grok_pstatus (abfd, note); 8339 #endif 8340 8341 #if defined (HAVE_LWPSTATUS_T) 8342 case NT_LWPSTATUS: 8343 return elfcore_grok_lwpstatus (abfd, note); 8344 #endif 8345 8346 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */ 8347 return elfcore_grok_prfpreg (abfd, note); 8348 8349 case NT_WIN32PSTATUS: 8350 return elfcore_grok_win32pstatus (abfd, note); 8351 8352 case NT_PRXFPREG: /* Linux SSE extension */ 8353 if (note->namesz == 6 8354 && strcmp (note->namedata, "LINUX") == 0) 8355 return elfcore_grok_prxfpreg (abfd, note); 8356 else 8357 return TRUE; 8358 8359 case NT_X86_XSTATE: /* Linux XSAVE extension */ 8360 if (note->namesz == 6 8361 && strcmp (note->namedata, "LINUX") == 0) 8362 return elfcore_grok_xstatereg (abfd, note); 8363 else 8364 return TRUE; 8365 8366 case NT_PPC_VMX: 8367 if (note->namesz == 6 8368 && strcmp (note->namedata, "LINUX") == 0) 8369 return elfcore_grok_ppc_vmx (abfd, note); 8370 else 8371 return TRUE; 8372 8373 case NT_PPC_VSX: 8374 if (note->namesz == 6 8375 && strcmp (note->namedata, "LINUX") == 0) 8376 return elfcore_grok_ppc_vsx (abfd, note); 8377 else 8378 return TRUE; 8379 8380 case NT_S390_HIGH_GPRS: 8381 if (note->namesz == 6 8382 && strcmp (note->namedata, "LINUX") == 0) 8383 return elfcore_grok_s390_high_gprs (abfd, note); 8384 else 8385 return TRUE; 8386 8387 case NT_S390_TIMER: 8388 if (note->namesz == 6 8389 && strcmp (note->namedata, "LINUX") == 0) 8390 return elfcore_grok_s390_timer (abfd, note); 8391 else 8392 return TRUE; 8393 8394 case NT_S390_TODCMP: 8395 if (note->namesz == 6 8396 && strcmp (note->namedata, "LINUX") == 0) 8397 return elfcore_grok_s390_todcmp (abfd, note); 8398 else 8399 return TRUE; 8400 8401 case NT_S390_TODPREG: 8402 if (note->namesz == 6 8403 && strcmp (note->namedata, "LINUX") == 0) 8404 return elfcore_grok_s390_todpreg (abfd, note); 8405 else 8406 return TRUE; 8407 8408 case NT_S390_CTRS: 8409 if (note->namesz == 6 8410 && strcmp (note->namedata, "LINUX") == 0) 8411 return elfcore_grok_s390_ctrs (abfd, note); 8412 else 8413 return TRUE; 8414 8415 case NT_S390_PREFIX: 8416 if (note->namesz == 6 8417 && strcmp (note->namedata, "LINUX") == 0) 8418 return elfcore_grok_s390_prefix (abfd, note); 8419 else 8420 return TRUE; 8421 8422 case NT_S390_LAST_BREAK: 8423 if (note->namesz == 6 8424 && strcmp (note->namedata, "LINUX") == 0) 8425 return elfcore_grok_s390_last_break (abfd, note); 8426 else 8427 return TRUE; 8428 8429 case NT_S390_SYSTEM_CALL: 8430 if (note->namesz == 6 8431 && strcmp (note->namedata, "LINUX") == 0) 8432 return elfcore_grok_s390_system_call (abfd, note); 8433 else 8434 return TRUE; 8435 8436 case NT_ARM_VFP: 8437 if (note->namesz == 6 8438 && strcmp (note->namedata, "LINUX") == 0) 8439 return elfcore_grok_arm_vfp (abfd, note); 8440 else 8441 return TRUE; 8442 8443 case NT_PRPSINFO: 8444 case NT_PSINFO: 8445 if (bed->elf_backend_grok_psinfo) 8446 if ((*bed->elf_backend_grok_psinfo) (abfd, note)) 8447 return TRUE; 8448 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) 8449 return elfcore_grok_psinfo (abfd, note); 8450 #else 8451 return TRUE; 8452 #endif 8453 8454 case NT_AUXV: 8455 { 8456 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv", 8457 SEC_HAS_CONTENTS); 8458 8459 if (sect == NULL) 8460 return FALSE; 8461 sect->size = note->descsz; 8462 sect->filepos = note->descpos; 8463 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32; 8464 8465 return TRUE; 8466 } 8467 } 8468 } 8469 8470 static bfd_boolean 8471 elfobj_grok_gnu_build_id (bfd *abfd, Elf_Internal_Note *note) 8472 { 8473 elf_tdata (abfd)->build_id_size = note->descsz; 8474 elf_tdata (abfd)->build_id = (bfd_byte *) bfd_alloc (abfd, note->descsz); 8475 if (elf_tdata (abfd)->build_id == NULL) 8476 return FALSE; 8477 8478 memcpy (elf_tdata (abfd)->build_id, note->descdata, note->descsz); 8479 8480 return TRUE; 8481 } 8482 8483 static bfd_boolean 8484 elfobj_grok_gnu_note (bfd *abfd, Elf_Internal_Note *note) 8485 { 8486 switch (note->type) 8487 { 8488 default: 8489 return TRUE; 8490 8491 case NT_GNU_BUILD_ID: 8492 return elfobj_grok_gnu_build_id (abfd, note); 8493 } 8494 } 8495 8496 static bfd_boolean 8497 elfobj_grok_stapsdt_note_1 (bfd *abfd, Elf_Internal_Note *note) 8498 { 8499 struct sdt_note *cur = 8500 (struct sdt_note *) bfd_alloc (abfd, sizeof (struct sdt_note) 8501 + note->descsz); 8502 8503 cur->next = (struct sdt_note *) (elf_tdata (abfd))->sdt_note_head; 8504 cur->size = (bfd_size_type) note->descsz; 8505 memcpy (cur->data, note->descdata, note->descsz); 8506 8507 elf_tdata (abfd)->sdt_note_head = cur; 8508 8509 return TRUE; 8510 } 8511 8512 static bfd_boolean 8513 elfobj_grok_stapsdt_note (bfd *abfd, Elf_Internal_Note *note) 8514 { 8515 switch (note->type) 8516 { 8517 case NT_STAPSDT: 8518 return elfobj_grok_stapsdt_note_1 (abfd, note); 8519 8520 default: 8521 return TRUE; 8522 } 8523 } 8524 8525 static bfd_boolean 8526 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp) 8527 { 8528 char *cp; 8529 8530 cp = strchr (note->namedata, '@'); 8531 if (cp != NULL) 8532 { 8533 *lwpidp = atoi(cp + 1); 8534 return TRUE; 8535 } 8536 return FALSE; 8537 } 8538 8539 static bfd_boolean 8540 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note) 8541 { 8542 /* Signal number at offset 0x08. */ 8543 elf_tdata (abfd)->core_signal 8544 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08); 8545 8546 /* Process ID at offset 0x50. */ 8547 elf_tdata (abfd)->core_pid 8548 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50); 8549 8550 /* Command name at 0x7c (max 32 bytes, including nul). */ 8551 elf_tdata (abfd)->core_command 8552 = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31); 8553 8554 return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo", 8555 note); 8556 } 8557 8558 static bfd_boolean 8559 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note) 8560 { 8561 int lwp; 8562 8563 if (elfcore_netbsd_get_lwpid (note, &lwp)) 8564 elf_tdata (abfd)->core_lwpid = lwp; 8565 8566 if (note->type == NT_NETBSDCORE_PROCINFO) 8567 { 8568 /* NetBSD-specific core "procinfo". Note that we expect to 8569 find this note before any of the others, which is fine, 8570 since the kernel writes this note out first when it 8571 creates a core file. */ 8572 8573 return elfcore_grok_netbsd_procinfo (abfd, note); 8574 } 8575 8576 /* As of Jan 2002 there are no other machine-independent notes 8577 defined for NetBSD core files. If the note type is less 8578 than the start of the machine-dependent note types, we don't 8579 understand it. */ 8580 8581 if (note->type < NT_NETBSDCORE_FIRSTMACH) 8582 return TRUE; 8583 8584 8585 switch (bfd_get_arch (abfd)) 8586 { 8587 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and 8588 PT_GETFPREGS == mach+2. */ 8589 8590 case bfd_arch_alpha: 8591 case bfd_arch_sparc: 8592 switch (note->type) 8593 { 8594 case NT_NETBSDCORE_FIRSTMACH+0: 8595 return elfcore_make_note_pseudosection (abfd, ".reg", note); 8596 8597 case NT_NETBSDCORE_FIRSTMACH+2: 8598 return elfcore_make_note_pseudosection (abfd, ".reg2", note); 8599 8600 default: 8601 return TRUE; 8602 } 8603 8604 /* On all other arch's, PT_GETREGS == mach+1 and 8605 PT_GETFPREGS == mach+3. */ 8606 8607 default: 8608 switch (note->type) 8609 { 8610 case NT_NETBSDCORE_FIRSTMACH+1: 8611 return elfcore_make_note_pseudosection (abfd, ".reg", note); 8612 8613 case NT_NETBSDCORE_FIRSTMACH+3: 8614 return elfcore_make_note_pseudosection (abfd, ".reg2", note); 8615 8616 default: 8617 return TRUE; 8618 } 8619 } 8620 /* NOTREACHED */ 8621 } 8622 8623 static bfd_boolean 8624 elfcore_grok_openbsd_procinfo (bfd *abfd, Elf_Internal_Note *note) 8625 { 8626 /* Signal number at offset 0x08. */ 8627 elf_tdata (abfd)->core_signal 8628 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08); 8629 8630 /* Process ID at offset 0x20. */ 8631 elf_tdata (abfd)->core_pid 8632 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x20); 8633 8634 /* Command name at 0x48 (max 32 bytes, including nul). */ 8635 elf_tdata (abfd)->core_command 8636 = _bfd_elfcore_strndup (abfd, note->descdata + 0x48, 31); 8637 8638 return TRUE; 8639 } 8640 8641 static bfd_boolean 8642 elfcore_grok_openbsd_note (bfd *abfd, Elf_Internal_Note *note) 8643 { 8644 if (note->type == NT_OPENBSD_PROCINFO) 8645 return elfcore_grok_openbsd_procinfo (abfd, note); 8646 8647 if (note->type == NT_OPENBSD_REGS) 8648 return elfcore_make_note_pseudosection (abfd, ".reg", note); 8649 8650 if (note->type == NT_OPENBSD_FPREGS) 8651 return elfcore_make_note_pseudosection (abfd, ".reg2", note); 8652 8653 if (note->type == NT_OPENBSD_XFPREGS) 8654 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note); 8655 8656 if (note->type == NT_OPENBSD_AUXV) 8657 { 8658 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv", 8659 SEC_HAS_CONTENTS); 8660 8661 if (sect == NULL) 8662 return FALSE; 8663 sect->size = note->descsz; 8664 sect->filepos = note->descpos; 8665 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32; 8666 8667 return TRUE; 8668 } 8669 8670 if (note->type == NT_OPENBSD_WCOOKIE) 8671 { 8672 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".wcookie", 8673 SEC_HAS_CONTENTS); 8674 8675 if (sect == NULL) 8676 return FALSE; 8677 sect->size = note->descsz; 8678 sect->filepos = note->descpos; 8679 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32; 8680 8681 return TRUE; 8682 } 8683 8684 return TRUE; 8685 } 8686 8687 static bfd_boolean 8688 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid) 8689 { 8690 void *ddata = note->descdata; 8691 char buf[100]; 8692 char *name; 8693 asection *sect; 8694 short sig; 8695 unsigned flags; 8696 8697 /* nto_procfs_status 'pid' field is at offset 0. */ 8698 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata); 8699 8700 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */ 8701 *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4); 8702 8703 /* nto_procfs_status 'flags' field is at offset 8. */ 8704 flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8); 8705 8706 /* nto_procfs_status 'what' field is at offset 14. */ 8707 if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0) 8708 { 8709 elf_tdata (abfd)->core_signal = sig; 8710 elf_tdata (abfd)->core_lwpid = *tid; 8711 } 8712 8713 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores 8714 do not come from signals so we make sure we set the current 8715 thread just in case. */ 8716 if (flags & 0x00000080) 8717 elf_tdata (abfd)->core_lwpid = *tid; 8718 8719 /* Make a ".qnx_core_status/%d" section. */ 8720 sprintf (buf, ".qnx_core_status/%ld", *tid); 8721 8722 name = (char *) bfd_alloc (abfd, strlen (buf) + 1); 8723 if (name == NULL) 8724 return FALSE; 8725 strcpy (name, buf); 8726 8727 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS); 8728 if (sect == NULL) 8729 return FALSE; 8730 8731 sect->size = note->descsz; 8732 sect->filepos = note->descpos; 8733 sect->alignment_power = 2; 8734 8735 return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect)); 8736 } 8737 8738 static bfd_boolean 8739 elfcore_grok_nto_regs (bfd *abfd, 8740 Elf_Internal_Note *note, 8741 long tid, 8742 char *base) 8743 { 8744 char buf[100]; 8745 char *name; 8746 asection *sect; 8747 8748 /* Make a "(base)/%d" section. */ 8749 sprintf (buf, "%s/%ld", base, tid); 8750 8751 name = (char *) bfd_alloc (abfd, strlen (buf) + 1); 8752 if (name == NULL) 8753 return FALSE; 8754 strcpy (name, buf); 8755 8756 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS); 8757 if (sect == NULL) 8758 return FALSE; 8759 8760 sect->size = note->descsz; 8761 sect->filepos = note->descpos; 8762 sect->alignment_power = 2; 8763 8764 /* This is the current thread. */ 8765 if (elf_tdata (abfd)->core_lwpid == tid) 8766 return elfcore_maybe_make_sect (abfd, base, sect); 8767 8768 return TRUE; 8769 } 8770 8771 #define BFD_QNT_CORE_INFO 7 8772 #define BFD_QNT_CORE_STATUS 8 8773 #define BFD_QNT_CORE_GREG 9 8774 #define BFD_QNT_CORE_FPREG 10 8775 8776 static bfd_boolean 8777 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note) 8778 { 8779 /* Every GREG section has a STATUS section before it. Store the 8780 tid from the previous call to pass down to the next gregs 8781 function. */ 8782 static long tid = 1; 8783 8784 switch (note->type) 8785 { 8786 case BFD_QNT_CORE_INFO: 8787 return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note); 8788 case BFD_QNT_CORE_STATUS: 8789 return elfcore_grok_nto_status (abfd, note, &tid); 8790 case BFD_QNT_CORE_GREG: 8791 return elfcore_grok_nto_regs (abfd, note, tid, ".reg"); 8792 case BFD_QNT_CORE_FPREG: 8793 return elfcore_grok_nto_regs (abfd, note, tid, ".reg2"); 8794 default: 8795 return TRUE; 8796 } 8797 } 8798 8799 static bfd_boolean 8800 elfcore_grok_spu_note (bfd *abfd, Elf_Internal_Note *note) 8801 { 8802 char *name; 8803 asection *sect; 8804 size_t len; 8805 8806 /* Use note name as section name. */ 8807 len = note->namesz; 8808 name = (char *) bfd_alloc (abfd, len); 8809 if (name == NULL) 8810 return FALSE; 8811 memcpy (name, note->namedata, len); 8812 name[len - 1] = '\0'; 8813 8814 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS); 8815 if (sect == NULL) 8816 return FALSE; 8817 8818 sect->size = note->descsz; 8819 sect->filepos = note->descpos; 8820 sect->alignment_power = 1; 8821 8822 return TRUE; 8823 } 8824 8825 /* Function: elfcore_write_note 8826 8827 Inputs: 8828 buffer to hold note, and current size of buffer 8829 name of note 8830 type of note 8831 data for note 8832 size of data for note 8833 8834 Writes note to end of buffer. ELF64 notes are written exactly as 8835 for ELF32, despite the current (as of 2006) ELF gabi specifying 8836 that they ought to have 8-byte namesz and descsz field, and have 8837 8-byte alignment. Other writers, eg. Linux kernel, do the same. 8838 8839 Return: 8840 Pointer to realloc'd buffer, *BUFSIZ updated. */ 8841 8842 char * 8843 elfcore_write_note (bfd *abfd, 8844 char *buf, 8845 int *bufsiz, 8846 const char *name, 8847 int type, 8848 const void *input, 8849 int size) 8850 { 8851 Elf_External_Note *xnp; 8852 size_t namesz; 8853 size_t newspace; 8854 char *dest; 8855 8856 namesz = 0; 8857 if (name != NULL) 8858 namesz = strlen (name) + 1; 8859 8860 newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4); 8861 8862 buf = (char *) realloc (buf, *bufsiz + newspace); 8863 if (buf == NULL) 8864 return buf; 8865 dest = buf + *bufsiz; 8866 *bufsiz += newspace; 8867 xnp = (Elf_External_Note *) dest; 8868 H_PUT_32 (abfd, namesz, xnp->namesz); 8869 H_PUT_32 (abfd, size, xnp->descsz); 8870 H_PUT_32 (abfd, type, xnp->type); 8871 dest = xnp->name; 8872 if (name != NULL) 8873 { 8874 memcpy (dest, name, namesz); 8875 dest += namesz; 8876 while (namesz & 3) 8877 { 8878 *dest++ = '\0'; 8879 ++namesz; 8880 } 8881 } 8882 memcpy (dest, input, size); 8883 dest += size; 8884 while (size & 3) 8885 { 8886 *dest++ = '\0'; 8887 ++size; 8888 } 8889 return buf; 8890 } 8891 8892 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) 8893 char * 8894 elfcore_write_prpsinfo (bfd *abfd, 8895 char *buf, 8896 int *bufsiz, 8897 const char *fname, 8898 const char *psargs) 8899 { 8900 const char *note_name = "CORE"; 8901 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 8902 8903 if (bed->elf_backend_write_core_note != NULL) 8904 { 8905 char *ret; 8906 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz, 8907 NT_PRPSINFO, fname, psargs); 8908 if (ret != NULL) 8909 return ret; 8910 } 8911 8912 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T) 8913 if (bed->s->elfclass == ELFCLASS32) 8914 { 8915 #if defined (HAVE_PSINFO32_T) 8916 psinfo32_t data; 8917 int note_type = NT_PSINFO; 8918 #else 8919 prpsinfo32_t data; 8920 int note_type = NT_PRPSINFO; 8921 #endif 8922 8923 memset (&data, 0, sizeof (data)); 8924 strncpy (data.pr_fname, fname, sizeof (data.pr_fname)); 8925 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs)); 8926 return elfcore_write_note (abfd, buf, bufsiz, 8927 note_name, note_type, &data, sizeof (data)); 8928 } 8929 else 8930 #endif 8931 { 8932 #if defined (HAVE_PSINFO_T) 8933 psinfo_t data; 8934 int note_type = NT_PSINFO; 8935 #else 8936 prpsinfo_t data; 8937 int note_type = NT_PRPSINFO; 8938 #endif 8939 8940 memset (&data, 0, sizeof (data)); 8941 strncpy (data.pr_fname, fname, sizeof (data.pr_fname)); 8942 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs)); 8943 return elfcore_write_note (abfd, buf, bufsiz, 8944 note_name, note_type, &data, sizeof (data)); 8945 } 8946 } 8947 #endif /* PSINFO_T or PRPSINFO_T */ 8948 8949 #if defined (HAVE_PRSTATUS_T) 8950 char * 8951 elfcore_write_prstatus (bfd *abfd, 8952 char *buf, 8953 int *bufsiz, 8954 long pid, 8955 int cursig, 8956 const void *gregs) 8957 { 8958 const char *note_name = "CORE"; 8959 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 8960 8961 if (bed->elf_backend_write_core_note != NULL) 8962 { 8963 char *ret; 8964 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz, 8965 NT_PRSTATUS, 8966 pid, cursig, gregs); 8967 if (ret != NULL) 8968 return ret; 8969 } 8970 8971 #if defined (HAVE_PRSTATUS32_T) 8972 if (bed->s->elfclass == ELFCLASS32) 8973 { 8974 prstatus32_t prstat; 8975 8976 memset (&prstat, 0, sizeof (prstat)); 8977 prstat.pr_pid = pid; 8978 prstat.pr_cursig = cursig; 8979 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg)); 8980 return elfcore_write_note (abfd, buf, bufsiz, note_name, 8981 NT_PRSTATUS, &prstat, sizeof (prstat)); 8982 } 8983 else 8984 #endif 8985 { 8986 prstatus_t prstat; 8987 8988 memset (&prstat, 0, sizeof (prstat)); 8989 prstat.pr_pid = pid; 8990 prstat.pr_cursig = cursig; 8991 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg)); 8992 return elfcore_write_note (abfd, buf, bufsiz, note_name, 8993 NT_PRSTATUS, &prstat, sizeof (prstat)); 8994 } 8995 } 8996 #endif /* HAVE_PRSTATUS_T */ 8997 8998 #if defined (HAVE_LWPSTATUS_T) 8999 char * 9000 elfcore_write_lwpstatus (bfd *abfd, 9001 char *buf, 9002 int *bufsiz, 9003 long pid, 9004 int cursig, 9005 const void *gregs) 9006 { 9007 lwpstatus_t lwpstat; 9008 const char *note_name = "CORE"; 9009 9010 memset (&lwpstat, 0, sizeof (lwpstat)); 9011 lwpstat.pr_lwpid = pid >> 16; 9012 lwpstat.pr_cursig = cursig; 9013 #if defined (HAVE_LWPSTATUS_T_PR_REG) 9014 memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg)); 9015 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT) 9016 #if !defined(gregs) 9017 memcpy (lwpstat.pr_context.uc_mcontext.gregs, 9018 gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs)); 9019 #else 9020 memcpy (lwpstat.pr_context.uc_mcontext.__gregs, 9021 gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs)); 9022 #endif 9023 #endif 9024 return elfcore_write_note (abfd, buf, bufsiz, note_name, 9025 NT_LWPSTATUS, &lwpstat, sizeof (lwpstat)); 9026 } 9027 #endif /* HAVE_LWPSTATUS_T */ 9028 9029 #if defined (HAVE_PSTATUS_T) 9030 char * 9031 elfcore_write_pstatus (bfd *abfd, 9032 char *buf, 9033 int *bufsiz, 9034 long pid, 9035 int cursig ATTRIBUTE_UNUSED, 9036 const void *gregs ATTRIBUTE_UNUSED) 9037 { 9038 const char *note_name = "CORE"; 9039 #if defined (HAVE_PSTATUS32_T) 9040 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 9041 9042 if (bed->s->elfclass == ELFCLASS32) 9043 { 9044 pstatus32_t pstat; 9045 9046 memset (&pstat, 0, sizeof (pstat)); 9047 pstat.pr_pid = pid & 0xffff; 9048 buf = elfcore_write_note (abfd, buf, bufsiz, note_name, 9049 NT_PSTATUS, &pstat, sizeof (pstat)); 9050 return buf; 9051 } 9052 else 9053 #endif 9054 { 9055 pstatus_t pstat; 9056 9057 memset (&pstat, 0, sizeof (pstat)); 9058 pstat.pr_pid = pid & 0xffff; 9059 buf = elfcore_write_note (abfd, buf, bufsiz, note_name, 9060 NT_PSTATUS, &pstat, sizeof (pstat)); 9061 return buf; 9062 } 9063 } 9064 #endif /* HAVE_PSTATUS_T */ 9065 9066 char * 9067 elfcore_write_prfpreg (bfd *abfd, 9068 char *buf, 9069 int *bufsiz, 9070 const void *fpregs, 9071 int size) 9072 { 9073 const char *note_name = "CORE"; 9074 return elfcore_write_note (abfd, buf, bufsiz, 9075 note_name, NT_FPREGSET, fpregs, size); 9076 } 9077 9078 char * 9079 elfcore_write_prxfpreg (bfd *abfd, 9080 char *buf, 9081 int *bufsiz, 9082 const void *xfpregs, 9083 int size) 9084 { 9085 char *note_name = "LINUX"; 9086 return elfcore_write_note (abfd, buf, bufsiz, 9087 note_name, NT_PRXFPREG, xfpregs, size); 9088 } 9089 9090 char * 9091 elfcore_write_xstatereg (bfd *abfd, char *buf, int *bufsiz, 9092 const void *xfpregs, int size) 9093 { 9094 char *note_name = "LINUX"; 9095 return elfcore_write_note (abfd, buf, bufsiz, 9096 note_name, NT_X86_XSTATE, xfpregs, size); 9097 } 9098 9099 char * 9100 elfcore_write_ppc_vmx (bfd *abfd, 9101 char *buf, 9102 int *bufsiz, 9103 const void *ppc_vmx, 9104 int size) 9105 { 9106 char *note_name = "LINUX"; 9107 return elfcore_write_note (abfd, buf, bufsiz, 9108 note_name, NT_PPC_VMX, ppc_vmx, size); 9109 } 9110 9111 char * 9112 elfcore_write_ppc_vsx (bfd *abfd, 9113 char *buf, 9114 int *bufsiz, 9115 const void *ppc_vsx, 9116 int size) 9117 { 9118 char *note_name = "LINUX"; 9119 return elfcore_write_note (abfd, buf, bufsiz, 9120 note_name, NT_PPC_VSX, ppc_vsx, size); 9121 } 9122 9123 static char * 9124 elfcore_write_s390_high_gprs (bfd *abfd, 9125 char *buf, 9126 int *bufsiz, 9127 const void *s390_high_gprs, 9128 int size) 9129 { 9130 char *note_name = "LINUX"; 9131 return elfcore_write_note (abfd, buf, bufsiz, 9132 note_name, NT_S390_HIGH_GPRS, 9133 s390_high_gprs, size); 9134 } 9135 9136 char * 9137 elfcore_write_s390_timer (bfd *abfd, 9138 char *buf, 9139 int *bufsiz, 9140 const void *s390_timer, 9141 int size) 9142 { 9143 char *note_name = "LINUX"; 9144 return elfcore_write_note (abfd, buf, bufsiz, 9145 note_name, NT_S390_TIMER, s390_timer, size); 9146 } 9147 9148 char * 9149 elfcore_write_s390_todcmp (bfd *abfd, 9150 char *buf, 9151 int *bufsiz, 9152 const void *s390_todcmp, 9153 int size) 9154 { 9155 char *note_name = "LINUX"; 9156 return elfcore_write_note (abfd, buf, bufsiz, 9157 note_name, NT_S390_TODCMP, s390_todcmp, size); 9158 } 9159 9160 char * 9161 elfcore_write_s390_todpreg (bfd *abfd, 9162 char *buf, 9163 int *bufsiz, 9164 const void *s390_todpreg, 9165 int size) 9166 { 9167 char *note_name = "LINUX"; 9168 return elfcore_write_note (abfd, buf, bufsiz, 9169 note_name, NT_S390_TODPREG, s390_todpreg, size); 9170 } 9171 9172 char * 9173 elfcore_write_s390_ctrs (bfd *abfd, 9174 char *buf, 9175 int *bufsiz, 9176 const void *s390_ctrs, 9177 int size) 9178 { 9179 char *note_name = "LINUX"; 9180 return elfcore_write_note (abfd, buf, bufsiz, 9181 note_name, NT_S390_CTRS, s390_ctrs, size); 9182 } 9183 9184 char * 9185 elfcore_write_s390_prefix (bfd *abfd, 9186 char *buf, 9187 int *bufsiz, 9188 const void *s390_prefix, 9189 int size) 9190 { 9191 char *note_name = "LINUX"; 9192 return elfcore_write_note (abfd, buf, bufsiz, 9193 note_name, NT_S390_PREFIX, s390_prefix, size); 9194 } 9195 9196 char * 9197 elfcore_write_s390_last_break (bfd *abfd, 9198 char *buf, 9199 int *bufsiz, 9200 const void *s390_last_break, 9201 int size) 9202 { 9203 char *note_name = "LINUX"; 9204 return elfcore_write_note (abfd, buf, bufsiz, 9205 note_name, NT_S390_LAST_BREAK, 9206 s390_last_break, size); 9207 } 9208 9209 char * 9210 elfcore_write_s390_system_call (bfd *abfd, 9211 char *buf, 9212 int *bufsiz, 9213 const void *s390_system_call, 9214 int size) 9215 { 9216 char *note_name = "LINUX"; 9217 return elfcore_write_note (abfd, buf, bufsiz, 9218 note_name, NT_S390_SYSTEM_CALL, 9219 s390_system_call, size); 9220 } 9221 9222 char * 9223 elfcore_write_arm_vfp (bfd *abfd, 9224 char *buf, 9225 int *bufsiz, 9226 const void *arm_vfp, 9227 int size) 9228 { 9229 char *note_name = "LINUX"; 9230 return elfcore_write_note (abfd, buf, bufsiz, 9231 note_name, NT_ARM_VFP, arm_vfp, size); 9232 } 9233 9234 char * 9235 elfcore_write_register_note (bfd *abfd, 9236 char *buf, 9237 int *bufsiz, 9238 const char *section, 9239 const void *data, 9240 int size) 9241 { 9242 if (strcmp (section, ".reg2") == 0) 9243 return elfcore_write_prfpreg (abfd, buf, bufsiz, data, size); 9244 if (strcmp (section, ".reg-xfp") == 0) 9245 return elfcore_write_prxfpreg (abfd, buf, bufsiz, data, size); 9246 if (strcmp (section, ".reg-xstate") == 0) 9247 return elfcore_write_xstatereg (abfd, buf, bufsiz, data, size); 9248 if (strcmp (section, ".reg-ppc-vmx") == 0) 9249 return elfcore_write_ppc_vmx (abfd, buf, bufsiz, data, size); 9250 if (strcmp (section, ".reg-ppc-vsx") == 0) 9251 return elfcore_write_ppc_vsx (abfd, buf, bufsiz, data, size); 9252 if (strcmp (section, ".reg-s390-high-gprs") == 0) 9253 return elfcore_write_s390_high_gprs (abfd, buf, bufsiz, data, size); 9254 if (strcmp (section, ".reg-s390-timer") == 0) 9255 return elfcore_write_s390_timer (abfd, buf, bufsiz, data, size); 9256 if (strcmp (section, ".reg-s390-todcmp") == 0) 9257 return elfcore_write_s390_todcmp (abfd, buf, bufsiz, data, size); 9258 if (strcmp (section, ".reg-s390-todpreg") == 0) 9259 return elfcore_write_s390_todpreg (abfd, buf, bufsiz, data, size); 9260 if (strcmp (section, ".reg-s390-ctrs") == 0) 9261 return elfcore_write_s390_ctrs (abfd, buf, bufsiz, data, size); 9262 if (strcmp (section, ".reg-s390-prefix") == 0) 9263 return elfcore_write_s390_prefix (abfd, buf, bufsiz, data, size); 9264 if (strcmp (section, ".reg-s390-last-break") == 0) 9265 return elfcore_write_s390_last_break (abfd, buf, bufsiz, data, size); 9266 if (strcmp (section, ".reg-s390-system-call") == 0) 9267 return elfcore_write_s390_system_call (abfd, buf, bufsiz, data, size); 9268 if (strcmp (section, ".reg-arm-vfp") == 0) 9269 return elfcore_write_arm_vfp (abfd, buf, bufsiz, data, size); 9270 return NULL; 9271 } 9272 9273 static bfd_boolean 9274 elf_parse_notes (bfd *abfd, char *buf, size_t size, file_ptr offset) 9275 { 9276 char *p; 9277 9278 p = buf; 9279 while (p < buf + size) 9280 { 9281 /* FIXME: bad alignment assumption. */ 9282 Elf_External_Note *xnp = (Elf_External_Note *) p; 9283 Elf_Internal_Note in; 9284 9285 if (offsetof (Elf_External_Note, name) > buf - p + size) 9286 return FALSE; 9287 9288 in.type = H_GET_32 (abfd, xnp->type); 9289 9290 in.namesz = H_GET_32 (abfd, xnp->namesz); 9291 in.namedata = xnp->name; 9292 if (in.namesz > buf - in.namedata + size) 9293 return FALSE; 9294 9295 in.descsz = H_GET_32 (abfd, xnp->descsz); 9296 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4); 9297 in.descpos = offset + (in.descdata - buf); 9298 if (in.descsz != 0 9299 && (in.descdata >= buf + size 9300 || in.descsz > buf - in.descdata + size)) 9301 return FALSE; 9302 9303 switch (bfd_get_format (abfd)) 9304 { 9305 default: 9306 return TRUE; 9307 9308 case bfd_core: 9309 if (CONST_STRNEQ (in.namedata, "NetBSD-CORE")) 9310 { 9311 if (! elfcore_grok_netbsd_note (abfd, &in)) 9312 return FALSE; 9313 } 9314 else if (CONST_STRNEQ (in.namedata, "OpenBSD")) 9315 { 9316 if (! elfcore_grok_openbsd_note (abfd, &in)) 9317 return FALSE; 9318 } 9319 else if (CONST_STRNEQ (in.namedata, "QNX")) 9320 { 9321 if (! elfcore_grok_nto_note (abfd, &in)) 9322 return FALSE; 9323 } 9324 else if (CONST_STRNEQ (in.namedata, "SPU/")) 9325 { 9326 if (! elfcore_grok_spu_note (abfd, &in)) 9327 return FALSE; 9328 } 9329 else 9330 { 9331 if (! elfcore_grok_note (abfd, &in)) 9332 return FALSE; 9333 } 9334 break; 9335 9336 case bfd_object: 9337 if (in.namesz == sizeof "GNU" && strcmp (in.namedata, "GNU") == 0) 9338 { 9339 if (! elfobj_grok_gnu_note (abfd, &in)) 9340 return FALSE; 9341 } 9342 else if (in.namesz == sizeof "stapsdt" 9343 && strcmp (in.namedata, "stapsdt") == 0) 9344 { 9345 if (! elfobj_grok_stapsdt_note (abfd, &in)) 9346 return FALSE; 9347 } 9348 break; 9349 } 9350 9351 p = in.descdata + BFD_ALIGN (in.descsz, 4); 9352 } 9353 9354 return TRUE; 9355 } 9356 9357 static bfd_boolean 9358 elf_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size) 9359 { 9360 char *buf; 9361 9362 if (size <= 0) 9363 return TRUE; 9364 9365 if (bfd_seek (abfd, offset, SEEK_SET) != 0) 9366 return FALSE; 9367 9368 buf = (char *) bfd_malloc (size); 9369 if (buf == NULL) 9370 return FALSE; 9371 9372 if (bfd_bread (buf, size, abfd) != size 9373 || !elf_parse_notes (abfd, buf, size, offset)) 9374 { 9375 free (buf); 9376 return FALSE; 9377 } 9378 9379 free (buf); 9380 return TRUE; 9381 } 9382 9383 /* Providing external access to the ELF program header table. */ 9384 9385 /* Return an upper bound on the number of bytes required to store a 9386 copy of ABFD's program header table entries. Return -1 if an error 9387 occurs; bfd_get_error will return an appropriate code. */ 9388 9389 long 9390 bfd_get_elf_phdr_upper_bound (bfd *abfd) 9391 { 9392 if (abfd->xvec->flavour != bfd_target_elf_flavour) 9393 { 9394 bfd_set_error (bfd_error_wrong_format); 9395 return -1; 9396 } 9397 9398 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr); 9399 } 9400 9401 /* Copy ABFD's program header table entries to *PHDRS. The entries 9402 will be stored as an array of Elf_Internal_Phdr structures, as 9403 defined in include/elf/internal.h. To find out how large the 9404 buffer needs to be, call bfd_get_elf_phdr_upper_bound. 9405 9406 Return the number of program header table entries read, or -1 if an 9407 error occurs; bfd_get_error will return an appropriate code. */ 9408 9409 int 9410 bfd_get_elf_phdrs (bfd *abfd, void *phdrs) 9411 { 9412 int num_phdrs; 9413 9414 if (abfd->xvec->flavour != bfd_target_elf_flavour) 9415 { 9416 bfd_set_error (bfd_error_wrong_format); 9417 return -1; 9418 } 9419 9420 num_phdrs = elf_elfheader (abfd)->e_phnum; 9421 memcpy (phdrs, elf_tdata (abfd)->phdr, 9422 num_phdrs * sizeof (Elf_Internal_Phdr)); 9423 9424 return num_phdrs; 9425 } 9426 9427 enum elf_reloc_type_class 9428 _bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED) 9429 { 9430 return reloc_class_normal; 9431 } 9432 9433 /* For RELA architectures, return the relocation value for a 9434 relocation against a local symbol. */ 9435 9436 bfd_vma 9437 _bfd_elf_rela_local_sym (bfd *abfd, 9438 Elf_Internal_Sym *sym, 9439 asection **psec, 9440 Elf_Internal_Rela *rel) 9441 { 9442 asection *sec = *psec; 9443 bfd_vma relocation; 9444 9445 relocation = (sec->output_section->vma 9446 + sec->output_offset 9447 + sym->st_value); 9448 if ((sec->flags & SEC_MERGE) 9449 && ELF_ST_TYPE (sym->st_info) == STT_SECTION 9450 && sec->sec_info_type == ELF_INFO_TYPE_MERGE) 9451 { 9452 rel->r_addend = 9453 _bfd_merged_section_offset (abfd, psec, 9454 elf_section_data (sec)->sec_info, 9455 sym->st_value + rel->r_addend); 9456 if (sec != *psec) 9457 { 9458 /* If we have changed the section, and our original section is 9459 marked with SEC_EXCLUDE, it means that the original 9460 SEC_MERGE section has been completely subsumed in some 9461 other SEC_MERGE section. In this case, we need to leave 9462 some info around for --emit-relocs. */ 9463 if ((sec->flags & SEC_EXCLUDE) != 0) 9464 sec->kept_section = *psec; 9465 sec = *psec; 9466 } 9467 rel->r_addend -= relocation; 9468 rel->r_addend += sec->output_section->vma + sec->output_offset; 9469 } 9470 return relocation; 9471 } 9472 9473 bfd_vma 9474 _bfd_elf_rel_local_sym (bfd *abfd, 9475 Elf_Internal_Sym *sym, 9476 asection **psec, 9477 bfd_vma addend) 9478 { 9479 asection *sec = *psec; 9480 9481 if (sec->sec_info_type != ELF_INFO_TYPE_MERGE) 9482 return sym->st_value + addend; 9483 9484 return _bfd_merged_section_offset (abfd, psec, 9485 elf_section_data (sec)->sec_info, 9486 sym->st_value + addend); 9487 } 9488 9489 bfd_vma 9490 _bfd_elf_section_offset (bfd *abfd, 9491 struct bfd_link_info *info, 9492 asection *sec, 9493 bfd_vma offset) 9494 { 9495 switch (sec->sec_info_type) 9496 { 9497 case ELF_INFO_TYPE_STABS: 9498 return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info, 9499 offset); 9500 case ELF_INFO_TYPE_EH_FRAME: 9501 return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset); 9502 default: 9503 if ((sec->flags & SEC_ELF_REVERSE_COPY) != 0) 9504 { 9505 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 9506 bfd_size_type address_size = bed->s->arch_size / 8; 9507 offset = sec->size - offset - address_size; 9508 } 9509 return offset; 9510 } 9511 } 9512 9513 /* Create a new BFD as if by bfd_openr. Rather than opening a file, 9514 reconstruct an ELF file by reading the segments out of remote memory 9515 based on the ELF file header at EHDR_VMA and the ELF program headers it 9516 points to. If not null, *LOADBASEP is filled in with the difference 9517 between the VMAs from which the segments were read, and the VMAs the 9518 file headers (and hence BFD's idea of each section's VMA) put them at. 9519 9520 The function TARGET_READ_MEMORY is called to copy LEN bytes from the 9521 remote memory at target address VMA into the local buffer at MYADDR; it 9522 should return zero on success or an `errno' code on failure. TEMPL must 9523 be a BFD for an ELF target with the word size and byte order found in 9524 the remote memory. */ 9525 9526 bfd * 9527 bfd_elf_bfd_from_remote_memory 9528 (bfd *templ, 9529 bfd_vma ehdr_vma, 9530 bfd_vma *loadbasep, 9531 int (*target_read_memory) (bfd_vma, bfd_byte *, int)) 9532 { 9533 return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory) 9534 (templ, ehdr_vma, loadbasep, target_read_memory); 9535 } 9536 9537 long 9538 _bfd_elf_get_synthetic_symtab (bfd *abfd, 9539 long symcount ATTRIBUTE_UNUSED, 9540 asymbol **syms ATTRIBUTE_UNUSED, 9541 long dynsymcount, 9542 asymbol **dynsyms, 9543 asymbol **ret) 9544 { 9545 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 9546 asection *relplt; 9547 asymbol *s; 9548 const char *relplt_name; 9549 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean); 9550 arelent *p; 9551 long count, i, n; 9552 size_t size; 9553 Elf_Internal_Shdr *hdr; 9554 char *names; 9555 asection *plt; 9556 9557 *ret = NULL; 9558 9559 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0) 9560 return 0; 9561 9562 if (dynsymcount <= 0) 9563 return 0; 9564 9565 if (!bed->plt_sym_val) 9566 return 0; 9567 9568 relplt_name = bed->relplt_name; 9569 if (relplt_name == NULL) 9570 relplt_name = bed->rela_plts_and_copies_p ? ".rela.plt" : ".rel.plt"; 9571 relplt = bfd_get_section_by_name (abfd, relplt_name); 9572 if (relplt == NULL) 9573 return 0; 9574 9575 hdr = &elf_section_data (relplt)->this_hdr; 9576 if (hdr->sh_link != elf_dynsymtab (abfd) 9577 || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA)) 9578 return 0; 9579 9580 plt = bfd_get_section_by_name (abfd, ".plt"); 9581 if (plt == NULL) 9582 return 0; 9583 9584 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table; 9585 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE)) 9586 return -1; 9587 9588 count = relplt->size / hdr->sh_entsize; 9589 size = count * sizeof (asymbol); 9590 p = relplt->relocation; 9591 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel) 9592 { 9593 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt"); 9594 if (p->addend != 0) 9595 { 9596 #ifdef BFD64 9597 size += sizeof ("+0x") - 1 + 8 + 8 * (bed->s->elfclass == ELFCLASS64); 9598 #else 9599 size += sizeof ("+0x") - 1 + 8; 9600 #endif 9601 } 9602 } 9603 9604 s = *ret = (asymbol *) bfd_malloc (size); 9605 if (s == NULL) 9606 return -1; 9607 9608 names = (char *) (s + count); 9609 p = relplt->relocation; 9610 n = 0; 9611 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel) 9612 { 9613 size_t len; 9614 bfd_vma addr; 9615 9616 addr = bed->plt_sym_val (i, plt, p); 9617 if (addr == (bfd_vma) -1) 9618 continue; 9619 9620 *s = **p->sym_ptr_ptr; 9621 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since 9622 we are defining a symbol, ensure one of them is set. */ 9623 if ((s->flags & BSF_LOCAL) == 0) 9624 s->flags |= BSF_GLOBAL; 9625 s->flags |= BSF_SYNTHETIC; 9626 s->section = plt; 9627 s->value = addr - plt->vma; 9628 s->name = names; 9629 s->udata.p = NULL; 9630 len = strlen ((*p->sym_ptr_ptr)->name); 9631 memcpy (names, (*p->sym_ptr_ptr)->name, len); 9632 names += len; 9633 if (p->addend != 0) 9634 { 9635 char buf[30], *a; 9636 9637 memcpy (names, "+0x", sizeof ("+0x") - 1); 9638 names += sizeof ("+0x") - 1; 9639 bfd_sprintf_vma (abfd, buf, p->addend); 9640 for (a = buf; *a == '0'; ++a) 9641 ; 9642 len = strlen (a); 9643 memcpy (names, a, len); 9644 names += len; 9645 } 9646 memcpy (names, "@plt", sizeof ("@plt")); 9647 names += sizeof ("@plt"); 9648 ++s, ++n; 9649 } 9650 9651 return n; 9652 } 9653 9654 /* It is only used by x86-64 so far. */ 9655 asection _bfd_elf_large_com_section 9656 = BFD_FAKE_SECTION (_bfd_elf_large_com_section, 9657 SEC_IS_COMMON, NULL, "LARGE_COMMON", 0); 9658 9659 void 9660 _bfd_elf_set_osabi (bfd * abfd, 9661 struct bfd_link_info * link_info ATTRIBUTE_UNUSED) 9662 { 9663 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */ 9664 9665 i_ehdrp = elf_elfheader (abfd); 9666 9667 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi; 9668 9669 /* To make things simpler for the loader on Linux systems we set the 9670 osabi field to ELFOSABI_GNU if the binary contains symbols of 9671 the STT_GNU_IFUNC type or STB_GNU_UNIQUE binding. */ 9672 if (i_ehdrp->e_ident[EI_OSABI] == ELFOSABI_NONE 9673 && elf_tdata (abfd)->has_gnu_symbols) 9674 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_GNU; 9675 } 9676 9677 9678 /* Return TRUE for ELF symbol types that represent functions. 9679 This is the default version of this function, which is sufficient for 9680 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */ 9681 9682 bfd_boolean 9683 _bfd_elf_is_function_type (unsigned int type) 9684 { 9685 return (type == STT_FUNC 9686 || type == STT_GNU_IFUNC); 9687 } 9688