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