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