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