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