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