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