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