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