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 *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. */ 2310 if ((!sec->flags && abfd->direction != read_direction) 2311 || (sec->flags & SEC_LINKER_CREATED) != 0) 2312 { 2313 ssect = (*bed->get_sec_type_attr) (abfd, sec); 2314 if (ssect != NULL) 2315 { 2316 elf_section_type (sec) = ssect->type; 2317 elf_section_flags (sec) = ssect->attr; 2318 } 2319 } 2320 2321 return _bfd_generic_new_section_hook (abfd, sec); 2322 } 2323 2324 /* Create a new bfd section from an ELF program header. 2325 2326 Since program segments have no names, we generate a synthetic name 2327 of the form segment<NUM>, where NUM is generally the index in the 2328 program header table. For segments that are split (see below) we 2329 generate the names segment<NUM>a and segment<NUM>b. 2330 2331 Note that some program segments may have a file size that is different than 2332 (less than) the memory size. All this means is that at execution the 2333 system must allocate the amount of memory specified by the memory size, 2334 but only initialize it with the first "file size" bytes read from the 2335 file. This would occur for example, with program segments consisting 2336 of combined data+bss. 2337 2338 To handle the above situation, this routine generates TWO bfd sections 2339 for the single program segment. The first has the length specified by 2340 the file size of the segment, and the second has the length specified 2341 by the difference between the two sizes. In effect, the segment is split 2342 into its initialized and uninitialized parts. 2343 2344 */ 2345 2346 bfd_boolean 2347 _bfd_elf_make_section_from_phdr (bfd *abfd, 2348 Elf_Internal_Phdr *hdr, 2349 int hdr_index, 2350 const char *type_name) 2351 { 2352 asection *newsect; 2353 char *name; 2354 char namebuf[64]; 2355 size_t len; 2356 int split; 2357 2358 split = ((hdr->p_memsz > 0) 2359 && (hdr->p_filesz > 0) 2360 && (hdr->p_memsz > hdr->p_filesz)); 2361 2362 if (hdr->p_filesz > 0) 2363 { 2364 sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "a" : ""); 2365 len = strlen (namebuf) + 1; 2366 name = (char *) bfd_alloc (abfd, len); 2367 if (!name) 2368 return FALSE; 2369 memcpy (name, namebuf, len); 2370 newsect = bfd_make_section (abfd, name); 2371 if (newsect == NULL) 2372 return FALSE; 2373 newsect->vma = hdr->p_vaddr; 2374 newsect->lma = hdr->p_paddr; 2375 newsect->size = hdr->p_filesz; 2376 newsect->filepos = hdr->p_offset; 2377 newsect->flags |= SEC_HAS_CONTENTS; 2378 newsect->alignment_power = bfd_log2 (hdr->p_align); 2379 if (hdr->p_type == PT_LOAD) 2380 { 2381 newsect->flags |= SEC_ALLOC; 2382 newsect->flags |= SEC_LOAD; 2383 if (hdr->p_flags & PF_X) 2384 { 2385 /* FIXME: all we known is that it has execute PERMISSION, 2386 may be data. */ 2387 newsect->flags |= SEC_CODE; 2388 } 2389 } 2390 if (!(hdr->p_flags & PF_W)) 2391 { 2392 newsect->flags |= SEC_READONLY; 2393 } 2394 } 2395 2396 if (hdr->p_memsz > hdr->p_filesz) 2397 { 2398 bfd_vma align; 2399 2400 sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "b" : ""); 2401 len = strlen (namebuf) + 1; 2402 name = (char *) bfd_alloc (abfd, len); 2403 if (!name) 2404 return FALSE; 2405 memcpy (name, namebuf, len); 2406 newsect = bfd_make_section (abfd, name); 2407 if (newsect == NULL) 2408 return FALSE; 2409 newsect->vma = hdr->p_vaddr + hdr->p_filesz; 2410 newsect->lma = hdr->p_paddr + hdr->p_filesz; 2411 newsect->size = hdr->p_memsz - hdr->p_filesz; 2412 newsect->filepos = hdr->p_offset + hdr->p_filesz; 2413 align = newsect->vma & -newsect->vma; 2414 if (align == 0 || align > hdr->p_align) 2415 align = hdr->p_align; 2416 newsect->alignment_power = bfd_log2 (align); 2417 if (hdr->p_type == PT_LOAD) 2418 { 2419 /* Hack for gdb. Segments that have not been modified do 2420 not have their contents written to a core file, on the 2421 assumption that a debugger can find the contents in the 2422 executable. We flag this case by setting the fake 2423 section size to zero. Note that "real" bss sections will 2424 always have their contents dumped to the core file. */ 2425 if (bfd_get_format (abfd) == bfd_core) 2426 newsect->size = 0; 2427 newsect->flags |= SEC_ALLOC; 2428 if (hdr->p_flags & PF_X) 2429 newsect->flags |= SEC_CODE; 2430 } 2431 if (!(hdr->p_flags & PF_W)) 2432 newsect->flags |= SEC_READONLY; 2433 } 2434 2435 return TRUE; 2436 } 2437 2438 bfd_boolean 2439 bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int hdr_index) 2440 { 2441 const struct elf_backend_data *bed; 2442 2443 switch (hdr->p_type) 2444 { 2445 case PT_NULL: 2446 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "null"); 2447 2448 case PT_LOAD: 2449 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "load"); 2450 2451 case PT_DYNAMIC: 2452 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "dynamic"); 2453 2454 case PT_INTERP: 2455 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "interp"); 2456 2457 case PT_NOTE: 2458 if (! _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "note")) 2459 return FALSE; 2460 if (! elf_read_notes (abfd, hdr->p_offset, hdr->p_filesz)) 2461 return FALSE; 2462 return TRUE; 2463 2464 case PT_SHLIB: 2465 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "shlib"); 2466 2467 case PT_PHDR: 2468 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "phdr"); 2469 2470 case PT_GNU_EH_FRAME: 2471 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, 2472 "eh_frame_hdr"); 2473 2474 case PT_GNU_STACK: 2475 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "stack"); 2476 2477 case PT_GNU_RELRO: 2478 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "relro"); 2479 2480 default: 2481 /* Check for any processor-specific program segment types. */ 2482 bed = get_elf_backend_data (abfd); 2483 return bed->elf_backend_section_from_phdr (abfd, hdr, hdr_index, "proc"); 2484 } 2485 } 2486 2487 /* Return the REL_HDR for SEC, assuming there is only a single one, either 2488 REL or RELA. */ 2489 2490 Elf_Internal_Shdr * 2491 _bfd_elf_single_rel_hdr (asection *sec) 2492 { 2493 if (elf_section_data (sec)->rel.hdr) 2494 { 2495 BFD_ASSERT (elf_section_data (sec)->rela.hdr == NULL); 2496 return elf_section_data (sec)->rel.hdr; 2497 } 2498 else 2499 return elf_section_data (sec)->rela.hdr; 2500 } 2501 2502 /* Allocate and initialize a section-header for a new reloc section, 2503 containing relocations against ASECT. It is stored in RELDATA. If 2504 USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL 2505 relocations. */ 2506 2507 bfd_boolean 2508 _bfd_elf_init_reloc_shdr (bfd *abfd, 2509 struct bfd_elf_section_reloc_data *reldata, 2510 asection *asect, 2511 bfd_boolean use_rela_p) 2512 { 2513 Elf_Internal_Shdr *rel_hdr; 2514 char *name; 2515 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 2516 bfd_size_type amt; 2517 2518 amt = sizeof (Elf_Internal_Shdr); 2519 BFD_ASSERT (reldata->hdr == NULL); 2520 rel_hdr = bfd_zalloc (abfd, amt); 2521 reldata->hdr = rel_hdr; 2522 2523 amt = sizeof ".rela" + strlen (asect->name); 2524 name = (char *) bfd_alloc (abfd, amt); 2525 if (name == NULL) 2526 return FALSE; 2527 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name); 2528 rel_hdr->sh_name = 2529 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name, 2530 FALSE); 2531 if (rel_hdr->sh_name == (unsigned int) -1) 2532 return FALSE; 2533 rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL; 2534 rel_hdr->sh_entsize = (use_rela_p 2535 ? bed->s->sizeof_rela 2536 : bed->s->sizeof_rel); 2537 rel_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align; 2538 rel_hdr->sh_flags = 0; 2539 rel_hdr->sh_addr = 0; 2540 rel_hdr->sh_size = 0; 2541 rel_hdr->sh_offset = 0; 2542 2543 return TRUE; 2544 } 2545 2546 /* Return the default section type based on the passed in section flags. */ 2547 2548 int 2549 bfd_elf_get_default_section_type (flagword flags) 2550 { 2551 if ((flags & SEC_ALLOC) != 0 2552 && (flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0) 2553 return SHT_NOBITS; 2554 return SHT_PROGBITS; 2555 } 2556 2557 struct fake_section_arg 2558 { 2559 struct bfd_link_info *link_info; 2560 bfd_boolean failed; 2561 }; 2562 2563 /* Set up an ELF internal section header for a section. */ 2564 2565 static void 2566 elf_fake_sections (bfd *abfd, asection *asect, void *fsarg) 2567 { 2568 struct fake_section_arg *arg = (struct fake_section_arg *)fsarg; 2569 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 2570 struct bfd_elf_section_data *esd = elf_section_data (asect); 2571 Elf_Internal_Shdr *this_hdr; 2572 unsigned int sh_type; 2573 2574 if (arg->failed) 2575 { 2576 /* We already failed; just get out of the bfd_map_over_sections 2577 loop. */ 2578 return; 2579 } 2580 2581 this_hdr = &esd->this_hdr; 2582 2583 this_hdr->sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), 2584 asect->name, FALSE); 2585 if (this_hdr->sh_name == (unsigned int) -1) 2586 { 2587 arg->failed = TRUE; 2588 return; 2589 } 2590 2591 /* Don't clear sh_flags. Assembler may set additional bits. */ 2592 2593 if ((asect->flags & SEC_ALLOC) != 0 2594 || asect->user_set_vma) 2595 this_hdr->sh_addr = asect->vma; 2596 else 2597 this_hdr->sh_addr = 0; 2598 2599 this_hdr->sh_offset = 0; 2600 this_hdr->sh_size = asect->size; 2601 this_hdr->sh_link = 0; 2602 this_hdr->sh_addralign = (bfd_vma) 1 << asect->alignment_power; 2603 /* The sh_entsize and sh_info fields may have been set already by 2604 copy_private_section_data. */ 2605 2606 this_hdr->bfd_section = asect; 2607 this_hdr->contents = NULL; 2608 2609 /* If the section type is unspecified, we set it based on 2610 asect->flags. */ 2611 if ((asect->flags & SEC_GROUP) != 0) 2612 sh_type = SHT_GROUP; 2613 else 2614 sh_type = bfd_elf_get_default_section_type (asect->flags); 2615 2616 if (this_hdr->sh_type == SHT_NULL) 2617 this_hdr->sh_type = sh_type; 2618 else if (this_hdr->sh_type == SHT_NOBITS 2619 && sh_type == SHT_PROGBITS 2620 && (asect->flags & SEC_ALLOC) != 0) 2621 { 2622 /* Warn if we are changing a NOBITS section to PROGBITS, but 2623 allow the link to proceed. This can happen when users link 2624 non-bss input sections to bss output sections, or emit data 2625 to a bss output section via a linker script. */ 2626 (*_bfd_error_handler) 2627 (_("warning: section `%A' type changed to PROGBITS"), asect); 2628 this_hdr->sh_type = sh_type; 2629 } 2630 2631 switch (this_hdr->sh_type) 2632 { 2633 default: 2634 break; 2635 2636 case SHT_STRTAB: 2637 case SHT_INIT_ARRAY: 2638 case SHT_FINI_ARRAY: 2639 case SHT_PREINIT_ARRAY: 2640 case SHT_NOTE: 2641 case SHT_NOBITS: 2642 case SHT_PROGBITS: 2643 break; 2644 2645 case SHT_HASH: 2646 this_hdr->sh_entsize = bed->s->sizeof_hash_entry; 2647 break; 2648 2649 case SHT_DYNSYM: 2650 this_hdr->sh_entsize = bed->s->sizeof_sym; 2651 break; 2652 2653 case SHT_DYNAMIC: 2654 this_hdr->sh_entsize = bed->s->sizeof_dyn; 2655 break; 2656 2657 case SHT_RELA: 2658 if (get_elf_backend_data (abfd)->may_use_rela_p) 2659 this_hdr->sh_entsize = bed->s->sizeof_rela; 2660 break; 2661 2662 case SHT_REL: 2663 if (get_elf_backend_data (abfd)->may_use_rel_p) 2664 this_hdr->sh_entsize = bed->s->sizeof_rel; 2665 break; 2666 2667 case SHT_GNU_versym: 2668 this_hdr->sh_entsize = sizeof (Elf_External_Versym); 2669 break; 2670 2671 case SHT_GNU_verdef: 2672 this_hdr->sh_entsize = 0; 2673 /* objcopy or strip will copy over sh_info, but may not set 2674 cverdefs. The linker will set cverdefs, but sh_info will be 2675 zero. */ 2676 if (this_hdr->sh_info == 0) 2677 this_hdr->sh_info = elf_tdata (abfd)->cverdefs; 2678 else 2679 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0 2680 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs); 2681 break; 2682 2683 case SHT_GNU_verneed: 2684 this_hdr->sh_entsize = 0; 2685 /* objcopy or strip will copy over sh_info, but may not set 2686 cverrefs. The linker will set cverrefs, but sh_info will be 2687 zero. */ 2688 if (this_hdr->sh_info == 0) 2689 this_hdr->sh_info = elf_tdata (abfd)->cverrefs; 2690 else 2691 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0 2692 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs); 2693 break; 2694 2695 case SHT_GROUP: 2696 this_hdr->sh_entsize = GRP_ENTRY_SIZE; 2697 break; 2698 2699 case SHT_GNU_HASH: 2700 this_hdr->sh_entsize = bed->s->arch_size == 64 ? 0 : 4; 2701 break; 2702 } 2703 2704 if ((asect->flags & SEC_ALLOC) != 0) 2705 this_hdr->sh_flags |= SHF_ALLOC; 2706 if ((asect->flags & SEC_READONLY) == 0) 2707 this_hdr->sh_flags |= SHF_WRITE; 2708 if ((asect->flags & SEC_CODE) != 0) 2709 this_hdr->sh_flags |= SHF_EXECINSTR; 2710 if ((asect->flags & SEC_MERGE) != 0) 2711 { 2712 this_hdr->sh_flags |= SHF_MERGE; 2713 this_hdr->sh_entsize = asect->entsize; 2714 if ((asect->flags & SEC_STRINGS) != 0) 2715 this_hdr->sh_flags |= SHF_STRINGS; 2716 } 2717 if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL) 2718 this_hdr->sh_flags |= SHF_GROUP; 2719 if ((asect->flags & SEC_THREAD_LOCAL) != 0) 2720 { 2721 this_hdr->sh_flags |= SHF_TLS; 2722 if (asect->size == 0 2723 && (asect->flags & SEC_HAS_CONTENTS) == 0) 2724 { 2725 struct bfd_link_order *o = asect->map_tail.link_order; 2726 2727 this_hdr->sh_size = 0; 2728 if (o != NULL) 2729 { 2730 this_hdr->sh_size = o->offset + o->size; 2731 if (this_hdr->sh_size != 0) 2732 this_hdr->sh_type = SHT_NOBITS; 2733 } 2734 } 2735 } 2736 if ((asect->flags & (SEC_GROUP | SEC_EXCLUDE)) == SEC_EXCLUDE) 2737 this_hdr->sh_flags |= SHF_EXCLUDE; 2738 2739 /* If the section has relocs, set up a section header for the 2740 SHT_REL[A] section. If two relocation sections are required for 2741 this section, it is up to the processor-specific back-end to 2742 create the other. */ 2743 if ((asect->flags & SEC_RELOC) != 0) 2744 { 2745 /* When doing a relocatable link, create both REL and RELA sections if 2746 needed. */ 2747 if (arg->link_info 2748 /* Do the normal setup if we wouldn't create any sections here. */ 2749 && esd->rel.count + esd->rela.count > 0 2750 && (arg->link_info->relocatable || arg->link_info->emitrelocations)) 2751 { 2752 if (esd->rel.count && esd->rel.hdr == NULL 2753 && !_bfd_elf_init_reloc_shdr (abfd, &esd->rel, asect, FALSE)) 2754 { 2755 arg->failed = TRUE; 2756 return; 2757 } 2758 if (esd->rela.count && esd->rela.hdr == NULL 2759 && !_bfd_elf_init_reloc_shdr (abfd, &esd->rela, asect, TRUE)) 2760 { 2761 arg->failed = TRUE; 2762 return; 2763 } 2764 } 2765 else if (!_bfd_elf_init_reloc_shdr (abfd, 2766 (asect->use_rela_p 2767 ? &esd->rela : &esd->rel), 2768 asect, 2769 asect->use_rela_p)) 2770 arg->failed = TRUE; 2771 } 2772 2773 /* Check for processor-specific section types. */ 2774 sh_type = this_hdr->sh_type; 2775 if (bed->elf_backend_fake_sections 2776 && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect)) 2777 arg->failed = TRUE; 2778 2779 if (sh_type == SHT_NOBITS && asect->size != 0) 2780 { 2781 /* Don't change the header type from NOBITS if we are being 2782 called for objcopy --only-keep-debug. */ 2783 this_hdr->sh_type = sh_type; 2784 } 2785 } 2786 2787 /* Fill in the contents of a SHT_GROUP section. Called from 2788 _bfd_elf_compute_section_file_positions for gas, objcopy, and 2789 when ELF targets use the generic linker, ld. Called for ld -r 2790 from bfd_elf_final_link. */ 2791 2792 void 2793 bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg) 2794 { 2795 bfd_boolean *failedptr = (bfd_boolean *) failedptrarg; 2796 asection *elt, *first; 2797 unsigned char *loc; 2798 bfd_boolean gas; 2799 2800 /* Ignore linker created group section. See elfNN_ia64_object_p in 2801 elfxx-ia64.c. */ 2802 if (((sec->flags & (SEC_GROUP | SEC_LINKER_CREATED)) != SEC_GROUP) 2803 || *failedptr) 2804 return; 2805 2806 if (elf_section_data (sec)->this_hdr.sh_info == 0) 2807 { 2808 unsigned long symindx = 0; 2809 2810 /* elf_group_id will have been set up by objcopy and the 2811 generic linker. */ 2812 if (elf_group_id (sec) != NULL) 2813 symindx = elf_group_id (sec)->udata.i; 2814 2815 if (symindx == 0) 2816 { 2817 /* If called from the assembler, swap_out_syms will have set up 2818 elf_section_syms. */ 2819 BFD_ASSERT (elf_section_syms (abfd) != NULL); 2820 symindx = elf_section_syms (abfd)[sec->index]->udata.i; 2821 } 2822 elf_section_data (sec)->this_hdr.sh_info = symindx; 2823 } 2824 else if (elf_section_data (sec)->this_hdr.sh_info == (unsigned int) -2) 2825 { 2826 /* The ELF backend linker sets sh_info to -2 when the group 2827 signature symbol is global, and thus the index can't be 2828 set until all local symbols are output. */ 2829 asection *igroup = elf_sec_group (elf_next_in_group (sec)); 2830 struct bfd_elf_section_data *sec_data = elf_section_data (igroup); 2831 unsigned long symndx = sec_data->this_hdr.sh_info; 2832 unsigned long extsymoff = 0; 2833 struct elf_link_hash_entry *h; 2834 2835 if (!elf_bad_symtab (igroup->owner)) 2836 { 2837 Elf_Internal_Shdr *symtab_hdr; 2838 2839 symtab_hdr = &elf_tdata (igroup->owner)->symtab_hdr; 2840 extsymoff = symtab_hdr->sh_info; 2841 } 2842 h = elf_sym_hashes (igroup->owner)[symndx - extsymoff]; 2843 while (h->root.type == bfd_link_hash_indirect 2844 || h->root.type == bfd_link_hash_warning) 2845 h = (struct elf_link_hash_entry *) h->root.u.i.link; 2846 2847 elf_section_data (sec)->this_hdr.sh_info = h->indx; 2848 } 2849 2850 /* The contents won't be allocated for "ld -r" or objcopy. */ 2851 gas = TRUE; 2852 if (sec->contents == NULL) 2853 { 2854 gas = FALSE; 2855 sec->contents = (unsigned char *) bfd_alloc (abfd, sec->size); 2856 2857 /* Arrange for the section to be written out. */ 2858 elf_section_data (sec)->this_hdr.contents = sec->contents; 2859 if (sec->contents == NULL) 2860 { 2861 *failedptr = TRUE; 2862 return; 2863 } 2864 } 2865 2866 loc = sec->contents + sec->size; 2867 2868 /* Get the pointer to the first section in the group that gas 2869 squirreled away here. objcopy arranges for this to be set to the 2870 start of the input section group. */ 2871 first = elt = elf_next_in_group (sec); 2872 2873 /* First element is a flag word. Rest of section is elf section 2874 indices for all the sections of the group. Write them backwards 2875 just to keep the group in the same order as given in .section 2876 directives, not that it matters. */ 2877 while (elt != NULL) 2878 { 2879 asection *s; 2880 2881 s = elt; 2882 if (!gas) 2883 s = s->output_section; 2884 if (s != NULL 2885 && !bfd_is_abs_section (s)) 2886 { 2887 unsigned int idx = elf_section_data (s)->this_idx; 2888 2889 loc -= 4; 2890 H_PUT_32 (abfd, idx, loc); 2891 } 2892 elt = elf_next_in_group (elt); 2893 if (elt == first) 2894 break; 2895 } 2896 2897 if ((loc -= 4) != sec->contents) 2898 abort (); 2899 2900 H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc); 2901 } 2902 2903 /* Assign all ELF section numbers. The dummy first section is handled here 2904 too. The link/info pointers for the standard section types are filled 2905 in here too, while we're at it. */ 2906 2907 static bfd_boolean 2908 assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info) 2909 { 2910 struct elf_obj_tdata *t = elf_tdata (abfd); 2911 asection *sec; 2912 unsigned int section_number, secn; 2913 Elf_Internal_Shdr **i_shdrp; 2914 struct bfd_elf_section_data *d; 2915 bfd_boolean need_symtab; 2916 2917 section_number = 1; 2918 2919 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd)); 2920 2921 /* SHT_GROUP sections are in relocatable files only. */ 2922 if (link_info == NULL || link_info->relocatable) 2923 { 2924 /* Put SHT_GROUP sections first. */ 2925 for (sec = abfd->sections; sec != NULL; sec = sec->next) 2926 { 2927 d = elf_section_data (sec); 2928 2929 if (d->this_hdr.sh_type == SHT_GROUP) 2930 { 2931 if (sec->flags & SEC_LINKER_CREATED) 2932 { 2933 /* Remove the linker created SHT_GROUP sections. */ 2934 bfd_section_list_remove (abfd, sec); 2935 abfd->section_count--; 2936 } 2937 else 2938 d->this_idx = section_number++; 2939 } 2940 } 2941 } 2942 2943 for (sec = abfd->sections; sec; sec = sec->next) 2944 { 2945 d = elf_section_data (sec); 2946 2947 if (d->this_hdr.sh_type != SHT_GROUP) 2948 d->this_idx = section_number++; 2949 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name); 2950 if (d->rel.hdr) 2951 { 2952 d->rel.idx = section_number++; 2953 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel.hdr->sh_name); 2954 } 2955 else 2956 d->rel.idx = 0; 2957 2958 if (d->rela.hdr) 2959 { 2960 d->rela.idx = section_number++; 2961 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rela.hdr->sh_name); 2962 } 2963 else 2964 d->rela.idx = 0; 2965 } 2966 2967 t->shstrtab_section = section_number++; 2968 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name); 2969 elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section; 2970 2971 need_symtab = (bfd_get_symcount (abfd) > 0 2972 || (link_info == NULL 2973 && ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC)) 2974 == HAS_RELOC))); 2975 if (need_symtab) 2976 { 2977 t->symtab_section = section_number++; 2978 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name); 2979 if (section_number > ((SHN_LORESERVE - 2) & 0xFFFF)) 2980 { 2981 t->symtab_shndx_section = section_number++; 2982 t->symtab_shndx_hdr.sh_name 2983 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), 2984 ".symtab_shndx", FALSE); 2985 if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1) 2986 return FALSE; 2987 } 2988 t->strtab_section = section_number++; 2989 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name); 2990 } 2991 2992 _bfd_elf_strtab_finalize (elf_shstrtab (abfd)); 2993 t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd)); 2994 2995 elf_numsections (abfd) = section_number; 2996 elf_elfheader (abfd)->e_shnum = section_number; 2997 2998 /* Set up the list of section header pointers, in agreement with the 2999 indices. */ 3000 i_shdrp = (Elf_Internal_Shdr **) bfd_zalloc2 (abfd, section_number, 3001 sizeof (Elf_Internal_Shdr *)); 3002 if (i_shdrp == NULL) 3003 return FALSE; 3004 3005 i_shdrp[0] = (Elf_Internal_Shdr *) bfd_zalloc (abfd, 3006 sizeof (Elf_Internal_Shdr)); 3007 if (i_shdrp[0] == NULL) 3008 { 3009 bfd_release (abfd, i_shdrp); 3010 return FALSE; 3011 } 3012 3013 elf_elfsections (abfd) = i_shdrp; 3014 3015 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr; 3016 if (need_symtab) 3017 { 3018 i_shdrp[t->symtab_section] = &t->symtab_hdr; 3019 if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF)) 3020 { 3021 i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr; 3022 t->symtab_shndx_hdr.sh_link = t->symtab_section; 3023 } 3024 i_shdrp[t->strtab_section] = &t->strtab_hdr; 3025 t->symtab_hdr.sh_link = t->strtab_section; 3026 } 3027 3028 for (sec = abfd->sections; sec; sec = sec->next) 3029 { 3030 asection *s; 3031 const char *name; 3032 3033 d = elf_section_data (sec); 3034 3035 i_shdrp[d->this_idx] = &d->this_hdr; 3036 if (d->rel.idx != 0) 3037 i_shdrp[d->rel.idx] = d->rel.hdr; 3038 if (d->rela.idx != 0) 3039 i_shdrp[d->rela.idx] = d->rela.hdr; 3040 3041 /* Fill in the sh_link and sh_info fields while we're at it. */ 3042 3043 /* sh_link of a reloc section is the section index of the symbol 3044 table. sh_info is the section index of the section to which 3045 the relocation entries apply. */ 3046 if (d->rel.idx != 0) 3047 { 3048 d->rel.hdr->sh_link = t->symtab_section; 3049 d->rel.hdr->sh_info = d->this_idx; 3050 } 3051 if (d->rela.idx != 0) 3052 { 3053 d->rela.hdr->sh_link = t->symtab_section; 3054 d->rela.hdr->sh_info = d->this_idx; 3055 } 3056 3057 /* We need to set up sh_link for SHF_LINK_ORDER. */ 3058 if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0) 3059 { 3060 s = elf_linked_to_section (sec); 3061 if (s) 3062 { 3063 /* elf_linked_to_section points to the input section. */ 3064 if (link_info != NULL) 3065 { 3066 /* Check discarded linkonce section. */ 3067 if (elf_discarded_section (s)) 3068 { 3069 asection *kept; 3070 (*_bfd_error_handler) 3071 (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"), 3072 abfd, d->this_hdr.bfd_section, 3073 s, s->owner); 3074 /* Point to the kept section if it has the same 3075 size as the discarded one. */ 3076 kept = _bfd_elf_check_kept_section (s, link_info); 3077 if (kept == NULL) 3078 { 3079 bfd_set_error (bfd_error_bad_value); 3080 return FALSE; 3081 } 3082 s = kept; 3083 } 3084 3085 s = s->output_section; 3086 BFD_ASSERT (s != NULL); 3087 } 3088 else 3089 { 3090 /* Handle objcopy. */ 3091 if (s->output_section == NULL) 3092 { 3093 (*_bfd_error_handler) 3094 (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"), 3095 abfd, d->this_hdr.bfd_section, s, s->owner); 3096 bfd_set_error (bfd_error_bad_value); 3097 return FALSE; 3098 } 3099 s = s->output_section; 3100 } 3101 d->this_hdr.sh_link = elf_section_data (s)->this_idx; 3102 } 3103 else 3104 { 3105 /* PR 290: 3106 The Intel C compiler generates SHT_IA_64_UNWIND with 3107 SHF_LINK_ORDER. But it doesn't set the sh_link or 3108 sh_info fields. Hence we could get the situation 3109 where s is NULL. */ 3110 const struct elf_backend_data *bed 3111 = get_elf_backend_data (abfd); 3112 if (bed->link_order_error_handler) 3113 bed->link_order_error_handler 3114 (_("%B: warning: sh_link not set for section `%A'"), 3115 abfd, sec); 3116 } 3117 } 3118 3119 switch (d->this_hdr.sh_type) 3120 { 3121 case SHT_REL: 3122 case SHT_RELA: 3123 /* A reloc section which we are treating as a normal BFD 3124 section. sh_link is the section index of the symbol 3125 table. sh_info is the section index of the section to 3126 which the relocation entries apply. We assume that an 3127 allocated reloc section uses the dynamic symbol table. 3128 FIXME: How can we be sure? */ 3129 s = bfd_get_section_by_name (abfd, ".dynsym"); 3130 if (s != NULL) 3131 d->this_hdr.sh_link = elf_section_data (s)->this_idx; 3132 3133 /* We look up the section the relocs apply to by name. */ 3134 name = sec->name; 3135 if (d->this_hdr.sh_type == SHT_REL) 3136 name += 4; 3137 else 3138 name += 5; 3139 s = bfd_get_section_by_name (abfd, name); 3140 if (s != NULL) 3141 d->this_hdr.sh_info = elf_section_data (s)->this_idx; 3142 break; 3143 3144 case SHT_STRTAB: 3145 /* We assume that a section named .stab*str is a stabs 3146 string section. We look for a section with the same name 3147 but without the trailing ``str'', and set its sh_link 3148 field to point to this section. */ 3149 if (CONST_STRNEQ (sec->name, ".stab") 3150 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0) 3151 { 3152 size_t len; 3153 char *alc; 3154 3155 len = strlen (sec->name); 3156 alc = (char *) bfd_malloc (len - 2); 3157 if (alc == NULL) 3158 return FALSE; 3159 memcpy (alc, sec->name, len - 3); 3160 alc[len - 3] = '\0'; 3161 s = bfd_get_section_by_name (abfd, alc); 3162 free (alc); 3163 if (s != NULL) 3164 { 3165 elf_section_data (s)->this_hdr.sh_link = d->this_idx; 3166 3167 /* This is a .stab section. */ 3168 if (elf_section_data (s)->this_hdr.sh_entsize == 0) 3169 elf_section_data (s)->this_hdr.sh_entsize 3170 = 4 + 2 * bfd_get_arch_size (abfd) / 8; 3171 } 3172 } 3173 break; 3174 3175 case SHT_DYNAMIC: 3176 case SHT_DYNSYM: 3177 case SHT_GNU_verneed: 3178 case SHT_GNU_verdef: 3179 /* sh_link is the section header index of the string table 3180 used for the dynamic entries, or the symbol table, or the 3181 version strings. */ 3182 s = bfd_get_section_by_name (abfd, ".dynstr"); 3183 if (s != NULL) 3184 d->this_hdr.sh_link = elf_section_data (s)->this_idx; 3185 break; 3186 3187 case SHT_GNU_LIBLIST: 3188 /* sh_link is the section header index of the prelink library 3189 list used for the dynamic entries, or the symbol table, or 3190 the version strings. */ 3191 s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC) 3192 ? ".dynstr" : ".gnu.libstr"); 3193 if (s != NULL) 3194 d->this_hdr.sh_link = elf_section_data (s)->this_idx; 3195 break; 3196 3197 case SHT_HASH: 3198 case SHT_GNU_HASH: 3199 case SHT_GNU_versym: 3200 /* sh_link is the section header index of the symbol table 3201 this hash table or version table is for. */ 3202 s = bfd_get_section_by_name (abfd, ".dynsym"); 3203 if (s != NULL) 3204 d->this_hdr.sh_link = elf_section_data (s)->this_idx; 3205 break; 3206 3207 case SHT_GROUP: 3208 d->this_hdr.sh_link = t->symtab_section; 3209 } 3210 } 3211 3212 for (secn = 1; secn < section_number; ++secn) 3213 if (i_shdrp[secn] == NULL) 3214 i_shdrp[secn] = i_shdrp[0]; 3215 else 3216 i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd), 3217 i_shdrp[secn]->sh_name); 3218 return TRUE; 3219 } 3220 3221 /* Map symbol from it's internal number to the external number, moving 3222 all local symbols to be at the head of the list. */ 3223 3224 static bfd_boolean 3225 sym_is_global (bfd *abfd, asymbol *sym) 3226 { 3227 /* If the backend has a special mapping, use it. */ 3228 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 3229 if (bed->elf_backend_sym_is_global) 3230 return (*bed->elf_backend_sym_is_global) (abfd, sym); 3231 3232 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE)) != 0 3233 || bfd_is_und_section (bfd_get_section (sym)) 3234 || bfd_is_com_section (bfd_get_section (sym))); 3235 } 3236 3237 /* Don't output section symbols for sections that are not going to be 3238 output. */ 3239 3240 static bfd_boolean 3241 ignore_section_sym (bfd *abfd, asymbol *sym) 3242 { 3243 return ((sym->flags & BSF_SECTION_SYM) != 0 3244 && !(sym->section->owner == abfd 3245 || (sym->section->output_section->owner == abfd 3246 && sym->section->output_offset == 0))); 3247 } 3248 3249 static bfd_boolean 3250 elf_map_symbols (bfd *abfd) 3251 { 3252 unsigned int symcount = bfd_get_symcount (abfd); 3253 asymbol **syms = bfd_get_outsymbols (abfd); 3254 asymbol **sect_syms; 3255 unsigned int num_locals = 0; 3256 unsigned int num_globals = 0; 3257 unsigned int num_locals2 = 0; 3258 unsigned int num_globals2 = 0; 3259 int max_index = 0; 3260 unsigned int idx; 3261 asection *asect; 3262 asymbol **new_syms; 3263 3264 #ifdef DEBUG 3265 fprintf (stderr, "elf_map_symbols\n"); 3266 fflush (stderr); 3267 #endif 3268 3269 for (asect = abfd->sections; asect; asect = asect->next) 3270 { 3271 if (max_index < asect->index) 3272 max_index = asect->index; 3273 } 3274 3275 max_index++; 3276 sect_syms = (asymbol **) bfd_zalloc2 (abfd, max_index, sizeof (asymbol *)); 3277 if (sect_syms == NULL) 3278 return FALSE; 3279 elf_section_syms (abfd) = sect_syms; 3280 elf_num_section_syms (abfd) = max_index; 3281 3282 /* Init sect_syms entries for any section symbols we have already 3283 decided to output. */ 3284 for (idx = 0; idx < symcount; idx++) 3285 { 3286 asymbol *sym = syms[idx]; 3287 3288 if ((sym->flags & BSF_SECTION_SYM) != 0 3289 && sym->value == 0 3290 && !ignore_section_sym (abfd, sym)) 3291 { 3292 asection *sec = sym->section; 3293 3294 if (sec->owner != abfd) 3295 sec = sec->output_section; 3296 3297 sect_syms[sec->index] = syms[idx]; 3298 } 3299 } 3300 3301 /* Classify all of the symbols. */ 3302 for (idx = 0; idx < symcount; idx++) 3303 { 3304 if (ignore_section_sym (abfd, syms[idx])) 3305 continue; 3306 if (!sym_is_global (abfd, syms[idx])) 3307 num_locals++; 3308 else 3309 num_globals++; 3310 } 3311 3312 /* We will be adding a section symbol for each normal BFD section. Most 3313 sections will already have a section symbol in outsymbols, but 3314 eg. SHT_GROUP sections will not, and we need the section symbol mapped 3315 at least in that case. */ 3316 for (asect = abfd->sections; asect; asect = asect->next) 3317 { 3318 if (sect_syms[asect->index] == NULL) 3319 { 3320 if (!sym_is_global (abfd, asect->symbol)) 3321 num_locals++; 3322 else 3323 num_globals++; 3324 } 3325 } 3326 3327 /* Now sort the symbols so the local symbols are first. */ 3328 new_syms = (asymbol **) bfd_alloc2 (abfd, num_locals + num_globals, 3329 sizeof (asymbol *)); 3330 3331 if (new_syms == NULL) 3332 return FALSE; 3333 3334 for (idx = 0; idx < symcount; idx++) 3335 { 3336 asymbol *sym = syms[idx]; 3337 unsigned int i; 3338 3339 if (ignore_section_sym (abfd, sym)) 3340 continue; 3341 if (!sym_is_global (abfd, sym)) 3342 i = num_locals2++; 3343 else 3344 i = num_locals + num_globals2++; 3345 new_syms[i] = sym; 3346 sym->udata.i = i + 1; 3347 } 3348 for (asect = abfd->sections; asect; asect = asect->next) 3349 { 3350 if (sect_syms[asect->index] == NULL) 3351 { 3352 asymbol *sym = asect->symbol; 3353 unsigned int i; 3354 3355 sect_syms[asect->index] = sym; 3356 if (!sym_is_global (abfd, sym)) 3357 i = num_locals2++; 3358 else 3359 i = num_locals + num_globals2++; 3360 new_syms[i] = sym; 3361 sym->udata.i = i + 1; 3362 } 3363 } 3364 3365 bfd_set_symtab (abfd, new_syms, num_locals + num_globals); 3366 3367 elf_num_locals (abfd) = num_locals; 3368 elf_num_globals (abfd) = num_globals; 3369 return TRUE; 3370 } 3371 3372 /* Align to the maximum file alignment that could be required for any 3373 ELF data structure. */ 3374 3375 static inline file_ptr 3376 align_file_position (file_ptr off, int align) 3377 { 3378 return (off + align - 1) & ~(align - 1); 3379 } 3380 3381 /* Assign a file position to a section, optionally aligning to the 3382 required section alignment. */ 3383 3384 file_ptr 3385 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp, 3386 file_ptr offset, 3387 bfd_boolean align) 3388 { 3389 if (align && i_shdrp->sh_addralign > 1) 3390 offset = BFD_ALIGN (offset, i_shdrp->sh_addralign); 3391 i_shdrp->sh_offset = offset; 3392 if (i_shdrp->bfd_section != NULL) 3393 i_shdrp->bfd_section->filepos = offset; 3394 if (i_shdrp->sh_type != SHT_NOBITS) 3395 offset += i_shdrp->sh_size; 3396 return offset; 3397 } 3398 3399 /* Compute the file positions we are going to put the sections at, and 3400 otherwise prepare to begin writing out the ELF file. If LINK_INFO 3401 is not NULL, this is being called by the ELF backend linker. */ 3402 3403 bfd_boolean 3404 _bfd_elf_compute_section_file_positions (bfd *abfd, 3405 struct bfd_link_info *link_info) 3406 { 3407 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 3408 struct fake_section_arg fsargs; 3409 bfd_boolean failed; 3410 struct bfd_strtab_hash *strtab = NULL; 3411 Elf_Internal_Shdr *shstrtab_hdr; 3412 bfd_boolean need_symtab; 3413 3414 if (abfd->output_has_begun) 3415 return TRUE; 3416 3417 /* Do any elf backend specific processing first. */ 3418 if (bed->elf_backend_begin_write_processing) 3419 (*bed->elf_backend_begin_write_processing) (abfd, link_info); 3420 3421 if (! prep_headers (abfd)) 3422 return FALSE; 3423 3424 /* Post process the headers if necessary. */ 3425 if (bed->elf_backend_post_process_headers) 3426 (*bed->elf_backend_post_process_headers) (abfd, link_info); 3427 3428 fsargs.failed = FALSE; 3429 fsargs.link_info = link_info; 3430 bfd_map_over_sections (abfd, elf_fake_sections, &fsargs); 3431 if (fsargs.failed) 3432 return FALSE; 3433 3434 if (!assign_section_numbers (abfd, link_info)) 3435 return FALSE; 3436 3437 /* The backend linker builds symbol table information itself. */ 3438 need_symtab = (link_info == NULL 3439 && (bfd_get_symcount (abfd) > 0 3440 || ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC)) 3441 == HAS_RELOC))); 3442 if (need_symtab) 3443 { 3444 /* Non-zero if doing a relocatable link. */ 3445 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC)); 3446 3447 if (! swap_out_syms (abfd, &strtab, relocatable_p)) 3448 return FALSE; 3449 } 3450 3451 failed = FALSE; 3452 if (link_info == NULL) 3453 { 3454 bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed); 3455 if (failed) 3456 return FALSE; 3457 } 3458 3459 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr; 3460 /* sh_name was set in prep_headers. */ 3461 shstrtab_hdr->sh_type = SHT_STRTAB; 3462 shstrtab_hdr->sh_flags = 0; 3463 shstrtab_hdr->sh_addr = 0; 3464 shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd)); 3465 shstrtab_hdr->sh_entsize = 0; 3466 shstrtab_hdr->sh_link = 0; 3467 shstrtab_hdr->sh_info = 0; 3468 /* sh_offset is set in assign_file_positions_except_relocs. */ 3469 shstrtab_hdr->sh_addralign = 1; 3470 3471 if (!assign_file_positions_except_relocs (abfd, link_info)) 3472 return FALSE; 3473 3474 if (need_symtab) 3475 { 3476 file_ptr off; 3477 Elf_Internal_Shdr *hdr; 3478 3479 off = elf_tdata (abfd)->next_file_pos; 3480 3481 hdr = &elf_tdata (abfd)->symtab_hdr; 3482 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE); 3483 3484 hdr = &elf_tdata (abfd)->symtab_shndx_hdr; 3485 if (hdr->sh_size != 0) 3486 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE); 3487 3488 hdr = &elf_tdata (abfd)->strtab_hdr; 3489 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE); 3490 3491 elf_tdata (abfd)->next_file_pos = off; 3492 3493 /* Now that we know where the .strtab section goes, write it 3494 out. */ 3495 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0 3496 || ! _bfd_stringtab_emit (abfd, strtab)) 3497 return FALSE; 3498 _bfd_stringtab_free (strtab); 3499 } 3500 3501 abfd->output_has_begun = TRUE; 3502 3503 return TRUE; 3504 } 3505 3506 /* Make an initial estimate of the size of the program header. If we 3507 get the number wrong here, we'll redo section placement. */ 3508 3509 static bfd_size_type 3510 get_program_header_size (bfd *abfd, struct bfd_link_info *info) 3511 { 3512 size_t segs; 3513 asection *s; 3514 const struct elf_backend_data *bed; 3515 3516 /* Assume we will need exactly two PT_LOAD segments: one for text 3517 and one for data. */ 3518 segs = 2; 3519 3520 s = bfd_get_section_by_name (abfd, ".interp"); 3521 if (s != NULL && (s->flags & SEC_LOAD) != 0) 3522 { 3523 /* If we have a loadable interpreter section, we need a 3524 PT_INTERP segment. In this case, assume we also need a 3525 PT_PHDR segment, although that may not be true for all 3526 targets. */ 3527 segs += 2; 3528 } 3529 3530 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL) 3531 { 3532 /* We need a PT_DYNAMIC segment. */ 3533 ++segs; 3534 } 3535 3536 if (info != NULL && info->relro) 3537 { 3538 /* We need a PT_GNU_RELRO segment. */ 3539 ++segs; 3540 } 3541 3542 if (elf_tdata (abfd)->eh_frame_hdr) 3543 { 3544 /* We need a PT_GNU_EH_FRAME segment. */ 3545 ++segs; 3546 } 3547 3548 if (elf_tdata (abfd)->stack_flags) 3549 { 3550 /* We need a PT_GNU_STACK segment. */ 3551 ++segs; 3552 } 3553 3554 for (s = abfd->sections; s != NULL; s = s->next) 3555 { 3556 if ((s->flags & SEC_LOAD) != 0 3557 && CONST_STRNEQ (s->name, ".note")) 3558 { 3559 /* We need a PT_NOTE segment. */ 3560 ++segs; 3561 /* Try to create just one PT_NOTE segment 3562 for all adjacent loadable .note* sections. 3563 gABI requires that within a PT_NOTE segment 3564 (and also inside of each SHT_NOTE section) 3565 each note is padded to a multiple of 4 size, 3566 so we check whether the sections are correctly 3567 aligned. */ 3568 if (s->alignment_power == 2) 3569 while (s->next != NULL 3570 && s->next->alignment_power == 2 3571 && (s->next->flags & SEC_LOAD) != 0 3572 && CONST_STRNEQ (s->next->name, ".note")) 3573 s = s->next; 3574 } 3575 } 3576 3577 for (s = abfd->sections; s != NULL; s = s->next) 3578 { 3579 if (s->flags & SEC_THREAD_LOCAL) 3580 { 3581 /* We need a PT_TLS segment. */ 3582 ++segs; 3583 break; 3584 } 3585 } 3586 3587 /* Let the backend count up any program headers it might need. */ 3588 bed = get_elf_backend_data (abfd); 3589 if (bed->elf_backend_additional_program_headers) 3590 { 3591 int a; 3592 3593 a = (*bed->elf_backend_additional_program_headers) (abfd, info); 3594 if (a == -1) 3595 abort (); 3596 segs += a; 3597 } 3598 3599 return segs * bed->s->sizeof_phdr; 3600 } 3601 3602 /* Find the segment that contains the output_section of section. */ 3603 3604 Elf_Internal_Phdr * 3605 _bfd_elf_find_segment_containing_section (bfd * abfd, asection * section) 3606 { 3607 struct elf_segment_map *m; 3608 Elf_Internal_Phdr *p; 3609 3610 for (m = elf_tdata (abfd)->segment_map, 3611 p = elf_tdata (abfd)->phdr; 3612 m != NULL; 3613 m = m->next, p++) 3614 { 3615 int i; 3616 3617 for (i = m->count - 1; i >= 0; i--) 3618 if (m->sections[i] == section) 3619 return p; 3620 } 3621 3622 return NULL; 3623 } 3624 3625 /* Create a mapping from a set of sections to a program segment. */ 3626 3627 static struct elf_segment_map * 3628 make_mapping (bfd *abfd, 3629 asection **sections, 3630 unsigned int from, 3631 unsigned int to, 3632 bfd_boolean phdr) 3633 { 3634 struct elf_segment_map *m; 3635 unsigned int i; 3636 asection **hdrpp; 3637 bfd_size_type amt; 3638 3639 amt = sizeof (struct elf_segment_map); 3640 amt += (to - from - 1) * sizeof (asection *); 3641 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt); 3642 if (m == NULL) 3643 return NULL; 3644 m->next = NULL; 3645 m->p_type = PT_LOAD; 3646 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++) 3647 m->sections[i - from] = *hdrpp; 3648 m->count = to - from; 3649 3650 if (from == 0 && phdr) 3651 { 3652 /* Include the headers in the first PT_LOAD segment. */ 3653 m->includes_filehdr = 1; 3654 m->includes_phdrs = 1; 3655 } 3656 3657 return m; 3658 } 3659 3660 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL 3661 on failure. */ 3662 3663 struct elf_segment_map * 3664 _bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec) 3665 { 3666 struct elf_segment_map *m; 3667 3668 m = (struct elf_segment_map *) bfd_zalloc (abfd, 3669 sizeof (struct elf_segment_map)); 3670 if (m == NULL) 3671 return NULL; 3672 m->next = NULL; 3673 m->p_type = PT_DYNAMIC; 3674 m->count = 1; 3675 m->sections[0] = dynsec; 3676 3677 return m; 3678 } 3679 3680 /* Possibly add or remove segments from the segment map. */ 3681 3682 static bfd_boolean 3683 elf_modify_segment_map (bfd *abfd, 3684 struct bfd_link_info *info, 3685 bfd_boolean remove_empty_load) 3686 { 3687 struct elf_segment_map **m; 3688 const struct elf_backend_data *bed; 3689 3690 /* The placement algorithm assumes that non allocated sections are 3691 not in PT_LOAD segments. We ensure this here by removing such 3692 sections from the segment map. We also remove excluded 3693 sections. Finally, any PT_LOAD segment without sections is 3694 removed. */ 3695 m = &elf_tdata (abfd)->segment_map; 3696 while (*m) 3697 { 3698 unsigned int i, new_count; 3699 3700 for (new_count = 0, i = 0; i < (*m)->count; i++) 3701 { 3702 if (((*m)->sections[i]->flags & SEC_EXCLUDE) == 0 3703 && (((*m)->sections[i]->flags & SEC_ALLOC) != 0 3704 || (*m)->p_type != PT_LOAD)) 3705 { 3706 (*m)->sections[new_count] = (*m)->sections[i]; 3707 new_count++; 3708 } 3709 } 3710 (*m)->count = new_count; 3711 3712 if (remove_empty_load && (*m)->p_type == PT_LOAD && (*m)->count == 0) 3713 *m = (*m)->next; 3714 else 3715 m = &(*m)->next; 3716 } 3717 3718 bed = get_elf_backend_data (abfd); 3719 if (bed->elf_backend_modify_segment_map != NULL) 3720 { 3721 if (!(*bed->elf_backend_modify_segment_map) (abfd, info)) 3722 return FALSE; 3723 } 3724 3725 return TRUE; 3726 } 3727 3728 /* Set up a mapping from BFD sections to program segments. */ 3729 3730 bfd_boolean 3731 _bfd_elf_map_sections_to_segments (bfd *abfd, struct bfd_link_info *info) 3732 { 3733 unsigned int count; 3734 struct elf_segment_map *m; 3735 asection **sections = NULL; 3736 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 3737 bfd_boolean no_user_phdrs; 3738 3739 no_user_phdrs = elf_tdata (abfd)->segment_map == NULL; 3740 if (no_user_phdrs && bfd_count_sections (abfd) != 0) 3741 { 3742 asection *s; 3743 unsigned int i; 3744 struct elf_segment_map *mfirst; 3745 struct elf_segment_map **pm; 3746 asection *last_hdr; 3747 bfd_vma last_size; 3748 unsigned int phdr_index; 3749 bfd_vma maxpagesize; 3750 asection **hdrpp; 3751 bfd_boolean phdr_in_segment = TRUE; 3752 bfd_boolean writable; 3753 int tls_count = 0; 3754 asection *first_tls = NULL; 3755 asection *dynsec, *eh_frame_hdr; 3756 bfd_size_type amt; 3757 bfd_vma addr_mask, wrap_to = 0; 3758 3759 /* Select the allocated sections, and sort them. */ 3760 3761 sections = (asection **) bfd_malloc2 (bfd_count_sections (abfd), 3762 sizeof (asection *)); 3763 if (sections == NULL) 3764 goto error_return; 3765 3766 /* Calculate top address, avoiding undefined behaviour of shift 3767 left operator when shift count is equal to size of type 3768 being shifted. */ 3769 addr_mask = ((bfd_vma) 1 << (bfd_arch_bits_per_address (abfd) - 1)) - 1; 3770 addr_mask = (addr_mask << 1) + 1; 3771 3772 i = 0; 3773 for (s = abfd->sections; s != NULL; s = s->next) 3774 { 3775 if ((s->flags & SEC_ALLOC) != 0) 3776 { 3777 sections[i] = s; 3778 ++i; 3779 /* A wrapping section potentially clashes with header. */ 3780 if (((s->lma + s->size) & addr_mask) < (s->lma & addr_mask)) 3781 wrap_to = (s->lma + s->size) & addr_mask; 3782 } 3783 } 3784 BFD_ASSERT (i <= bfd_count_sections (abfd)); 3785 count = i; 3786 3787 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections); 3788 3789 /* Build the mapping. */ 3790 3791 mfirst = NULL; 3792 pm = &mfirst; 3793 3794 /* If we have a .interp section, then create a PT_PHDR segment for 3795 the program headers and a PT_INTERP segment for the .interp 3796 section. */ 3797 s = bfd_get_section_by_name (abfd, ".interp"); 3798 if (s != NULL && (s->flags & SEC_LOAD) != 0) 3799 { 3800 amt = sizeof (struct elf_segment_map); 3801 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt); 3802 if (m == NULL) 3803 goto error_return; 3804 m->next = NULL; 3805 m->p_type = PT_PHDR; 3806 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */ 3807 m->p_flags = PF_R | PF_X; 3808 m->p_flags_valid = 1; 3809 m->includes_phdrs = 1; 3810 3811 *pm = m; 3812 pm = &m->next; 3813 3814 amt = sizeof (struct elf_segment_map); 3815 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt); 3816 if (m == NULL) 3817 goto error_return; 3818 m->next = NULL; 3819 m->p_type = PT_INTERP; 3820 m->count = 1; 3821 m->sections[0] = s; 3822 3823 *pm = m; 3824 pm = &m->next; 3825 } 3826 3827 /* Look through the sections. We put sections in the same program 3828 segment when the start of the second section can be placed within 3829 a few bytes of the end of the first section. */ 3830 last_hdr = NULL; 3831 last_size = 0; 3832 phdr_index = 0; 3833 maxpagesize = bed->maxpagesize; 3834 writable = FALSE; 3835 dynsec = bfd_get_section_by_name (abfd, ".dynamic"); 3836 if (dynsec != NULL 3837 && (dynsec->flags & SEC_LOAD) == 0) 3838 dynsec = NULL; 3839 3840 /* Deal with -Ttext or something similar such that the first section 3841 is not adjacent to the program headers. This is an 3842 approximation, since at this point we don't know exactly how many 3843 program headers we will need. */ 3844 if (count > 0) 3845 { 3846 bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size; 3847 3848 if (phdr_size == (bfd_size_type) -1) 3849 phdr_size = get_program_header_size (abfd, info); 3850 if ((abfd->flags & D_PAGED) == 0 3851 || (sections[0]->lma & addr_mask) < phdr_size 3852 || ((sections[0]->lma & addr_mask) % maxpagesize 3853 < phdr_size % maxpagesize) 3854 || (sections[0]->lma & addr_mask & -maxpagesize) < wrap_to) 3855 phdr_in_segment = FALSE; 3856 } 3857 3858 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++) 3859 { 3860 asection *hdr; 3861 bfd_boolean new_segment; 3862 3863 hdr = *hdrpp; 3864 3865 /* See if this section and the last one will fit in the same 3866 segment. */ 3867 3868 if (last_hdr == NULL) 3869 { 3870 /* If we don't have a segment yet, then we don't need a new 3871 one (we build the last one after this loop). */ 3872 new_segment = FALSE; 3873 } 3874 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma) 3875 { 3876 /* If this section has a different relation between the 3877 virtual address and the load address, then we need a new 3878 segment. */ 3879 new_segment = TRUE; 3880 } 3881 else if (hdr->lma < last_hdr->lma + last_size 3882 || last_hdr->lma + last_size < last_hdr->lma) 3883 { 3884 /* If this section has a load address that makes it overlap 3885 the previous section, then we need a new segment. */ 3886 new_segment = TRUE; 3887 } 3888 /* In the next test we have to be careful when last_hdr->lma is close 3889 to the end of the address space. If the aligned address wraps 3890 around to the start of the address space, then there are no more 3891 pages left in memory and it is OK to assume that the current 3892 section can be included in the current segment. */ 3893 else if ((BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize 3894 > last_hdr->lma) 3895 && (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize 3896 <= hdr->lma)) 3897 { 3898 /* If putting this section in this segment would force us to 3899 skip a page in the segment, then we need a new segment. */ 3900 new_segment = TRUE; 3901 } 3902 else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0 3903 && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0) 3904 { 3905 /* We don't want to put a loadable section after a 3906 nonloadable section in the same segment. 3907 Consider .tbss sections as loadable for this purpose. */ 3908 new_segment = TRUE; 3909 } 3910 else if ((abfd->flags & D_PAGED) == 0) 3911 { 3912 /* If the file is not demand paged, which means that we 3913 don't require the sections to be correctly aligned in the 3914 file, then there is no other reason for a new segment. */ 3915 new_segment = FALSE; 3916 } 3917 else if (! writable 3918 && (hdr->flags & SEC_READONLY) == 0 3919 && (((last_hdr->lma + last_size - 1) & -maxpagesize) 3920 != (hdr->lma & -maxpagesize))) 3921 { 3922 /* We don't want to put a writable section in a read only 3923 segment, unless they are on the same page in memory 3924 anyhow. We already know that the last section does not 3925 bring us past the current section on the page, so the 3926 only case in which the new section is not on the same 3927 page as the previous section is when the previous section 3928 ends precisely on a page boundary. */ 3929 new_segment = TRUE; 3930 } 3931 else 3932 { 3933 /* Otherwise, we can use the same segment. */ 3934 new_segment = FALSE; 3935 } 3936 3937 /* Allow interested parties a chance to override our decision. */ 3938 if (last_hdr != NULL 3939 && info != NULL 3940 && info->callbacks->override_segment_assignment != NULL) 3941 new_segment 3942 = info->callbacks->override_segment_assignment (info, abfd, hdr, 3943 last_hdr, 3944 new_segment); 3945 3946 if (! new_segment) 3947 { 3948 if ((hdr->flags & SEC_READONLY) == 0) 3949 writable = TRUE; 3950 last_hdr = hdr; 3951 /* .tbss sections effectively have zero size. */ 3952 if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) 3953 != SEC_THREAD_LOCAL) 3954 last_size = hdr->size; 3955 else 3956 last_size = 0; 3957 continue; 3958 } 3959 3960 /* We need a new program segment. We must create a new program 3961 header holding all the sections from phdr_index until hdr. */ 3962 3963 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment); 3964 if (m == NULL) 3965 goto error_return; 3966 3967 *pm = m; 3968 pm = &m->next; 3969 3970 if ((hdr->flags & SEC_READONLY) == 0) 3971 writable = TRUE; 3972 else 3973 writable = FALSE; 3974 3975 last_hdr = hdr; 3976 /* .tbss sections effectively have zero size. */ 3977 if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL) 3978 last_size = hdr->size; 3979 else 3980 last_size = 0; 3981 phdr_index = i; 3982 phdr_in_segment = FALSE; 3983 } 3984 3985 /* Create a final PT_LOAD program segment, but not if it's just 3986 for .tbss. */ 3987 if (last_hdr != NULL 3988 && (i - phdr_index != 1 3989 || ((last_hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) 3990 != SEC_THREAD_LOCAL))) 3991 { 3992 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment); 3993 if (m == NULL) 3994 goto error_return; 3995 3996 *pm = m; 3997 pm = &m->next; 3998 } 3999 4000 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */ 4001 if (dynsec != NULL) 4002 { 4003 m = _bfd_elf_make_dynamic_segment (abfd, dynsec); 4004 if (m == NULL) 4005 goto error_return; 4006 *pm = m; 4007 pm = &m->next; 4008 } 4009 4010 /* For each batch of consecutive loadable .note sections, 4011 add a PT_NOTE segment. We don't use bfd_get_section_by_name, 4012 because if we link together nonloadable .note sections and 4013 loadable .note sections, we will generate two .note sections 4014 in the output file. FIXME: Using names for section types is 4015 bogus anyhow. */ 4016 for (s = abfd->sections; s != NULL; s = s->next) 4017 { 4018 if ((s->flags & SEC_LOAD) != 0 4019 && CONST_STRNEQ (s->name, ".note")) 4020 { 4021 asection *s2; 4022 4023 count = 1; 4024 amt = sizeof (struct elf_segment_map); 4025 if (s->alignment_power == 2) 4026 for (s2 = s; s2->next != NULL; s2 = s2->next) 4027 { 4028 if (s2->next->alignment_power == 2 4029 && (s2->next->flags & SEC_LOAD) != 0 4030 && CONST_STRNEQ (s2->next->name, ".note") 4031 && align_power (s2->lma + s2->size, 2) 4032 == s2->next->lma) 4033 count++; 4034 else 4035 break; 4036 } 4037 amt += (count - 1) * sizeof (asection *); 4038 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt); 4039 if (m == NULL) 4040 goto error_return; 4041 m->next = NULL; 4042 m->p_type = PT_NOTE; 4043 m->count = count; 4044 while (count > 1) 4045 { 4046 m->sections[m->count - count--] = s; 4047 BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0); 4048 s = s->next; 4049 } 4050 m->sections[m->count - 1] = s; 4051 BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0); 4052 *pm = m; 4053 pm = &m->next; 4054 } 4055 if (s->flags & SEC_THREAD_LOCAL) 4056 { 4057 if (! tls_count) 4058 first_tls = s; 4059 tls_count++; 4060 } 4061 } 4062 4063 /* If there are any SHF_TLS output sections, add PT_TLS segment. */ 4064 if (tls_count > 0) 4065 { 4066 amt = sizeof (struct elf_segment_map); 4067 amt += (tls_count - 1) * sizeof (asection *); 4068 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt); 4069 if (m == NULL) 4070 goto error_return; 4071 m->next = NULL; 4072 m->p_type = PT_TLS; 4073 m->count = tls_count; 4074 /* Mandated PF_R. */ 4075 m->p_flags = PF_R; 4076 m->p_flags_valid = 1; 4077 for (i = 0; i < (unsigned int) tls_count; ++i) 4078 { 4079 BFD_ASSERT (first_tls->flags & SEC_THREAD_LOCAL); 4080 m->sections[i] = first_tls; 4081 first_tls = first_tls->next; 4082 } 4083 4084 *pm = m; 4085 pm = &m->next; 4086 } 4087 4088 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME 4089 segment. */ 4090 eh_frame_hdr = elf_tdata (abfd)->eh_frame_hdr; 4091 if (eh_frame_hdr != NULL 4092 && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0) 4093 { 4094 amt = sizeof (struct elf_segment_map); 4095 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt); 4096 if (m == NULL) 4097 goto error_return; 4098 m->next = NULL; 4099 m->p_type = PT_GNU_EH_FRAME; 4100 m->count = 1; 4101 m->sections[0] = eh_frame_hdr->output_section; 4102 4103 *pm = m; 4104 pm = &m->next; 4105 } 4106 4107 if (elf_tdata (abfd)->stack_flags) 4108 { 4109 amt = sizeof (struct elf_segment_map); 4110 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt); 4111 if (m == NULL) 4112 goto error_return; 4113 m->next = NULL; 4114 m->p_type = PT_GNU_STACK; 4115 m->p_flags = elf_tdata (abfd)->stack_flags; 4116 m->p_flags_valid = 1; 4117 4118 *pm = m; 4119 pm = &m->next; 4120 } 4121 4122 if (info != NULL && info->relro) 4123 { 4124 for (m = mfirst; m != NULL; m = m->next) 4125 { 4126 if (m->p_type == PT_LOAD) 4127 { 4128 asection *last = m->sections[m->count - 1]; 4129 bfd_vma vaddr = m->sections[0]->vma; 4130 bfd_vma filesz = last->vma - vaddr + last->size; 4131 4132 if (vaddr < info->relro_end 4133 && vaddr >= info->relro_start 4134 && (vaddr + filesz) >= info->relro_end) 4135 break; 4136 } 4137 } 4138 4139 /* Make a PT_GNU_RELRO segment only when it isn't empty. */ 4140 if (m != NULL) 4141 { 4142 amt = sizeof (struct elf_segment_map); 4143 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt); 4144 if (m == NULL) 4145 goto error_return; 4146 m->next = NULL; 4147 m->p_type = PT_GNU_RELRO; 4148 m->p_flags = PF_R; 4149 m->p_flags_valid = 1; 4150 4151 *pm = m; 4152 pm = &m->next; 4153 } 4154 } 4155 4156 free (sections); 4157 elf_tdata (abfd)->segment_map = mfirst; 4158 } 4159 4160 if (!elf_modify_segment_map (abfd, info, no_user_phdrs)) 4161 return FALSE; 4162 4163 for (count = 0, m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next) 4164 ++count; 4165 elf_tdata (abfd)->program_header_size = count * bed->s->sizeof_phdr; 4166 4167 return TRUE; 4168 4169 error_return: 4170 if (sections != NULL) 4171 free (sections); 4172 return FALSE; 4173 } 4174 4175 /* Sort sections by address. */ 4176 4177 static int 4178 elf_sort_sections (const void *arg1, const void *arg2) 4179 { 4180 const asection *sec1 = *(const asection **) arg1; 4181 const asection *sec2 = *(const asection **) arg2; 4182 bfd_size_type size1, size2; 4183 4184 /* Sort by LMA first, since this is the address used to 4185 place the section into a segment. */ 4186 if (sec1->lma < sec2->lma) 4187 return -1; 4188 else if (sec1->lma > sec2->lma) 4189 return 1; 4190 4191 /* Then sort by VMA. Normally the LMA and the VMA will be 4192 the same, and this will do nothing. */ 4193 if (sec1->vma < sec2->vma) 4194 return -1; 4195 else if (sec1->vma > sec2->vma) 4196 return 1; 4197 4198 /* Put !SEC_LOAD sections after SEC_LOAD ones. */ 4199 4200 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0) 4201 4202 if (TOEND (sec1)) 4203 { 4204 if (TOEND (sec2)) 4205 { 4206 /* If the indicies are the same, do not return 0 4207 here, but continue to try the next comparison. */ 4208 if (sec1->target_index - sec2->target_index != 0) 4209 return sec1->target_index - sec2->target_index; 4210 } 4211 else 4212 return 1; 4213 } 4214 else if (TOEND (sec2)) 4215 return -1; 4216 4217 #undef TOEND 4218 4219 /* Sort by size, to put zero sized sections 4220 before others at the same address. */ 4221 4222 size1 = (sec1->flags & SEC_LOAD) ? sec1->size : 0; 4223 size2 = (sec2->flags & SEC_LOAD) ? sec2->size : 0; 4224 4225 if (size1 < size2) 4226 return -1; 4227 if (size1 > size2) 4228 return 1; 4229 4230 return sec1->target_index - sec2->target_index; 4231 } 4232 4233 /* Ian Lance Taylor writes: 4234 4235 We shouldn't be using % with a negative signed number. That's just 4236 not good. We have to make sure either that the number is not 4237 negative, or that the number has an unsigned type. When the types 4238 are all the same size they wind up as unsigned. When file_ptr is a 4239 larger signed type, the arithmetic winds up as signed long long, 4240 which is wrong. 4241 4242 What we're trying to say here is something like ``increase OFF by 4243 the least amount that will cause it to be equal to the VMA modulo 4244 the page size.'' */ 4245 /* In other words, something like: 4246 4247 vma_offset = m->sections[0]->vma % bed->maxpagesize; 4248 off_offset = off % bed->maxpagesize; 4249 if (vma_offset < off_offset) 4250 adjustment = vma_offset + bed->maxpagesize - off_offset; 4251 else 4252 adjustment = vma_offset - off_offset; 4253 4254 which can can be collapsed into the expression below. */ 4255 4256 static file_ptr 4257 vma_page_aligned_bias (bfd_vma vma, ufile_ptr off, bfd_vma maxpagesize) 4258 { 4259 return ((vma - off) % maxpagesize); 4260 } 4261 4262 static void 4263 print_segment_map (const struct elf_segment_map *m) 4264 { 4265 unsigned int j; 4266 const char *pt = get_segment_type (m->p_type); 4267 char buf[32]; 4268 4269 if (pt == NULL) 4270 { 4271 if (m->p_type >= PT_LOPROC && m->p_type <= PT_HIPROC) 4272 sprintf (buf, "LOPROC+%7.7x", 4273 (unsigned int) (m->p_type - PT_LOPROC)); 4274 else if (m->p_type >= PT_LOOS && m->p_type <= PT_HIOS) 4275 sprintf (buf, "LOOS+%7.7x", 4276 (unsigned int) (m->p_type - PT_LOOS)); 4277 else 4278 snprintf (buf, sizeof (buf), "%8.8x", 4279 (unsigned int) m->p_type); 4280 pt = buf; 4281 } 4282 fflush (stdout); 4283 fprintf (stderr, "%s:", pt); 4284 for (j = 0; j < m->count; j++) 4285 fprintf (stderr, " %s", m->sections [j]->name); 4286 putc ('\n',stderr); 4287 fflush (stderr); 4288 } 4289 4290 static bfd_boolean 4291 write_zeros (bfd *abfd, file_ptr pos, bfd_size_type len) 4292 { 4293 void *buf; 4294 bfd_boolean ret; 4295 4296 if (bfd_seek (abfd, pos, SEEK_SET) != 0) 4297 return FALSE; 4298 buf = bfd_zmalloc (len); 4299 if (buf == NULL) 4300 return FALSE; 4301 ret = bfd_bwrite (buf, len, abfd) == len; 4302 free (buf); 4303 return ret; 4304 } 4305 4306 /* Assign file positions to the sections based on the mapping from 4307 sections to segments. This function also sets up some fields in 4308 the file header. */ 4309 4310 static bfd_boolean 4311 assign_file_positions_for_load_sections (bfd *abfd, 4312 struct bfd_link_info *link_info) 4313 { 4314 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 4315 struct elf_segment_map *m; 4316 Elf_Internal_Phdr *phdrs; 4317 Elf_Internal_Phdr *p; 4318 file_ptr off; 4319 bfd_size_type maxpagesize; 4320 unsigned int alloc; 4321 unsigned int i, j; 4322 bfd_vma header_pad = 0; 4323 4324 if (link_info == NULL 4325 && !_bfd_elf_map_sections_to_segments (abfd, link_info)) 4326 return FALSE; 4327 4328 alloc = 0; 4329 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next) 4330 { 4331 ++alloc; 4332 if (m->header_size) 4333 header_pad = m->header_size; 4334 } 4335 4336 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr; 4337 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr; 4338 elf_elfheader (abfd)->e_phnum = alloc; 4339 4340 if (elf_tdata (abfd)->program_header_size == (bfd_size_type) -1) 4341 elf_tdata (abfd)->program_header_size = alloc * bed->s->sizeof_phdr; 4342 else 4343 BFD_ASSERT (elf_tdata (abfd)->program_header_size 4344 >= alloc * bed->s->sizeof_phdr); 4345 4346 if (alloc == 0) 4347 { 4348 elf_tdata (abfd)->next_file_pos = bed->s->sizeof_ehdr; 4349 return TRUE; 4350 } 4351 4352 /* We're writing the size in elf_tdata (abfd)->program_header_size, 4353 see assign_file_positions_except_relocs, so make sure we have 4354 that amount allocated, with trailing space cleared. 4355 The variable alloc contains the computed need, while elf_tdata 4356 (abfd)->program_header_size contains the size used for the 4357 layout. 4358 See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments 4359 where the layout is forced to according to a larger size in the 4360 last iterations for the testcase ld-elf/header. */ 4361 BFD_ASSERT (elf_tdata (abfd)->program_header_size % bed->s->sizeof_phdr 4362 == 0); 4363 phdrs = (Elf_Internal_Phdr *) 4364 bfd_zalloc2 (abfd, 4365 (elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr), 4366 sizeof (Elf_Internal_Phdr)); 4367 elf_tdata (abfd)->phdr = phdrs; 4368 if (phdrs == NULL) 4369 return FALSE; 4370 4371 maxpagesize = 1; 4372 if ((abfd->flags & D_PAGED) != 0) 4373 maxpagesize = bed->maxpagesize; 4374 4375 off = bed->s->sizeof_ehdr; 4376 off += alloc * bed->s->sizeof_phdr; 4377 if (header_pad < (bfd_vma) off) 4378 header_pad = 0; 4379 else 4380 header_pad -= off; 4381 off += header_pad; 4382 4383 for (m = elf_tdata (abfd)->segment_map, p = phdrs, j = 0; 4384 m != NULL; 4385 m = m->next, p++, j++) 4386 { 4387 asection **secpp; 4388 bfd_vma off_adjust; 4389 bfd_boolean no_contents; 4390 4391 /* If elf_segment_map is not from map_sections_to_segments, the 4392 sections may not be correctly ordered. NOTE: sorting should 4393 not be done to the PT_NOTE section of a corefile, which may 4394 contain several pseudo-sections artificially created by bfd. 4395 Sorting these pseudo-sections breaks things badly. */ 4396 if (m->count > 1 4397 && !(elf_elfheader (abfd)->e_type == ET_CORE 4398 && m->p_type == PT_NOTE)) 4399 qsort (m->sections, (size_t) m->count, sizeof (asection *), 4400 elf_sort_sections); 4401 4402 /* An ELF segment (described by Elf_Internal_Phdr) may contain a 4403 number of sections with contents contributing to both p_filesz 4404 and p_memsz, followed by a number of sections with no contents 4405 that just contribute to p_memsz. In this loop, OFF tracks next 4406 available file offset for PT_LOAD and PT_NOTE segments. */ 4407 p->p_type = m->p_type; 4408 p->p_flags = m->p_flags; 4409 4410 if (m->count == 0) 4411 p->p_vaddr = 0; 4412 else 4413 p->p_vaddr = m->sections[0]->vma - m->p_vaddr_offset; 4414 4415 if (m->p_paddr_valid) 4416 p->p_paddr = m->p_paddr; 4417 else if (m->count == 0) 4418 p->p_paddr = 0; 4419 else 4420 p->p_paddr = m->sections[0]->lma - m->p_vaddr_offset; 4421 4422 if (p->p_type == PT_LOAD 4423 && (abfd->flags & D_PAGED) != 0) 4424 { 4425 /* p_align in demand paged PT_LOAD segments effectively stores 4426 the maximum page size. When copying an executable with 4427 objcopy, we set m->p_align from the input file. Use this 4428 value for maxpagesize rather than bed->maxpagesize, which 4429 may be different. Note that we use maxpagesize for PT_TLS 4430 segment alignment later in this function, so we are relying 4431 on at least one PT_LOAD segment appearing before a PT_TLS 4432 segment. */ 4433 if (m->p_align_valid) 4434 maxpagesize = m->p_align; 4435 4436 p->p_align = maxpagesize; 4437 } 4438 else if (m->p_align_valid) 4439 p->p_align = m->p_align; 4440 else if (m->count == 0) 4441 p->p_align = 1 << bed->s->log_file_align; 4442 else 4443 p->p_align = 0; 4444 4445 no_contents = FALSE; 4446 off_adjust = 0; 4447 if (p->p_type == PT_LOAD 4448 && m->count > 0) 4449 { 4450 bfd_size_type align; 4451 unsigned int align_power = 0; 4452 4453 if (m->p_align_valid) 4454 align = p->p_align; 4455 else 4456 { 4457 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++) 4458 { 4459 unsigned int secalign; 4460 4461 secalign = bfd_get_section_alignment (abfd, *secpp); 4462 if (secalign > align_power) 4463 align_power = secalign; 4464 } 4465 align = (bfd_size_type) 1 << align_power; 4466 if (align < maxpagesize) 4467 align = maxpagesize; 4468 } 4469 4470 for (i = 0; i < m->count; i++) 4471 if ((m->sections[i]->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0) 4472 /* If we aren't making room for this section, then 4473 it must be SHT_NOBITS regardless of what we've 4474 set via struct bfd_elf_special_section. */ 4475 elf_section_type (m->sections[i]) = SHT_NOBITS; 4476 4477 /* Find out whether this segment contains any loadable 4478 sections. */ 4479 no_contents = TRUE; 4480 for (i = 0; i < m->count; i++) 4481 if (elf_section_type (m->sections[i]) != SHT_NOBITS) 4482 { 4483 no_contents = FALSE; 4484 break; 4485 } 4486 4487 off_adjust = vma_page_aligned_bias (p->p_vaddr, off, align); 4488 off += off_adjust; 4489 if (no_contents) 4490 { 4491 /* We shouldn't need to align the segment on disk since 4492 the segment doesn't need file space, but the gABI 4493 arguably requires the alignment and glibc ld.so 4494 checks it. So to comply with the alignment 4495 requirement but not waste file space, we adjust 4496 p_offset for just this segment. (OFF_ADJUST is 4497 subtracted from OFF later.) This may put p_offset 4498 past the end of file, but that shouldn't matter. */ 4499 } 4500 else 4501 off_adjust = 0; 4502 } 4503 /* Make sure the .dynamic section is the first section in the 4504 PT_DYNAMIC segment. */ 4505 else if (p->p_type == PT_DYNAMIC 4506 && m->count > 1 4507 && strcmp (m->sections[0]->name, ".dynamic") != 0) 4508 { 4509 _bfd_error_handler 4510 (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"), 4511 abfd); 4512 bfd_set_error (bfd_error_bad_value); 4513 return FALSE; 4514 } 4515 /* Set the note section type to SHT_NOTE. */ 4516 else if (p->p_type == PT_NOTE) 4517 for (i = 0; i < m->count; i++) 4518 elf_section_type (m->sections[i]) = SHT_NOTE; 4519 4520 p->p_offset = 0; 4521 p->p_filesz = 0; 4522 p->p_memsz = 0; 4523 4524 if (m->includes_filehdr) 4525 { 4526 if (!m->p_flags_valid) 4527 p->p_flags |= PF_R; 4528 p->p_filesz = bed->s->sizeof_ehdr; 4529 p->p_memsz = bed->s->sizeof_ehdr; 4530 if (m->count > 0) 4531 { 4532 BFD_ASSERT (p->p_type == PT_LOAD); 4533 4534 if (p->p_vaddr < (bfd_vma) off) 4535 { 4536 (*_bfd_error_handler) 4537 (_("%B: Not enough room for program headers, try linking with -N"), 4538 abfd); 4539 bfd_set_error (bfd_error_bad_value); 4540 return FALSE; 4541 } 4542 4543 p->p_vaddr -= off; 4544 if (!m->p_paddr_valid) 4545 p->p_paddr -= off; 4546 } 4547 } 4548 4549 if (m->includes_phdrs) 4550 { 4551 if (!m->p_flags_valid) 4552 p->p_flags |= PF_R; 4553 4554 if (!m->includes_filehdr) 4555 { 4556 p->p_offset = bed->s->sizeof_ehdr; 4557 4558 if (m->count > 0) 4559 { 4560 BFD_ASSERT (p->p_type == PT_LOAD); 4561 p->p_vaddr -= off - p->p_offset; 4562 if (!m->p_paddr_valid) 4563 p->p_paddr -= off - p->p_offset; 4564 } 4565 } 4566 4567 p->p_filesz += alloc * bed->s->sizeof_phdr; 4568 p->p_memsz += alloc * bed->s->sizeof_phdr; 4569 if (m->count) 4570 { 4571 p->p_filesz += header_pad; 4572 p->p_memsz += header_pad; 4573 } 4574 } 4575 4576 if (p->p_type == PT_LOAD 4577 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)) 4578 { 4579 if (!m->includes_filehdr && !m->includes_phdrs) 4580 p->p_offset = off; 4581 else 4582 { 4583 file_ptr adjust; 4584 4585 adjust = off - (p->p_offset + p->p_filesz); 4586 if (!no_contents) 4587 p->p_filesz += adjust; 4588 p->p_memsz += adjust; 4589 } 4590 } 4591 4592 /* Set up p_filesz, p_memsz, p_align and p_flags from the section 4593 maps. Set filepos for sections in PT_LOAD segments, and in 4594 core files, for sections in PT_NOTE segments. 4595 assign_file_positions_for_non_load_sections will set filepos 4596 for other sections and update p_filesz for other segments. */ 4597 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++) 4598 { 4599 asection *sec; 4600 bfd_size_type align; 4601 Elf_Internal_Shdr *this_hdr; 4602 4603 sec = *secpp; 4604 this_hdr = &elf_section_data (sec)->this_hdr; 4605 align = (bfd_size_type) 1 << bfd_get_section_alignment (abfd, sec); 4606 4607 if ((p->p_type == PT_LOAD 4608 || p->p_type == PT_TLS) 4609 && (this_hdr->sh_type != SHT_NOBITS 4610 || ((this_hdr->sh_flags & SHF_ALLOC) != 0 4611 && ((this_hdr->sh_flags & SHF_TLS) == 0 4612 || p->p_type == PT_TLS)))) 4613 { 4614 bfd_vma p_start = p->p_paddr; 4615 bfd_vma p_end = p_start + p->p_memsz; 4616 bfd_vma s_start = sec->lma; 4617 bfd_vma adjust = s_start - p_end; 4618 4619 if (adjust != 0 4620 && (s_start < p_end 4621 || p_end < p_start)) 4622 { 4623 (*_bfd_error_handler) 4624 (_("%B: section %A lma %#lx adjusted to %#lx"), abfd, sec, 4625 (unsigned long) s_start, (unsigned long) p_end); 4626 adjust = 0; 4627 sec->lma = p_end; 4628 } 4629 p->p_memsz += adjust; 4630 4631 if (this_hdr->sh_type != SHT_NOBITS) 4632 { 4633 if (p->p_filesz + adjust < p->p_memsz) 4634 { 4635 /* We have a PROGBITS section following NOBITS ones. 4636 Allocate file space for the NOBITS section(s) and 4637 zero it. */ 4638 adjust = p->p_memsz - p->p_filesz; 4639 if (!write_zeros (abfd, off, adjust)) 4640 return FALSE; 4641 } 4642 off += adjust; 4643 p->p_filesz += adjust; 4644 } 4645 } 4646 4647 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core) 4648 { 4649 /* The section at i == 0 is the one that actually contains 4650 everything. */ 4651 if (i == 0) 4652 { 4653 this_hdr->sh_offset = sec->filepos = off; 4654 off += this_hdr->sh_size; 4655 p->p_filesz = this_hdr->sh_size; 4656 p->p_memsz = 0; 4657 p->p_align = 1; 4658 } 4659 else 4660 { 4661 /* The rest are fake sections that shouldn't be written. */ 4662 sec->filepos = 0; 4663 sec->size = 0; 4664 sec->flags = 0; 4665 continue; 4666 } 4667 } 4668 else 4669 { 4670 if (p->p_type == PT_LOAD) 4671 { 4672 this_hdr->sh_offset = sec->filepos = off; 4673 if (this_hdr->sh_type != SHT_NOBITS) 4674 off += this_hdr->sh_size; 4675 } 4676 else if (this_hdr->sh_type == SHT_NOBITS 4677 && (this_hdr->sh_flags & SHF_TLS) != 0 4678 && this_hdr->sh_offset == 0) 4679 { 4680 /* This is a .tbss section that didn't get a PT_LOAD. 4681 (See _bfd_elf_map_sections_to_segments "Create a 4682 final PT_LOAD".) Set sh_offset to the value it 4683 would have if we had created a zero p_filesz and 4684 p_memsz PT_LOAD header for the section. This 4685 also makes the PT_TLS header have the same 4686 p_offset value. */ 4687 bfd_vma adjust = vma_page_aligned_bias (this_hdr->sh_addr, 4688 off, align); 4689 this_hdr->sh_offset = sec->filepos = off + adjust; 4690 } 4691 4692 if (this_hdr->sh_type != SHT_NOBITS) 4693 { 4694 p->p_filesz += this_hdr->sh_size; 4695 /* A load section without SHF_ALLOC is something like 4696 a note section in a PT_NOTE segment. These take 4697 file space but are not loaded into memory. */ 4698 if ((this_hdr->sh_flags & SHF_ALLOC) != 0) 4699 p->p_memsz += this_hdr->sh_size; 4700 } 4701 else if ((this_hdr->sh_flags & SHF_ALLOC) != 0) 4702 { 4703 if (p->p_type == PT_TLS) 4704 p->p_memsz += this_hdr->sh_size; 4705 4706 /* .tbss is special. It doesn't contribute to p_memsz of 4707 normal segments. */ 4708 else if ((this_hdr->sh_flags & SHF_TLS) == 0) 4709 p->p_memsz += this_hdr->sh_size; 4710 } 4711 4712 if (align > p->p_align 4713 && !m->p_align_valid 4714 && (p->p_type != PT_LOAD 4715 || (abfd->flags & D_PAGED) == 0)) 4716 p->p_align = align; 4717 } 4718 4719 if (!m->p_flags_valid) 4720 { 4721 p->p_flags |= PF_R; 4722 if ((this_hdr->sh_flags & SHF_EXECINSTR) != 0) 4723 p->p_flags |= PF_X; 4724 if ((this_hdr->sh_flags & SHF_WRITE) != 0) 4725 p->p_flags |= PF_W; 4726 } 4727 } 4728 off -= off_adjust; 4729 4730 /* Check that all sections are in a PT_LOAD segment. 4731 Don't check funky gdb generated core files. */ 4732 if (p->p_type == PT_LOAD && bfd_get_format (abfd) != bfd_core) 4733 { 4734 bfd_boolean check_vma = TRUE; 4735 4736 for (i = 1; i < m->count; i++) 4737 if (m->sections[i]->vma == m->sections[i - 1]->vma 4738 && ELF_SECTION_SIZE (&(elf_section_data (m->sections[i]) 4739 ->this_hdr), p) != 0 4740 && ELF_SECTION_SIZE (&(elf_section_data (m->sections[i - 1]) 4741 ->this_hdr), p) != 0) 4742 { 4743 /* Looks like we have overlays packed into the segment. */ 4744 check_vma = FALSE; 4745 break; 4746 } 4747 4748 for (i = 0; i < m->count; i++) 4749 { 4750 Elf_Internal_Shdr *this_hdr; 4751 asection *sec; 4752 4753 sec = m->sections[i]; 4754 this_hdr = &(elf_section_data(sec)->this_hdr); 4755 if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr, p, check_vma, 0) 4756 && !ELF_TBSS_SPECIAL (this_hdr, p)) 4757 { 4758 (*_bfd_error_handler) 4759 (_("%B: section `%A' can't be allocated in segment %d"), 4760 abfd, sec, j); 4761 print_segment_map (m); 4762 } 4763 } 4764 } 4765 } 4766 4767 elf_tdata (abfd)->next_file_pos = off; 4768 return TRUE; 4769 } 4770 4771 /* Assign file positions for the other sections. */ 4772 4773 static bfd_boolean 4774 assign_file_positions_for_non_load_sections (bfd *abfd, 4775 struct bfd_link_info *link_info) 4776 { 4777 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 4778 Elf_Internal_Shdr **i_shdrpp; 4779 Elf_Internal_Shdr **hdrpp; 4780 Elf_Internal_Phdr *phdrs; 4781 Elf_Internal_Phdr *p; 4782 struct elf_segment_map *m; 4783 bfd_vma filehdr_vaddr, filehdr_paddr; 4784 bfd_vma phdrs_vaddr, phdrs_paddr; 4785 file_ptr off; 4786 unsigned int num_sec; 4787 unsigned int i; 4788 unsigned int count; 4789 4790 i_shdrpp = elf_elfsections (abfd); 4791 num_sec = elf_numsections (abfd); 4792 off = elf_tdata (abfd)->next_file_pos; 4793 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++) 4794 { 4795 struct elf_obj_tdata *tdata = elf_tdata (abfd); 4796 Elf_Internal_Shdr *hdr; 4797 4798 hdr = *hdrpp; 4799 if (hdr->bfd_section != NULL 4800 && (hdr->bfd_section->filepos != 0 4801 || (hdr->sh_type == SHT_NOBITS 4802 && hdr->contents == NULL))) 4803 BFD_ASSERT (hdr->sh_offset == hdr->bfd_section->filepos); 4804 else if ((hdr->sh_flags & SHF_ALLOC) != 0) 4805 { 4806 (*_bfd_error_handler) 4807 (_("%B: warning: allocated section `%s' not in segment"), 4808 abfd, 4809 (hdr->bfd_section == NULL 4810 ? "*unknown*" 4811 : hdr->bfd_section->name)); 4812 /* We don't need to page align empty sections. */ 4813 if ((abfd->flags & D_PAGED) != 0 && hdr->sh_size != 0) 4814 off += vma_page_aligned_bias (hdr->sh_addr, off, 4815 bed->maxpagesize); 4816 else 4817 off += vma_page_aligned_bias (hdr->sh_addr, off, 4818 hdr->sh_addralign); 4819 off = _bfd_elf_assign_file_position_for_section (hdr, off, 4820 FALSE); 4821 } 4822 else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA) 4823 && hdr->bfd_section == NULL) 4824 || hdr == i_shdrpp[tdata->symtab_section] 4825 || hdr == i_shdrpp[tdata->symtab_shndx_section] 4826 || hdr == i_shdrpp[tdata->strtab_section]) 4827 hdr->sh_offset = -1; 4828 else 4829 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE); 4830 } 4831 4832 /* Now that we have set the section file positions, we can set up 4833 the file positions for the non PT_LOAD segments. */ 4834 count = 0; 4835 filehdr_vaddr = 0; 4836 filehdr_paddr = 0; 4837 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr; 4838 phdrs_paddr = 0; 4839 phdrs = elf_tdata (abfd)->phdr; 4840 for (m = elf_tdata (abfd)->segment_map, p = phdrs; 4841 m != NULL; 4842 m = m->next, p++) 4843 { 4844 ++count; 4845 if (p->p_type != PT_LOAD) 4846 continue; 4847 4848 if (m->includes_filehdr) 4849 { 4850 filehdr_vaddr = p->p_vaddr; 4851 filehdr_paddr = p->p_paddr; 4852 } 4853 if (m->includes_phdrs) 4854 { 4855 phdrs_vaddr = p->p_vaddr; 4856 phdrs_paddr = p->p_paddr; 4857 if (m->includes_filehdr) 4858 { 4859 phdrs_vaddr += bed->s->sizeof_ehdr; 4860 phdrs_paddr += bed->s->sizeof_ehdr; 4861 } 4862 } 4863 } 4864 4865 for (m = elf_tdata (abfd)->segment_map, p = phdrs; 4866 m != NULL; 4867 m = m->next, p++) 4868 { 4869 if (p->p_type == PT_GNU_RELRO) 4870 { 4871 const Elf_Internal_Phdr *lp; 4872 4873 BFD_ASSERT (!m->includes_filehdr && !m->includes_phdrs); 4874 4875 if (link_info != NULL) 4876 { 4877 /* During linking the range of the RELRO segment is passed 4878 in link_info. */ 4879 for (lp = phdrs; lp < phdrs + count; ++lp) 4880 { 4881 if (lp->p_type == PT_LOAD 4882 && lp->p_vaddr >= link_info->relro_start 4883 && lp->p_vaddr < link_info->relro_end 4884 && lp->p_vaddr + lp->p_filesz >= link_info->relro_end) 4885 break; 4886 } 4887 } 4888 else 4889 { 4890 /* Otherwise we are copying an executable or shared 4891 library, but we need to use the same linker logic. */ 4892 for (lp = phdrs; lp < phdrs + count; ++lp) 4893 { 4894 if (lp->p_type == PT_LOAD 4895 && lp->p_paddr == p->p_paddr) 4896 break; 4897 } 4898 } 4899 4900 if (lp < phdrs + count) 4901 { 4902 p->p_vaddr = lp->p_vaddr; 4903 p->p_paddr = lp->p_paddr; 4904 p->p_offset = lp->p_offset; 4905 if (link_info != NULL) 4906 p->p_filesz = link_info->relro_end - lp->p_vaddr; 4907 else if (m->p_size_valid) 4908 p->p_filesz = m->p_size; 4909 else 4910 abort (); 4911 p->p_memsz = p->p_filesz; 4912 p->p_align = 1; 4913 p->p_flags = (lp->p_flags & ~PF_W); 4914 } 4915 else 4916 { 4917 memset (p, 0, sizeof *p); 4918 p->p_type = PT_NULL; 4919 } 4920 } 4921 else if (m->count != 0) 4922 { 4923 if (p->p_type != PT_LOAD 4924 && (p->p_type != PT_NOTE 4925 || bfd_get_format (abfd) != bfd_core)) 4926 { 4927 BFD_ASSERT (!m->includes_filehdr && !m->includes_phdrs); 4928 4929 p->p_filesz = 0; 4930 p->p_offset = m->sections[0]->filepos; 4931 for (i = m->count; i-- != 0;) 4932 { 4933 asection *sect = m->sections[i]; 4934 Elf_Internal_Shdr *hdr = &elf_section_data (sect)->this_hdr; 4935 if (hdr->sh_type != SHT_NOBITS) 4936 { 4937 p->p_filesz = (sect->filepos - m->sections[0]->filepos 4938 + hdr->sh_size); 4939 break; 4940 } 4941 } 4942 } 4943 } 4944 else if (m->includes_filehdr) 4945 { 4946 p->p_vaddr = filehdr_vaddr; 4947 if (! m->p_paddr_valid) 4948 p->p_paddr = filehdr_paddr; 4949 } 4950 else if (m->includes_phdrs) 4951 { 4952 p->p_vaddr = phdrs_vaddr; 4953 if (! m->p_paddr_valid) 4954 p->p_paddr = phdrs_paddr; 4955 } 4956 } 4957 4958 elf_tdata (abfd)->next_file_pos = off; 4959 4960 return TRUE; 4961 } 4962 4963 /* Work out the file positions of all the sections. This is called by 4964 _bfd_elf_compute_section_file_positions. All the section sizes and 4965 VMAs must be known before this is called. 4966 4967 Reloc sections come in two flavours: Those processed specially as 4968 "side-channel" data attached to a section to which they apply, and 4969 those that bfd doesn't process as relocations. The latter sort are 4970 stored in a normal bfd section by bfd_section_from_shdr. We don't 4971 consider the former sort here, unless they form part of the loadable 4972 image. Reloc sections not assigned here will be handled later by 4973 assign_file_positions_for_relocs. 4974 4975 We also don't set the positions of the .symtab and .strtab here. */ 4976 4977 static bfd_boolean 4978 assign_file_positions_except_relocs (bfd *abfd, 4979 struct bfd_link_info *link_info) 4980 { 4981 struct elf_obj_tdata *tdata = elf_tdata (abfd); 4982 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd); 4983 file_ptr off; 4984 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 4985 4986 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 4987 && bfd_get_format (abfd) != bfd_core) 4988 { 4989 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd); 4990 unsigned int num_sec = elf_numsections (abfd); 4991 Elf_Internal_Shdr **hdrpp; 4992 unsigned int i; 4993 4994 /* Start after the ELF header. */ 4995 off = i_ehdrp->e_ehsize; 4996 4997 /* We are not creating an executable, which means that we are 4998 not creating a program header, and that the actual order of 4999 the sections in the file is unimportant. */ 5000 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++) 5001 { 5002 Elf_Internal_Shdr *hdr; 5003 5004 hdr = *hdrpp; 5005 if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA) 5006 && hdr->bfd_section == NULL) 5007 || i == tdata->symtab_section 5008 || i == tdata->symtab_shndx_section 5009 || i == tdata->strtab_section) 5010 { 5011 hdr->sh_offset = -1; 5012 } 5013 else 5014 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE); 5015 } 5016 } 5017 else 5018 { 5019 unsigned int alloc; 5020 5021 /* Assign file positions for the loaded sections based on the 5022 assignment of sections to segments. */ 5023 if (!assign_file_positions_for_load_sections (abfd, link_info)) 5024 return FALSE; 5025 5026 /* And for non-load sections. */ 5027 if (!assign_file_positions_for_non_load_sections (abfd, link_info)) 5028 return FALSE; 5029 5030 if (bed->elf_backend_modify_program_headers != NULL) 5031 { 5032 if (!(*bed->elf_backend_modify_program_headers) (abfd, link_info)) 5033 return FALSE; 5034 } 5035 5036 /* Write out the program headers. */ 5037 alloc = tdata->program_header_size / bed->s->sizeof_phdr; 5038 if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0 5039 || bed->s->write_out_phdrs (abfd, tdata->phdr, alloc) != 0) 5040 return FALSE; 5041 5042 off = tdata->next_file_pos; 5043 } 5044 5045 /* Place the section headers. */ 5046 off = align_file_position (off, 1 << bed->s->log_file_align); 5047 i_ehdrp->e_shoff = off; 5048 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize; 5049 5050 tdata->next_file_pos = off; 5051 5052 return TRUE; 5053 } 5054 5055 static bfd_boolean 5056 prep_headers (bfd *abfd) 5057 { 5058 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form. */ 5059 struct elf_strtab_hash *shstrtab; 5060 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 5061 5062 i_ehdrp = elf_elfheader (abfd); 5063 5064 shstrtab = _bfd_elf_strtab_init (); 5065 if (shstrtab == NULL) 5066 return FALSE; 5067 5068 elf_shstrtab (abfd) = shstrtab; 5069 5070 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0; 5071 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1; 5072 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2; 5073 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3; 5074 5075 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass; 5076 i_ehdrp->e_ident[EI_DATA] = 5077 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB; 5078 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current; 5079 5080 if ((abfd->flags & DYNAMIC) != 0) 5081 i_ehdrp->e_type = ET_DYN; 5082 else if ((abfd->flags & EXEC_P) != 0) 5083 i_ehdrp->e_type = ET_EXEC; 5084 else if (bfd_get_format (abfd) == bfd_core) 5085 i_ehdrp->e_type = ET_CORE; 5086 else 5087 i_ehdrp->e_type = ET_REL; 5088 5089 switch (bfd_get_arch (abfd)) 5090 { 5091 case bfd_arch_unknown: 5092 i_ehdrp->e_machine = EM_NONE; 5093 break; 5094 5095 /* There used to be a long list of cases here, each one setting 5096 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE 5097 in the corresponding bfd definition. To avoid duplication, 5098 the switch was removed. Machines that need special handling 5099 can generally do it in elf_backend_final_write_processing(), 5100 unless they need the information earlier than the final write. 5101 Such need can generally be supplied by replacing the tests for 5102 e_machine with the conditions used to determine it. */ 5103 default: 5104 i_ehdrp->e_machine = bed->elf_machine_code; 5105 } 5106 5107 i_ehdrp->e_version = bed->s->ev_current; 5108 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr; 5109 5110 /* No program header, for now. */ 5111 i_ehdrp->e_phoff = 0; 5112 i_ehdrp->e_phentsize = 0; 5113 i_ehdrp->e_phnum = 0; 5114 5115 /* Each bfd section is section header entry. */ 5116 i_ehdrp->e_entry = bfd_get_start_address (abfd); 5117 i_ehdrp->e_shentsize = bed->s->sizeof_shdr; 5118 5119 /* If we're building an executable, we'll need a program header table. */ 5120 if (abfd->flags & EXEC_P) 5121 /* It all happens later. */ 5122 ; 5123 else 5124 { 5125 i_ehdrp->e_phentsize = 0; 5126 i_ehdrp->e_phoff = 0; 5127 } 5128 5129 elf_tdata (abfd)->symtab_hdr.sh_name = 5130 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE); 5131 elf_tdata (abfd)->strtab_hdr.sh_name = 5132 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE); 5133 elf_tdata (abfd)->shstrtab_hdr.sh_name = 5134 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE); 5135 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1 5136 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1 5137 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1) 5138 return FALSE; 5139 5140 return TRUE; 5141 } 5142 5143 /* Assign file positions for all the reloc sections which are not part 5144 of the loadable file image. */ 5145 5146 void 5147 _bfd_elf_assign_file_positions_for_relocs (bfd *abfd) 5148 { 5149 file_ptr off; 5150 unsigned int i, num_sec; 5151 Elf_Internal_Shdr **shdrpp; 5152 5153 off = elf_tdata (abfd)->next_file_pos; 5154 5155 num_sec = elf_numsections (abfd); 5156 for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++) 5157 { 5158 Elf_Internal_Shdr *shdrp; 5159 5160 shdrp = *shdrpp; 5161 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA) 5162 && shdrp->sh_offset == -1) 5163 off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE); 5164 } 5165 5166 elf_tdata (abfd)->next_file_pos = off; 5167 } 5168 5169 bfd_boolean 5170 _bfd_elf_write_object_contents (bfd *abfd) 5171 { 5172 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 5173 Elf_Internal_Shdr **i_shdrp; 5174 bfd_boolean failed; 5175 unsigned int count, num_sec; 5176 5177 if (! abfd->output_has_begun 5178 && ! _bfd_elf_compute_section_file_positions (abfd, NULL)) 5179 return FALSE; 5180 5181 i_shdrp = elf_elfsections (abfd); 5182 5183 failed = FALSE; 5184 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed); 5185 if (failed) 5186 return FALSE; 5187 5188 _bfd_elf_assign_file_positions_for_relocs (abfd); 5189 5190 /* After writing the headers, we need to write the sections too... */ 5191 num_sec = elf_numsections (abfd); 5192 for (count = 1; count < num_sec; count++) 5193 { 5194 if (bed->elf_backend_section_processing) 5195 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]); 5196 if (i_shdrp[count]->contents) 5197 { 5198 bfd_size_type amt = i_shdrp[count]->sh_size; 5199 5200 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0 5201 || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt) 5202 return FALSE; 5203 } 5204 } 5205 5206 /* Write out the section header names. */ 5207 if (elf_shstrtab (abfd) != NULL 5208 && (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0 5209 || !_bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd)))) 5210 return FALSE; 5211 5212 if (bed->elf_backend_final_write_processing) 5213 (*bed->elf_backend_final_write_processing) (abfd, 5214 elf_tdata (abfd)->linker); 5215 5216 if (!bed->s->write_shdrs_and_ehdr (abfd)) 5217 return FALSE; 5218 5219 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */ 5220 if (elf_tdata (abfd)->after_write_object_contents) 5221 return (*elf_tdata (abfd)->after_write_object_contents) (abfd); 5222 5223 return TRUE; 5224 } 5225 5226 bfd_boolean 5227 _bfd_elf_write_corefile_contents (bfd *abfd) 5228 { 5229 /* Hopefully this can be done just like an object file. */ 5230 return _bfd_elf_write_object_contents (abfd); 5231 } 5232 5233 /* Given a section, search the header to find them. */ 5234 5235 unsigned int 5236 _bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect) 5237 { 5238 const struct elf_backend_data *bed; 5239 unsigned int sec_index; 5240 5241 if (elf_section_data (asect) != NULL 5242 && elf_section_data (asect)->this_idx != 0) 5243 return elf_section_data (asect)->this_idx; 5244 5245 if (bfd_is_abs_section (asect)) 5246 sec_index = SHN_ABS; 5247 else if (bfd_is_com_section (asect)) 5248 sec_index = SHN_COMMON; 5249 else if (bfd_is_und_section (asect)) 5250 sec_index = SHN_UNDEF; 5251 else 5252 sec_index = SHN_BAD; 5253 5254 bed = get_elf_backend_data (abfd); 5255 if (bed->elf_backend_section_from_bfd_section) 5256 { 5257 int retval = sec_index; 5258 5259 if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval)) 5260 return retval; 5261 } 5262 5263 if (sec_index == SHN_BAD) 5264 bfd_set_error (bfd_error_nonrepresentable_section); 5265 5266 return sec_index; 5267 } 5268 5269 /* Given a BFD symbol, return the index in the ELF symbol table, or -1 5270 on error. */ 5271 5272 int 5273 _bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr) 5274 { 5275 asymbol *asym_ptr = *asym_ptr_ptr; 5276 int idx; 5277 flagword flags = asym_ptr->flags; 5278 5279 /* When gas creates relocations against local labels, it creates its 5280 own symbol for the section, but does put the symbol into the 5281 symbol chain, so udata is 0. When the linker is generating 5282 relocatable output, this section symbol may be for one of the 5283 input sections rather than the output section. */ 5284 if (asym_ptr->udata.i == 0 5285 && (flags & BSF_SECTION_SYM) 5286 && asym_ptr->section) 5287 { 5288 asection *sec; 5289 int indx; 5290 5291 sec = asym_ptr->section; 5292 if (sec->owner != abfd && sec->output_section != NULL) 5293 sec = sec->output_section; 5294 if (sec->owner == abfd 5295 && (indx = sec->index) < elf_num_section_syms (abfd) 5296 && elf_section_syms (abfd)[indx] != NULL) 5297 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i; 5298 } 5299 5300 idx = asym_ptr->udata.i; 5301 5302 if (idx == 0) 5303 { 5304 /* This case can occur when using --strip-symbol on a symbol 5305 which is used in a relocation entry. */ 5306 (*_bfd_error_handler) 5307 (_("%B: symbol `%s' required but not present"), 5308 abfd, bfd_asymbol_name (asym_ptr)); 5309 bfd_set_error (bfd_error_no_symbols); 5310 return -1; 5311 } 5312 5313 #if DEBUG & 4 5314 { 5315 fprintf (stderr, 5316 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx\n", 5317 (long) asym_ptr, asym_ptr->name, idx, (long) flags); 5318 fflush (stderr); 5319 } 5320 #endif 5321 5322 return idx; 5323 } 5324 5325 /* Rewrite program header information. */ 5326 5327 static bfd_boolean 5328 rewrite_elf_program_header (bfd *ibfd, bfd *obfd) 5329 { 5330 Elf_Internal_Ehdr *iehdr; 5331 struct elf_segment_map *map; 5332 struct elf_segment_map *map_first; 5333 struct elf_segment_map **pointer_to_map; 5334 Elf_Internal_Phdr *segment; 5335 asection *section; 5336 unsigned int i; 5337 unsigned int num_segments; 5338 bfd_boolean phdr_included = FALSE; 5339 bfd_boolean p_paddr_valid; 5340 bfd_vma maxpagesize; 5341 struct elf_segment_map *phdr_adjust_seg = NULL; 5342 unsigned int phdr_adjust_num = 0; 5343 const struct elf_backend_data *bed; 5344 5345 bed = get_elf_backend_data (ibfd); 5346 iehdr = elf_elfheader (ibfd); 5347 5348 map_first = NULL; 5349 pointer_to_map = &map_first; 5350 5351 num_segments = elf_elfheader (ibfd)->e_phnum; 5352 maxpagesize = get_elf_backend_data (obfd)->maxpagesize; 5353 5354 /* Returns the end address of the segment + 1. */ 5355 #define SEGMENT_END(segment, start) \ 5356 (start + (segment->p_memsz > segment->p_filesz \ 5357 ? segment->p_memsz : segment->p_filesz)) 5358 5359 #define SECTION_SIZE(section, segment) \ 5360 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \ 5361 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \ 5362 ? section->size : 0) 5363 5364 /* Returns TRUE if the given section is contained within 5365 the given segment. VMA addresses are compared. */ 5366 #define IS_CONTAINED_BY_VMA(section, segment) \ 5367 (section->vma >= segment->p_vaddr \ 5368 && (section->vma + SECTION_SIZE (section, segment) \ 5369 <= (SEGMENT_END (segment, segment->p_vaddr)))) 5370 5371 /* Returns TRUE if the given section is contained within 5372 the given segment. LMA addresses are compared. */ 5373 #define IS_CONTAINED_BY_LMA(section, segment, base) \ 5374 (section->lma >= base \ 5375 && (section->lma + SECTION_SIZE (section, segment) \ 5376 <= SEGMENT_END (segment, base))) 5377 5378 /* Handle PT_NOTE segment. */ 5379 #define IS_NOTE(p, s) \ 5380 (p->p_type == PT_NOTE \ 5381 && elf_section_type (s) == SHT_NOTE \ 5382 && (bfd_vma) s->filepos >= p->p_offset \ 5383 && ((bfd_vma) s->filepos + s->size \ 5384 <= p->p_offset + p->p_filesz)) 5385 5386 /* Special case: corefile "NOTE" section containing regs, prpsinfo 5387 etc. */ 5388 #define IS_COREFILE_NOTE(p, s) \ 5389 (IS_NOTE (p, s) \ 5390 && bfd_get_format (ibfd) == bfd_core \ 5391 && s->vma == 0 \ 5392 && s->lma == 0) 5393 5394 /* The complicated case when p_vaddr is 0 is to handle the Solaris 5395 linker, which generates a PT_INTERP section with p_vaddr and 5396 p_memsz set to 0. */ 5397 #define IS_SOLARIS_PT_INTERP(p, s) \ 5398 (p->p_vaddr == 0 \ 5399 && p->p_paddr == 0 \ 5400 && p->p_memsz == 0 \ 5401 && p->p_filesz > 0 \ 5402 && (s->flags & SEC_HAS_CONTENTS) != 0 \ 5403 && s->size > 0 \ 5404 && (bfd_vma) s->filepos >= p->p_offset \ 5405 && ((bfd_vma) s->filepos + s->size \ 5406 <= p->p_offset + p->p_filesz)) 5407 5408 /* Decide if the given section should be included in the given segment. 5409 A section will be included if: 5410 1. It is within the address space of the segment -- we use the LMA 5411 if that is set for the segment and the VMA otherwise, 5412 2. It is an allocated section or a NOTE section in a PT_NOTE 5413 segment. 5414 3. There is an output section associated with it, 5415 4. The section has not already been allocated to a previous segment. 5416 5. PT_GNU_STACK segments do not include any sections. 5417 6. PT_TLS segment includes only SHF_TLS sections. 5418 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments. 5419 8. PT_DYNAMIC should not contain empty sections at the beginning 5420 (with the possible exception of .dynamic). */ 5421 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \ 5422 ((((segment->p_paddr \ 5423 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \ 5424 : IS_CONTAINED_BY_VMA (section, segment)) \ 5425 && (section->flags & SEC_ALLOC) != 0) \ 5426 || IS_NOTE (segment, section)) \ 5427 && segment->p_type != PT_GNU_STACK \ 5428 && (segment->p_type != PT_TLS \ 5429 || (section->flags & SEC_THREAD_LOCAL)) \ 5430 && (segment->p_type == PT_LOAD \ 5431 || segment->p_type == PT_TLS \ 5432 || (section->flags & SEC_THREAD_LOCAL) == 0) \ 5433 && (segment->p_type != PT_DYNAMIC \ 5434 || SECTION_SIZE (section, segment) > 0 \ 5435 || (segment->p_paddr \ 5436 ? segment->p_paddr != section->lma \ 5437 : segment->p_vaddr != section->vma) \ 5438 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \ 5439 == 0)) \ 5440 && !section->segment_mark) 5441 5442 /* If the output section of a section in the input segment is NULL, 5443 it is removed from the corresponding output segment. */ 5444 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \ 5445 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \ 5446 && section->output_section != NULL) 5447 5448 /* Returns TRUE iff seg1 starts after the end of seg2. */ 5449 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \ 5450 (seg1->field >= SEGMENT_END (seg2, seg2->field)) 5451 5452 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both 5453 their VMA address ranges and their LMA address ranges overlap. 5454 It is possible to have overlapping VMA ranges without overlapping LMA 5455 ranges. RedBoot images for example can have both .data and .bss mapped 5456 to the same VMA range, but with the .data section mapped to a different 5457 LMA. */ 5458 #define SEGMENT_OVERLAPS(seg1, seg2) \ 5459 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \ 5460 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \ 5461 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \ 5462 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr))) 5463 5464 /* Initialise the segment mark field. */ 5465 for (section = ibfd->sections; section != NULL; section = section->next) 5466 section->segment_mark = FALSE; 5467 5468 /* The Solaris linker creates program headers in which all the 5469 p_paddr fields are zero. When we try to objcopy or strip such a 5470 file, we get confused. Check for this case, and if we find it 5471 don't set the p_paddr_valid fields. */ 5472 p_paddr_valid = FALSE; 5473 for (i = 0, segment = elf_tdata (ibfd)->phdr; 5474 i < num_segments; 5475 i++, segment++) 5476 if (segment->p_paddr != 0) 5477 { 5478 p_paddr_valid = TRUE; 5479 break; 5480 } 5481 5482 /* Scan through the segments specified in the program header 5483 of the input BFD. For this first scan we look for overlaps 5484 in the loadable segments. These can be created by weird 5485 parameters to objcopy. Also, fix some solaris weirdness. */ 5486 for (i = 0, segment = elf_tdata (ibfd)->phdr; 5487 i < num_segments; 5488 i++, segment++) 5489 { 5490 unsigned int j; 5491 Elf_Internal_Phdr *segment2; 5492 5493 if (segment->p_type == PT_INTERP) 5494 for (section = ibfd->sections; section; section = section->next) 5495 if (IS_SOLARIS_PT_INTERP (segment, section)) 5496 { 5497 /* Mininal change so that the normal section to segment 5498 assignment code will work. */ 5499 segment->p_vaddr = section->vma; 5500 break; 5501 } 5502 5503 if (segment->p_type != PT_LOAD) 5504 { 5505 /* Remove PT_GNU_RELRO segment. */ 5506 if (segment->p_type == PT_GNU_RELRO) 5507 segment->p_type = PT_NULL; 5508 continue; 5509 } 5510 5511 /* Determine if this segment overlaps any previous segments. */ 5512 for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2++) 5513 { 5514 bfd_signed_vma extra_length; 5515 5516 if (segment2->p_type != PT_LOAD 5517 || !SEGMENT_OVERLAPS (segment, segment2)) 5518 continue; 5519 5520 /* Merge the two segments together. */ 5521 if (segment2->p_vaddr < segment->p_vaddr) 5522 { 5523 /* Extend SEGMENT2 to include SEGMENT and then delete 5524 SEGMENT. */ 5525 extra_length = (SEGMENT_END (segment, segment->p_vaddr) 5526 - SEGMENT_END (segment2, segment2->p_vaddr)); 5527 5528 if (extra_length > 0) 5529 { 5530 segment2->p_memsz += extra_length; 5531 segment2->p_filesz += extra_length; 5532 } 5533 5534 segment->p_type = PT_NULL; 5535 5536 /* Since we have deleted P we must restart the outer loop. */ 5537 i = 0; 5538 segment = elf_tdata (ibfd)->phdr; 5539 break; 5540 } 5541 else 5542 { 5543 /* Extend SEGMENT to include SEGMENT2 and then delete 5544 SEGMENT2. */ 5545 extra_length = (SEGMENT_END (segment2, segment2->p_vaddr) 5546 - SEGMENT_END (segment, segment->p_vaddr)); 5547 5548 if (extra_length > 0) 5549 { 5550 segment->p_memsz += extra_length; 5551 segment->p_filesz += extra_length; 5552 } 5553 5554 segment2->p_type = PT_NULL; 5555 } 5556 } 5557 } 5558 5559 /* The second scan attempts to assign sections to segments. */ 5560 for (i = 0, segment = elf_tdata (ibfd)->phdr; 5561 i < num_segments; 5562 i++, segment++) 5563 { 5564 unsigned int section_count; 5565 asection **sections; 5566 asection *output_section; 5567 unsigned int isec; 5568 bfd_vma matching_lma; 5569 bfd_vma suggested_lma; 5570 unsigned int j; 5571 bfd_size_type amt; 5572 asection *first_section; 5573 bfd_boolean first_matching_lma; 5574 bfd_boolean first_suggested_lma; 5575 5576 if (segment->p_type == PT_NULL) 5577 continue; 5578 5579 first_section = NULL; 5580 /* Compute how many sections might be placed into this segment. */ 5581 for (section = ibfd->sections, section_count = 0; 5582 section != NULL; 5583 section = section->next) 5584 { 5585 /* Find the first section in the input segment, which may be 5586 removed from the corresponding output segment. */ 5587 if (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed)) 5588 { 5589 if (first_section == NULL) 5590 first_section = section; 5591 if (section->output_section != NULL) 5592 ++section_count; 5593 } 5594 } 5595 5596 /* Allocate a segment map big enough to contain 5597 all of the sections we have selected. */ 5598 amt = sizeof (struct elf_segment_map); 5599 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *); 5600 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt); 5601 if (map == NULL) 5602 return FALSE; 5603 5604 /* Initialise the fields of the segment map. Default to 5605 using the physical address of the segment in the input BFD. */ 5606 map->next = NULL; 5607 map->p_type = segment->p_type; 5608 map->p_flags = segment->p_flags; 5609 map->p_flags_valid = 1; 5610 5611 /* If the first section in the input segment is removed, there is 5612 no need to preserve segment physical address in the corresponding 5613 output segment. */ 5614 if (!first_section || first_section->output_section != NULL) 5615 { 5616 map->p_paddr = segment->p_paddr; 5617 map->p_paddr_valid = p_paddr_valid; 5618 } 5619 5620 /* Determine if this segment contains the ELF file header 5621 and if it contains the program headers themselves. */ 5622 map->includes_filehdr = (segment->p_offset == 0 5623 && segment->p_filesz >= iehdr->e_ehsize); 5624 map->includes_phdrs = 0; 5625 5626 if (!phdr_included || segment->p_type != PT_LOAD) 5627 { 5628 map->includes_phdrs = 5629 (segment->p_offset <= (bfd_vma) iehdr->e_phoff 5630 && (segment->p_offset + segment->p_filesz 5631 >= ((bfd_vma) iehdr->e_phoff 5632 + iehdr->e_phnum * iehdr->e_phentsize))); 5633 5634 if (segment->p_type == PT_LOAD && map->includes_phdrs) 5635 phdr_included = TRUE; 5636 } 5637 5638 if (section_count == 0) 5639 { 5640 /* Special segments, such as the PT_PHDR segment, may contain 5641 no sections, but ordinary, loadable segments should contain 5642 something. They are allowed by the ELF spec however, so only 5643 a warning is produced. */ 5644 if (segment->p_type == PT_LOAD) 5645 (*_bfd_error_handler) (_("%B: warning: Empty loadable segment" 5646 " detected, is this intentional ?\n"), 5647 ibfd); 5648 5649 map->count = 0; 5650 *pointer_to_map = map; 5651 pointer_to_map = &map->next; 5652 5653 continue; 5654 } 5655 5656 /* Now scan the sections in the input BFD again and attempt 5657 to add their corresponding output sections to the segment map. 5658 The problem here is how to handle an output section which has 5659 been moved (ie had its LMA changed). There are four possibilities: 5660 5661 1. None of the sections have been moved. 5662 In this case we can continue to use the segment LMA from the 5663 input BFD. 5664 5665 2. All of the sections have been moved by the same amount. 5666 In this case we can change the segment's LMA to match the LMA 5667 of the first section. 5668 5669 3. Some of the sections have been moved, others have not. 5670 In this case those sections which have not been moved can be 5671 placed in the current segment which will have to have its size, 5672 and possibly its LMA changed, and a new segment or segments will 5673 have to be created to contain the other sections. 5674 5675 4. The sections have been moved, but not by the same amount. 5676 In this case we can change the segment's LMA to match the LMA 5677 of the first section and we will have to create a new segment 5678 or segments to contain the other sections. 5679 5680 In order to save time, we allocate an array to hold the section 5681 pointers that we are interested in. As these sections get assigned 5682 to a segment, they are removed from this array. */ 5683 5684 sections = (asection **) bfd_malloc2 (section_count, sizeof (asection *)); 5685 if (sections == NULL) 5686 return FALSE; 5687 5688 /* Step One: Scan for segment vs section LMA conflicts. 5689 Also add the sections to the section array allocated above. 5690 Also add the sections to the current segment. In the common 5691 case, where the sections have not been moved, this means that 5692 we have completely filled the segment, and there is nothing 5693 more to do. */ 5694 isec = 0; 5695 matching_lma = 0; 5696 suggested_lma = 0; 5697 first_matching_lma = TRUE; 5698 first_suggested_lma = TRUE; 5699 5700 for (section = ibfd->sections; 5701 section != NULL; 5702 section = section->next) 5703 if (section == first_section) 5704 break; 5705 5706 for (j = 0; section != NULL; section = section->next) 5707 { 5708 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed)) 5709 { 5710 output_section = section->output_section; 5711 5712 sections[j++] = section; 5713 5714 /* The Solaris native linker always sets p_paddr to 0. 5715 We try to catch that case here, and set it to the 5716 correct value. Note - some backends require that 5717 p_paddr be left as zero. */ 5718 if (!p_paddr_valid 5719 && segment->p_vaddr != 0 5720 && !bed->want_p_paddr_set_to_zero 5721 && isec == 0 5722 && output_section->lma != 0 5723 && output_section->vma == (segment->p_vaddr 5724 + (map->includes_filehdr 5725 ? iehdr->e_ehsize 5726 : 0) 5727 + (map->includes_phdrs 5728 ? (iehdr->e_phnum 5729 * iehdr->e_phentsize) 5730 : 0))) 5731 map->p_paddr = segment->p_vaddr; 5732 5733 /* Match up the physical address of the segment with the 5734 LMA address of the output section. */ 5735 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr) 5736 || IS_COREFILE_NOTE (segment, section) 5737 || (bed->want_p_paddr_set_to_zero 5738 && IS_CONTAINED_BY_VMA (output_section, segment))) 5739 { 5740 if (first_matching_lma || output_section->lma < matching_lma) 5741 { 5742 matching_lma = output_section->lma; 5743 first_matching_lma = FALSE; 5744 } 5745 5746 /* We assume that if the section fits within the segment 5747 then it does not overlap any other section within that 5748 segment. */ 5749 map->sections[isec++] = output_section; 5750 } 5751 else if (first_suggested_lma) 5752 { 5753 suggested_lma = output_section->lma; 5754 first_suggested_lma = FALSE; 5755 } 5756 5757 if (j == section_count) 5758 break; 5759 } 5760 } 5761 5762 BFD_ASSERT (j == section_count); 5763 5764 /* Step Two: Adjust the physical address of the current segment, 5765 if necessary. */ 5766 if (isec == section_count) 5767 { 5768 /* All of the sections fitted within the segment as currently 5769 specified. This is the default case. Add the segment to 5770 the list of built segments and carry on to process the next 5771 program header in the input BFD. */ 5772 map->count = section_count; 5773 *pointer_to_map = map; 5774 pointer_to_map = &map->next; 5775 5776 if (p_paddr_valid 5777 && !bed->want_p_paddr_set_to_zero 5778 && matching_lma != map->p_paddr 5779 && !map->includes_filehdr 5780 && !map->includes_phdrs) 5781 /* There is some padding before the first section in the 5782 segment. So, we must account for that in the output 5783 segment's vma. */ 5784 map->p_vaddr_offset = matching_lma - map->p_paddr; 5785 5786 free (sections); 5787 continue; 5788 } 5789 else 5790 { 5791 if (!first_matching_lma) 5792 { 5793 /* At least one section fits inside the current segment. 5794 Keep it, but modify its physical address to match the 5795 LMA of the first section that fitted. */ 5796 map->p_paddr = matching_lma; 5797 } 5798 else 5799 { 5800 /* None of the sections fitted inside the current segment. 5801 Change the current segment's physical address to match 5802 the LMA of the first section. */ 5803 map->p_paddr = suggested_lma; 5804 } 5805 5806 /* Offset the segment physical address from the lma 5807 to allow for space taken up by elf headers. */ 5808 if (map->includes_filehdr) 5809 { 5810 if (map->p_paddr >= iehdr->e_ehsize) 5811 map->p_paddr -= iehdr->e_ehsize; 5812 else 5813 { 5814 map->includes_filehdr = FALSE; 5815 map->includes_phdrs = FALSE; 5816 } 5817 } 5818 5819 if (map->includes_phdrs) 5820 { 5821 if (map->p_paddr >= iehdr->e_phnum * iehdr->e_phentsize) 5822 { 5823 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize; 5824 5825 /* iehdr->e_phnum is just an estimate of the number 5826 of program headers that we will need. Make a note 5827 here of the number we used and the segment we chose 5828 to hold these headers, so that we can adjust the 5829 offset when we know the correct value. */ 5830 phdr_adjust_num = iehdr->e_phnum; 5831 phdr_adjust_seg = map; 5832 } 5833 else 5834 map->includes_phdrs = FALSE; 5835 } 5836 } 5837 5838 /* Step Three: Loop over the sections again, this time assigning 5839 those that fit to the current segment and removing them from the 5840 sections array; but making sure not to leave large gaps. Once all 5841 possible sections have been assigned to the current segment it is 5842 added to the list of built segments and if sections still remain 5843 to be assigned, a new segment is constructed before repeating 5844 the loop. */ 5845 isec = 0; 5846 do 5847 { 5848 map->count = 0; 5849 suggested_lma = 0; 5850 first_suggested_lma = TRUE; 5851 5852 /* Fill the current segment with sections that fit. */ 5853 for (j = 0; j < section_count; j++) 5854 { 5855 section = sections[j]; 5856 5857 if (section == NULL) 5858 continue; 5859 5860 output_section = section->output_section; 5861 5862 BFD_ASSERT (output_section != NULL); 5863 5864 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr) 5865 || IS_COREFILE_NOTE (segment, section)) 5866 { 5867 if (map->count == 0) 5868 { 5869 /* If the first section in a segment does not start at 5870 the beginning of the segment, then something is 5871 wrong. */ 5872 if (output_section->lma 5873 != (map->p_paddr 5874 + (map->includes_filehdr ? iehdr->e_ehsize : 0) 5875 + (map->includes_phdrs 5876 ? iehdr->e_phnum * iehdr->e_phentsize 5877 : 0))) 5878 abort (); 5879 } 5880 else 5881 { 5882 asection *prev_sec; 5883 5884 prev_sec = map->sections[map->count - 1]; 5885 5886 /* If the gap between the end of the previous section 5887 and the start of this section is more than 5888 maxpagesize then we need to start a new segment. */ 5889 if ((BFD_ALIGN (prev_sec->lma + prev_sec->size, 5890 maxpagesize) 5891 < BFD_ALIGN (output_section->lma, maxpagesize)) 5892 || (prev_sec->lma + prev_sec->size 5893 > output_section->lma)) 5894 { 5895 if (first_suggested_lma) 5896 { 5897 suggested_lma = output_section->lma; 5898 first_suggested_lma = FALSE; 5899 } 5900 5901 continue; 5902 } 5903 } 5904 5905 map->sections[map->count++] = output_section; 5906 ++isec; 5907 sections[j] = NULL; 5908 section->segment_mark = TRUE; 5909 } 5910 else if (first_suggested_lma) 5911 { 5912 suggested_lma = output_section->lma; 5913 first_suggested_lma = FALSE; 5914 } 5915 } 5916 5917 BFD_ASSERT (map->count > 0); 5918 5919 /* Add the current segment to the list of built segments. */ 5920 *pointer_to_map = map; 5921 pointer_to_map = &map->next; 5922 5923 if (isec < section_count) 5924 { 5925 /* We still have not allocated all of the sections to 5926 segments. Create a new segment here, initialise it 5927 and carry on looping. */ 5928 amt = sizeof (struct elf_segment_map); 5929 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *); 5930 map = (struct elf_segment_map *) bfd_alloc (obfd, amt); 5931 if (map == NULL) 5932 { 5933 free (sections); 5934 return FALSE; 5935 } 5936 5937 /* Initialise the fields of the segment map. Set the physical 5938 physical address to the LMA of the first section that has 5939 not yet been assigned. */ 5940 map->next = NULL; 5941 map->p_type = segment->p_type; 5942 map->p_flags = segment->p_flags; 5943 map->p_flags_valid = 1; 5944 map->p_paddr = suggested_lma; 5945 map->p_paddr_valid = p_paddr_valid; 5946 map->includes_filehdr = 0; 5947 map->includes_phdrs = 0; 5948 } 5949 } 5950 while (isec < section_count); 5951 5952 free (sections); 5953 } 5954 5955 elf_tdata (obfd)->segment_map = map_first; 5956 5957 /* If we had to estimate the number of program headers that were 5958 going to be needed, then check our estimate now and adjust 5959 the offset if necessary. */ 5960 if (phdr_adjust_seg != NULL) 5961 { 5962 unsigned int count; 5963 5964 for (count = 0, map = map_first; map != NULL; map = map->next) 5965 count++; 5966 5967 if (count > phdr_adjust_num) 5968 phdr_adjust_seg->p_paddr 5969 -= (count - phdr_adjust_num) * iehdr->e_phentsize; 5970 } 5971 5972 #undef SEGMENT_END 5973 #undef SECTION_SIZE 5974 #undef IS_CONTAINED_BY_VMA 5975 #undef IS_CONTAINED_BY_LMA 5976 #undef IS_NOTE 5977 #undef IS_COREFILE_NOTE 5978 #undef IS_SOLARIS_PT_INTERP 5979 #undef IS_SECTION_IN_INPUT_SEGMENT 5980 #undef INCLUDE_SECTION_IN_SEGMENT 5981 #undef SEGMENT_AFTER_SEGMENT 5982 #undef SEGMENT_OVERLAPS 5983 return TRUE; 5984 } 5985 5986 /* Copy ELF program header information. */ 5987 5988 static bfd_boolean 5989 copy_elf_program_header (bfd *ibfd, bfd *obfd) 5990 { 5991 Elf_Internal_Ehdr *iehdr; 5992 struct elf_segment_map *map; 5993 struct elf_segment_map *map_first; 5994 struct elf_segment_map **pointer_to_map; 5995 Elf_Internal_Phdr *segment; 5996 unsigned int i; 5997 unsigned int num_segments; 5998 bfd_boolean phdr_included = FALSE; 5999 bfd_boolean p_paddr_valid; 6000 6001 iehdr = elf_elfheader (ibfd); 6002 6003 map_first = NULL; 6004 pointer_to_map = &map_first; 6005 6006 /* If all the segment p_paddr fields are zero, don't set 6007 map->p_paddr_valid. */ 6008 p_paddr_valid = FALSE; 6009 num_segments = elf_elfheader (ibfd)->e_phnum; 6010 for (i = 0, segment = elf_tdata (ibfd)->phdr; 6011 i < num_segments; 6012 i++, segment++) 6013 if (segment->p_paddr != 0) 6014 { 6015 p_paddr_valid = TRUE; 6016 break; 6017 } 6018 6019 for (i = 0, segment = elf_tdata (ibfd)->phdr; 6020 i < num_segments; 6021 i++, segment++) 6022 { 6023 asection *section; 6024 unsigned int section_count; 6025 bfd_size_type amt; 6026 Elf_Internal_Shdr *this_hdr; 6027 asection *first_section = NULL; 6028 asection *lowest_section; 6029 6030 /* Compute how many sections are in this segment. */ 6031 for (section = ibfd->sections, section_count = 0; 6032 section != NULL; 6033 section = section->next) 6034 { 6035 this_hdr = &(elf_section_data(section)->this_hdr); 6036 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment)) 6037 { 6038 if (first_section == NULL) 6039 first_section = section; 6040 section_count++; 6041 } 6042 } 6043 6044 /* Allocate a segment map big enough to contain 6045 all of the sections we have selected. */ 6046 amt = sizeof (struct elf_segment_map); 6047 if (section_count != 0) 6048 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *); 6049 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt); 6050 if (map == NULL) 6051 return FALSE; 6052 6053 /* Initialize the fields of the output segment map with the 6054 input segment. */ 6055 map->next = NULL; 6056 map->p_type = segment->p_type; 6057 map->p_flags = segment->p_flags; 6058 map->p_flags_valid = 1; 6059 map->p_paddr = segment->p_paddr; 6060 map->p_paddr_valid = p_paddr_valid; 6061 map->p_align = segment->p_align; 6062 map->p_align_valid = 1; 6063 map->p_vaddr_offset = 0; 6064 6065 if (map->p_type == PT_GNU_RELRO) 6066 { 6067 /* The PT_GNU_RELRO segment may contain the first a few 6068 bytes in the .got.plt section even if the whole .got.plt 6069 section isn't in the PT_GNU_RELRO segment. We won't 6070 change the size of the PT_GNU_RELRO segment. */ 6071 map->p_size = segment->p_memsz; 6072 map->p_size_valid = 1; 6073 } 6074 6075 /* Determine if this segment contains the ELF file header 6076 and if it contains the program headers themselves. */ 6077 map->includes_filehdr = (segment->p_offset == 0 6078 && segment->p_filesz >= iehdr->e_ehsize); 6079 6080 map->includes_phdrs = 0; 6081 if (! phdr_included || segment->p_type != PT_LOAD) 6082 { 6083 map->includes_phdrs = 6084 (segment->p_offset <= (bfd_vma) iehdr->e_phoff 6085 && (segment->p_offset + segment->p_filesz 6086 >= ((bfd_vma) iehdr->e_phoff 6087 + iehdr->e_phnum * iehdr->e_phentsize))); 6088 6089 if (segment->p_type == PT_LOAD && map->includes_phdrs) 6090 phdr_included = TRUE; 6091 } 6092 6093 lowest_section = first_section; 6094 if (section_count != 0) 6095 { 6096 unsigned int isec = 0; 6097 6098 for (section = first_section; 6099 section != NULL; 6100 section = section->next) 6101 { 6102 this_hdr = &(elf_section_data(section)->this_hdr); 6103 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment)) 6104 { 6105 map->sections[isec++] = section->output_section; 6106 if (section->lma < lowest_section->lma) 6107 lowest_section = section; 6108 if ((section->flags & SEC_ALLOC) != 0) 6109 { 6110 bfd_vma seg_off; 6111 6112 /* Section lmas are set up from PT_LOAD header 6113 p_paddr in _bfd_elf_make_section_from_shdr. 6114 If this header has a p_paddr that disagrees 6115 with the section lma, flag the p_paddr as 6116 invalid. */ 6117 if ((section->flags & SEC_LOAD) != 0) 6118 seg_off = this_hdr->sh_offset - segment->p_offset; 6119 else 6120 seg_off = this_hdr->sh_addr - segment->p_vaddr; 6121 if (section->lma - segment->p_paddr != seg_off) 6122 map->p_paddr_valid = FALSE; 6123 } 6124 if (isec == section_count) 6125 break; 6126 } 6127 } 6128 } 6129 6130 if (map->includes_filehdr && lowest_section != NULL) 6131 /* We need to keep the space used by the headers fixed. */ 6132 map->header_size = lowest_section->vma - segment->p_vaddr; 6133 6134 if (!map->includes_phdrs 6135 && !map->includes_filehdr 6136 && map->p_paddr_valid) 6137 /* There is some other padding before the first section. */ 6138 map->p_vaddr_offset = ((lowest_section ? lowest_section->lma : 0) 6139 - segment->p_paddr); 6140 6141 map->count = section_count; 6142 *pointer_to_map = map; 6143 pointer_to_map = &map->next; 6144 } 6145 6146 elf_tdata (obfd)->segment_map = map_first; 6147 return TRUE; 6148 } 6149 6150 /* Copy private BFD data. This copies or rewrites ELF program header 6151 information. */ 6152 6153 static bfd_boolean 6154 copy_private_bfd_data (bfd *ibfd, bfd *obfd) 6155 { 6156 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 6157 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 6158 return TRUE; 6159 6160 if (elf_tdata (ibfd)->phdr == NULL) 6161 return TRUE; 6162 6163 if (ibfd->xvec == obfd->xvec) 6164 { 6165 /* Check to see if any sections in the input BFD 6166 covered by ELF program header have changed. */ 6167 Elf_Internal_Phdr *segment; 6168 asection *section, *osec; 6169 unsigned int i, num_segments; 6170 Elf_Internal_Shdr *this_hdr; 6171 const struct elf_backend_data *bed; 6172 6173 bed = get_elf_backend_data (ibfd); 6174 6175 /* Regenerate the segment map if p_paddr is set to 0. */ 6176 if (bed->want_p_paddr_set_to_zero) 6177 goto rewrite; 6178 6179 /* Initialize the segment mark field. */ 6180 for (section = obfd->sections; section != NULL; 6181 section = section->next) 6182 section->segment_mark = FALSE; 6183 6184 num_segments = elf_elfheader (ibfd)->e_phnum; 6185 for (i = 0, segment = elf_tdata (ibfd)->phdr; 6186 i < num_segments; 6187 i++, segment++) 6188 { 6189 /* PR binutils/3535. The Solaris linker always sets the p_paddr 6190 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0 6191 which severly confuses things, so always regenerate the segment 6192 map in this case. */ 6193 if (segment->p_paddr == 0 6194 && segment->p_memsz == 0 6195 && (segment->p_type == PT_INTERP || segment->p_type == PT_DYNAMIC)) 6196 goto rewrite; 6197 6198 for (section = ibfd->sections; 6199 section != NULL; section = section->next) 6200 { 6201 /* We mark the output section so that we know it comes 6202 from the input BFD. */ 6203 osec = section->output_section; 6204 if (osec) 6205 osec->segment_mark = TRUE; 6206 6207 /* Check if this section is covered by the segment. */ 6208 this_hdr = &(elf_section_data(section)->this_hdr); 6209 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment)) 6210 { 6211 /* FIXME: Check if its output section is changed or 6212 removed. What else do we need to check? */ 6213 if (osec == NULL 6214 || section->flags != osec->flags 6215 || section->lma != osec->lma 6216 || section->vma != osec->vma 6217 || section->size != osec->size 6218 || section->rawsize != osec->rawsize 6219 || section->alignment_power != osec->alignment_power) 6220 goto rewrite; 6221 } 6222 } 6223 } 6224 6225 /* Check to see if any output section do not come from the 6226 input BFD. */ 6227 for (section = obfd->sections; section != NULL; 6228 section = section->next) 6229 { 6230 if (section->segment_mark == FALSE) 6231 goto rewrite; 6232 else 6233 section->segment_mark = FALSE; 6234 } 6235 6236 return copy_elf_program_header (ibfd, obfd); 6237 } 6238 6239 rewrite: 6240 return rewrite_elf_program_header (ibfd, obfd); 6241 } 6242 6243 /* Initialize private output section information from input section. */ 6244 6245 bfd_boolean 6246 _bfd_elf_init_private_section_data (bfd *ibfd, 6247 asection *isec, 6248 bfd *obfd, 6249 asection *osec, 6250 struct bfd_link_info *link_info) 6251 6252 { 6253 Elf_Internal_Shdr *ihdr, *ohdr; 6254 bfd_boolean final_link = link_info != NULL && !link_info->relocatable; 6255 6256 if (ibfd->xvec->flavour != bfd_target_elf_flavour 6257 || obfd->xvec->flavour != bfd_target_elf_flavour) 6258 return TRUE; 6259 6260 /* For objcopy and relocatable link, don't copy the output ELF 6261 section type from input if the output BFD section flags have been 6262 set to something different. For a final link allow some flags 6263 that the linker clears to differ. */ 6264 if (elf_section_type (osec) == SHT_NULL 6265 && (osec->flags == isec->flags 6266 || (final_link 6267 && ((osec->flags ^ isec->flags) 6268 & ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC)) == 0))) 6269 elf_section_type (osec) = elf_section_type (isec); 6270 6271 /* FIXME: Is this correct for all OS/PROC specific flags? */ 6272 elf_section_flags (osec) |= (elf_section_flags (isec) 6273 & (SHF_MASKOS | SHF_MASKPROC)); 6274 6275 /* Set things up for objcopy and relocatable link. The output 6276 SHT_GROUP section will have its elf_next_in_group pointing back 6277 to the input group members. Ignore linker created group section. 6278 See elfNN_ia64_object_p in elfxx-ia64.c. */ 6279 if (!final_link) 6280 { 6281 if (elf_sec_group (isec) == NULL 6282 || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0) 6283 { 6284 if (elf_section_flags (isec) & SHF_GROUP) 6285 elf_section_flags (osec) |= SHF_GROUP; 6286 elf_next_in_group (osec) = elf_next_in_group (isec); 6287 elf_section_data (osec)->group = elf_section_data (isec)->group; 6288 } 6289 } 6290 6291 ihdr = &elf_section_data (isec)->this_hdr; 6292 6293 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We 6294 don't use the output section of the linked-to section since it 6295 may be NULL at this point. */ 6296 if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0) 6297 { 6298 ohdr = &elf_section_data (osec)->this_hdr; 6299 ohdr->sh_flags |= SHF_LINK_ORDER; 6300 elf_linked_to_section (osec) = elf_linked_to_section (isec); 6301 } 6302 6303 osec->use_rela_p = isec->use_rela_p; 6304 6305 return TRUE; 6306 } 6307 6308 /* Copy private section information. This copies over the entsize 6309 field, and sometimes the info field. */ 6310 6311 bfd_boolean 6312 _bfd_elf_copy_private_section_data (bfd *ibfd, 6313 asection *isec, 6314 bfd *obfd, 6315 asection *osec) 6316 { 6317 Elf_Internal_Shdr *ihdr, *ohdr; 6318 6319 if (ibfd->xvec->flavour != bfd_target_elf_flavour 6320 || obfd->xvec->flavour != bfd_target_elf_flavour) 6321 return TRUE; 6322 6323 ihdr = &elf_section_data (isec)->this_hdr; 6324 ohdr = &elf_section_data (osec)->this_hdr; 6325 6326 ohdr->sh_entsize = ihdr->sh_entsize; 6327 6328 if (ihdr->sh_type == SHT_SYMTAB 6329 || ihdr->sh_type == SHT_DYNSYM 6330 || ihdr->sh_type == SHT_GNU_verneed 6331 || ihdr->sh_type == SHT_GNU_verdef) 6332 ohdr->sh_info = ihdr->sh_info; 6333 6334 return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec, 6335 NULL); 6336 } 6337 6338 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments 6339 necessary if we are removing either the SHT_GROUP section or any of 6340 the group member sections. DISCARDED is the value that a section's 6341 output_section has if the section will be discarded, NULL when this 6342 function is called from objcopy, bfd_abs_section_ptr when called 6343 from the linker. */ 6344 6345 bfd_boolean 6346 _bfd_elf_fixup_group_sections (bfd *ibfd, asection *discarded) 6347 { 6348 asection *isec; 6349 6350 for (isec = ibfd->sections; isec != NULL; isec = isec->next) 6351 if (elf_section_type (isec) == SHT_GROUP) 6352 { 6353 asection *first = elf_next_in_group (isec); 6354 asection *s = first; 6355 bfd_size_type removed = 0; 6356 6357 while (s != NULL) 6358 { 6359 /* If this member section is being output but the 6360 SHT_GROUP section is not, then clear the group info 6361 set up by _bfd_elf_copy_private_section_data. */ 6362 if (s->output_section != discarded 6363 && isec->output_section == discarded) 6364 { 6365 elf_section_flags (s->output_section) &= ~SHF_GROUP; 6366 elf_group_name (s->output_section) = NULL; 6367 } 6368 /* Conversely, if the member section is not being output 6369 but the SHT_GROUP section is, then adjust its size. */ 6370 else if (s->output_section == discarded 6371 && isec->output_section != discarded) 6372 removed += 4; 6373 s = elf_next_in_group (s); 6374 if (s == first) 6375 break; 6376 } 6377 if (removed != 0) 6378 { 6379 if (discarded != NULL) 6380 { 6381 /* If we've been called for ld -r, then we need to 6382 adjust the input section size. This function may 6383 be called multiple times, so save the original 6384 size. */ 6385 if (isec->rawsize == 0) 6386 isec->rawsize = isec->size; 6387 isec->size = isec->rawsize - removed; 6388 } 6389 else 6390 { 6391 /* Adjust the output section size when called from 6392 objcopy. */ 6393 isec->output_section->size -= removed; 6394 } 6395 } 6396 } 6397 6398 return TRUE; 6399 } 6400 6401 /* Copy private header information. */ 6402 6403 bfd_boolean 6404 _bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd) 6405 { 6406 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 6407 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 6408 return TRUE; 6409 6410 /* Copy over private BFD data if it has not already been copied. 6411 This must be done here, rather than in the copy_private_bfd_data 6412 entry point, because the latter is called after the section 6413 contents have been set, which means that the program headers have 6414 already been worked out. */ 6415 if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL) 6416 { 6417 if (! copy_private_bfd_data (ibfd, obfd)) 6418 return FALSE; 6419 } 6420 6421 return _bfd_elf_fixup_group_sections (ibfd, NULL); 6422 } 6423 6424 /* Copy private symbol information. If this symbol is in a section 6425 which we did not map into a BFD section, try to map the section 6426 index correctly. We use special macro definitions for the mapped 6427 section indices; these definitions are interpreted by the 6428 swap_out_syms function. */ 6429 6430 #define MAP_ONESYMTAB (SHN_HIOS + 1) 6431 #define MAP_DYNSYMTAB (SHN_HIOS + 2) 6432 #define MAP_STRTAB (SHN_HIOS + 3) 6433 #define MAP_SHSTRTAB (SHN_HIOS + 4) 6434 #define MAP_SYM_SHNDX (SHN_HIOS + 5) 6435 6436 bfd_boolean 6437 _bfd_elf_copy_private_symbol_data (bfd *ibfd, 6438 asymbol *isymarg, 6439 bfd *obfd, 6440 asymbol *osymarg) 6441 { 6442 elf_symbol_type *isym, *osym; 6443 6444 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 6445 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 6446 return TRUE; 6447 6448 isym = elf_symbol_from (ibfd, isymarg); 6449 osym = elf_symbol_from (obfd, osymarg); 6450 6451 if (isym != NULL 6452 && isym->internal_elf_sym.st_shndx != 0 6453 && osym != NULL 6454 && bfd_is_abs_section (isym->symbol.section)) 6455 { 6456 unsigned int shndx; 6457 6458 shndx = isym->internal_elf_sym.st_shndx; 6459 if (shndx == elf_onesymtab (ibfd)) 6460 shndx = MAP_ONESYMTAB; 6461 else if (shndx == elf_dynsymtab (ibfd)) 6462 shndx = MAP_DYNSYMTAB; 6463 else if (shndx == elf_tdata (ibfd)->strtab_section) 6464 shndx = MAP_STRTAB; 6465 else if (shndx == elf_tdata (ibfd)->shstrtab_section) 6466 shndx = MAP_SHSTRTAB; 6467 else if (shndx == elf_tdata (ibfd)->symtab_shndx_section) 6468 shndx = MAP_SYM_SHNDX; 6469 osym->internal_elf_sym.st_shndx = shndx; 6470 } 6471 6472 return TRUE; 6473 } 6474 6475 /* Swap out the symbols. */ 6476 6477 static bfd_boolean 6478 swap_out_syms (bfd *abfd, 6479 struct bfd_strtab_hash **sttp, 6480 int relocatable_p) 6481 { 6482 const struct elf_backend_data *bed; 6483 int symcount; 6484 asymbol **syms; 6485 struct bfd_strtab_hash *stt; 6486 Elf_Internal_Shdr *symtab_hdr; 6487 Elf_Internal_Shdr *symtab_shndx_hdr; 6488 Elf_Internal_Shdr *symstrtab_hdr; 6489 bfd_byte *outbound_syms; 6490 bfd_byte *outbound_shndx; 6491 int idx; 6492 bfd_size_type amt; 6493 bfd_boolean name_local_sections; 6494 6495 if (!elf_map_symbols (abfd)) 6496 return FALSE; 6497 6498 /* Dump out the symtabs. */ 6499 stt = _bfd_elf_stringtab_init (); 6500 if (stt == NULL) 6501 return FALSE; 6502 6503 bed = get_elf_backend_data (abfd); 6504 symcount = bfd_get_symcount (abfd); 6505 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 6506 symtab_hdr->sh_type = SHT_SYMTAB; 6507 symtab_hdr->sh_entsize = bed->s->sizeof_sym; 6508 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1); 6509 symtab_hdr->sh_info = elf_num_locals (abfd) + 1; 6510 symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align; 6511 6512 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr; 6513 symstrtab_hdr->sh_type = SHT_STRTAB; 6514 6515 outbound_syms = (bfd_byte *) bfd_alloc2 (abfd, 1 + symcount, 6516 bed->s->sizeof_sym); 6517 if (outbound_syms == NULL) 6518 { 6519 _bfd_stringtab_free (stt); 6520 return FALSE; 6521 } 6522 symtab_hdr->contents = outbound_syms; 6523 6524 outbound_shndx = NULL; 6525 symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr; 6526 if (symtab_shndx_hdr->sh_name != 0) 6527 { 6528 amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx); 6529 outbound_shndx = (bfd_byte *) 6530 bfd_zalloc2 (abfd, 1 + symcount, sizeof (Elf_External_Sym_Shndx)); 6531 if (outbound_shndx == NULL) 6532 { 6533 _bfd_stringtab_free (stt); 6534 return FALSE; 6535 } 6536 6537 symtab_shndx_hdr->contents = outbound_shndx; 6538 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX; 6539 symtab_shndx_hdr->sh_size = amt; 6540 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx); 6541 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx); 6542 } 6543 6544 /* Now generate the data (for "contents"). */ 6545 { 6546 /* Fill in zeroth symbol and swap it out. */ 6547 Elf_Internal_Sym sym; 6548 sym.st_name = 0; 6549 sym.st_value = 0; 6550 sym.st_size = 0; 6551 sym.st_info = 0; 6552 sym.st_other = 0; 6553 sym.st_shndx = SHN_UNDEF; 6554 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx); 6555 outbound_syms += bed->s->sizeof_sym; 6556 if (outbound_shndx != NULL) 6557 outbound_shndx += sizeof (Elf_External_Sym_Shndx); 6558 } 6559 6560 name_local_sections 6561 = (bed->elf_backend_name_local_section_symbols 6562 && bed->elf_backend_name_local_section_symbols (abfd)); 6563 6564 syms = bfd_get_outsymbols (abfd); 6565 for (idx = 0; idx < symcount; idx++) 6566 { 6567 Elf_Internal_Sym sym; 6568 bfd_vma value = syms[idx]->value; 6569 elf_symbol_type *type_ptr; 6570 flagword flags = syms[idx]->flags; 6571 int type; 6572 6573 if (!name_local_sections 6574 && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM) 6575 { 6576 /* Local section symbols have no name. */ 6577 sym.st_name = 0; 6578 } 6579 else 6580 { 6581 sym.st_name = (unsigned long) _bfd_stringtab_add (stt, 6582 syms[idx]->name, 6583 TRUE, FALSE); 6584 if (sym.st_name == (unsigned long) -1) 6585 { 6586 _bfd_stringtab_free (stt); 6587 return FALSE; 6588 } 6589 } 6590 6591 type_ptr = elf_symbol_from (abfd, syms[idx]); 6592 6593 if ((flags & BSF_SECTION_SYM) == 0 6594 && bfd_is_com_section (syms[idx]->section)) 6595 { 6596 /* ELF common symbols put the alignment into the `value' field, 6597 and the size into the `size' field. This is backwards from 6598 how BFD handles it, so reverse it here. */ 6599 sym.st_size = value; 6600 if (type_ptr == NULL 6601 || type_ptr->internal_elf_sym.st_value == 0) 6602 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value)); 6603 else 6604 sym.st_value = type_ptr->internal_elf_sym.st_value; 6605 sym.st_shndx = _bfd_elf_section_from_bfd_section 6606 (abfd, syms[idx]->section); 6607 } 6608 else 6609 { 6610 asection *sec = syms[idx]->section; 6611 unsigned int shndx; 6612 6613 if (sec->output_section) 6614 { 6615 value += sec->output_offset; 6616 sec = sec->output_section; 6617 } 6618 6619 /* Don't add in the section vma for relocatable output. */ 6620 if (! relocatable_p) 6621 value += sec->vma; 6622 sym.st_value = value; 6623 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0; 6624 6625 if (bfd_is_abs_section (sec) 6626 && type_ptr != NULL 6627 && type_ptr->internal_elf_sym.st_shndx != 0) 6628 { 6629 /* This symbol is in a real ELF section which we did 6630 not create as a BFD section. Undo the mapping done 6631 by copy_private_symbol_data. */ 6632 shndx = type_ptr->internal_elf_sym.st_shndx; 6633 switch (shndx) 6634 { 6635 case MAP_ONESYMTAB: 6636 shndx = elf_onesymtab (abfd); 6637 break; 6638 case MAP_DYNSYMTAB: 6639 shndx = elf_dynsymtab (abfd); 6640 break; 6641 case MAP_STRTAB: 6642 shndx = elf_tdata (abfd)->strtab_section; 6643 break; 6644 case MAP_SHSTRTAB: 6645 shndx = elf_tdata (abfd)->shstrtab_section; 6646 break; 6647 case MAP_SYM_SHNDX: 6648 shndx = elf_tdata (abfd)->symtab_shndx_section; 6649 break; 6650 default: 6651 break; 6652 } 6653 } 6654 else 6655 { 6656 shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 6657 6658 if (shndx == SHN_BAD) 6659 { 6660 asection *sec2; 6661 6662 /* Writing this would be a hell of a lot easier if 6663 we had some decent documentation on bfd, and 6664 knew what to expect of the library, and what to 6665 demand of applications. For example, it 6666 appears that `objcopy' might not set the 6667 section of a symbol to be a section that is 6668 actually in the output file. */ 6669 sec2 = bfd_get_section_by_name (abfd, sec->name); 6670 if (sec2 == NULL) 6671 { 6672 _bfd_error_handler (_("\ 6673 Unable to find equivalent output section for symbol '%s' from section '%s'"), 6674 syms[idx]->name ? syms[idx]->name : "<Local sym>", 6675 sec->name); 6676 bfd_set_error (bfd_error_invalid_operation); 6677 _bfd_stringtab_free (stt); 6678 return FALSE; 6679 } 6680 6681 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2); 6682 BFD_ASSERT (shndx != SHN_BAD); 6683 } 6684 } 6685 6686 sym.st_shndx = shndx; 6687 } 6688 6689 if ((flags & BSF_THREAD_LOCAL) != 0) 6690 type = STT_TLS; 6691 else if ((flags & BSF_GNU_INDIRECT_FUNCTION) != 0) 6692 type = STT_GNU_IFUNC; 6693 else if ((flags & BSF_FUNCTION) != 0) 6694 type = STT_FUNC; 6695 else if ((flags & BSF_OBJECT) != 0) 6696 type = STT_OBJECT; 6697 else if ((flags & BSF_RELC) != 0) 6698 type = STT_RELC; 6699 else if ((flags & BSF_SRELC) != 0) 6700 type = STT_SRELC; 6701 else 6702 type = STT_NOTYPE; 6703 6704 if (syms[idx]->section->flags & SEC_THREAD_LOCAL) 6705 type = STT_TLS; 6706 6707 /* Processor-specific types. */ 6708 if (type_ptr != NULL 6709 && bed->elf_backend_get_symbol_type) 6710 type = ((*bed->elf_backend_get_symbol_type) 6711 (&type_ptr->internal_elf_sym, type)); 6712 6713 if (flags & BSF_SECTION_SYM) 6714 { 6715 if (flags & BSF_GLOBAL) 6716 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION); 6717 else 6718 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION); 6719 } 6720 else if (bfd_is_com_section (syms[idx]->section)) 6721 { 6722 #ifdef USE_STT_COMMON 6723 if (type == STT_OBJECT) 6724 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_COMMON); 6725 else 6726 #endif 6727 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type); 6728 } 6729 else if (bfd_is_und_section (syms[idx]->section)) 6730 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK) 6731 ? STB_WEAK 6732 : STB_GLOBAL), 6733 type); 6734 else if (flags & BSF_FILE) 6735 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE); 6736 else 6737 { 6738 int bind = STB_LOCAL; 6739 6740 if (flags & BSF_LOCAL) 6741 bind = STB_LOCAL; 6742 else if (flags & BSF_GNU_UNIQUE) 6743 bind = STB_GNU_UNIQUE; 6744 else if (flags & BSF_WEAK) 6745 bind = STB_WEAK; 6746 else if (flags & BSF_GLOBAL) 6747 bind = STB_GLOBAL; 6748 6749 sym.st_info = ELF_ST_INFO (bind, type); 6750 } 6751 6752 if (type_ptr != NULL) 6753 sym.st_other = type_ptr->internal_elf_sym.st_other; 6754 else 6755 sym.st_other = 0; 6756 6757 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx); 6758 outbound_syms += bed->s->sizeof_sym; 6759 if (outbound_shndx != NULL) 6760 outbound_shndx += sizeof (Elf_External_Sym_Shndx); 6761 } 6762 6763 *sttp = stt; 6764 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt); 6765 symstrtab_hdr->sh_type = SHT_STRTAB; 6766 6767 symstrtab_hdr->sh_flags = 0; 6768 symstrtab_hdr->sh_addr = 0; 6769 symstrtab_hdr->sh_entsize = 0; 6770 symstrtab_hdr->sh_link = 0; 6771 symstrtab_hdr->sh_info = 0; 6772 symstrtab_hdr->sh_addralign = 1; 6773 6774 return TRUE; 6775 } 6776 6777 /* Return the number of bytes required to hold the symtab vector. 6778 6779 Note that we base it on the count plus 1, since we will null terminate 6780 the vector allocated based on this size. However, the ELF symbol table 6781 always has a dummy entry as symbol #0, so it ends up even. */ 6782 6783 long 6784 _bfd_elf_get_symtab_upper_bound (bfd *abfd) 6785 { 6786 long symcount; 6787 long symtab_size; 6788 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr; 6789 6790 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym; 6791 symtab_size = (symcount + 1) * (sizeof (asymbol *)); 6792 if (symcount > 0) 6793 symtab_size -= sizeof (asymbol *); 6794 6795 return symtab_size; 6796 } 6797 6798 long 6799 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd) 6800 { 6801 long symcount; 6802 long symtab_size; 6803 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr; 6804 6805 if (elf_dynsymtab (abfd) == 0) 6806 { 6807 bfd_set_error (bfd_error_invalid_operation); 6808 return -1; 6809 } 6810 6811 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym; 6812 symtab_size = (symcount + 1) * (sizeof (asymbol *)); 6813 if (symcount > 0) 6814 symtab_size -= sizeof (asymbol *); 6815 6816 return symtab_size; 6817 } 6818 6819 long 6820 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, 6821 sec_ptr asect) 6822 { 6823 return (asect->reloc_count + 1) * sizeof (arelent *); 6824 } 6825 6826 /* Canonicalize the relocs. */ 6827 6828 long 6829 _bfd_elf_canonicalize_reloc (bfd *abfd, 6830 sec_ptr section, 6831 arelent **relptr, 6832 asymbol **symbols) 6833 { 6834 arelent *tblptr; 6835 unsigned int i; 6836 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 6837 6838 if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE)) 6839 return -1; 6840 6841 tblptr = section->relocation; 6842 for (i = 0; i < section->reloc_count; i++) 6843 *relptr++ = tblptr++; 6844 6845 *relptr = NULL; 6846 6847 return section->reloc_count; 6848 } 6849 6850 long 6851 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation) 6852 { 6853 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 6854 long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE); 6855 6856 if (symcount >= 0) 6857 bfd_get_symcount (abfd) = symcount; 6858 return symcount; 6859 } 6860 6861 long 6862 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd, 6863 asymbol **allocation) 6864 { 6865 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 6866 long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE); 6867 6868 if (symcount >= 0) 6869 bfd_get_dynamic_symcount (abfd) = symcount; 6870 return symcount; 6871 } 6872 6873 /* Return the size required for the dynamic reloc entries. Any loadable 6874 section that was actually installed in the BFD, and has type SHT_REL 6875 or SHT_RELA, and uses the dynamic symbol table, is considered to be a 6876 dynamic reloc section. */ 6877 6878 long 6879 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd) 6880 { 6881 long ret; 6882 asection *s; 6883 6884 if (elf_dynsymtab (abfd) == 0) 6885 { 6886 bfd_set_error (bfd_error_invalid_operation); 6887 return -1; 6888 } 6889 6890 ret = sizeof (arelent *); 6891 for (s = abfd->sections; s != NULL; s = s->next) 6892 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd) 6893 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL 6894 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)) 6895 ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize) 6896 * sizeof (arelent *)); 6897 6898 return ret; 6899 } 6900 6901 /* Canonicalize the dynamic relocation entries. Note that we return the 6902 dynamic relocations as a single block, although they are actually 6903 associated with particular sections; the interface, which was 6904 designed for SunOS style shared libraries, expects that there is only 6905 one set of dynamic relocs. Any loadable section that was actually 6906 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the 6907 dynamic symbol table, is considered to be a dynamic reloc section. */ 6908 6909 long 6910 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd, 6911 arelent **storage, 6912 asymbol **syms) 6913 { 6914 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean); 6915 asection *s; 6916 long ret; 6917 6918 if (elf_dynsymtab (abfd) == 0) 6919 { 6920 bfd_set_error (bfd_error_invalid_operation); 6921 return -1; 6922 } 6923 6924 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table; 6925 ret = 0; 6926 for (s = abfd->sections; s != NULL; s = s->next) 6927 { 6928 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd) 6929 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL 6930 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)) 6931 { 6932 arelent *p; 6933 long count, i; 6934 6935 if (! (*slurp_relocs) (abfd, s, syms, TRUE)) 6936 return -1; 6937 count = s->size / elf_section_data (s)->this_hdr.sh_entsize; 6938 p = s->relocation; 6939 for (i = 0; i < count; i++) 6940 *storage++ = p++; 6941 ret += count; 6942 } 6943 } 6944 6945 *storage = NULL; 6946 6947 return ret; 6948 } 6949 6950 /* Read in the version information. */ 6951 6952 bfd_boolean 6953 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver) 6954 { 6955 bfd_byte *contents = NULL; 6956 unsigned int freeidx = 0; 6957 6958 if (elf_dynverref (abfd) != 0) 6959 { 6960 Elf_Internal_Shdr *hdr; 6961 Elf_External_Verneed *everneed; 6962 Elf_Internal_Verneed *iverneed; 6963 unsigned int i; 6964 bfd_byte *contents_end; 6965 6966 hdr = &elf_tdata (abfd)->dynverref_hdr; 6967 6968 elf_tdata (abfd)->verref = (Elf_Internal_Verneed *) 6969 bfd_zalloc2 (abfd, hdr->sh_info, sizeof (Elf_Internal_Verneed)); 6970 if (elf_tdata (abfd)->verref == NULL) 6971 goto error_return; 6972 6973 elf_tdata (abfd)->cverrefs = hdr->sh_info; 6974 6975 contents = (bfd_byte *) bfd_malloc (hdr->sh_size); 6976 if (contents == NULL) 6977 { 6978 error_return_verref: 6979 elf_tdata (abfd)->verref = NULL; 6980 elf_tdata (abfd)->cverrefs = 0; 6981 goto error_return; 6982 } 6983 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0 6984 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size) 6985 goto error_return_verref; 6986 6987 if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verneed)) 6988 goto error_return_verref; 6989 6990 BFD_ASSERT (sizeof (Elf_External_Verneed) 6991 == sizeof (Elf_External_Vernaux)); 6992 contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed); 6993 everneed = (Elf_External_Verneed *) contents; 6994 iverneed = elf_tdata (abfd)->verref; 6995 for (i = 0; i < hdr->sh_info; i++, iverneed++) 6996 { 6997 Elf_External_Vernaux *evernaux; 6998 Elf_Internal_Vernaux *ivernaux; 6999 unsigned int j; 7000 7001 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed); 7002 7003 iverneed->vn_bfd = abfd; 7004 7005 iverneed->vn_filename = 7006 bfd_elf_string_from_elf_section (abfd, hdr->sh_link, 7007 iverneed->vn_file); 7008 if (iverneed->vn_filename == NULL) 7009 goto error_return_verref; 7010 7011 if (iverneed->vn_cnt == 0) 7012 iverneed->vn_auxptr = NULL; 7013 else 7014 { 7015 iverneed->vn_auxptr = (struct elf_internal_vernaux *) 7016 bfd_alloc2 (abfd, iverneed->vn_cnt, 7017 sizeof (Elf_Internal_Vernaux)); 7018 if (iverneed->vn_auxptr == NULL) 7019 goto error_return_verref; 7020 } 7021 7022 if (iverneed->vn_aux 7023 > (size_t) (contents_end - (bfd_byte *) everneed)) 7024 goto error_return_verref; 7025 7026 evernaux = ((Elf_External_Vernaux *) 7027 ((bfd_byte *) everneed + iverneed->vn_aux)); 7028 ivernaux = iverneed->vn_auxptr; 7029 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++) 7030 { 7031 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux); 7032 7033 ivernaux->vna_nodename = 7034 bfd_elf_string_from_elf_section (abfd, hdr->sh_link, 7035 ivernaux->vna_name); 7036 if (ivernaux->vna_nodename == NULL) 7037 goto error_return_verref; 7038 7039 if (j + 1 < iverneed->vn_cnt) 7040 ivernaux->vna_nextptr = ivernaux + 1; 7041 else 7042 ivernaux->vna_nextptr = NULL; 7043 7044 if (ivernaux->vna_next 7045 > (size_t) (contents_end - (bfd_byte *) evernaux)) 7046 goto error_return_verref; 7047 7048 evernaux = ((Elf_External_Vernaux *) 7049 ((bfd_byte *) evernaux + ivernaux->vna_next)); 7050 7051 if (ivernaux->vna_other > freeidx) 7052 freeidx = ivernaux->vna_other; 7053 } 7054 7055 if (i + 1 < hdr->sh_info) 7056 iverneed->vn_nextref = iverneed + 1; 7057 else 7058 iverneed->vn_nextref = NULL; 7059 7060 if (iverneed->vn_next 7061 > (size_t) (contents_end - (bfd_byte *) everneed)) 7062 goto error_return_verref; 7063 7064 everneed = ((Elf_External_Verneed *) 7065 ((bfd_byte *) everneed + iverneed->vn_next)); 7066 } 7067 7068 free (contents); 7069 contents = NULL; 7070 } 7071 7072 if (elf_dynverdef (abfd) != 0) 7073 { 7074 Elf_Internal_Shdr *hdr; 7075 Elf_External_Verdef *everdef; 7076 Elf_Internal_Verdef *iverdef; 7077 Elf_Internal_Verdef *iverdefarr; 7078 Elf_Internal_Verdef iverdefmem; 7079 unsigned int i; 7080 unsigned int maxidx; 7081 bfd_byte *contents_end_def, *contents_end_aux; 7082 7083 hdr = &elf_tdata (abfd)->dynverdef_hdr; 7084 7085 contents = (bfd_byte *) bfd_malloc (hdr->sh_size); 7086 if (contents == NULL) 7087 goto error_return; 7088 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0 7089 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size) 7090 goto error_return; 7091 7092 if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verdef)) 7093 goto error_return; 7094 7095 BFD_ASSERT (sizeof (Elf_External_Verdef) 7096 >= sizeof (Elf_External_Verdaux)); 7097 contents_end_def = contents + hdr->sh_size 7098 - sizeof (Elf_External_Verdef); 7099 contents_end_aux = contents + hdr->sh_size 7100 - sizeof (Elf_External_Verdaux); 7101 7102 /* We know the number of entries in the section but not the maximum 7103 index. Therefore we have to run through all entries and find 7104 the maximum. */ 7105 everdef = (Elf_External_Verdef *) contents; 7106 maxidx = 0; 7107 for (i = 0; i < hdr->sh_info; ++i) 7108 { 7109 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem); 7110 7111 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx) 7112 maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION); 7113 7114 if (iverdefmem.vd_next 7115 > (size_t) (contents_end_def - (bfd_byte *) everdef)) 7116 goto error_return; 7117 7118 everdef = ((Elf_External_Verdef *) 7119 ((bfd_byte *) everdef + iverdefmem.vd_next)); 7120 } 7121 7122 if (default_imported_symver) 7123 { 7124 if (freeidx > maxidx) 7125 maxidx = ++freeidx; 7126 else 7127 freeidx = ++maxidx; 7128 } 7129 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *) 7130 bfd_zalloc2 (abfd, maxidx, sizeof (Elf_Internal_Verdef)); 7131 if (elf_tdata (abfd)->verdef == NULL) 7132 goto error_return; 7133 7134 elf_tdata (abfd)->cverdefs = maxidx; 7135 7136 everdef = (Elf_External_Verdef *) contents; 7137 iverdefarr = elf_tdata (abfd)->verdef; 7138 for (i = 0; i < hdr->sh_info; i++) 7139 { 7140 Elf_External_Verdaux *everdaux; 7141 Elf_Internal_Verdaux *iverdaux; 7142 unsigned int j; 7143 7144 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem); 7145 7146 if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0) 7147 { 7148 error_return_verdef: 7149 elf_tdata (abfd)->verdef = NULL; 7150 elf_tdata (abfd)->cverdefs = 0; 7151 goto error_return; 7152 } 7153 7154 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1]; 7155 memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef)); 7156 7157 iverdef->vd_bfd = abfd; 7158 7159 if (iverdef->vd_cnt == 0) 7160 iverdef->vd_auxptr = NULL; 7161 else 7162 { 7163 iverdef->vd_auxptr = (struct elf_internal_verdaux *) 7164 bfd_alloc2 (abfd, iverdef->vd_cnt, 7165 sizeof (Elf_Internal_Verdaux)); 7166 if (iverdef->vd_auxptr == NULL) 7167 goto error_return_verdef; 7168 } 7169 7170 if (iverdef->vd_aux 7171 > (size_t) (contents_end_aux - (bfd_byte *) everdef)) 7172 goto error_return_verdef; 7173 7174 everdaux = ((Elf_External_Verdaux *) 7175 ((bfd_byte *) everdef + iverdef->vd_aux)); 7176 iverdaux = iverdef->vd_auxptr; 7177 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++) 7178 { 7179 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux); 7180 7181 iverdaux->vda_nodename = 7182 bfd_elf_string_from_elf_section (abfd, hdr->sh_link, 7183 iverdaux->vda_name); 7184 if (iverdaux->vda_nodename == NULL) 7185 goto error_return_verdef; 7186 7187 if (j + 1 < iverdef->vd_cnt) 7188 iverdaux->vda_nextptr = iverdaux + 1; 7189 else 7190 iverdaux->vda_nextptr = NULL; 7191 7192 if (iverdaux->vda_next 7193 > (size_t) (contents_end_aux - (bfd_byte *) everdaux)) 7194 goto error_return_verdef; 7195 7196 everdaux = ((Elf_External_Verdaux *) 7197 ((bfd_byte *) everdaux + iverdaux->vda_next)); 7198 } 7199 7200 if (iverdef->vd_cnt) 7201 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename; 7202 7203 if ((size_t) (iverdef - iverdefarr) + 1 < maxidx) 7204 iverdef->vd_nextdef = iverdef + 1; 7205 else 7206 iverdef->vd_nextdef = NULL; 7207 7208 everdef = ((Elf_External_Verdef *) 7209 ((bfd_byte *) everdef + iverdef->vd_next)); 7210 } 7211 7212 free (contents); 7213 contents = NULL; 7214 } 7215 else if (default_imported_symver) 7216 { 7217 if (freeidx < 3) 7218 freeidx = 3; 7219 else 7220 freeidx++; 7221 7222 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *) 7223 bfd_zalloc2 (abfd, freeidx, sizeof (Elf_Internal_Verdef)); 7224 if (elf_tdata (abfd)->verdef == NULL) 7225 goto error_return; 7226 7227 elf_tdata (abfd)->cverdefs = freeidx; 7228 } 7229 7230 /* Create a default version based on the soname. */ 7231 if (default_imported_symver) 7232 { 7233 Elf_Internal_Verdef *iverdef; 7234 Elf_Internal_Verdaux *iverdaux; 7235 7236 iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];; 7237 7238 iverdef->vd_version = VER_DEF_CURRENT; 7239 iverdef->vd_flags = 0; 7240 iverdef->vd_ndx = freeidx; 7241 iverdef->vd_cnt = 1; 7242 7243 iverdef->vd_bfd = abfd; 7244 7245 iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd); 7246 if (iverdef->vd_nodename == NULL) 7247 goto error_return_verdef; 7248 iverdef->vd_nextdef = NULL; 7249 iverdef->vd_auxptr = (struct elf_internal_verdaux *) 7250 bfd_alloc (abfd, sizeof (Elf_Internal_Verdaux)); 7251 if (iverdef->vd_auxptr == NULL) 7252 goto error_return_verdef; 7253 7254 iverdaux = iverdef->vd_auxptr; 7255 iverdaux->vda_nodename = iverdef->vd_nodename; 7256 iverdaux->vda_nextptr = NULL; 7257 } 7258 7259 return TRUE; 7260 7261 error_return: 7262 if (contents != NULL) 7263 free (contents); 7264 return FALSE; 7265 } 7266 7267 asymbol * 7268 _bfd_elf_make_empty_symbol (bfd *abfd) 7269 { 7270 elf_symbol_type *newsym; 7271 bfd_size_type amt = sizeof (elf_symbol_type); 7272 7273 newsym = (elf_symbol_type *) bfd_zalloc (abfd, amt); 7274 if (!newsym) 7275 return NULL; 7276 else 7277 { 7278 newsym->symbol.the_bfd = abfd; 7279 return &newsym->symbol; 7280 } 7281 } 7282 7283 void 7284 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED, 7285 asymbol *symbol, 7286 symbol_info *ret) 7287 { 7288 bfd_symbol_info (symbol, ret); 7289 } 7290 7291 /* Return whether a symbol name implies a local symbol. Most targets 7292 use this function for the is_local_label_name entry point, but some 7293 override it. */ 7294 7295 bfd_boolean 7296 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, 7297 const char *name) 7298 { 7299 /* Normal local symbols start with ``.L''. */ 7300 if (name[0] == '.' && name[1] == 'L') 7301 return TRUE; 7302 7303 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate 7304 DWARF debugging symbols starting with ``..''. */ 7305 if (name[0] == '.' && name[1] == '.') 7306 return TRUE; 7307 7308 /* gcc will sometimes generate symbols beginning with ``_.L_'' when 7309 emitting DWARF debugging output. I suspect this is actually a 7310 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call 7311 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading 7312 underscore to be emitted on some ELF targets). For ease of use, 7313 we treat such symbols as local. */ 7314 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_') 7315 return TRUE; 7316 7317 return FALSE; 7318 } 7319 7320 alent * 7321 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED, 7322 asymbol *symbol ATTRIBUTE_UNUSED) 7323 { 7324 abort (); 7325 return NULL; 7326 } 7327 7328 bfd_boolean 7329 _bfd_elf_set_arch_mach (bfd *abfd, 7330 enum bfd_architecture arch, 7331 unsigned long machine) 7332 { 7333 /* If this isn't the right architecture for this backend, and this 7334 isn't the generic backend, fail. */ 7335 if (arch != get_elf_backend_data (abfd)->arch 7336 && arch != bfd_arch_unknown 7337 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown) 7338 return FALSE; 7339 7340 return bfd_default_set_arch_mach (abfd, arch, machine); 7341 } 7342 7343 /* Find the function to a particular section and offset, 7344 for error reporting. */ 7345 7346 static bfd_boolean 7347 elf_find_function (bfd *abfd, 7348 asection *section, 7349 asymbol **symbols, 7350 bfd_vma offset, 7351 const char **filename_ptr, 7352 const char **functionname_ptr) 7353 { 7354 const char *filename; 7355 asymbol *func, *file; 7356 bfd_vma low_func; 7357 asymbol **p; 7358 /* ??? Given multiple file symbols, it is impossible to reliably 7359 choose the right file name for global symbols. File symbols are 7360 local symbols, and thus all file symbols must sort before any 7361 global symbols. The ELF spec may be interpreted to say that a 7362 file symbol must sort before other local symbols, but currently 7363 ld -r doesn't do this. So, for ld -r output, it is possible to 7364 make a better choice of file name for local symbols by ignoring 7365 file symbols appearing after a given local symbol. */ 7366 enum { nothing_seen, symbol_seen, file_after_symbol_seen } state; 7367 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 7368 7369 filename = NULL; 7370 func = NULL; 7371 file = NULL; 7372 low_func = 0; 7373 state = nothing_seen; 7374 7375 for (p = symbols; *p != NULL; p++) 7376 { 7377 elf_symbol_type *q; 7378 unsigned int type; 7379 7380 q = (elf_symbol_type *) *p; 7381 7382 type = ELF_ST_TYPE (q->internal_elf_sym.st_info); 7383 switch (type) 7384 { 7385 case STT_FILE: 7386 file = &q->symbol; 7387 if (state == symbol_seen) 7388 state = file_after_symbol_seen; 7389 continue; 7390 default: 7391 if (!bed->is_function_type (type)) 7392 break; 7393 case STT_NOTYPE: 7394 if (bfd_get_section (&q->symbol) == section 7395 && q->symbol.value >= low_func 7396 && q->symbol.value <= offset) 7397 { 7398 func = (asymbol *) q; 7399 low_func = q->symbol.value; 7400 filename = NULL; 7401 if (file != NULL 7402 && (ELF_ST_BIND (q->internal_elf_sym.st_info) == STB_LOCAL 7403 || state != file_after_symbol_seen)) 7404 filename = bfd_asymbol_name (file); 7405 } 7406 break; 7407 } 7408 if (state == nothing_seen) 7409 state = symbol_seen; 7410 } 7411 7412 if (func == NULL) 7413 return FALSE; 7414 7415 if (filename_ptr) 7416 *filename_ptr = filename; 7417 if (functionname_ptr) 7418 *functionname_ptr = bfd_asymbol_name (func); 7419 7420 return TRUE; 7421 } 7422 7423 /* Find the nearest line to a particular section and offset, 7424 for error reporting. */ 7425 7426 bfd_boolean 7427 _bfd_elf_find_nearest_line (bfd *abfd, 7428 asection *section, 7429 asymbol **symbols, 7430 bfd_vma offset, 7431 const char **filename_ptr, 7432 const char **functionname_ptr, 7433 unsigned int *line_ptr) 7434 { 7435 bfd_boolean found; 7436 7437 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset, 7438 filename_ptr, functionname_ptr, 7439 line_ptr)) 7440 { 7441 if (!*functionname_ptr) 7442 elf_find_function (abfd, section, symbols, offset, 7443 *filename_ptr ? NULL : filename_ptr, 7444 functionname_ptr); 7445 7446 return TRUE; 7447 } 7448 7449 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset, 7450 filename_ptr, functionname_ptr, 7451 line_ptr, 0, 7452 &elf_tdata (abfd)->dwarf2_find_line_info)) 7453 { 7454 if (!*functionname_ptr) 7455 elf_find_function (abfd, section, symbols, offset, 7456 *filename_ptr ? NULL : filename_ptr, 7457 functionname_ptr); 7458 7459 return TRUE; 7460 } 7461 7462 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, 7463 &found, filename_ptr, 7464 functionname_ptr, line_ptr, 7465 &elf_tdata (abfd)->line_info)) 7466 return FALSE; 7467 if (found && (*functionname_ptr || *line_ptr)) 7468 return TRUE; 7469 7470 if (symbols == NULL) 7471 return FALSE; 7472 7473 if (! elf_find_function (abfd, section, symbols, offset, 7474 filename_ptr, functionname_ptr)) 7475 return FALSE; 7476 7477 *line_ptr = 0; 7478 return TRUE; 7479 } 7480 7481 /* Find the line for a symbol. */ 7482 7483 bfd_boolean 7484 _bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol, 7485 const char **filename_ptr, unsigned int *line_ptr) 7486 { 7487 return _bfd_dwarf2_find_line (abfd, symbols, symbol, 7488 filename_ptr, line_ptr, 0, 7489 &elf_tdata (abfd)->dwarf2_find_line_info); 7490 } 7491 7492 /* After a call to bfd_find_nearest_line, successive calls to 7493 bfd_find_inliner_info can be used to get source information about 7494 each level of function inlining that terminated at the address 7495 passed to bfd_find_nearest_line. Currently this is only supported 7496 for DWARF2 with appropriate DWARF3 extensions. */ 7497 7498 bfd_boolean 7499 _bfd_elf_find_inliner_info (bfd *abfd, 7500 const char **filename_ptr, 7501 const char **functionname_ptr, 7502 unsigned int *line_ptr) 7503 { 7504 bfd_boolean found; 7505 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr, 7506 functionname_ptr, line_ptr, 7507 & elf_tdata (abfd)->dwarf2_find_line_info); 7508 return found; 7509 } 7510 7511 int 7512 _bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info) 7513 { 7514 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 7515 int ret = bed->s->sizeof_ehdr; 7516 7517 if (!info->relocatable) 7518 { 7519 bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size; 7520 7521 if (phdr_size == (bfd_size_type) -1) 7522 { 7523 struct elf_segment_map *m; 7524 7525 phdr_size = 0; 7526 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next) 7527 phdr_size += bed->s->sizeof_phdr; 7528 7529 if (phdr_size == 0) 7530 phdr_size = get_program_header_size (abfd, info); 7531 } 7532 7533 elf_tdata (abfd)->program_header_size = phdr_size; 7534 ret += phdr_size; 7535 } 7536 7537 return ret; 7538 } 7539 7540 bfd_boolean 7541 _bfd_elf_set_section_contents (bfd *abfd, 7542 sec_ptr section, 7543 const void *location, 7544 file_ptr offset, 7545 bfd_size_type count) 7546 { 7547 Elf_Internal_Shdr *hdr; 7548 bfd_signed_vma pos; 7549 7550 if (! abfd->output_has_begun 7551 && ! _bfd_elf_compute_section_file_positions (abfd, NULL)) 7552 return FALSE; 7553 7554 hdr = &elf_section_data (section)->this_hdr; 7555 pos = hdr->sh_offset + offset; 7556 if (bfd_seek (abfd, pos, SEEK_SET) != 0 7557 || bfd_bwrite (location, count, abfd) != count) 7558 return FALSE; 7559 7560 return TRUE; 7561 } 7562 7563 void 7564 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, 7565 arelent *cache_ptr ATTRIBUTE_UNUSED, 7566 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED) 7567 { 7568 abort (); 7569 } 7570 7571 /* Try to convert a non-ELF reloc into an ELF one. */ 7572 7573 bfd_boolean 7574 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc) 7575 { 7576 /* Check whether we really have an ELF howto. */ 7577 7578 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec) 7579 { 7580 bfd_reloc_code_real_type code; 7581 reloc_howto_type *howto; 7582 7583 /* Alien reloc: Try to determine its type to replace it with an 7584 equivalent ELF reloc. */ 7585 7586 if (areloc->howto->pc_relative) 7587 { 7588 switch (areloc->howto->bitsize) 7589 { 7590 case 8: 7591 code = BFD_RELOC_8_PCREL; 7592 break; 7593 case 12: 7594 code = BFD_RELOC_12_PCREL; 7595 break; 7596 case 16: 7597 code = BFD_RELOC_16_PCREL; 7598 break; 7599 case 24: 7600 code = BFD_RELOC_24_PCREL; 7601 break; 7602 case 32: 7603 code = BFD_RELOC_32_PCREL; 7604 break; 7605 case 64: 7606 code = BFD_RELOC_64_PCREL; 7607 break; 7608 default: 7609 goto fail; 7610 } 7611 7612 howto = bfd_reloc_type_lookup (abfd, code); 7613 7614 if (areloc->howto->pcrel_offset != howto->pcrel_offset) 7615 { 7616 if (howto->pcrel_offset) 7617 areloc->addend += areloc->address; 7618 else 7619 areloc->addend -= areloc->address; /* addend is unsigned!! */ 7620 } 7621 } 7622 else 7623 { 7624 switch (areloc->howto->bitsize) 7625 { 7626 case 8: 7627 code = BFD_RELOC_8; 7628 break; 7629 case 14: 7630 code = BFD_RELOC_14; 7631 break; 7632 case 16: 7633 code = BFD_RELOC_16; 7634 break; 7635 case 26: 7636 code = BFD_RELOC_26; 7637 break; 7638 case 32: 7639 code = BFD_RELOC_32; 7640 break; 7641 case 64: 7642 code = BFD_RELOC_64; 7643 break; 7644 default: 7645 goto fail; 7646 } 7647 7648 howto = bfd_reloc_type_lookup (abfd, code); 7649 } 7650 7651 if (howto) 7652 areloc->howto = howto; 7653 else 7654 goto fail; 7655 } 7656 7657 return TRUE; 7658 7659 fail: 7660 (*_bfd_error_handler) 7661 (_("%B: unsupported relocation type %s"), 7662 abfd, areloc->howto->name); 7663 bfd_set_error (bfd_error_bad_value); 7664 return FALSE; 7665 } 7666 7667 bfd_boolean 7668 _bfd_elf_close_and_cleanup (bfd *abfd) 7669 { 7670 if (bfd_get_format (abfd) == bfd_object) 7671 { 7672 if (elf_tdata (abfd) != NULL && elf_shstrtab (abfd) != NULL) 7673 _bfd_elf_strtab_free (elf_shstrtab (abfd)); 7674 _bfd_dwarf2_cleanup_debug_info (abfd); 7675 } 7676 7677 return _bfd_generic_close_and_cleanup (abfd); 7678 } 7679 7680 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY 7681 in the relocation's offset. Thus we cannot allow any sort of sanity 7682 range-checking to interfere. There is nothing else to do in processing 7683 this reloc. */ 7684 7685 bfd_reloc_status_type 7686 _bfd_elf_rel_vtable_reloc_fn 7687 (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED, 7688 struct bfd_symbol *symbol ATTRIBUTE_UNUSED, 7689 void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED, 7690 bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED) 7691 { 7692 return bfd_reloc_ok; 7693 } 7694 7695 /* Elf core file support. Much of this only works on native 7696 toolchains, since we rely on knowing the 7697 machine-dependent procfs structure in order to pick 7698 out details about the corefile. */ 7699 7700 #ifdef HAVE_SYS_PROCFS_H 7701 /* Needed for new procfs interface on sparc-solaris. */ 7702 # define _STRUCTURED_PROC 1 7703 # include <sys/procfs.h> 7704 #endif 7705 7706 /* Return a PID that identifies a "thread" for threaded cores, or the 7707 PID of the main process for non-threaded cores. */ 7708 7709 static int 7710 elfcore_make_pid (bfd *abfd) 7711 { 7712 int pid; 7713 7714 pid = elf_tdata (abfd)->core_lwpid; 7715 if (pid == 0) 7716 pid = elf_tdata (abfd)->core_pid; 7717 7718 return pid; 7719 } 7720 7721 /* If there isn't a section called NAME, make one, using 7722 data from SECT. Note, this function will generate a 7723 reference to NAME, so you shouldn't deallocate or 7724 overwrite it. */ 7725 7726 static bfd_boolean 7727 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect) 7728 { 7729 asection *sect2; 7730 7731 if (bfd_get_section_by_name (abfd, name) != NULL) 7732 return TRUE; 7733 7734 sect2 = bfd_make_section_with_flags (abfd, name, sect->flags); 7735 if (sect2 == NULL) 7736 return FALSE; 7737 7738 sect2->size = sect->size; 7739 sect2->filepos = sect->filepos; 7740 sect2->alignment_power = sect->alignment_power; 7741 return TRUE; 7742 } 7743 7744 /* Create a pseudosection containing SIZE bytes at FILEPOS. This 7745 actually creates up to two pseudosections: 7746 - For the single-threaded case, a section named NAME, unless 7747 such a section already exists. 7748 - For the multi-threaded case, a section named "NAME/PID", where 7749 PID is elfcore_make_pid (abfd). 7750 Both pseudosections have identical contents. */ 7751 bfd_boolean 7752 _bfd_elfcore_make_pseudosection (bfd *abfd, 7753 char *name, 7754 size_t size, 7755 ufile_ptr filepos) 7756 { 7757 char buf[100]; 7758 char *threaded_name; 7759 size_t len; 7760 asection *sect; 7761 7762 /* Build the section name. */ 7763 7764 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd)); 7765 len = strlen (buf) + 1; 7766 threaded_name = (char *) bfd_alloc (abfd, len); 7767 if (threaded_name == NULL) 7768 return FALSE; 7769 memcpy (threaded_name, buf, len); 7770 7771 sect = bfd_make_section_anyway_with_flags (abfd, threaded_name, 7772 SEC_HAS_CONTENTS); 7773 if (sect == NULL) 7774 return FALSE; 7775 sect->size = size; 7776 sect->filepos = filepos; 7777 sect->alignment_power = 2; 7778 7779 return elfcore_maybe_make_sect (abfd, name, sect); 7780 } 7781 7782 /* prstatus_t exists on: 7783 solaris 2.5+ 7784 linux 2.[01] + glibc 7785 unixware 4.2 7786 */ 7787 7788 #if defined (HAVE_PRSTATUS_T) 7789 7790 static bfd_boolean 7791 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) 7792 { 7793 size_t size; 7794 int offset; 7795 7796 if (note->descsz == sizeof (prstatus_t)) 7797 { 7798 prstatus_t prstat; 7799 7800 size = sizeof (prstat.pr_reg); 7801 offset = offsetof (prstatus_t, pr_reg); 7802 memcpy (&prstat, note->descdata, sizeof (prstat)); 7803 7804 /* Do not overwrite the core signal if it 7805 has already been set by another thread. */ 7806 if (elf_tdata (abfd)->core_signal == 0) 7807 elf_tdata (abfd)->core_signal = prstat.pr_cursig; 7808 if (elf_tdata (abfd)->core_pid == 0) 7809 elf_tdata (abfd)->core_pid = prstat.pr_pid; 7810 7811 /* pr_who exists on: 7812 solaris 2.5+ 7813 unixware 4.2 7814 pr_who doesn't exist on: 7815 linux 2.[01] 7816 */ 7817 #if defined (HAVE_PRSTATUS_T_PR_WHO) 7818 elf_tdata (abfd)->core_lwpid = prstat.pr_who; 7819 #else 7820 elf_tdata (abfd)->core_lwpid = prstat.pr_pid; 7821 #endif 7822 } 7823 #if defined (HAVE_PRSTATUS32_T) 7824 else if (note->descsz == sizeof (prstatus32_t)) 7825 { 7826 /* 64-bit host, 32-bit corefile */ 7827 prstatus32_t prstat; 7828 7829 size = sizeof (prstat.pr_reg); 7830 offset = offsetof (prstatus32_t, pr_reg); 7831 memcpy (&prstat, note->descdata, sizeof (prstat)); 7832 7833 /* Do not overwrite the core signal if it 7834 has already been set by another thread. */ 7835 if (elf_tdata (abfd)->core_signal == 0) 7836 elf_tdata (abfd)->core_signal = prstat.pr_cursig; 7837 if (elf_tdata (abfd)->core_pid == 0) 7838 elf_tdata (abfd)->core_pid = prstat.pr_pid; 7839 7840 /* pr_who exists on: 7841 solaris 2.5+ 7842 unixware 4.2 7843 pr_who doesn't exist on: 7844 linux 2.[01] 7845 */ 7846 #if defined (HAVE_PRSTATUS32_T_PR_WHO) 7847 elf_tdata (abfd)->core_lwpid = prstat.pr_who; 7848 #else 7849 elf_tdata (abfd)->core_lwpid = prstat.pr_pid; 7850 #endif 7851 } 7852 #endif /* HAVE_PRSTATUS32_T */ 7853 else 7854 { 7855 /* Fail - we don't know how to handle any other 7856 note size (ie. data object type). */ 7857 return TRUE; 7858 } 7859 7860 /* Make a ".reg/999" section and a ".reg" section. */ 7861 return _bfd_elfcore_make_pseudosection (abfd, ".reg", 7862 size, note->descpos + offset); 7863 } 7864 #endif /* defined (HAVE_PRSTATUS_T) */ 7865 7866 /* Create a pseudosection containing the exact contents of NOTE. */ 7867 static bfd_boolean 7868 elfcore_make_note_pseudosection (bfd *abfd, 7869 char *name, 7870 Elf_Internal_Note *note) 7871 { 7872 return _bfd_elfcore_make_pseudosection (abfd, name, 7873 note->descsz, note->descpos); 7874 } 7875 7876 /* There isn't a consistent prfpregset_t across platforms, 7877 but it doesn't matter, because we don't have to pick this 7878 data structure apart. */ 7879 7880 static bfd_boolean 7881 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note) 7882 { 7883 return elfcore_make_note_pseudosection (abfd, ".reg2", note); 7884 } 7885 7886 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note 7887 type of NT_PRXFPREG. Just include the whole note's contents 7888 literally. */ 7889 7890 static bfd_boolean 7891 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note) 7892 { 7893 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note); 7894 } 7895 7896 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX" 7897 with a note type of NT_X86_XSTATE. Just include the whole note's 7898 contents literally. */ 7899 7900 static bfd_boolean 7901 elfcore_grok_xstatereg (bfd *abfd, Elf_Internal_Note *note) 7902 { 7903 return elfcore_make_note_pseudosection (abfd, ".reg-xstate", note); 7904 } 7905 7906 static bfd_boolean 7907 elfcore_grok_ppc_vmx (bfd *abfd, Elf_Internal_Note *note) 7908 { 7909 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vmx", note); 7910 } 7911 7912 static bfd_boolean 7913 elfcore_grok_ppc_vsx (bfd *abfd, Elf_Internal_Note *note) 7914 { 7915 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vsx", note); 7916 } 7917 7918 static bfd_boolean 7919 elfcore_grok_s390_high_gprs (bfd *abfd, Elf_Internal_Note *note) 7920 { 7921 return elfcore_make_note_pseudosection (abfd, ".reg-s390-high-gprs", note); 7922 } 7923 7924 static bfd_boolean 7925 elfcore_grok_s390_timer (bfd *abfd, Elf_Internal_Note *note) 7926 { 7927 return elfcore_make_note_pseudosection (abfd, ".reg-s390-timer", note); 7928 } 7929 7930 static bfd_boolean 7931 elfcore_grok_s390_todcmp (bfd *abfd, Elf_Internal_Note *note) 7932 { 7933 return elfcore_make_note_pseudosection (abfd, ".reg-s390-todcmp", note); 7934 } 7935 7936 static bfd_boolean 7937 elfcore_grok_s390_todpreg (bfd *abfd, Elf_Internal_Note *note) 7938 { 7939 return elfcore_make_note_pseudosection (abfd, ".reg-s390-todpreg", note); 7940 } 7941 7942 static bfd_boolean 7943 elfcore_grok_s390_ctrs (bfd *abfd, Elf_Internal_Note *note) 7944 { 7945 return elfcore_make_note_pseudosection (abfd, ".reg-s390-ctrs", note); 7946 } 7947 7948 static bfd_boolean 7949 elfcore_grok_s390_prefix (bfd *abfd, Elf_Internal_Note *note) 7950 { 7951 return elfcore_make_note_pseudosection (abfd, ".reg-s390-prefix", note); 7952 } 7953 7954 #if defined (HAVE_PRPSINFO_T) 7955 typedef prpsinfo_t elfcore_psinfo_t; 7956 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */ 7957 typedef prpsinfo32_t elfcore_psinfo32_t; 7958 #endif 7959 #endif 7960 7961 #if defined (HAVE_PSINFO_T) 7962 typedef psinfo_t elfcore_psinfo_t; 7963 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */ 7964 typedef psinfo32_t elfcore_psinfo32_t; 7965 #endif 7966 #endif 7967 7968 /* return a malloc'ed copy of a string at START which is at 7969 most MAX bytes long, possibly without a terminating '\0'. 7970 the copy will always have a terminating '\0'. */ 7971 7972 char * 7973 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max) 7974 { 7975 char *dups; 7976 char *end = (char *) memchr (start, '\0', max); 7977 size_t len; 7978 7979 if (end == NULL) 7980 len = max; 7981 else 7982 len = end - start; 7983 7984 dups = (char *) bfd_alloc (abfd, len + 1); 7985 if (dups == NULL) 7986 return NULL; 7987 7988 memcpy (dups, start, len); 7989 dups[len] = '\0'; 7990 7991 return dups; 7992 } 7993 7994 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) 7995 static bfd_boolean 7996 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) 7997 { 7998 if (note->descsz == sizeof (elfcore_psinfo_t)) 7999 { 8000 elfcore_psinfo_t psinfo; 8001 8002 memcpy (&psinfo, note->descdata, sizeof (psinfo)); 8003 8004 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID) 8005 elf_tdata (abfd)->core_pid = psinfo.pr_pid; 8006 #endif 8007 elf_tdata (abfd)->core_program 8008 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname, 8009 sizeof (psinfo.pr_fname)); 8010 8011 elf_tdata (abfd)->core_command 8012 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs, 8013 sizeof (psinfo.pr_psargs)); 8014 } 8015 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T) 8016 else if (note->descsz == sizeof (elfcore_psinfo32_t)) 8017 { 8018 /* 64-bit host, 32-bit corefile */ 8019 elfcore_psinfo32_t psinfo; 8020 8021 memcpy (&psinfo, note->descdata, sizeof (psinfo)); 8022 8023 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID) 8024 elf_tdata (abfd)->core_pid = psinfo.pr_pid; 8025 #endif 8026 elf_tdata (abfd)->core_program 8027 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname, 8028 sizeof (psinfo.pr_fname)); 8029 8030 elf_tdata (abfd)->core_command 8031 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs, 8032 sizeof (psinfo.pr_psargs)); 8033 } 8034 #endif 8035 8036 else 8037 { 8038 /* Fail - we don't know how to handle any other 8039 note size (ie. data object type). */ 8040 return TRUE; 8041 } 8042 8043 /* Note that for some reason, a spurious space is tacked 8044 onto the end of the args in some (at least one anyway) 8045 implementations, so strip it off if it exists. */ 8046 8047 { 8048 char *command = elf_tdata (abfd)->core_command; 8049 int n = strlen (command); 8050 8051 if (0 < n && command[n - 1] == ' ') 8052 command[n - 1] = '\0'; 8053 } 8054 8055 return TRUE; 8056 } 8057 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */ 8058 8059 #if defined (HAVE_PSTATUS_T) 8060 static bfd_boolean 8061 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note) 8062 { 8063 if (note->descsz == sizeof (pstatus_t) 8064 #if defined (HAVE_PXSTATUS_T) 8065 || note->descsz == sizeof (pxstatus_t) 8066 #endif 8067 ) 8068 { 8069 pstatus_t pstat; 8070 8071 memcpy (&pstat, note->descdata, sizeof (pstat)); 8072 8073 elf_tdata (abfd)->core_pid = pstat.pr_pid; 8074 } 8075 #if defined (HAVE_PSTATUS32_T) 8076 else if (note->descsz == sizeof (pstatus32_t)) 8077 { 8078 /* 64-bit host, 32-bit corefile */ 8079 pstatus32_t pstat; 8080 8081 memcpy (&pstat, note->descdata, sizeof (pstat)); 8082 8083 elf_tdata (abfd)->core_pid = pstat.pr_pid; 8084 } 8085 #endif 8086 /* Could grab some more details from the "representative" 8087 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an 8088 NT_LWPSTATUS note, presumably. */ 8089 8090 return TRUE; 8091 } 8092 #endif /* defined (HAVE_PSTATUS_T) */ 8093 8094 #if defined (HAVE_LWPSTATUS_T) 8095 static bfd_boolean 8096 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note) 8097 { 8098 lwpstatus_t lwpstat; 8099 char buf[100]; 8100 char *name; 8101 size_t len; 8102 asection *sect; 8103 8104 if (note->descsz != sizeof (lwpstat) 8105 #if defined (HAVE_LWPXSTATUS_T) 8106 && note->descsz != sizeof (lwpxstatus_t) 8107 #endif 8108 ) 8109 return TRUE; 8110 8111 memcpy (&lwpstat, note->descdata, sizeof (lwpstat)); 8112 8113 elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid; 8114 /* Do not overwrite the core signal if it has already been set by 8115 another thread. */ 8116 if (elf_tdata (abfd)->core_signal == 0) 8117 elf_tdata (abfd)->core_signal = lwpstat.pr_cursig; 8118 8119 /* Make a ".reg/999" section. */ 8120 8121 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd)); 8122 len = strlen (buf) + 1; 8123 name = bfd_alloc (abfd, len); 8124 if (name == NULL) 8125 return FALSE; 8126 memcpy (name, buf, len); 8127 8128 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS); 8129 if (sect == NULL) 8130 return FALSE; 8131 8132 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT) 8133 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs); 8134 sect->filepos = note->descpos 8135 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs); 8136 #endif 8137 8138 #if defined (HAVE_LWPSTATUS_T_PR_REG) 8139 sect->size = sizeof (lwpstat.pr_reg); 8140 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg); 8141 #endif 8142 8143 sect->alignment_power = 2; 8144 8145 if (!elfcore_maybe_make_sect (abfd, ".reg", sect)) 8146 return FALSE; 8147 8148 /* Make a ".reg2/999" section */ 8149 8150 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd)); 8151 len = strlen (buf) + 1; 8152 name = bfd_alloc (abfd, len); 8153 if (name == NULL) 8154 return FALSE; 8155 memcpy (name, buf, len); 8156 8157 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS); 8158 if (sect == NULL) 8159 return FALSE; 8160 8161 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT) 8162 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs); 8163 sect->filepos = note->descpos 8164 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs); 8165 #endif 8166 8167 #if defined (HAVE_LWPSTATUS_T_PR_FPREG) 8168 sect->size = sizeof (lwpstat.pr_fpreg); 8169 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg); 8170 #endif 8171 8172 sect->alignment_power = 2; 8173 8174 return elfcore_maybe_make_sect (abfd, ".reg2", sect); 8175 } 8176 #endif /* defined (HAVE_LWPSTATUS_T) */ 8177 8178 static bfd_boolean 8179 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note) 8180 { 8181 char buf[30]; 8182 char *name; 8183 size_t len; 8184 asection *sect; 8185 int type; 8186 int is_active_thread; 8187 bfd_vma base_addr; 8188 8189 if (note->descsz < 728) 8190 return TRUE; 8191 8192 if (! CONST_STRNEQ (note->namedata, "win32")) 8193 return TRUE; 8194 8195 type = bfd_get_32 (abfd, note->descdata); 8196 8197 switch (type) 8198 { 8199 case 1 /* NOTE_INFO_PROCESS */: 8200 /* FIXME: need to add ->core_command. */ 8201 /* process_info.pid */ 8202 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 8); 8203 /* process_info.signal */ 8204 elf_tdata (abfd)->core_signal = bfd_get_32 (abfd, note->descdata + 12); 8205 break; 8206 8207 case 2 /* NOTE_INFO_THREAD */: 8208 /* Make a ".reg/999" section. */ 8209 /* thread_info.tid */ 8210 sprintf (buf, ".reg/%ld", (long) bfd_get_32 (abfd, note->descdata + 8)); 8211 8212 len = strlen (buf) + 1; 8213 name = (char *) bfd_alloc (abfd, len); 8214 if (name == NULL) 8215 return FALSE; 8216 8217 memcpy (name, buf, len); 8218 8219 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS); 8220 if (sect == NULL) 8221 return FALSE; 8222 8223 /* sizeof (thread_info.thread_context) */ 8224 sect->size = 716; 8225 /* offsetof (thread_info.thread_context) */ 8226 sect->filepos = note->descpos + 12; 8227 sect->alignment_power = 2; 8228 8229 /* thread_info.is_active_thread */ 8230 is_active_thread = bfd_get_32 (abfd, note->descdata + 8); 8231 8232 if (is_active_thread) 8233 if (! elfcore_maybe_make_sect (abfd, ".reg", sect)) 8234 return FALSE; 8235 break; 8236 8237 case 3 /* NOTE_INFO_MODULE */: 8238 /* Make a ".module/xxxxxxxx" section. */ 8239 /* module_info.base_address */ 8240 base_addr = bfd_get_32 (abfd, note->descdata + 4); 8241 sprintf (buf, ".module/%08lx", (unsigned long) base_addr); 8242 8243 len = strlen (buf) + 1; 8244 name = (char *) bfd_alloc (abfd, len); 8245 if (name == NULL) 8246 return FALSE; 8247 8248 memcpy (name, buf, len); 8249 8250 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS); 8251 8252 if (sect == NULL) 8253 return FALSE; 8254 8255 sect->size = note->descsz; 8256 sect->filepos = note->descpos; 8257 sect->alignment_power = 2; 8258 break; 8259 8260 default: 8261 return TRUE; 8262 } 8263 8264 return TRUE; 8265 } 8266 8267 static bfd_boolean 8268 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note) 8269 { 8270 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 8271 8272 switch (note->type) 8273 { 8274 default: 8275 return TRUE; 8276 8277 case NT_PRSTATUS: 8278 if (bed->elf_backend_grok_prstatus) 8279 if ((*bed->elf_backend_grok_prstatus) (abfd, note)) 8280 return TRUE; 8281 #if defined (HAVE_PRSTATUS_T) 8282 return elfcore_grok_prstatus (abfd, note); 8283 #else 8284 return TRUE; 8285 #endif 8286 8287 #if defined (HAVE_PSTATUS_T) 8288 case NT_PSTATUS: 8289 return elfcore_grok_pstatus (abfd, note); 8290 #endif 8291 8292 #if defined (HAVE_LWPSTATUS_T) 8293 case NT_LWPSTATUS: 8294 return elfcore_grok_lwpstatus (abfd, note); 8295 #endif 8296 8297 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */ 8298 return elfcore_grok_prfpreg (abfd, note); 8299 8300 case NT_WIN32PSTATUS: 8301 return elfcore_grok_win32pstatus (abfd, note); 8302 8303 case NT_PRXFPREG: /* Linux SSE extension */ 8304 if (note->namesz == 6 8305 && strcmp (note->namedata, "LINUX") == 0) 8306 return elfcore_grok_prxfpreg (abfd, note); 8307 else 8308 return TRUE; 8309 8310 case NT_X86_XSTATE: /* Linux XSAVE extension */ 8311 if (note->namesz == 6 8312 && strcmp (note->namedata, "LINUX") == 0) 8313 return elfcore_grok_xstatereg (abfd, note); 8314 else 8315 return TRUE; 8316 8317 case NT_PPC_VMX: 8318 if (note->namesz == 6 8319 && strcmp (note->namedata, "LINUX") == 0) 8320 return elfcore_grok_ppc_vmx (abfd, note); 8321 else 8322 return TRUE; 8323 8324 case NT_PPC_VSX: 8325 if (note->namesz == 6 8326 && strcmp (note->namedata, "LINUX") == 0) 8327 return elfcore_grok_ppc_vsx (abfd, note); 8328 else 8329 return TRUE; 8330 8331 case NT_S390_HIGH_GPRS: 8332 if (note->namesz == 6 8333 && strcmp (note->namedata, "LINUX") == 0) 8334 return elfcore_grok_s390_high_gprs (abfd, note); 8335 else 8336 return TRUE; 8337 8338 case NT_S390_TIMER: 8339 if (note->namesz == 6 8340 && strcmp (note->namedata, "LINUX") == 0) 8341 return elfcore_grok_s390_timer (abfd, note); 8342 else 8343 return TRUE; 8344 8345 case NT_S390_TODCMP: 8346 if (note->namesz == 6 8347 && strcmp (note->namedata, "LINUX") == 0) 8348 return elfcore_grok_s390_todcmp (abfd, note); 8349 else 8350 return TRUE; 8351 8352 case NT_S390_TODPREG: 8353 if (note->namesz == 6 8354 && strcmp (note->namedata, "LINUX") == 0) 8355 return elfcore_grok_s390_todpreg (abfd, note); 8356 else 8357 return TRUE; 8358 8359 case NT_S390_CTRS: 8360 if (note->namesz == 6 8361 && strcmp (note->namedata, "LINUX") == 0) 8362 return elfcore_grok_s390_ctrs (abfd, note); 8363 else 8364 return TRUE; 8365 8366 case NT_S390_PREFIX: 8367 if (note->namesz == 6 8368 && strcmp (note->namedata, "LINUX") == 0) 8369 return elfcore_grok_s390_prefix (abfd, note); 8370 else 8371 return TRUE; 8372 8373 case NT_PRPSINFO: 8374 case NT_PSINFO: 8375 if (bed->elf_backend_grok_psinfo) 8376 if ((*bed->elf_backend_grok_psinfo) (abfd, note)) 8377 return TRUE; 8378 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) 8379 return elfcore_grok_psinfo (abfd, note); 8380 #else 8381 return TRUE; 8382 #endif 8383 8384 case NT_AUXV: 8385 { 8386 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv", 8387 SEC_HAS_CONTENTS); 8388 8389 if (sect == NULL) 8390 return FALSE; 8391 sect->size = note->descsz; 8392 sect->filepos = note->descpos; 8393 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32; 8394 8395 return TRUE; 8396 } 8397 } 8398 } 8399 8400 static bfd_boolean 8401 elfobj_grok_gnu_build_id (bfd *abfd, Elf_Internal_Note *note) 8402 { 8403 elf_tdata (abfd)->build_id_size = note->descsz; 8404 elf_tdata (abfd)->build_id = (bfd_byte *) bfd_alloc (abfd, note->descsz); 8405 if (elf_tdata (abfd)->build_id == NULL) 8406 return FALSE; 8407 8408 memcpy (elf_tdata (abfd)->build_id, note->descdata, note->descsz); 8409 8410 return TRUE; 8411 } 8412 8413 static bfd_boolean 8414 elfobj_grok_gnu_note (bfd *abfd, Elf_Internal_Note *note) 8415 { 8416 switch (note->type) 8417 { 8418 default: 8419 return TRUE; 8420 8421 case NT_GNU_BUILD_ID: 8422 return elfobj_grok_gnu_build_id (abfd, note); 8423 } 8424 } 8425 8426 static bfd_boolean 8427 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp) 8428 { 8429 char *cp; 8430 8431 cp = strchr (note->namedata, '@'); 8432 if (cp != NULL) 8433 { 8434 *lwpidp = atoi(cp + 1); 8435 return TRUE; 8436 } 8437 return FALSE; 8438 } 8439 8440 static bfd_boolean 8441 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note) 8442 { 8443 /* Signal number at offset 0x08. */ 8444 elf_tdata (abfd)->core_signal 8445 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08); 8446 8447 /* Process ID at offset 0x50. */ 8448 elf_tdata (abfd)->core_pid 8449 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50); 8450 8451 /* Command name at 0x7c (max 32 bytes, including nul). */ 8452 elf_tdata (abfd)->core_command 8453 = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31); 8454 8455 return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo", 8456 note); 8457 } 8458 8459 static bfd_boolean 8460 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note) 8461 { 8462 int lwp; 8463 8464 if (elfcore_netbsd_get_lwpid (note, &lwp)) 8465 elf_tdata (abfd)->core_lwpid = lwp; 8466 8467 if (note->type == NT_NETBSDCORE_PROCINFO) 8468 { 8469 /* NetBSD-specific core "procinfo". Note that we expect to 8470 find this note before any of the others, which is fine, 8471 since the kernel writes this note out first when it 8472 creates a core file. */ 8473 8474 return elfcore_grok_netbsd_procinfo (abfd, note); 8475 } 8476 8477 /* As of Jan 2002 there are no other machine-independent notes 8478 defined for NetBSD core files. If the note type is less 8479 than the start of the machine-dependent note types, we don't 8480 understand it. */ 8481 8482 if (note->type < NT_NETBSDCORE_FIRSTMACH) 8483 return TRUE; 8484 8485 8486 switch (bfd_get_arch (abfd)) 8487 { 8488 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and 8489 PT_GETFPREGS == mach+2. */ 8490 8491 case bfd_arch_alpha: 8492 case bfd_arch_sparc: 8493 switch (note->type) 8494 { 8495 case NT_NETBSDCORE_FIRSTMACH+0: 8496 return elfcore_make_note_pseudosection (abfd, ".reg", note); 8497 8498 case NT_NETBSDCORE_FIRSTMACH+2: 8499 return elfcore_make_note_pseudosection (abfd, ".reg2", note); 8500 8501 default: 8502 return TRUE; 8503 } 8504 8505 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5. 8506 There's also old PT___GETREGS40 == mach + 1 for old reg 8507 structure which lacks GBR. */ 8508 8509 case bfd_arch_sh: 8510 switch (note->type) 8511 { 8512 case NT_NETBSDCORE_FIRSTMACH+3: 8513 return elfcore_make_note_pseudosection (abfd, ".reg", note); 8514 8515 case NT_NETBSDCORE_FIRSTMACH+5: 8516 return elfcore_make_note_pseudosection (abfd, ".reg2", note); 8517 8518 default: 8519 return TRUE; 8520 } 8521 8522 /* On all other arch's, PT_GETREGS == mach+1 and 8523 PT_GETFPREGS == mach+3. */ 8524 8525 default: 8526 switch (note->type) 8527 { 8528 case NT_NETBSDCORE_FIRSTMACH+1: 8529 return elfcore_make_note_pseudosection (abfd, ".reg", note); 8530 8531 case NT_NETBSDCORE_FIRSTMACH+3: 8532 return elfcore_make_note_pseudosection (abfd, ".reg2", note); 8533 8534 default: 8535 return TRUE; 8536 } 8537 } 8538 /* NOTREACHED */ 8539 } 8540 8541 static bfd_boolean 8542 elfcore_grok_openbsd_procinfo (bfd *abfd, Elf_Internal_Note *note) 8543 { 8544 /* Signal number at offset 0x08. */ 8545 elf_tdata (abfd)->core_signal 8546 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08); 8547 8548 /* Process ID at offset 0x20. */ 8549 elf_tdata (abfd)->core_pid 8550 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x20); 8551 8552 /* Command name at 0x48 (max 32 bytes, including nul). */ 8553 elf_tdata (abfd)->core_command 8554 = _bfd_elfcore_strndup (abfd, note->descdata + 0x48, 31); 8555 8556 return TRUE; 8557 } 8558 8559 static bfd_boolean 8560 elfcore_grok_openbsd_note (bfd *abfd, Elf_Internal_Note *note) 8561 { 8562 if (note->type == NT_OPENBSD_PROCINFO) 8563 return elfcore_grok_openbsd_procinfo (abfd, note); 8564 8565 if (note->type == NT_OPENBSD_REGS) 8566 return elfcore_make_note_pseudosection (abfd, ".reg", note); 8567 8568 if (note->type == NT_OPENBSD_FPREGS) 8569 return elfcore_make_note_pseudosection (abfd, ".reg2", note); 8570 8571 if (note->type == NT_OPENBSD_XFPREGS) 8572 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note); 8573 8574 if (note->type == NT_OPENBSD_AUXV) 8575 { 8576 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv", 8577 SEC_HAS_CONTENTS); 8578 8579 if (sect == NULL) 8580 return FALSE; 8581 sect->size = note->descsz; 8582 sect->filepos = note->descpos; 8583 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32; 8584 8585 return TRUE; 8586 } 8587 8588 if (note->type == NT_OPENBSD_WCOOKIE) 8589 { 8590 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".wcookie", 8591 SEC_HAS_CONTENTS); 8592 8593 if (sect == NULL) 8594 return FALSE; 8595 sect->size = note->descsz; 8596 sect->filepos = note->descpos; 8597 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32; 8598 8599 return TRUE; 8600 } 8601 8602 return TRUE; 8603 } 8604 8605 static bfd_boolean 8606 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid) 8607 { 8608 void *ddata = note->descdata; 8609 char buf[100]; 8610 char *name; 8611 asection *sect; 8612 short sig; 8613 unsigned flags; 8614 8615 /* nto_procfs_status 'pid' field is at offset 0. */ 8616 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata); 8617 8618 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */ 8619 *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4); 8620 8621 /* nto_procfs_status 'flags' field is at offset 8. */ 8622 flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8); 8623 8624 /* nto_procfs_status 'what' field is at offset 14. */ 8625 if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0) 8626 { 8627 elf_tdata (abfd)->core_signal = sig; 8628 elf_tdata (abfd)->core_lwpid = *tid; 8629 } 8630 8631 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores 8632 do not come from signals so we make sure we set the current 8633 thread just in case. */ 8634 if (flags & 0x00000080) 8635 elf_tdata (abfd)->core_lwpid = *tid; 8636 8637 /* Make a ".qnx_core_status/%d" section. */ 8638 sprintf (buf, ".qnx_core_status/%ld", *tid); 8639 8640 name = (char *) bfd_alloc (abfd, strlen (buf) + 1); 8641 if (name == NULL) 8642 return FALSE; 8643 strcpy (name, buf); 8644 8645 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS); 8646 if (sect == NULL) 8647 return FALSE; 8648 8649 sect->size = note->descsz; 8650 sect->filepos = note->descpos; 8651 sect->alignment_power = 2; 8652 8653 return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect)); 8654 } 8655 8656 static bfd_boolean 8657 elfcore_grok_nto_regs (bfd *abfd, 8658 Elf_Internal_Note *note, 8659 long tid, 8660 char *base) 8661 { 8662 char buf[100]; 8663 char *name; 8664 asection *sect; 8665 8666 /* Make a "(base)/%d" section. */ 8667 sprintf (buf, "%s/%ld", base, tid); 8668 8669 name = (char *) bfd_alloc (abfd, strlen (buf) + 1); 8670 if (name == NULL) 8671 return FALSE; 8672 strcpy (name, buf); 8673 8674 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS); 8675 if (sect == NULL) 8676 return FALSE; 8677 8678 sect->size = note->descsz; 8679 sect->filepos = note->descpos; 8680 sect->alignment_power = 2; 8681 8682 /* This is the current thread. */ 8683 if (elf_tdata (abfd)->core_lwpid == tid) 8684 return elfcore_maybe_make_sect (abfd, base, sect); 8685 8686 return TRUE; 8687 } 8688 8689 #define BFD_QNT_CORE_INFO 7 8690 #define BFD_QNT_CORE_STATUS 8 8691 #define BFD_QNT_CORE_GREG 9 8692 #define BFD_QNT_CORE_FPREG 10 8693 8694 static bfd_boolean 8695 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note) 8696 { 8697 /* Every GREG section has a STATUS section before it. Store the 8698 tid from the previous call to pass down to the next gregs 8699 function. */ 8700 static long tid = 1; 8701 8702 switch (note->type) 8703 { 8704 case BFD_QNT_CORE_INFO: 8705 return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note); 8706 case BFD_QNT_CORE_STATUS: 8707 return elfcore_grok_nto_status (abfd, note, &tid); 8708 case BFD_QNT_CORE_GREG: 8709 return elfcore_grok_nto_regs (abfd, note, tid, ".reg"); 8710 case BFD_QNT_CORE_FPREG: 8711 return elfcore_grok_nto_regs (abfd, note, tid, ".reg2"); 8712 default: 8713 return TRUE; 8714 } 8715 } 8716 8717 static bfd_boolean 8718 elfcore_grok_spu_note (bfd *abfd, Elf_Internal_Note *note) 8719 { 8720 char *name; 8721 asection *sect; 8722 size_t len; 8723 8724 /* Use note name as section name. */ 8725 len = note->namesz; 8726 name = (char *) bfd_alloc (abfd, len); 8727 if (name == NULL) 8728 return FALSE; 8729 memcpy (name, note->namedata, len); 8730 name[len - 1] = '\0'; 8731 8732 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS); 8733 if (sect == NULL) 8734 return FALSE; 8735 8736 sect->size = note->descsz; 8737 sect->filepos = note->descpos; 8738 sect->alignment_power = 1; 8739 8740 return TRUE; 8741 } 8742 8743 /* Function: elfcore_write_note 8744 8745 Inputs: 8746 buffer to hold note, and current size of buffer 8747 name of note 8748 type of note 8749 data for note 8750 size of data for note 8751 8752 Writes note to end of buffer. ELF64 notes are written exactly as 8753 for ELF32, despite the current (as of 2006) ELF gabi specifying 8754 that they ought to have 8-byte namesz and descsz field, and have 8755 8-byte alignment. Other writers, eg. Linux kernel, do the same. 8756 8757 Return: 8758 Pointer to realloc'd buffer, *BUFSIZ updated. */ 8759 8760 char * 8761 elfcore_write_note (bfd *abfd, 8762 char *buf, 8763 int *bufsiz, 8764 const char *name, 8765 int type, 8766 const void *input, 8767 int size) 8768 { 8769 Elf_External_Note *xnp; 8770 size_t namesz; 8771 size_t newspace; 8772 char *dest; 8773 8774 namesz = 0; 8775 if (name != NULL) 8776 namesz = strlen (name) + 1; 8777 8778 newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4); 8779 8780 buf = (char *) realloc (buf, *bufsiz + newspace); 8781 if (buf == NULL) 8782 return buf; 8783 dest = buf + *bufsiz; 8784 *bufsiz += newspace; 8785 xnp = (Elf_External_Note *) dest; 8786 H_PUT_32 (abfd, namesz, xnp->namesz); 8787 H_PUT_32 (abfd, size, xnp->descsz); 8788 H_PUT_32 (abfd, type, xnp->type); 8789 dest = xnp->name; 8790 if (name != NULL) 8791 { 8792 memcpy (dest, name, namesz); 8793 dest += namesz; 8794 while (namesz & 3) 8795 { 8796 *dest++ = '\0'; 8797 ++namesz; 8798 } 8799 } 8800 memcpy (dest, input, size); 8801 dest += size; 8802 while (size & 3) 8803 { 8804 *dest++ = '\0'; 8805 ++size; 8806 } 8807 return buf; 8808 } 8809 8810 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) 8811 char * 8812 elfcore_write_prpsinfo (bfd *abfd, 8813 char *buf, 8814 int *bufsiz, 8815 const char *fname, 8816 const char *psargs) 8817 { 8818 const char *note_name = "CORE"; 8819 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 8820 8821 if (bed->elf_backend_write_core_note != NULL) 8822 { 8823 char *ret; 8824 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz, 8825 NT_PRPSINFO, fname, psargs); 8826 if (ret != NULL) 8827 return ret; 8828 } 8829 8830 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T) 8831 if (bed->s->elfclass == ELFCLASS32) 8832 { 8833 #if defined (HAVE_PSINFO32_T) 8834 psinfo32_t data; 8835 int note_type = NT_PSINFO; 8836 #else 8837 prpsinfo32_t data; 8838 int note_type = NT_PRPSINFO; 8839 #endif 8840 8841 memset (&data, 0, sizeof (data)); 8842 strncpy (data.pr_fname, fname, sizeof (data.pr_fname)); 8843 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs)); 8844 return elfcore_write_note (abfd, buf, bufsiz, 8845 note_name, note_type, &data, sizeof (data)); 8846 } 8847 else 8848 #endif 8849 { 8850 #if defined (HAVE_PSINFO_T) 8851 psinfo_t data; 8852 int note_type = NT_PSINFO; 8853 #else 8854 prpsinfo_t data; 8855 int note_type = NT_PRPSINFO; 8856 #endif 8857 8858 memset (&data, 0, sizeof (data)); 8859 strncpy (data.pr_fname, fname, sizeof (data.pr_fname)); 8860 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs)); 8861 return elfcore_write_note (abfd, buf, bufsiz, 8862 note_name, note_type, &data, sizeof (data)); 8863 } 8864 } 8865 #endif /* PSINFO_T or PRPSINFO_T */ 8866 8867 #if defined (HAVE_PRSTATUS_T) 8868 char * 8869 elfcore_write_prstatus (bfd *abfd, 8870 char *buf, 8871 int *bufsiz, 8872 long pid, 8873 int cursig, 8874 const void *gregs) 8875 { 8876 const char *note_name = "CORE"; 8877 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 8878 8879 if (bed->elf_backend_write_core_note != NULL) 8880 { 8881 char *ret; 8882 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz, 8883 NT_PRSTATUS, 8884 pid, cursig, gregs); 8885 if (ret != NULL) 8886 return ret; 8887 } 8888 8889 #if defined (HAVE_PRSTATUS32_T) 8890 if (bed->s->elfclass == ELFCLASS32) 8891 { 8892 prstatus32_t prstat; 8893 8894 memset (&prstat, 0, sizeof (prstat)); 8895 prstat.pr_pid = pid; 8896 prstat.pr_cursig = cursig; 8897 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg)); 8898 return elfcore_write_note (abfd, buf, bufsiz, note_name, 8899 NT_PRSTATUS, &prstat, sizeof (prstat)); 8900 } 8901 else 8902 #endif 8903 { 8904 prstatus_t prstat; 8905 8906 memset (&prstat, 0, sizeof (prstat)); 8907 prstat.pr_pid = pid; 8908 prstat.pr_cursig = cursig; 8909 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg)); 8910 return elfcore_write_note (abfd, buf, bufsiz, note_name, 8911 NT_PRSTATUS, &prstat, sizeof (prstat)); 8912 } 8913 } 8914 #endif /* HAVE_PRSTATUS_T */ 8915 8916 #if defined (HAVE_LWPSTATUS_T) 8917 char * 8918 elfcore_write_lwpstatus (bfd *abfd, 8919 char *buf, 8920 int *bufsiz, 8921 long pid, 8922 int cursig, 8923 const void *gregs) 8924 { 8925 lwpstatus_t lwpstat; 8926 const char *note_name = "CORE"; 8927 8928 memset (&lwpstat, 0, sizeof (lwpstat)); 8929 lwpstat.pr_lwpid = pid >> 16; 8930 lwpstat.pr_cursig = cursig; 8931 #if defined (HAVE_LWPSTATUS_T_PR_REG) 8932 memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg)); 8933 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT) 8934 #if !defined(gregs) 8935 memcpy (lwpstat.pr_context.uc_mcontext.gregs, 8936 gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs)); 8937 #else 8938 memcpy (lwpstat.pr_context.uc_mcontext.__gregs, 8939 gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs)); 8940 #endif 8941 #endif 8942 return elfcore_write_note (abfd, buf, bufsiz, note_name, 8943 NT_LWPSTATUS, &lwpstat, sizeof (lwpstat)); 8944 } 8945 #endif /* HAVE_LWPSTATUS_T */ 8946 8947 #if defined (HAVE_PSTATUS_T) 8948 char * 8949 elfcore_write_pstatus (bfd *abfd, 8950 char *buf, 8951 int *bufsiz, 8952 long pid, 8953 int cursig ATTRIBUTE_UNUSED, 8954 const void *gregs ATTRIBUTE_UNUSED) 8955 { 8956 const char *note_name = "CORE"; 8957 #if defined (HAVE_PSTATUS32_T) 8958 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 8959 8960 if (bed->s->elfclass == ELFCLASS32) 8961 { 8962 pstatus32_t pstat; 8963 8964 memset (&pstat, 0, sizeof (pstat)); 8965 pstat.pr_pid = pid & 0xffff; 8966 buf = elfcore_write_note (abfd, buf, bufsiz, note_name, 8967 NT_PSTATUS, &pstat, sizeof (pstat)); 8968 return buf; 8969 } 8970 else 8971 #endif 8972 { 8973 pstatus_t pstat; 8974 8975 memset (&pstat, 0, sizeof (pstat)); 8976 pstat.pr_pid = pid & 0xffff; 8977 buf = elfcore_write_note (abfd, buf, bufsiz, note_name, 8978 NT_PSTATUS, &pstat, sizeof (pstat)); 8979 return buf; 8980 } 8981 } 8982 #endif /* HAVE_PSTATUS_T */ 8983 8984 char * 8985 elfcore_write_prfpreg (bfd *abfd, 8986 char *buf, 8987 int *bufsiz, 8988 const void *fpregs, 8989 int size) 8990 { 8991 const char *note_name = "CORE"; 8992 return elfcore_write_note (abfd, buf, bufsiz, 8993 note_name, NT_FPREGSET, fpregs, size); 8994 } 8995 8996 char * 8997 elfcore_write_prxfpreg (bfd *abfd, 8998 char *buf, 8999 int *bufsiz, 9000 const void *xfpregs, 9001 int size) 9002 { 9003 char *note_name = "LINUX"; 9004 return elfcore_write_note (abfd, buf, bufsiz, 9005 note_name, NT_PRXFPREG, xfpregs, size); 9006 } 9007 9008 char * 9009 elfcore_write_xstatereg (bfd *abfd, char *buf, int *bufsiz, 9010 const void *xfpregs, int size) 9011 { 9012 char *note_name = "LINUX"; 9013 return elfcore_write_note (abfd, buf, bufsiz, 9014 note_name, NT_X86_XSTATE, xfpregs, size); 9015 } 9016 9017 char * 9018 elfcore_write_ppc_vmx (bfd *abfd, 9019 char *buf, 9020 int *bufsiz, 9021 const void *ppc_vmx, 9022 int size) 9023 { 9024 char *note_name = "LINUX"; 9025 return elfcore_write_note (abfd, buf, bufsiz, 9026 note_name, NT_PPC_VMX, ppc_vmx, size); 9027 } 9028 9029 char * 9030 elfcore_write_ppc_vsx (bfd *abfd, 9031 char *buf, 9032 int *bufsiz, 9033 const void *ppc_vsx, 9034 int size) 9035 { 9036 char *note_name = "LINUX"; 9037 return elfcore_write_note (abfd, buf, bufsiz, 9038 note_name, NT_PPC_VSX, ppc_vsx, size); 9039 } 9040 9041 static char * 9042 elfcore_write_s390_high_gprs (bfd *abfd, 9043 char *buf, 9044 int *bufsiz, 9045 const void *s390_high_gprs, 9046 int size) 9047 { 9048 char *note_name = "LINUX"; 9049 return elfcore_write_note (abfd, buf, bufsiz, 9050 note_name, NT_S390_HIGH_GPRS, 9051 s390_high_gprs, size); 9052 } 9053 9054 char * 9055 elfcore_write_s390_timer (bfd *abfd, 9056 char *buf, 9057 int *bufsiz, 9058 const void *s390_timer, 9059 int size) 9060 { 9061 char *note_name = "LINUX"; 9062 return elfcore_write_note (abfd, buf, bufsiz, 9063 note_name, NT_S390_TIMER, s390_timer, size); 9064 } 9065 9066 char * 9067 elfcore_write_s390_todcmp (bfd *abfd, 9068 char *buf, 9069 int *bufsiz, 9070 const void *s390_todcmp, 9071 int size) 9072 { 9073 char *note_name = "LINUX"; 9074 return elfcore_write_note (abfd, buf, bufsiz, 9075 note_name, NT_S390_TODCMP, s390_todcmp, size); 9076 } 9077 9078 char * 9079 elfcore_write_s390_todpreg (bfd *abfd, 9080 char *buf, 9081 int *bufsiz, 9082 const void *s390_todpreg, 9083 int size) 9084 { 9085 char *note_name = "LINUX"; 9086 return elfcore_write_note (abfd, buf, bufsiz, 9087 note_name, NT_S390_TODPREG, s390_todpreg, size); 9088 } 9089 9090 char * 9091 elfcore_write_s390_ctrs (bfd *abfd, 9092 char *buf, 9093 int *bufsiz, 9094 const void *s390_ctrs, 9095 int size) 9096 { 9097 char *note_name = "LINUX"; 9098 return elfcore_write_note (abfd, buf, bufsiz, 9099 note_name, NT_S390_CTRS, s390_ctrs, size); 9100 } 9101 9102 char * 9103 elfcore_write_s390_prefix (bfd *abfd, 9104 char *buf, 9105 int *bufsiz, 9106 const void *s390_prefix, 9107 int size) 9108 { 9109 char *note_name = "LINUX"; 9110 return elfcore_write_note (abfd, buf, bufsiz, 9111 note_name, NT_S390_PREFIX, s390_prefix, size); 9112 } 9113 9114 char * 9115 elfcore_write_register_note (bfd *abfd, 9116 char *buf, 9117 int *bufsiz, 9118 const char *section, 9119 const void *data, 9120 int size) 9121 { 9122 if (strcmp (section, ".reg2") == 0) 9123 return elfcore_write_prfpreg (abfd, buf, bufsiz, data, size); 9124 if (strcmp (section, ".reg-xfp") == 0) 9125 return elfcore_write_prxfpreg (abfd, buf, bufsiz, data, size); 9126 if (strcmp (section, ".reg-xstate") == 0) 9127 return elfcore_write_xstatereg (abfd, buf, bufsiz, data, size); 9128 if (strcmp (section, ".reg-ppc-vmx") == 0) 9129 return elfcore_write_ppc_vmx (abfd, buf, bufsiz, data, size); 9130 if (strcmp (section, ".reg-ppc-vsx") == 0) 9131 return elfcore_write_ppc_vsx (abfd, buf, bufsiz, data, size); 9132 if (strcmp (section, ".reg-s390-high-gprs") == 0) 9133 return elfcore_write_s390_high_gprs (abfd, buf, bufsiz, data, size); 9134 if (strcmp (section, ".reg-s390-timer") == 0) 9135 return elfcore_write_s390_timer (abfd, buf, bufsiz, data, size); 9136 if (strcmp (section, ".reg-s390-todcmp") == 0) 9137 return elfcore_write_s390_todcmp (abfd, buf, bufsiz, data, size); 9138 if (strcmp (section, ".reg-s390-todpreg") == 0) 9139 return elfcore_write_s390_todpreg (abfd, buf, bufsiz, data, size); 9140 if (strcmp (section, ".reg-s390-ctrs") == 0) 9141 return elfcore_write_s390_ctrs (abfd, buf, bufsiz, data, size); 9142 if (strcmp (section, ".reg-s390-prefix") == 0) 9143 return elfcore_write_s390_prefix (abfd, buf, bufsiz, data, size); 9144 return NULL; 9145 } 9146 9147 static bfd_boolean 9148 elf_parse_notes (bfd *abfd, char *buf, size_t size, file_ptr offset) 9149 { 9150 char *p; 9151 9152 p = buf; 9153 while (p < buf + size) 9154 { 9155 /* FIXME: bad alignment assumption. */ 9156 Elf_External_Note *xnp = (Elf_External_Note *) p; 9157 Elf_Internal_Note in; 9158 9159 if (offsetof (Elf_External_Note, name) > buf - p + size) 9160 return FALSE; 9161 9162 in.type = H_GET_32 (abfd, xnp->type); 9163 9164 in.namesz = H_GET_32 (abfd, xnp->namesz); 9165 in.namedata = xnp->name; 9166 if (in.namesz > buf - in.namedata + size) 9167 return FALSE; 9168 9169 in.descsz = H_GET_32 (abfd, xnp->descsz); 9170 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4); 9171 in.descpos = offset + (in.descdata - buf); 9172 if (in.descsz != 0 9173 && (in.descdata >= buf + size 9174 || in.descsz > buf - in.descdata + size)) 9175 return FALSE; 9176 9177 switch (bfd_get_format (abfd)) 9178 { 9179 default: 9180 return TRUE; 9181 9182 case bfd_core: 9183 if (CONST_STRNEQ (in.namedata, "NetBSD-CORE")) 9184 { 9185 if (! elfcore_grok_netbsd_note (abfd, &in)) 9186 return FALSE; 9187 } 9188 else if (CONST_STRNEQ (in.namedata, "OpenBSD")) 9189 { 9190 if (! elfcore_grok_openbsd_note (abfd, &in)) 9191 return FALSE; 9192 } 9193 else if (CONST_STRNEQ (in.namedata, "QNX")) 9194 { 9195 if (! elfcore_grok_nto_note (abfd, &in)) 9196 return FALSE; 9197 } 9198 else if (CONST_STRNEQ (in.namedata, "SPU/")) 9199 { 9200 if (! elfcore_grok_spu_note (abfd, &in)) 9201 return FALSE; 9202 } 9203 else 9204 { 9205 if (! elfcore_grok_note (abfd, &in)) 9206 return FALSE; 9207 } 9208 break; 9209 9210 case bfd_object: 9211 if (in.namesz == sizeof "GNU" && strcmp (in.namedata, "GNU") == 0) 9212 { 9213 if (! elfobj_grok_gnu_note (abfd, &in)) 9214 return FALSE; 9215 } 9216 break; 9217 } 9218 9219 p = in.descdata + BFD_ALIGN (in.descsz, 4); 9220 } 9221 9222 return TRUE; 9223 } 9224 9225 static bfd_boolean 9226 elf_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size) 9227 { 9228 char *buf; 9229 9230 if (size <= 0) 9231 return TRUE; 9232 9233 if (bfd_seek (abfd, offset, SEEK_SET) != 0) 9234 return FALSE; 9235 9236 buf = (char *) bfd_malloc (size); 9237 if (buf == NULL) 9238 return FALSE; 9239 9240 if (bfd_bread (buf, size, abfd) != size 9241 || !elf_parse_notes (abfd, buf, size, offset)) 9242 { 9243 free (buf); 9244 return FALSE; 9245 } 9246 9247 free (buf); 9248 return TRUE; 9249 } 9250 9251 /* Providing external access to the ELF program header table. */ 9252 9253 /* Return an upper bound on the number of bytes required to store a 9254 copy of ABFD's program header table entries. Return -1 if an error 9255 occurs; bfd_get_error will return an appropriate code. */ 9256 9257 long 9258 bfd_get_elf_phdr_upper_bound (bfd *abfd) 9259 { 9260 if (abfd->xvec->flavour != bfd_target_elf_flavour) 9261 { 9262 bfd_set_error (bfd_error_wrong_format); 9263 return -1; 9264 } 9265 9266 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr); 9267 } 9268 9269 /* Copy ABFD's program header table entries to *PHDRS. The entries 9270 will be stored as an array of Elf_Internal_Phdr structures, as 9271 defined in include/elf/internal.h. To find out how large the 9272 buffer needs to be, call bfd_get_elf_phdr_upper_bound. 9273 9274 Return the number of program header table entries read, or -1 if an 9275 error occurs; bfd_get_error will return an appropriate code. */ 9276 9277 int 9278 bfd_get_elf_phdrs (bfd *abfd, void *phdrs) 9279 { 9280 int num_phdrs; 9281 9282 if (abfd->xvec->flavour != bfd_target_elf_flavour) 9283 { 9284 bfd_set_error (bfd_error_wrong_format); 9285 return -1; 9286 } 9287 9288 num_phdrs = elf_elfheader (abfd)->e_phnum; 9289 memcpy (phdrs, elf_tdata (abfd)->phdr, 9290 num_phdrs * sizeof (Elf_Internal_Phdr)); 9291 9292 return num_phdrs; 9293 } 9294 9295 enum elf_reloc_type_class 9296 _bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED) 9297 { 9298 return reloc_class_normal; 9299 } 9300 9301 /* For RELA architectures, return the relocation value for a 9302 relocation against a local symbol. */ 9303 9304 bfd_vma 9305 _bfd_elf_rela_local_sym (bfd *abfd, 9306 Elf_Internal_Sym *sym, 9307 asection **psec, 9308 Elf_Internal_Rela *rel) 9309 { 9310 asection *sec = *psec; 9311 bfd_vma relocation; 9312 9313 relocation = (sec->output_section->vma 9314 + sec->output_offset 9315 + sym->st_value); 9316 if ((sec->flags & SEC_MERGE) 9317 && ELF_ST_TYPE (sym->st_info) == STT_SECTION 9318 && sec->sec_info_type == ELF_INFO_TYPE_MERGE) 9319 { 9320 rel->r_addend = 9321 _bfd_merged_section_offset (abfd, psec, 9322 elf_section_data (sec)->sec_info, 9323 sym->st_value + rel->r_addend); 9324 if (sec != *psec) 9325 { 9326 /* If we have changed the section, and our original section is 9327 marked with SEC_EXCLUDE, it means that the original 9328 SEC_MERGE section has been completely subsumed in some 9329 other SEC_MERGE section. In this case, we need to leave 9330 some info around for --emit-relocs. */ 9331 if ((sec->flags & SEC_EXCLUDE) != 0) 9332 sec->kept_section = *psec; 9333 sec = *psec; 9334 } 9335 rel->r_addend -= relocation; 9336 rel->r_addend += sec->output_section->vma + sec->output_offset; 9337 } 9338 return relocation; 9339 } 9340 9341 bfd_vma 9342 _bfd_elf_rel_local_sym (bfd *abfd, 9343 Elf_Internal_Sym *sym, 9344 asection **psec, 9345 bfd_vma addend) 9346 { 9347 asection *sec = *psec; 9348 9349 if (sec->sec_info_type != ELF_INFO_TYPE_MERGE) 9350 return sym->st_value + addend; 9351 9352 return _bfd_merged_section_offset (abfd, psec, 9353 elf_section_data (sec)->sec_info, 9354 sym->st_value + addend); 9355 } 9356 9357 bfd_vma 9358 _bfd_elf_section_offset (bfd *abfd, 9359 struct bfd_link_info *info, 9360 asection *sec, 9361 bfd_vma offset) 9362 { 9363 switch (sec->sec_info_type) 9364 { 9365 case ELF_INFO_TYPE_STABS: 9366 return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info, 9367 offset); 9368 case ELF_INFO_TYPE_EH_FRAME: 9369 return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset); 9370 default: 9371 return offset; 9372 } 9373 } 9374 9375 /* Create a new BFD as if by bfd_openr. Rather than opening a file, 9376 reconstruct an ELF file by reading the segments out of remote memory 9377 based on the ELF file header at EHDR_VMA and the ELF program headers it 9378 points to. If not null, *LOADBASEP is filled in with the difference 9379 between the VMAs from which the segments were read, and the VMAs the 9380 file headers (and hence BFD's idea of each section's VMA) put them at. 9381 9382 The function TARGET_READ_MEMORY is called to copy LEN bytes from the 9383 remote memory at target address VMA into the local buffer at MYADDR; it 9384 should return zero on success or an `errno' code on failure. TEMPL must 9385 be a BFD for an ELF target with the word size and byte order found in 9386 the remote memory. */ 9387 9388 bfd * 9389 bfd_elf_bfd_from_remote_memory 9390 (bfd *templ, 9391 bfd_vma ehdr_vma, 9392 bfd_vma *loadbasep, 9393 int (*target_read_memory) (bfd_vma, bfd_byte *, int)) 9394 { 9395 return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory) 9396 (templ, ehdr_vma, loadbasep, target_read_memory); 9397 } 9398 9399 long 9400 _bfd_elf_get_synthetic_symtab (bfd *abfd, 9401 long symcount ATTRIBUTE_UNUSED, 9402 asymbol **syms ATTRIBUTE_UNUSED, 9403 long dynsymcount, 9404 asymbol **dynsyms, 9405 asymbol **ret) 9406 { 9407 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 9408 asection *relplt; 9409 asymbol *s; 9410 const char *relplt_name; 9411 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean); 9412 arelent *p; 9413 long count, i, n; 9414 size_t size; 9415 Elf_Internal_Shdr *hdr; 9416 char *names; 9417 asection *plt; 9418 9419 *ret = NULL; 9420 9421 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0) 9422 return 0; 9423 9424 if (dynsymcount <= 0) 9425 return 0; 9426 9427 if (!bed->plt_sym_val) 9428 return 0; 9429 9430 relplt_name = bed->relplt_name; 9431 if (relplt_name == NULL) 9432 relplt_name = bed->rela_plts_and_copies_p ? ".rela.plt" : ".rel.plt"; 9433 relplt = bfd_get_section_by_name (abfd, relplt_name); 9434 if (relplt == NULL) 9435 return 0; 9436 9437 hdr = &elf_section_data (relplt)->this_hdr; 9438 if (hdr->sh_link != elf_dynsymtab (abfd) 9439 || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA)) 9440 return 0; 9441 9442 plt = bfd_get_section_by_name (abfd, ".plt"); 9443 if (plt == NULL) 9444 return 0; 9445 9446 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table; 9447 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE)) 9448 return -1; 9449 9450 count = relplt->size / hdr->sh_entsize; 9451 size = count * sizeof (asymbol); 9452 p = relplt->relocation; 9453 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel) 9454 { 9455 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt"); 9456 if (p->addend != 0) 9457 { 9458 #ifdef BFD64 9459 size += sizeof ("+0x") - 1 + 8 + 8 * (bed->s->elfclass == ELFCLASS64); 9460 #else 9461 size += sizeof ("+0x") - 1 + 8; 9462 #endif 9463 } 9464 } 9465 9466 s = *ret = (asymbol *) bfd_malloc (size); 9467 if (s == NULL) 9468 return -1; 9469 9470 names = (char *) (s + count); 9471 p = relplt->relocation; 9472 n = 0; 9473 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel) 9474 { 9475 size_t len; 9476 bfd_vma addr; 9477 9478 addr = bed->plt_sym_val (i, plt, p); 9479 if (addr == (bfd_vma) -1) 9480 continue; 9481 9482 *s = **p->sym_ptr_ptr; 9483 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since 9484 we are defining a symbol, ensure one of them is set. */ 9485 if ((s->flags & BSF_LOCAL) == 0) 9486 s->flags |= BSF_GLOBAL; 9487 s->flags |= BSF_SYNTHETIC; 9488 s->section = plt; 9489 s->value = addr - plt->vma; 9490 s->name = names; 9491 s->udata.p = NULL; 9492 len = strlen ((*p->sym_ptr_ptr)->name); 9493 memcpy (names, (*p->sym_ptr_ptr)->name, len); 9494 names += len; 9495 if (p->addend != 0) 9496 { 9497 char buf[30], *a; 9498 9499 memcpy (names, "+0x", sizeof ("+0x") - 1); 9500 names += sizeof ("+0x") - 1; 9501 bfd_sprintf_vma (abfd, buf, p->addend); 9502 for (a = buf; *a == '0'; ++a) 9503 ; 9504 len = strlen (a); 9505 memcpy (names, a, len); 9506 names += len; 9507 } 9508 memcpy (names, "@plt", sizeof ("@plt")); 9509 names += sizeof ("@plt"); 9510 ++s, ++n; 9511 } 9512 9513 return n; 9514 } 9515 9516 /* It is only used by x86-64 so far. */ 9517 asection _bfd_elf_large_com_section 9518 = BFD_FAKE_SECTION (_bfd_elf_large_com_section, 9519 SEC_IS_COMMON, NULL, "LARGE_COMMON", 0); 9520 9521 void 9522 _bfd_elf_set_osabi (bfd * abfd, 9523 struct bfd_link_info * link_info ATTRIBUTE_UNUSED) 9524 { 9525 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */ 9526 9527 i_ehdrp = elf_elfheader (abfd); 9528 9529 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi; 9530 9531 /* To make things simpler for the loader on Linux systems we set the 9532 osabi field to ELFOSABI_LINUX if the binary contains symbols of 9533 the STT_GNU_IFUNC type or STB_GNU_UNIQUE binding. */ 9534 if (i_ehdrp->e_ident[EI_OSABI] == ELFOSABI_NONE 9535 && elf_tdata (abfd)->has_gnu_symbols) 9536 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_LINUX; 9537 } 9538 9539 9540 /* Return TRUE for ELF symbol types that represent functions. 9541 This is the default version of this function, which is sufficient for 9542 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */ 9543 9544 bfd_boolean 9545 _bfd_elf_is_function_type (unsigned int type) 9546 { 9547 return (type == STT_FUNC 9548 || type == STT_GNU_IFUNC); 9549 } 9550