1 /* .eh_frame section optimization. 2 Copyright (C) 2001-2020 Free Software Foundation, Inc. 3 Written by Jakub Jelinek <jakub@redhat.com>. 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 #include "sysdep.h" 23 #include "bfd.h" 24 #include "libbfd.h" 25 #include "elf-bfd.h" 26 #include "dwarf2.h" 27 28 #define EH_FRAME_HDR_SIZE 8 29 30 struct cie 31 { 32 unsigned int length; 33 unsigned int hash; 34 unsigned char version; 35 unsigned char local_personality; 36 char augmentation[20]; 37 bfd_vma code_align; 38 bfd_signed_vma data_align; 39 bfd_vma ra_column; 40 bfd_vma augmentation_size; 41 union { 42 struct elf_link_hash_entry *h; 43 struct { 44 unsigned int bfd_id; 45 unsigned int index; 46 } sym; 47 unsigned int reloc_index; 48 } personality; 49 struct eh_cie_fde *cie_inf; 50 unsigned char per_encoding; 51 unsigned char lsda_encoding; 52 unsigned char fde_encoding; 53 unsigned char initial_insn_length; 54 unsigned char can_make_lsda_relative; 55 unsigned char initial_instructions[50]; 56 }; 57 58 59 60 /* If *ITER hasn't reached END yet, read the next byte into *RESULT and 61 move onto the next byte. Return true on success. */ 62 63 static inline bfd_boolean 64 read_byte (bfd_byte **iter, bfd_byte *end, unsigned char *result) 65 { 66 if (*iter >= end) 67 return FALSE; 68 *result = *((*iter)++); 69 return TRUE; 70 } 71 72 /* Move *ITER over LENGTH bytes, or up to END, whichever is closer. 73 Return true it was possible to move LENGTH bytes. */ 74 75 static inline bfd_boolean 76 skip_bytes (bfd_byte **iter, bfd_byte *end, bfd_size_type length) 77 { 78 if ((bfd_size_type) (end - *iter) < length) 79 { 80 *iter = end; 81 return FALSE; 82 } 83 *iter += length; 84 return TRUE; 85 } 86 87 /* Move *ITER over an leb128, stopping at END. Return true if the end 88 of the leb128 was found. */ 89 90 static bfd_boolean 91 skip_leb128 (bfd_byte **iter, bfd_byte *end) 92 { 93 unsigned char byte; 94 do 95 if (!read_byte (iter, end, &byte)) 96 return FALSE; 97 while (byte & 0x80); 98 return TRUE; 99 } 100 101 /* Like skip_leb128, but treat the leb128 as an unsigned value and 102 store it in *VALUE. */ 103 104 static bfd_boolean 105 read_uleb128 (bfd_byte **iter, bfd_byte *end, bfd_vma *value) 106 { 107 bfd_byte *start, *p; 108 109 start = *iter; 110 if (!skip_leb128 (iter, end)) 111 return FALSE; 112 113 p = *iter; 114 *value = *--p; 115 while (p > start) 116 *value = (*value << 7) | (*--p & 0x7f); 117 118 return TRUE; 119 } 120 121 /* Like read_uleb128, but for signed values. */ 122 123 static bfd_boolean 124 read_sleb128 (bfd_byte **iter, bfd_byte *end, bfd_signed_vma *value) 125 { 126 bfd_byte *start, *p; 127 128 start = *iter; 129 if (!skip_leb128 (iter, end)) 130 return FALSE; 131 132 p = *iter; 133 *value = ((*--p & 0x7f) ^ 0x40) - 0x40; 134 while (p > start) 135 *value = (*value << 7) | (*--p & 0x7f); 136 137 return TRUE; 138 } 139 140 /* Return 0 if either encoding is variable width, or not yet known to bfd. */ 141 142 static 143 int get_DW_EH_PE_width (int encoding, int ptr_size) 144 { 145 /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame 146 was added to bfd. */ 147 if ((encoding & 0x60) == 0x60) 148 return 0; 149 150 switch (encoding & 7) 151 { 152 case DW_EH_PE_udata2: return 2; 153 case DW_EH_PE_udata4: return 4; 154 case DW_EH_PE_udata8: return 8; 155 case DW_EH_PE_absptr: return ptr_size; 156 default: 157 break; 158 } 159 160 return 0; 161 } 162 163 #define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0) 164 165 /* Read a width sized value from memory. */ 166 167 static bfd_vma 168 read_value (bfd *abfd, bfd_byte *buf, int width, int is_signed) 169 { 170 bfd_vma value; 171 172 switch (width) 173 { 174 case 2: 175 if (is_signed) 176 value = bfd_get_signed_16 (abfd, buf); 177 else 178 value = bfd_get_16 (abfd, buf); 179 break; 180 case 4: 181 if (is_signed) 182 value = bfd_get_signed_32 (abfd, buf); 183 else 184 value = bfd_get_32 (abfd, buf); 185 break; 186 case 8: 187 if (is_signed) 188 value = bfd_get_signed_64 (abfd, buf); 189 else 190 value = bfd_get_64 (abfd, buf); 191 break; 192 default: 193 BFD_FAIL (); 194 return 0; 195 } 196 197 return value; 198 } 199 200 /* Store a width sized value to memory. */ 201 202 static void 203 write_value (bfd *abfd, bfd_byte *buf, bfd_vma value, int width) 204 { 205 switch (width) 206 { 207 case 2: bfd_put_16 (abfd, value, buf); break; 208 case 4: bfd_put_32 (abfd, value, buf); break; 209 case 8: bfd_put_64 (abfd, value, buf); break; 210 default: BFD_FAIL (); 211 } 212 } 213 214 /* Return one if C1 and C2 CIEs can be merged. */ 215 216 static int 217 cie_eq (const void *e1, const void *e2) 218 { 219 const struct cie *c1 = (const struct cie *) e1; 220 const struct cie *c2 = (const struct cie *) e2; 221 222 if (c1->hash == c2->hash 223 && c1->length == c2->length 224 && c1->version == c2->version 225 && c1->local_personality == c2->local_personality 226 && strcmp (c1->augmentation, c2->augmentation) == 0 227 && strcmp (c1->augmentation, "eh") != 0 228 && c1->code_align == c2->code_align 229 && c1->data_align == c2->data_align 230 && c1->ra_column == c2->ra_column 231 && c1->augmentation_size == c2->augmentation_size 232 && memcmp (&c1->personality, &c2->personality, 233 sizeof (c1->personality)) == 0 234 && (c1->cie_inf->u.cie.u.sec->output_section 235 == c2->cie_inf->u.cie.u.sec->output_section) 236 && c1->per_encoding == c2->per_encoding 237 && c1->lsda_encoding == c2->lsda_encoding 238 && c1->fde_encoding == c2->fde_encoding 239 && c1->initial_insn_length == c2->initial_insn_length 240 && c1->initial_insn_length <= sizeof (c1->initial_instructions) 241 && memcmp (c1->initial_instructions, 242 c2->initial_instructions, 243 c1->initial_insn_length) == 0) 244 return 1; 245 246 return 0; 247 } 248 249 static hashval_t 250 cie_hash (const void *e) 251 { 252 const struct cie *c = (const struct cie *) e; 253 return c->hash; 254 } 255 256 static hashval_t 257 cie_compute_hash (struct cie *c) 258 { 259 hashval_t h = 0; 260 size_t len; 261 h = iterative_hash_object (c->length, h); 262 h = iterative_hash_object (c->version, h); 263 h = iterative_hash (c->augmentation, strlen (c->augmentation) + 1, h); 264 h = iterative_hash_object (c->code_align, h); 265 h = iterative_hash_object (c->data_align, h); 266 h = iterative_hash_object (c->ra_column, h); 267 h = iterative_hash_object (c->augmentation_size, h); 268 h = iterative_hash_object (c->personality, h); 269 h = iterative_hash_object (c->cie_inf->u.cie.u.sec->output_section, h); 270 h = iterative_hash_object (c->per_encoding, h); 271 h = iterative_hash_object (c->lsda_encoding, h); 272 h = iterative_hash_object (c->fde_encoding, h); 273 h = iterative_hash_object (c->initial_insn_length, h); 274 len = c->initial_insn_length; 275 if (len > sizeof (c->initial_instructions)) 276 len = sizeof (c->initial_instructions); 277 h = iterative_hash (c->initial_instructions, len, h); 278 c->hash = h; 279 return h; 280 } 281 282 /* Return the number of extra bytes that we'll be inserting into 283 ENTRY's augmentation string. */ 284 285 static INLINE unsigned int 286 extra_augmentation_string_bytes (struct eh_cie_fde *entry) 287 { 288 unsigned int size = 0; 289 if (entry->cie) 290 { 291 if (entry->add_augmentation_size) 292 size++; 293 if (entry->u.cie.add_fde_encoding) 294 size++; 295 } 296 return size; 297 } 298 299 /* Likewise ENTRY's augmentation data. */ 300 301 static INLINE unsigned int 302 extra_augmentation_data_bytes (struct eh_cie_fde *entry) 303 { 304 unsigned int size = 0; 305 if (entry->add_augmentation_size) 306 size++; 307 if (entry->cie && entry->u.cie.add_fde_encoding) 308 size++; 309 return size; 310 } 311 312 /* Return the size that ENTRY will have in the output. */ 313 314 static unsigned int 315 size_of_output_cie_fde (struct eh_cie_fde *entry) 316 { 317 if (entry->removed) 318 return 0; 319 if (entry->size == 4) 320 return 4; 321 return (entry->size 322 + extra_augmentation_string_bytes (entry) 323 + extra_augmentation_data_bytes (entry)); 324 } 325 326 /* Return the offset of the FDE or CIE after ENT. */ 327 328 static unsigned int 329 next_cie_fde_offset (const struct eh_cie_fde *ent, 330 const struct eh_cie_fde *last, 331 const asection *sec) 332 { 333 while (++ent < last) 334 { 335 if (!ent->removed) 336 return ent->new_offset; 337 } 338 return sec->size; 339 } 340 341 /* Assume that the bytes between *ITER and END are CFA instructions. 342 Try to move *ITER past the first instruction and return true on 343 success. ENCODED_PTR_WIDTH gives the width of pointer entries. */ 344 345 static bfd_boolean 346 skip_cfa_op (bfd_byte **iter, bfd_byte *end, unsigned int encoded_ptr_width) 347 { 348 bfd_byte op; 349 bfd_vma length; 350 351 if (!read_byte (iter, end, &op)) 352 return FALSE; 353 354 switch (op & 0xc0 ? op & 0xc0 : op) 355 { 356 case DW_CFA_nop: 357 case DW_CFA_advance_loc: 358 case DW_CFA_restore: 359 case DW_CFA_remember_state: 360 case DW_CFA_restore_state: 361 case DW_CFA_GNU_window_save: 362 /* No arguments. */ 363 return TRUE; 364 365 case DW_CFA_offset: 366 case DW_CFA_restore_extended: 367 case DW_CFA_undefined: 368 case DW_CFA_same_value: 369 case DW_CFA_def_cfa_register: 370 case DW_CFA_def_cfa_offset: 371 case DW_CFA_def_cfa_offset_sf: 372 case DW_CFA_GNU_args_size: 373 /* One leb128 argument. */ 374 return skip_leb128 (iter, end); 375 376 case DW_CFA_val_offset: 377 case DW_CFA_val_offset_sf: 378 case DW_CFA_offset_extended: 379 case DW_CFA_register: 380 case DW_CFA_def_cfa: 381 case DW_CFA_offset_extended_sf: 382 case DW_CFA_GNU_negative_offset_extended: 383 case DW_CFA_def_cfa_sf: 384 /* Two leb128 arguments. */ 385 return (skip_leb128 (iter, end) 386 && skip_leb128 (iter, end)); 387 388 case DW_CFA_def_cfa_expression: 389 /* A variable-length argument. */ 390 return (read_uleb128 (iter, end, &length) 391 && skip_bytes (iter, end, length)); 392 393 case DW_CFA_expression: 394 case DW_CFA_val_expression: 395 /* A leb128 followed by a variable-length argument. */ 396 return (skip_leb128 (iter, end) 397 && read_uleb128 (iter, end, &length) 398 && skip_bytes (iter, end, length)); 399 400 case DW_CFA_set_loc: 401 return skip_bytes (iter, end, encoded_ptr_width); 402 403 case DW_CFA_advance_loc1: 404 return skip_bytes (iter, end, 1); 405 406 case DW_CFA_advance_loc2: 407 return skip_bytes (iter, end, 2); 408 409 case DW_CFA_advance_loc4: 410 return skip_bytes (iter, end, 4); 411 412 case DW_CFA_MIPS_advance_loc8: 413 return skip_bytes (iter, end, 8); 414 415 default: 416 return FALSE; 417 } 418 } 419 420 /* Try to interpret the bytes between BUF and END as CFA instructions. 421 If every byte makes sense, return a pointer to the first DW_CFA_nop 422 padding byte, or END if there is no padding. Return null otherwise. 423 ENCODED_PTR_WIDTH is as for skip_cfa_op. */ 424 425 static bfd_byte * 426 skip_non_nops (bfd_byte *buf, bfd_byte *end, unsigned int encoded_ptr_width, 427 unsigned int *set_loc_count) 428 { 429 bfd_byte *last; 430 431 last = buf; 432 while (buf < end) 433 if (*buf == DW_CFA_nop) 434 buf++; 435 else 436 { 437 if (*buf == DW_CFA_set_loc) 438 ++*set_loc_count; 439 if (!skip_cfa_op (&buf, end, encoded_ptr_width)) 440 return 0; 441 last = buf; 442 } 443 return last; 444 } 445 446 /* Convert absolute encoding ENCODING into PC-relative form. 447 SIZE is the size of a pointer. */ 448 449 static unsigned char 450 make_pc_relative (unsigned char encoding, unsigned int ptr_size) 451 { 452 if ((encoding & 0x7f) == DW_EH_PE_absptr) 453 switch (ptr_size) 454 { 455 case 2: 456 encoding |= DW_EH_PE_sdata2; 457 break; 458 case 4: 459 encoding |= DW_EH_PE_sdata4; 460 break; 461 case 8: 462 encoding |= DW_EH_PE_sdata8; 463 break; 464 } 465 return encoding | DW_EH_PE_pcrel; 466 } 467 468 /* Examine each .eh_frame_entry section and discard those 469 those that are marked SEC_EXCLUDE. */ 470 471 static void 472 bfd_elf_discard_eh_frame_entry (struct eh_frame_hdr_info *hdr_info) 473 { 474 unsigned int i; 475 for (i = 0; i < hdr_info->array_count; i++) 476 { 477 if (hdr_info->u.compact.entries[i]->flags & SEC_EXCLUDE) 478 { 479 unsigned int j; 480 for (j = i + 1; j < hdr_info->array_count; j++) 481 hdr_info->u.compact.entries[j-1] = hdr_info->u.compact.entries[j]; 482 483 hdr_info->array_count--; 484 hdr_info->u.compact.entries[hdr_info->array_count] = NULL; 485 i--; 486 } 487 } 488 } 489 490 /* Add a .eh_frame_entry section. */ 491 492 static void 493 bfd_elf_record_eh_frame_entry (struct eh_frame_hdr_info *hdr_info, 494 asection *sec) 495 { 496 if (hdr_info->array_count == hdr_info->u.compact.allocated_entries) 497 { 498 if (hdr_info->u.compact.allocated_entries == 0) 499 { 500 hdr_info->frame_hdr_is_compact = TRUE; 501 hdr_info->u.compact.allocated_entries = 2; 502 hdr_info->u.compact.entries = 503 bfd_malloc (hdr_info->u.compact.allocated_entries 504 * sizeof (hdr_info->u.compact.entries[0])); 505 } 506 else 507 { 508 hdr_info->u.compact.allocated_entries *= 2; 509 hdr_info->u.compact.entries = 510 bfd_realloc (hdr_info->u.compact.entries, 511 hdr_info->u.compact.allocated_entries 512 * sizeof (hdr_info->u.compact.entries[0])); 513 } 514 515 BFD_ASSERT (hdr_info->u.compact.entries); 516 } 517 518 hdr_info->u.compact.entries[hdr_info->array_count++] = sec; 519 } 520 521 /* Parse a .eh_frame_entry section. Figure out which text section it 522 references. */ 523 524 bfd_boolean 525 _bfd_elf_parse_eh_frame_entry (struct bfd_link_info *info, 526 asection *sec, struct elf_reloc_cookie *cookie) 527 { 528 struct elf_link_hash_table *htab; 529 struct eh_frame_hdr_info *hdr_info; 530 unsigned long r_symndx; 531 asection *text_sec; 532 533 htab = elf_hash_table (info); 534 hdr_info = &htab->eh_info; 535 536 if (sec->size == 0 537 || sec->sec_info_type != SEC_INFO_TYPE_NONE) 538 { 539 return TRUE; 540 } 541 542 if (sec->output_section && bfd_is_abs_section (sec->output_section)) 543 { 544 /* At least one of the sections is being discarded from the 545 link, so we should just ignore them. */ 546 return TRUE; 547 } 548 549 if (cookie->rel == cookie->relend) 550 return FALSE; 551 552 /* The first relocation is the function start. */ 553 r_symndx = cookie->rel->r_info >> cookie->r_sym_shift; 554 if (r_symndx == STN_UNDEF) 555 return FALSE; 556 557 text_sec = _bfd_elf_section_for_symbol (cookie, r_symndx, FALSE); 558 559 if (text_sec == NULL) 560 return FALSE; 561 562 elf_section_eh_frame_entry (text_sec) = sec; 563 if (text_sec->output_section 564 && bfd_is_abs_section (text_sec->output_section)) 565 sec->flags |= SEC_EXCLUDE; 566 567 sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME_ENTRY; 568 elf_section_data (sec)->sec_info = text_sec; 569 bfd_elf_record_eh_frame_entry (hdr_info, sec); 570 return TRUE; 571 } 572 573 /* Try to parse .eh_frame section SEC, which belongs to ABFD. Store the 574 information in the section's sec_info field on success. COOKIE 575 describes the relocations in SEC. */ 576 577 void 578 _bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info, 579 asection *sec, struct elf_reloc_cookie *cookie) 580 { 581 #define REQUIRE(COND) \ 582 do \ 583 if (!(COND)) \ 584 goto free_no_table; \ 585 while (0) 586 587 bfd_byte *ehbuf = NULL, *buf, *end; 588 bfd_byte *last_fde; 589 struct eh_cie_fde *this_inf; 590 unsigned int hdr_length, hdr_id; 591 unsigned int cie_count; 592 struct cie *cie, *local_cies = NULL; 593 struct elf_link_hash_table *htab; 594 struct eh_frame_hdr_info *hdr_info; 595 struct eh_frame_sec_info *sec_info = NULL; 596 unsigned int ptr_size; 597 unsigned int num_cies; 598 unsigned int num_entries; 599 elf_gc_mark_hook_fn gc_mark_hook; 600 601 htab = elf_hash_table (info); 602 hdr_info = &htab->eh_info; 603 604 if (sec->size == 0 605 || sec->sec_info_type != SEC_INFO_TYPE_NONE) 606 { 607 /* This file does not contain .eh_frame information. */ 608 return; 609 } 610 611 if (bfd_is_abs_section (sec->output_section)) 612 { 613 /* At least one of the sections is being discarded from the 614 link, so we should just ignore them. */ 615 return; 616 } 617 618 /* Read the frame unwind information from abfd. */ 619 620 REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf)); 621 622 /* If .eh_frame section size doesn't fit into int, we cannot handle 623 it (it would need to use 64-bit .eh_frame format anyway). */ 624 REQUIRE (sec->size == (unsigned int) sec->size); 625 626 ptr_size = (get_elf_backend_data (abfd) 627 ->elf_backend_eh_frame_address_size (abfd, sec)); 628 REQUIRE (ptr_size != 0); 629 630 /* Go through the section contents and work out how many FDEs and 631 CIEs there are. */ 632 buf = ehbuf; 633 end = ehbuf + sec->size; 634 num_cies = 0; 635 num_entries = 0; 636 while (buf != end) 637 { 638 num_entries++; 639 640 /* Read the length of the entry. */ 641 REQUIRE (skip_bytes (&buf, end, 4)); 642 hdr_length = bfd_get_32 (abfd, buf - 4); 643 644 /* 64-bit .eh_frame is not supported. */ 645 REQUIRE (hdr_length != 0xffffffff); 646 if (hdr_length == 0) 647 break; 648 649 REQUIRE (skip_bytes (&buf, end, 4)); 650 hdr_id = bfd_get_32 (abfd, buf - 4); 651 if (hdr_id == 0) 652 num_cies++; 653 654 REQUIRE (skip_bytes (&buf, end, hdr_length - 4)); 655 } 656 657 sec_info = (struct eh_frame_sec_info *) 658 bfd_zmalloc (sizeof (struct eh_frame_sec_info) 659 + (num_entries - 1) * sizeof (struct eh_cie_fde)); 660 REQUIRE (sec_info); 661 662 /* We need to have a "struct cie" for each CIE in this section. */ 663 if (num_cies) 664 { 665 local_cies = (struct cie *) bfd_zmalloc (num_cies * sizeof (*local_cies)); 666 REQUIRE (local_cies); 667 } 668 669 /* FIXME: octets_per_byte. */ 670 #define ENSURE_NO_RELOCS(buf) \ 671 while (cookie->rel < cookie->relend \ 672 && (cookie->rel->r_offset \ 673 < (bfd_size_type) ((buf) - ehbuf))) \ 674 { \ 675 REQUIRE (cookie->rel->r_info == 0); \ 676 cookie->rel++; \ 677 } 678 679 /* FIXME: octets_per_byte. */ 680 #define SKIP_RELOCS(buf) \ 681 while (cookie->rel < cookie->relend \ 682 && (cookie->rel->r_offset \ 683 < (bfd_size_type) ((buf) - ehbuf))) \ 684 cookie->rel++ 685 686 /* FIXME: octets_per_byte. */ 687 #define GET_RELOC(buf) \ 688 ((cookie->rel < cookie->relend \ 689 && (cookie->rel->r_offset \ 690 == (bfd_size_type) ((buf) - ehbuf))) \ 691 ? cookie->rel : NULL) 692 693 buf = ehbuf; 694 cie_count = 0; 695 gc_mark_hook = get_elf_backend_data (abfd)->gc_mark_hook; 696 while ((bfd_size_type) (buf - ehbuf) != sec->size) 697 { 698 char *aug; 699 bfd_byte *start, *insns, *insns_end; 700 bfd_size_type length; 701 unsigned int set_loc_count; 702 703 this_inf = sec_info->entry + sec_info->count; 704 last_fde = buf; 705 706 /* Read the length of the entry. */ 707 REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4)); 708 hdr_length = bfd_get_32 (abfd, buf - 4); 709 710 /* The CIE/FDE must be fully contained in this input section. */ 711 REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size); 712 end = buf + hdr_length; 713 714 this_inf->offset = last_fde - ehbuf; 715 this_inf->size = 4 + hdr_length; 716 this_inf->reloc_index = cookie->rel - cookie->rels; 717 718 if (hdr_length == 0) 719 { 720 /* A zero-length CIE should only be found at the end of 721 the section, but allow multiple terminators. */ 722 while (skip_bytes (&buf, ehbuf + sec->size, 4)) 723 REQUIRE (bfd_get_32 (abfd, buf - 4) == 0); 724 REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size); 725 ENSURE_NO_RELOCS (buf); 726 sec_info->count++; 727 break; 728 } 729 730 REQUIRE (skip_bytes (&buf, end, 4)); 731 hdr_id = bfd_get_32 (abfd, buf - 4); 732 733 if (hdr_id == 0) 734 { 735 unsigned int initial_insn_length; 736 737 /* CIE */ 738 this_inf->cie = 1; 739 740 /* Point CIE to one of the section-local cie structures. */ 741 cie = local_cies + cie_count++; 742 743 cie->cie_inf = this_inf; 744 cie->length = hdr_length; 745 start = buf; 746 REQUIRE (read_byte (&buf, end, &cie->version)); 747 748 /* Cannot handle unknown versions. */ 749 REQUIRE (cie->version == 1 750 || cie->version == 3 751 || cie->version == 4); 752 REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation)); 753 754 strcpy (cie->augmentation, (char *) buf); 755 buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1; 756 this_inf->u.cie.aug_str_len = buf - start - 1; 757 ENSURE_NO_RELOCS (buf); 758 if (buf[0] == 'e' && buf[1] == 'h') 759 { 760 /* GCC < 3.0 .eh_frame CIE */ 761 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__ 762 is private to each CIE, so we don't need it for anything. 763 Just skip it. */ 764 REQUIRE (skip_bytes (&buf, end, ptr_size)); 765 SKIP_RELOCS (buf); 766 } 767 if (cie->version >= 4) 768 { 769 REQUIRE (buf + 1 < end); 770 REQUIRE (buf[0] == ptr_size); 771 REQUIRE (buf[1] == 0); 772 buf += 2; 773 } 774 REQUIRE (read_uleb128 (&buf, end, &cie->code_align)); 775 REQUIRE (read_sleb128 (&buf, end, &cie->data_align)); 776 if (cie->version == 1) 777 { 778 REQUIRE (buf < end); 779 cie->ra_column = *buf++; 780 } 781 else 782 REQUIRE (read_uleb128 (&buf, end, &cie->ra_column)); 783 ENSURE_NO_RELOCS (buf); 784 cie->lsda_encoding = DW_EH_PE_omit; 785 cie->fde_encoding = DW_EH_PE_omit; 786 cie->per_encoding = DW_EH_PE_omit; 787 aug = cie->augmentation; 788 if (aug[0] != 'e' || aug[1] != 'h') 789 { 790 if (*aug == 'z') 791 { 792 aug++; 793 REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size)); 794 ENSURE_NO_RELOCS (buf); 795 } 796 797 while (*aug != '\0') 798 switch (*aug++) 799 { 800 case 'B': 801 break; 802 case 'L': 803 REQUIRE (read_byte (&buf, end, &cie->lsda_encoding)); 804 ENSURE_NO_RELOCS (buf); 805 REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size)); 806 break; 807 case 'R': 808 REQUIRE (read_byte (&buf, end, &cie->fde_encoding)); 809 ENSURE_NO_RELOCS (buf); 810 REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size)); 811 break; 812 case 'S': 813 break; 814 case 'P': 815 { 816 int per_width; 817 818 REQUIRE (read_byte (&buf, end, &cie->per_encoding)); 819 per_width = get_DW_EH_PE_width (cie->per_encoding, 820 ptr_size); 821 REQUIRE (per_width); 822 if ((cie->per_encoding & 0x70) == DW_EH_PE_aligned) 823 { 824 length = -(buf - ehbuf) & (per_width - 1); 825 REQUIRE (skip_bytes (&buf, end, length)); 826 if (per_width == 8) 827 this_inf->u.cie.per_encoding_aligned8 = 1; 828 } 829 this_inf->u.cie.personality_offset = buf - start; 830 ENSURE_NO_RELOCS (buf); 831 /* Ensure we have a reloc here. */ 832 REQUIRE (GET_RELOC (buf)); 833 cie->personality.reloc_index 834 = cookie->rel - cookie->rels; 835 /* Cope with MIPS-style composite relocations. */ 836 do 837 cookie->rel++; 838 while (GET_RELOC (buf) != NULL); 839 REQUIRE (skip_bytes (&buf, end, per_width)); 840 } 841 break; 842 default: 843 /* Unrecognized augmentation. Better bail out. */ 844 goto free_no_table; 845 } 846 } 847 this_inf->u.cie.aug_data_len 848 = buf - start - 1 - this_inf->u.cie.aug_str_len; 849 850 /* For shared libraries, try to get rid of as many RELATIVE relocs 851 as possible. */ 852 if (bfd_link_pic (info) 853 && (get_elf_backend_data (abfd) 854 ->elf_backend_can_make_relative_eh_frame 855 (abfd, info, sec))) 856 { 857 if ((cie->fde_encoding & 0x70) == DW_EH_PE_absptr) 858 this_inf->make_relative = 1; 859 /* If the CIE doesn't already have an 'R' entry, it's fairly 860 easy to add one, provided that there's no aligned data 861 after the augmentation string. */ 862 else if (cie->fde_encoding == DW_EH_PE_omit 863 && (cie->per_encoding & 0x70) != DW_EH_PE_aligned) 864 { 865 if (*cie->augmentation == 0) 866 this_inf->add_augmentation_size = 1; 867 this_inf->u.cie.add_fde_encoding = 1; 868 this_inf->make_relative = 1; 869 } 870 871 if ((cie->lsda_encoding & 0x70) == DW_EH_PE_absptr) 872 cie->can_make_lsda_relative = 1; 873 } 874 875 /* If FDE encoding was not specified, it defaults to 876 DW_EH_absptr. */ 877 if (cie->fde_encoding == DW_EH_PE_omit) 878 cie->fde_encoding = DW_EH_PE_absptr; 879 880 initial_insn_length = end - buf; 881 cie->initial_insn_length = initial_insn_length; 882 memcpy (cie->initial_instructions, buf, 883 initial_insn_length <= sizeof (cie->initial_instructions) 884 ? initial_insn_length : sizeof (cie->initial_instructions)); 885 insns = buf; 886 buf += initial_insn_length; 887 ENSURE_NO_RELOCS (buf); 888 889 if (!bfd_link_relocatable (info)) 890 { 891 /* Keep info for merging cies. */ 892 this_inf->u.cie.u.full_cie = cie; 893 this_inf->u.cie.per_encoding_relative 894 = (cie->per_encoding & 0x70) == DW_EH_PE_pcrel; 895 } 896 } 897 else 898 { 899 /* Find the corresponding CIE. */ 900 unsigned int cie_offset = this_inf->offset + 4 - hdr_id; 901 for (cie = local_cies; cie < local_cies + cie_count; cie++) 902 if (cie_offset == cie->cie_inf->offset) 903 break; 904 905 /* Ensure this FDE references one of the CIEs in this input 906 section. */ 907 REQUIRE (cie != local_cies + cie_count); 908 this_inf->u.fde.cie_inf = cie->cie_inf; 909 this_inf->make_relative = cie->cie_inf->make_relative; 910 this_inf->add_augmentation_size 911 = cie->cie_inf->add_augmentation_size; 912 913 ENSURE_NO_RELOCS (buf); 914 if ((sec->flags & SEC_LINKER_CREATED) == 0 || cookie->rels != NULL) 915 { 916 asection *rsec; 917 918 REQUIRE (GET_RELOC (buf)); 919 920 /* Chain together the FDEs for each section. */ 921 rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, 922 cookie, NULL); 923 /* RSEC will be NULL if FDE was cleared out as it was belonging to 924 a discarded SHT_GROUP. */ 925 if (rsec) 926 { 927 REQUIRE (rsec->owner == abfd); 928 this_inf->u.fde.next_for_section = elf_fde_list (rsec); 929 elf_fde_list (rsec) = this_inf; 930 } 931 } 932 933 /* Skip the initial location and address range. */ 934 start = buf; 935 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size); 936 REQUIRE (skip_bytes (&buf, end, 2 * length)); 937 938 SKIP_RELOCS (buf - length); 939 if (!GET_RELOC (buf - length) 940 && read_value (abfd, buf - length, length, FALSE) == 0) 941 { 942 (*info->callbacks->minfo) 943 /* xgettext:c-format */ 944 (_("discarding zero address range FDE in %pB(%pA).\n"), 945 abfd, sec); 946 this_inf->u.fde.cie_inf = NULL; 947 } 948 949 /* Skip the augmentation size, if present. */ 950 if (cie->augmentation[0] == 'z') 951 REQUIRE (read_uleb128 (&buf, end, &length)); 952 else 953 length = 0; 954 955 /* Of the supported augmentation characters above, only 'L' 956 adds augmentation data to the FDE. This code would need to 957 be adjusted if any future augmentations do the same thing. */ 958 if (cie->lsda_encoding != DW_EH_PE_omit) 959 { 960 SKIP_RELOCS (buf); 961 if (cie->can_make_lsda_relative && GET_RELOC (buf)) 962 cie->cie_inf->u.cie.make_lsda_relative = 1; 963 this_inf->lsda_offset = buf - start; 964 /* If there's no 'z' augmentation, we don't know where the 965 CFA insns begin. Assume no padding. */ 966 if (cie->augmentation[0] != 'z') 967 length = end - buf; 968 } 969 970 /* Skip over the augmentation data. */ 971 REQUIRE (skip_bytes (&buf, end, length)); 972 insns = buf; 973 974 buf = last_fde + 4 + hdr_length; 975 976 /* For NULL RSEC (cleared FDE belonging to a discarded section) 977 the relocations are commonly cleared. We do not sanity check if 978 all these relocations are cleared as (1) relocations to 979 .gcc_except_table will remain uncleared (they will get dropped 980 with the drop of this unused FDE) and (2) BFD already safely drops 981 relocations of any type to .eh_frame by 982 elf_section_ignore_discarded_relocs. 983 TODO: The .gcc_except_table entries should be also filtered as 984 .eh_frame entries; or GCC could rather use COMDAT for them. */ 985 SKIP_RELOCS (buf); 986 } 987 988 /* Try to interpret the CFA instructions and find the first 989 padding nop. Shrink this_inf's size so that it doesn't 990 include the padding. */ 991 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size); 992 set_loc_count = 0; 993 insns_end = skip_non_nops (insns, end, length, &set_loc_count); 994 /* If we don't understand the CFA instructions, we can't know 995 what needs to be adjusted there. */ 996 if (insns_end == NULL 997 /* For the time being we don't support DW_CFA_set_loc in 998 CIE instructions. */ 999 || (set_loc_count && this_inf->cie)) 1000 goto free_no_table; 1001 this_inf->size -= end - insns_end; 1002 if (insns_end != end && this_inf->cie) 1003 { 1004 cie->initial_insn_length -= end - insns_end; 1005 cie->length -= end - insns_end; 1006 } 1007 if (set_loc_count 1008 && ((cie->fde_encoding & 0x70) == DW_EH_PE_pcrel 1009 || this_inf->make_relative)) 1010 { 1011 unsigned int cnt; 1012 bfd_byte *p; 1013 1014 this_inf->set_loc = (unsigned int *) 1015 bfd_malloc ((set_loc_count + 1) * sizeof (unsigned int)); 1016 REQUIRE (this_inf->set_loc); 1017 this_inf->set_loc[0] = set_loc_count; 1018 p = insns; 1019 cnt = 0; 1020 while (p < end) 1021 { 1022 if (*p == DW_CFA_set_loc) 1023 this_inf->set_loc[++cnt] = p + 1 - start; 1024 REQUIRE (skip_cfa_op (&p, end, length)); 1025 } 1026 } 1027 1028 this_inf->removed = 1; 1029 this_inf->fde_encoding = cie->fde_encoding; 1030 this_inf->lsda_encoding = cie->lsda_encoding; 1031 sec_info->count++; 1032 } 1033 BFD_ASSERT (sec_info->count == num_entries); 1034 BFD_ASSERT (cie_count == num_cies); 1035 1036 elf_section_data (sec)->sec_info = sec_info; 1037 sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME; 1038 if (!bfd_link_relocatable (info)) 1039 { 1040 /* Keep info for merging cies. */ 1041 sec_info->cies = local_cies; 1042 local_cies = NULL; 1043 } 1044 goto success; 1045 1046 free_no_table: 1047 _bfd_error_handler 1048 /* xgettext:c-format */ 1049 (_("error in %pB(%pA); no .eh_frame_hdr table will be created"), 1050 abfd, sec); 1051 hdr_info->u.dwarf.table = FALSE; 1052 free (sec_info); 1053 success: 1054 free (ehbuf); 1055 free (local_cies); 1056 #undef REQUIRE 1057 } 1058 1059 /* Order eh_frame_hdr entries by the VMA of their text section. */ 1060 1061 static int 1062 cmp_eh_frame_hdr (const void *a, const void *b) 1063 { 1064 bfd_vma text_a; 1065 bfd_vma text_b; 1066 asection *sec; 1067 1068 sec = *(asection *const *)a; 1069 sec = (asection *) elf_section_data (sec)->sec_info; 1070 text_a = sec->output_section->vma + sec->output_offset; 1071 sec = *(asection *const *)b; 1072 sec = (asection *) elf_section_data (sec)->sec_info; 1073 text_b = sec->output_section->vma + sec->output_offset; 1074 1075 if (text_a < text_b) 1076 return -1; 1077 return text_a > text_b; 1078 1079 } 1080 1081 /* Add space for a CANTUNWIND terminator to SEC if the text sections 1082 referenced by it and NEXT are not contiguous, or NEXT is NULL. */ 1083 1084 static void 1085 add_eh_frame_hdr_terminator (asection *sec, 1086 asection *next) 1087 { 1088 bfd_vma end; 1089 bfd_vma next_start; 1090 asection *text_sec; 1091 1092 if (next) 1093 { 1094 /* See if there is a gap (presumably a text section without unwind info) 1095 between these two entries. */ 1096 text_sec = (asection *) elf_section_data (sec)->sec_info; 1097 end = text_sec->output_section->vma + text_sec->output_offset 1098 + text_sec->size; 1099 text_sec = (asection *) elf_section_data (next)->sec_info; 1100 next_start = text_sec->output_section->vma + text_sec->output_offset; 1101 if (end == next_start) 1102 return; 1103 } 1104 1105 /* Add space for a CANTUNWIND terminator. */ 1106 if (!sec->rawsize) 1107 sec->rawsize = sec->size; 1108 1109 bfd_set_section_size (sec, sec->size + 8); 1110 } 1111 1112 /* Finish a pass over all .eh_frame_entry sections. */ 1113 1114 bfd_boolean 1115 _bfd_elf_end_eh_frame_parsing (struct bfd_link_info *info) 1116 { 1117 struct eh_frame_hdr_info *hdr_info; 1118 unsigned int i; 1119 1120 hdr_info = &elf_hash_table (info)->eh_info; 1121 1122 if (info->eh_frame_hdr_type != COMPACT_EH_HDR 1123 || hdr_info->array_count == 0) 1124 return FALSE; 1125 1126 bfd_elf_discard_eh_frame_entry (hdr_info); 1127 1128 qsort (hdr_info->u.compact.entries, hdr_info->array_count, 1129 sizeof (asection *), cmp_eh_frame_hdr); 1130 1131 for (i = 0; i < hdr_info->array_count - 1; i++) 1132 { 1133 add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i], 1134 hdr_info->u.compact.entries[i + 1]); 1135 } 1136 1137 /* Add a CANTUNWIND terminator after the last entry. */ 1138 add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i], NULL); 1139 return TRUE; 1140 } 1141 1142 /* Mark all relocations against CIE or FDE ENT, which occurs in 1143 .eh_frame section SEC. COOKIE describes the relocations in SEC; 1144 its "rel" field can be changed freely. */ 1145 1146 static bfd_boolean 1147 mark_entry (struct bfd_link_info *info, asection *sec, 1148 struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook, 1149 struct elf_reloc_cookie *cookie) 1150 { 1151 /* FIXME: octets_per_byte. */ 1152 for (cookie->rel = cookie->rels + ent->reloc_index; 1153 cookie->rel < cookie->relend 1154 && cookie->rel->r_offset < ent->offset + ent->size; 1155 cookie->rel++) 1156 if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie)) 1157 return FALSE; 1158 1159 return TRUE; 1160 } 1161 1162 /* Mark all the relocations against FDEs that relate to code in input 1163 section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose 1164 relocations are described by COOKIE. */ 1165 1166 bfd_boolean 1167 _bfd_elf_gc_mark_fdes (struct bfd_link_info *info, asection *sec, 1168 asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook, 1169 struct elf_reloc_cookie *cookie) 1170 { 1171 struct eh_cie_fde *fde, *cie; 1172 1173 for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section) 1174 { 1175 if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie)) 1176 return FALSE; 1177 1178 /* At this stage, all cie_inf fields point to local CIEs, so we 1179 can use the same cookie to refer to them. */ 1180 cie = fde->u.fde.cie_inf; 1181 if (cie != NULL && !cie->u.cie.gc_mark) 1182 { 1183 cie->u.cie.gc_mark = 1; 1184 if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie)) 1185 return FALSE; 1186 } 1187 } 1188 return TRUE; 1189 } 1190 1191 /* Input section SEC of ABFD is an .eh_frame section that contains the 1192 CIE described by CIE_INF. Return a version of CIE_INF that is going 1193 to be kept in the output, adding CIE_INF to the output if necessary. 1194 1195 HDR_INFO is the .eh_frame_hdr information and COOKIE describes the 1196 relocations in REL. */ 1197 1198 static struct eh_cie_fde * 1199 find_merged_cie (bfd *abfd, struct bfd_link_info *info, asection *sec, 1200 struct eh_frame_hdr_info *hdr_info, 1201 struct elf_reloc_cookie *cookie, 1202 struct eh_cie_fde *cie_inf) 1203 { 1204 unsigned long r_symndx; 1205 struct cie *cie, *new_cie; 1206 Elf_Internal_Rela *rel; 1207 void **loc; 1208 1209 /* Use CIE_INF if we have already decided to keep it. */ 1210 if (!cie_inf->removed) 1211 return cie_inf; 1212 1213 /* If we have merged CIE_INF with another CIE, use that CIE instead. */ 1214 if (cie_inf->u.cie.merged) 1215 return cie_inf->u.cie.u.merged_with; 1216 1217 cie = cie_inf->u.cie.u.full_cie; 1218 1219 /* Assume we will need to keep CIE_INF. */ 1220 cie_inf->removed = 0; 1221 cie_inf->u.cie.u.sec = sec; 1222 1223 /* If we are not merging CIEs, use CIE_INF. */ 1224 if (cie == NULL) 1225 return cie_inf; 1226 1227 if (cie->per_encoding != DW_EH_PE_omit) 1228 { 1229 bfd_boolean per_binds_local; 1230 1231 /* Work out the address of personality routine, or at least 1232 enough info that we could calculate the address had we made a 1233 final section layout. The symbol on the reloc is enough, 1234 either the hash for a global, or (bfd id, index) pair for a 1235 local. The assumption here is that no one uses addends on 1236 the reloc. */ 1237 rel = cookie->rels + cie->personality.reloc_index; 1238 memset (&cie->personality, 0, sizeof (cie->personality)); 1239 #ifdef BFD64 1240 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64) 1241 r_symndx = ELF64_R_SYM (rel->r_info); 1242 else 1243 #endif 1244 r_symndx = ELF32_R_SYM (rel->r_info); 1245 if (r_symndx >= cookie->locsymcount 1246 || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL) 1247 { 1248 struct elf_link_hash_entry *h; 1249 1250 r_symndx -= cookie->extsymoff; 1251 h = cookie->sym_hashes[r_symndx]; 1252 1253 while (h->root.type == bfd_link_hash_indirect 1254 || h->root.type == bfd_link_hash_warning) 1255 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1256 1257 cie->personality.h = h; 1258 per_binds_local = SYMBOL_REFERENCES_LOCAL (info, h); 1259 } 1260 else 1261 { 1262 Elf_Internal_Sym *sym; 1263 asection *sym_sec; 1264 1265 sym = &cookie->locsyms[r_symndx]; 1266 sym_sec = bfd_section_from_elf_index (abfd, sym->st_shndx); 1267 if (sym_sec == NULL) 1268 return cie_inf; 1269 1270 if (sym_sec->kept_section != NULL) 1271 sym_sec = sym_sec->kept_section; 1272 if (sym_sec->output_section == NULL) 1273 return cie_inf; 1274 1275 cie->local_personality = 1; 1276 cie->personality.sym.bfd_id = abfd->id; 1277 cie->personality.sym.index = r_symndx; 1278 per_binds_local = TRUE; 1279 } 1280 1281 if (per_binds_local 1282 && bfd_link_pic (info) 1283 && (cie->per_encoding & 0x70) == DW_EH_PE_absptr 1284 && (get_elf_backend_data (abfd) 1285 ->elf_backend_can_make_relative_eh_frame (abfd, info, sec))) 1286 { 1287 cie_inf->u.cie.make_per_encoding_relative = 1; 1288 cie_inf->u.cie.per_encoding_relative = 1; 1289 } 1290 } 1291 1292 /* See if we can merge this CIE with an earlier one. */ 1293 cie_compute_hash (cie); 1294 if (hdr_info->u.dwarf.cies == NULL) 1295 { 1296 hdr_info->u.dwarf.cies = htab_try_create (1, cie_hash, cie_eq, free); 1297 if (hdr_info->u.dwarf.cies == NULL) 1298 return cie_inf; 1299 } 1300 loc = htab_find_slot_with_hash (hdr_info->u.dwarf.cies, cie, 1301 cie->hash, INSERT); 1302 if (loc == NULL) 1303 return cie_inf; 1304 1305 new_cie = (struct cie *) *loc; 1306 if (new_cie == NULL) 1307 { 1308 /* Keep CIE_INF and record it in the hash table. */ 1309 new_cie = (struct cie *) malloc (sizeof (struct cie)); 1310 if (new_cie == NULL) 1311 return cie_inf; 1312 1313 memcpy (new_cie, cie, sizeof (struct cie)); 1314 *loc = new_cie; 1315 } 1316 else 1317 { 1318 /* Merge CIE_INF with NEW_CIE->CIE_INF. */ 1319 cie_inf->removed = 1; 1320 cie_inf->u.cie.merged = 1; 1321 cie_inf->u.cie.u.merged_with = new_cie->cie_inf; 1322 if (cie_inf->u.cie.make_lsda_relative) 1323 new_cie->cie_inf->u.cie.make_lsda_relative = 1; 1324 } 1325 return new_cie->cie_inf; 1326 } 1327 1328 /* For a given OFFSET in SEC, return the delta to the new location 1329 after .eh_frame editing. */ 1330 1331 static bfd_signed_vma 1332 offset_adjust (bfd_vma offset, const asection *sec) 1333 { 1334 struct eh_frame_sec_info *sec_info 1335 = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info; 1336 unsigned int lo, hi, mid; 1337 struct eh_cie_fde *ent = NULL; 1338 bfd_signed_vma delta; 1339 1340 lo = 0; 1341 hi = sec_info->count; 1342 if (hi == 0) 1343 return 0; 1344 1345 while (lo < hi) 1346 { 1347 mid = (lo + hi) / 2; 1348 ent = &sec_info->entry[mid]; 1349 if (offset < ent->offset) 1350 hi = mid; 1351 else if (mid + 1 >= hi) 1352 break; 1353 else if (offset >= ent[1].offset) 1354 lo = mid + 1; 1355 else 1356 break; 1357 } 1358 1359 if (!ent->removed) 1360 delta = (bfd_vma) ent->new_offset - (bfd_vma) ent->offset; 1361 else if (ent->cie && ent->u.cie.merged) 1362 { 1363 struct eh_cie_fde *cie = ent->u.cie.u.merged_with; 1364 delta = ((bfd_vma) cie->new_offset + cie->u.cie.u.sec->output_offset 1365 - (bfd_vma) ent->offset - sec->output_offset); 1366 } 1367 else 1368 { 1369 /* Is putting the symbol on the next entry best for a deleted 1370 CIE/FDE? */ 1371 struct eh_cie_fde *last = sec_info->entry + sec_info->count; 1372 delta = ((bfd_vma) next_cie_fde_offset (ent, last, sec) 1373 - (bfd_vma) ent->offset); 1374 return delta; 1375 } 1376 1377 /* Account for editing within this CIE/FDE. */ 1378 offset -= ent->offset; 1379 if (ent->cie) 1380 { 1381 unsigned int extra 1382 = ent->add_augmentation_size + ent->u.cie.add_fde_encoding; 1383 if (extra == 0 1384 || offset <= 9u + ent->u.cie.aug_str_len) 1385 return delta; 1386 delta += extra; 1387 if (offset <= 9u + ent->u.cie.aug_str_len + ent->u.cie.aug_data_len) 1388 return delta; 1389 delta += extra; 1390 } 1391 else 1392 { 1393 unsigned int ptr_size, width, extra = ent->add_augmentation_size; 1394 if (offset <= 12 || extra == 0) 1395 return delta; 1396 ptr_size = (get_elf_backend_data (sec->owner) 1397 ->elf_backend_eh_frame_address_size (sec->owner, sec)); 1398 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 1399 if (offset <= 8 + 2 * width) 1400 return delta; 1401 delta += extra; 1402 } 1403 1404 return delta; 1405 } 1406 1407 /* Adjust a global symbol defined in .eh_frame, so that it stays 1408 relative to its original CIE/FDE. It is assumed that a symbol 1409 defined at the beginning of a CIE/FDE belongs to that CIE/FDE 1410 rather than marking the end of the previous CIE/FDE. This matters 1411 when a CIE is merged with a previous CIE, since the symbol is 1412 moved to the merged CIE. */ 1413 1414 bfd_boolean 1415 _bfd_elf_adjust_eh_frame_global_symbol (struct elf_link_hash_entry *h, 1416 void *arg ATTRIBUTE_UNUSED) 1417 { 1418 asection *sym_sec; 1419 bfd_signed_vma delta; 1420 1421 if (h->root.type != bfd_link_hash_defined 1422 && h->root.type != bfd_link_hash_defweak) 1423 return TRUE; 1424 1425 sym_sec = h->root.u.def.section; 1426 if (sym_sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME 1427 || elf_section_data (sym_sec)->sec_info == NULL) 1428 return TRUE; 1429 1430 delta = offset_adjust (h->root.u.def.value, sym_sec); 1431 h->root.u.def.value += delta; 1432 1433 return TRUE; 1434 } 1435 1436 /* The same for all local symbols defined in .eh_frame. Returns true 1437 if any symbol was changed. */ 1438 1439 static int 1440 adjust_eh_frame_local_symbols (const asection *sec, 1441 struct elf_reloc_cookie *cookie) 1442 { 1443 unsigned int shndx; 1444 Elf_Internal_Sym *sym; 1445 Elf_Internal_Sym *end_sym; 1446 int adjusted = 0; 1447 1448 shndx = elf_section_data (sec)->this_idx; 1449 end_sym = cookie->locsyms + cookie->locsymcount; 1450 for (sym = cookie->locsyms + 1; sym < end_sym; ++sym) 1451 if (sym->st_info <= ELF_ST_INFO (STB_LOCAL, STT_OBJECT) 1452 && sym->st_shndx == shndx) 1453 { 1454 bfd_signed_vma delta = offset_adjust (sym->st_value, sec); 1455 1456 if (delta != 0) 1457 { 1458 adjusted = 1; 1459 sym->st_value += delta; 1460 } 1461 } 1462 return adjusted; 1463 } 1464 1465 /* This function is called for each input file before the .eh_frame 1466 section is relocated. It discards duplicate CIEs and FDEs for discarded 1467 functions. The function returns TRUE iff any entries have been 1468 deleted. */ 1469 1470 bfd_boolean 1471 _bfd_elf_discard_section_eh_frame 1472 (bfd *abfd, struct bfd_link_info *info, asection *sec, 1473 bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *), 1474 struct elf_reloc_cookie *cookie) 1475 { 1476 struct eh_cie_fde *ent; 1477 struct eh_frame_sec_info *sec_info; 1478 struct eh_frame_hdr_info *hdr_info; 1479 unsigned int ptr_size, offset, eh_alignment; 1480 int changed; 1481 1482 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME) 1483 return FALSE; 1484 1485 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info; 1486 if (sec_info == NULL) 1487 return FALSE; 1488 1489 ptr_size = (get_elf_backend_data (sec->owner) 1490 ->elf_backend_eh_frame_address_size (sec->owner, sec)); 1491 1492 hdr_info = &elf_hash_table (info)->eh_info; 1493 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent) 1494 if (ent->size == 4) 1495 /* There should only be one zero terminator, on the last input 1496 file supplying .eh_frame (crtend.o). Remove any others. */ 1497 ent->removed = sec->map_head.s != NULL; 1498 else if (!ent->cie && ent->u.fde.cie_inf != NULL) 1499 { 1500 bfd_boolean keep; 1501 if ((sec->flags & SEC_LINKER_CREATED) != 0 && cookie->rels == NULL) 1502 { 1503 unsigned int width 1504 = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 1505 bfd_vma value 1506 = read_value (abfd, sec->contents + ent->offset + 8 + width, 1507 width, get_DW_EH_PE_signed (ent->fde_encoding)); 1508 keep = value != 0; 1509 } 1510 else 1511 { 1512 cookie->rel = cookie->rels + ent->reloc_index; 1513 /* FIXME: octets_per_byte. */ 1514 BFD_ASSERT (cookie->rel < cookie->relend 1515 && cookie->rel->r_offset == ent->offset + 8); 1516 keep = !(*reloc_symbol_deleted_p) (ent->offset + 8, cookie); 1517 } 1518 if (keep) 1519 { 1520 if (bfd_link_pic (info) 1521 && (((ent->fde_encoding & 0x70) == DW_EH_PE_absptr 1522 && ent->make_relative == 0) 1523 || (ent->fde_encoding & 0x70) == DW_EH_PE_aligned)) 1524 { 1525 static int num_warnings_issued = 0; 1526 1527 /* If a shared library uses absolute pointers 1528 which we cannot turn into PC relative, 1529 don't create the binary search table, 1530 since it is affected by runtime relocations. */ 1531 hdr_info->u.dwarf.table = FALSE; 1532 /* Only warn if --eh-frame-hdr was specified. */ 1533 if (info->eh_frame_hdr_type != 0) 1534 { 1535 if (num_warnings_issued < 10) 1536 { 1537 _bfd_error_handler 1538 /* xgettext:c-format */ 1539 (_("FDE encoding in %pB(%pA) prevents .eh_frame_hdr" 1540 " table being created"), abfd, sec); 1541 num_warnings_issued ++; 1542 } 1543 else if (num_warnings_issued == 10) 1544 { 1545 _bfd_error_handler 1546 (_("further warnings about FDE encoding preventing .eh_frame_hdr generation dropped")); 1547 num_warnings_issued ++; 1548 } 1549 } 1550 } 1551 ent->removed = 0; 1552 hdr_info->u.dwarf.fde_count++; 1553 ent->u.fde.cie_inf = find_merged_cie (abfd, info, sec, hdr_info, 1554 cookie, ent->u.fde.cie_inf); 1555 } 1556 } 1557 1558 free (sec_info->cies); 1559 sec_info->cies = NULL; 1560 1561 /* It may be that some .eh_frame input section has greater alignment 1562 than other .eh_frame sections. In that case we run the risk of 1563 padding with zeros before that section, which would be seen as a 1564 zero terminator. Alignment padding must be added *inside* the 1565 last FDE instead. For other FDEs we align according to their 1566 encoding, in order to align FDE address range entries naturally. */ 1567 offset = 0; 1568 changed = 0; 1569 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent) 1570 if (!ent->removed) 1571 { 1572 eh_alignment = 4; 1573 if (ent->size == 4) 1574 ; 1575 else if (ent->cie) 1576 { 1577 if (ent->u.cie.per_encoding_aligned8) 1578 eh_alignment = 8; 1579 } 1580 else 1581 { 1582 eh_alignment = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 1583 if (eh_alignment < 4) 1584 eh_alignment = 4; 1585 } 1586 offset = (offset + eh_alignment - 1) & -eh_alignment; 1587 ent->new_offset = offset; 1588 if (ent->new_offset != ent->offset) 1589 changed = 1; 1590 offset += size_of_output_cie_fde (ent); 1591 } 1592 1593 eh_alignment = 4; 1594 offset = (offset + eh_alignment - 1) & -eh_alignment; 1595 sec->rawsize = sec->size; 1596 sec->size = offset; 1597 if (sec->size != sec->rawsize) 1598 changed = 1; 1599 1600 if (changed && adjust_eh_frame_local_symbols (sec, cookie)) 1601 { 1602 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1603 symtab_hdr->contents = (unsigned char *) cookie->locsyms; 1604 } 1605 return changed; 1606 } 1607 1608 /* This function is called for .eh_frame_hdr section after 1609 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame 1610 input sections. It finalizes the size of .eh_frame_hdr section. */ 1611 1612 bfd_boolean 1613 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 1614 { 1615 struct elf_link_hash_table *htab; 1616 struct eh_frame_hdr_info *hdr_info; 1617 asection *sec; 1618 1619 htab = elf_hash_table (info); 1620 hdr_info = &htab->eh_info; 1621 1622 if (!hdr_info->frame_hdr_is_compact && hdr_info->u.dwarf.cies != NULL) 1623 { 1624 htab_delete (hdr_info->u.dwarf.cies); 1625 hdr_info->u.dwarf.cies = NULL; 1626 } 1627 1628 sec = hdr_info->hdr_sec; 1629 if (sec == NULL) 1630 return FALSE; 1631 1632 if (info->eh_frame_hdr_type == COMPACT_EH_HDR) 1633 { 1634 /* For compact frames we only add the header. The actual table comes 1635 from the .eh_frame_entry sections. */ 1636 sec->size = 8; 1637 } 1638 else 1639 { 1640 sec->size = EH_FRAME_HDR_SIZE; 1641 if (hdr_info->u.dwarf.table) 1642 sec->size += 4 + hdr_info->u.dwarf.fde_count * 8; 1643 } 1644 1645 elf_eh_frame_hdr (abfd) = sec; 1646 return TRUE; 1647 } 1648 1649 /* Return true if there is at least one non-empty .eh_frame section in 1650 input files. Can only be called after ld has mapped input to 1651 output sections, and before sections are stripped. */ 1652 1653 bfd_boolean 1654 _bfd_elf_eh_frame_present (struct bfd_link_info *info) 1655 { 1656 asection *eh = bfd_get_section_by_name (info->output_bfd, ".eh_frame"); 1657 1658 if (eh == NULL) 1659 return FALSE; 1660 1661 /* Count only sections which have at least a single CIE or FDE. 1662 There cannot be any CIE or FDE <= 8 bytes. */ 1663 for (eh = eh->map_head.s; eh != NULL; eh = eh->map_head.s) 1664 if (eh->size > 8) 1665 return TRUE; 1666 1667 return FALSE; 1668 } 1669 1670 /* Return true if there is at least one .eh_frame_entry section in 1671 input files. */ 1672 1673 bfd_boolean 1674 _bfd_elf_eh_frame_entry_present (struct bfd_link_info *info) 1675 { 1676 asection *o; 1677 bfd *abfd; 1678 1679 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next) 1680 { 1681 for (o = abfd->sections; o; o = o->next) 1682 { 1683 const char *name = bfd_section_name (o); 1684 1685 if (strcmp (name, ".eh_frame_entry") 1686 && !bfd_is_abs_section (o->output_section)) 1687 return TRUE; 1688 } 1689 } 1690 return FALSE; 1691 } 1692 1693 /* This function is called from size_dynamic_sections. 1694 It needs to decide whether .eh_frame_hdr should be output or not, 1695 because when the dynamic symbol table has been sized it is too late 1696 to strip sections. */ 1697 1698 bfd_boolean 1699 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info) 1700 { 1701 struct elf_link_hash_table *htab; 1702 struct eh_frame_hdr_info *hdr_info; 1703 struct bfd_link_hash_entry *bh = NULL; 1704 struct elf_link_hash_entry *h; 1705 1706 htab = elf_hash_table (info); 1707 hdr_info = &htab->eh_info; 1708 if (hdr_info->hdr_sec == NULL) 1709 return TRUE; 1710 1711 if (bfd_is_abs_section (hdr_info->hdr_sec->output_section) 1712 || info->eh_frame_hdr_type == 0 1713 || (info->eh_frame_hdr_type == DWARF2_EH_HDR 1714 && !_bfd_elf_eh_frame_present (info)) 1715 || (info->eh_frame_hdr_type == COMPACT_EH_HDR 1716 && !_bfd_elf_eh_frame_entry_present (info))) 1717 { 1718 hdr_info->hdr_sec->flags |= SEC_EXCLUDE; 1719 hdr_info->hdr_sec = NULL; 1720 return TRUE; 1721 } 1722 1723 /* Add a hidden symbol so that systems without access to PHDRs can 1724 find the table. */ 1725 if (! (_bfd_generic_link_add_one_symbol 1726 (info, info->output_bfd, "__GNU_EH_FRAME_HDR", BSF_LOCAL, 1727 hdr_info->hdr_sec, 0, NULL, FALSE, FALSE, &bh))) 1728 return FALSE; 1729 1730 h = (struct elf_link_hash_entry *) bh; 1731 h->def_regular = 1; 1732 h->other = STV_HIDDEN; 1733 get_elf_backend_data 1734 (info->output_bfd)->elf_backend_hide_symbol (info, h, TRUE); 1735 1736 if (!hdr_info->frame_hdr_is_compact) 1737 hdr_info->u.dwarf.table = TRUE; 1738 return TRUE; 1739 } 1740 1741 /* Adjust an address in the .eh_frame section. Given OFFSET within 1742 SEC, this returns the new offset in the adjusted .eh_frame section, 1743 or -1 if the address refers to a CIE/FDE which has been removed 1744 or to offset with dynamic relocation which is no longer needed. */ 1745 1746 bfd_vma 1747 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED, 1748 struct bfd_link_info *info ATTRIBUTE_UNUSED, 1749 asection *sec, 1750 bfd_vma offset) 1751 { 1752 struct eh_frame_sec_info *sec_info; 1753 unsigned int lo, hi, mid; 1754 1755 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME) 1756 return offset; 1757 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info; 1758 1759 if (offset >= sec->rawsize) 1760 return offset - sec->rawsize + sec->size; 1761 1762 lo = 0; 1763 hi = sec_info->count; 1764 mid = 0; 1765 while (lo < hi) 1766 { 1767 mid = (lo + hi) / 2; 1768 if (offset < sec_info->entry[mid].offset) 1769 hi = mid; 1770 else if (offset 1771 >= sec_info->entry[mid].offset + sec_info->entry[mid].size) 1772 lo = mid + 1; 1773 else 1774 break; 1775 } 1776 1777 BFD_ASSERT (lo < hi); 1778 1779 /* FDE or CIE was removed. */ 1780 if (sec_info->entry[mid].removed) 1781 return (bfd_vma) -1; 1782 1783 /* If converting personality pointers to DW_EH_PE_pcrel, there will be 1784 no need for run-time relocation against the personality field. */ 1785 if (sec_info->entry[mid].cie 1786 && sec_info->entry[mid].u.cie.make_per_encoding_relative 1787 && offset == (sec_info->entry[mid].offset + 8 1788 + sec_info->entry[mid].u.cie.personality_offset)) 1789 return (bfd_vma) -2; 1790 1791 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time 1792 relocation against FDE's initial_location field. */ 1793 if (!sec_info->entry[mid].cie 1794 && sec_info->entry[mid].make_relative 1795 && offset == sec_info->entry[mid].offset + 8) 1796 return (bfd_vma) -2; 1797 1798 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need 1799 for run-time relocation against LSDA field. */ 1800 if (!sec_info->entry[mid].cie 1801 && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative 1802 && offset == (sec_info->entry[mid].offset + 8 1803 + sec_info->entry[mid].lsda_offset)) 1804 return (bfd_vma) -2; 1805 1806 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time 1807 relocation against DW_CFA_set_loc's arguments. */ 1808 if (sec_info->entry[mid].set_loc 1809 && sec_info->entry[mid].make_relative 1810 && (offset >= sec_info->entry[mid].offset + 8 1811 + sec_info->entry[mid].set_loc[1])) 1812 { 1813 unsigned int cnt; 1814 1815 for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++) 1816 if (offset == sec_info->entry[mid].offset + 8 1817 + sec_info->entry[mid].set_loc[cnt]) 1818 return (bfd_vma) -2; 1819 } 1820 1821 /* Any new augmentation bytes go before the first relocation. */ 1822 return (offset + sec_info->entry[mid].new_offset 1823 - sec_info->entry[mid].offset 1824 + extra_augmentation_string_bytes (sec_info->entry + mid) 1825 + extra_augmentation_data_bytes (sec_info->entry + mid)); 1826 } 1827 1828 /* Write out .eh_frame_entry section. Add CANTUNWIND terminator if needed. 1829 Also check that the contents look sane. */ 1830 1831 bfd_boolean 1832 _bfd_elf_write_section_eh_frame_entry (bfd *abfd, struct bfd_link_info *info, 1833 asection *sec, bfd_byte *contents) 1834 { 1835 const struct elf_backend_data *bed; 1836 bfd_byte cantunwind[8]; 1837 bfd_vma addr; 1838 bfd_vma last_addr; 1839 bfd_vma offset; 1840 asection *text_sec = (asection *) elf_section_data (sec)->sec_info; 1841 1842 if (!sec->rawsize) 1843 sec->rawsize = sec->size; 1844 1845 BFD_ASSERT (sec->sec_info_type == SEC_INFO_TYPE_EH_FRAME_ENTRY); 1846 1847 /* Check to make sure that the text section corresponding to this eh_frame_entry 1848 section has not been excluded. In particular, mips16 stub entries will be 1849 excluded outside of the normal process. */ 1850 if (sec->flags & SEC_EXCLUDE 1851 || text_sec->flags & SEC_EXCLUDE) 1852 return TRUE; 1853 1854 if (!bfd_set_section_contents (abfd, sec->output_section, contents, 1855 sec->output_offset, sec->rawsize)) 1856 return FALSE; 1857 1858 last_addr = bfd_get_signed_32 (abfd, contents); 1859 /* Check that all the entries are in order. */ 1860 for (offset = 8; offset < sec->rawsize; offset += 8) 1861 { 1862 addr = bfd_get_signed_32 (abfd, contents + offset) + offset; 1863 if (addr <= last_addr) 1864 { 1865 /* xgettext:c-format */ 1866 _bfd_error_handler (_("%pB: %pA not in order"), sec->owner, sec); 1867 return FALSE; 1868 } 1869 1870 last_addr = addr; 1871 } 1872 1873 addr = text_sec->output_section->vma + text_sec->output_offset 1874 + text_sec->size; 1875 addr &= ~1; 1876 addr -= (sec->output_section->vma + sec->output_offset + sec->rawsize); 1877 if (addr & 1) 1878 { 1879 /* xgettext:c-format */ 1880 _bfd_error_handler (_("%pB: %pA invalid input section size"), 1881 sec->owner, sec); 1882 bfd_set_error (bfd_error_bad_value); 1883 return FALSE; 1884 } 1885 if (last_addr >= addr + sec->rawsize) 1886 { 1887 /* xgettext:c-format */ 1888 _bfd_error_handler (_("%pB: %pA points past end of text section"), 1889 sec->owner, sec); 1890 bfd_set_error (bfd_error_bad_value); 1891 return FALSE; 1892 } 1893 1894 if (sec->size == sec->rawsize) 1895 return TRUE; 1896 1897 bed = get_elf_backend_data (abfd); 1898 BFD_ASSERT (sec->size == sec->rawsize + 8); 1899 BFD_ASSERT ((addr & 1) == 0); 1900 BFD_ASSERT (bed->cant_unwind_opcode); 1901 1902 bfd_put_32 (abfd, addr, cantunwind); 1903 bfd_put_32 (abfd, (*bed->cant_unwind_opcode) (info), cantunwind + 4); 1904 return bfd_set_section_contents (abfd, sec->output_section, cantunwind, 1905 sec->output_offset + sec->rawsize, 8); 1906 } 1907 1908 /* Write out .eh_frame section. This is called with the relocated 1909 contents. */ 1910 1911 bfd_boolean 1912 _bfd_elf_write_section_eh_frame (bfd *abfd, 1913 struct bfd_link_info *info, 1914 asection *sec, 1915 bfd_byte *contents) 1916 { 1917 struct eh_frame_sec_info *sec_info; 1918 struct elf_link_hash_table *htab; 1919 struct eh_frame_hdr_info *hdr_info; 1920 unsigned int ptr_size; 1921 struct eh_cie_fde *ent, *last_ent; 1922 1923 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME) 1924 /* FIXME: octets_per_byte. */ 1925 return bfd_set_section_contents (abfd, sec->output_section, contents, 1926 sec->output_offset, sec->size); 1927 1928 ptr_size = (get_elf_backend_data (abfd) 1929 ->elf_backend_eh_frame_address_size (abfd, sec)); 1930 BFD_ASSERT (ptr_size != 0); 1931 1932 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info; 1933 htab = elf_hash_table (info); 1934 hdr_info = &htab->eh_info; 1935 1936 if (hdr_info->u.dwarf.table && hdr_info->u.dwarf.array == NULL) 1937 { 1938 hdr_info->frame_hdr_is_compact = FALSE; 1939 hdr_info->u.dwarf.array = (struct eh_frame_array_ent *) 1940 bfd_malloc (hdr_info->u.dwarf.fde_count 1941 * sizeof (*hdr_info->u.dwarf.array)); 1942 } 1943 if (hdr_info->u.dwarf.array == NULL) 1944 hdr_info = NULL; 1945 1946 /* The new offsets can be bigger or smaller than the original offsets. 1947 We therefore need to make two passes over the section: one backward 1948 pass to move entries up and one forward pass to move entries down. 1949 The two passes won't interfere with each other because entries are 1950 not reordered */ 1951 for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;) 1952 if (!ent->removed && ent->new_offset > ent->offset) 1953 memmove (contents + ent->new_offset, contents + ent->offset, ent->size); 1954 1955 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent) 1956 if (!ent->removed && ent->new_offset < ent->offset) 1957 memmove (contents + ent->new_offset, contents + ent->offset, ent->size); 1958 1959 last_ent = sec_info->entry + sec_info->count; 1960 for (ent = sec_info->entry; ent < last_ent; ++ent) 1961 { 1962 unsigned char *buf, *end; 1963 unsigned int new_size; 1964 1965 if (ent->removed) 1966 continue; 1967 1968 if (ent->size == 4) 1969 { 1970 /* Any terminating FDE must be at the end of the section. */ 1971 BFD_ASSERT (ent == last_ent - 1); 1972 continue; 1973 } 1974 1975 buf = contents + ent->new_offset; 1976 end = buf + ent->size; 1977 new_size = next_cie_fde_offset (ent, last_ent, sec) - ent->new_offset; 1978 1979 /* Update the size. It may be shrinked. */ 1980 bfd_put_32 (abfd, new_size - 4, buf); 1981 1982 /* Filling the extra bytes with DW_CFA_nops. */ 1983 if (new_size != ent->size) 1984 memset (end, 0, new_size - ent->size); 1985 1986 if (ent->cie) 1987 { 1988 /* CIE */ 1989 if (ent->make_relative 1990 || ent->u.cie.make_lsda_relative 1991 || ent->u.cie.per_encoding_relative) 1992 { 1993 char *aug; 1994 unsigned int version, action, extra_string, extra_data; 1995 unsigned int per_width, per_encoding; 1996 1997 /* Need to find 'R' or 'L' augmentation's argument and modify 1998 DW_EH_PE_* value. */ 1999 action = ((ent->make_relative ? 1 : 0) 2000 | (ent->u.cie.make_lsda_relative ? 2 : 0) 2001 | (ent->u.cie.per_encoding_relative ? 4 : 0)); 2002 extra_string = extra_augmentation_string_bytes (ent); 2003 extra_data = extra_augmentation_data_bytes (ent); 2004 2005 /* Skip length, id. */ 2006 buf += 8; 2007 version = *buf++; 2008 aug = (char *) buf; 2009 buf += strlen (aug) + 1; 2010 skip_leb128 (&buf, end); 2011 skip_leb128 (&buf, end); 2012 if (version == 1) 2013 skip_bytes (&buf, end, 1); 2014 else 2015 skip_leb128 (&buf, end); 2016 if (*aug == 'z') 2017 { 2018 /* The uleb128 will always be a single byte for the kind 2019 of augmentation strings that we're prepared to handle. */ 2020 *buf++ += extra_data; 2021 aug++; 2022 } 2023 2024 /* Make room for the new augmentation string and data bytes. */ 2025 memmove (buf + extra_string + extra_data, buf, end - buf); 2026 memmove (aug + extra_string, aug, buf - (bfd_byte *) aug); 2027 buf += extra_string; 2028 end += extra_string + extra_data; 2029 2030 if (ent->add_augmentation_size) 2031 { 2032 *aug++ = 'z'; 2033 *buf++ = extra_data - 1; 2034 } 2035 if (ent->u.cie.add_fde_encoding) 2036 { 2037 BFD_ASSERT (action & 1); 2038 *aug++ = 'R'; 2039 *buf++ = make_pc_relative (DW_EH_PE_absptr, ptr_size); 2040 action &= ~1; 2041 } 2042 2043 while (action) 2044 switch (*aug++) 2045 { 2046 case 'L': 2047 if (action & 2) 2048 { 2049 BFD_ASSERT (*buf == ent->lsda_encoding); 2050 *buf = make_pc_relative (*buf, ptr_size); 2051 action &= ~2; 2052 } 2053 buf++; 2054 break; 2055 case 'P': 2056 if (ent->u.cie.make_per_encoding_relative) 2057 *buf = make_pc_relative (*buf, ptr_size); 2058 per_encoding = *buf++; 2059 per_width = get_DW_EH_PE_width (per_encoding, ptr_size); 2060 BFD_ASSERT (per_width != 0); 2061 BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel) 2062 == ent->u.cie.per_encoding_relative); 2063 if ((per_encoding & 0x70) == DW_EH_PE_aligned) 2064 buf = (contents 2065 + ((buf - contents + per_width - 1) 2066 & ~((bfd_size_type) per_width - 1))); 2067 if (action & 4) 2068 { 2069 bfd_vma val; 2070 2071 val = read_value (abfd, buf, per_width, 2072 get_DW_EH_PE_signed (per_encoding)); 2073 if (ent->u.cie.make_per_encoding_relative) 2074 val -= (sec->output_section->vma 2075 + sec->output_offset 2076 + (buf - contents)); 2077 else 2078 { 2079 val += (bfd_vma) ent->offset - ent->new_offset; 2080 val -= extra_string + extra_data; 2081 } 2082 write_value (abfd, buf, val, per_width); 2083 action &= ~4; 2084 } 2085 buf += per_width; 2086 break; 2087 case 'R': 2088 if (action & 1) 2089 { 2090 BFD_ASSERT (*buf == ent->fde_encoding); 2091 *buf = make_pc_relative (*buf, ptr_size); 2092 action &= ~1; 2093 } 2094 buf++; 2095 break; 2096 case 'S': 2097 break; 2098 default: 2099 BFD_FAIL (); 2100 } 2101 } 2102 } 2103 else 2104 { 2105 /* FDE */ 2106 bfd_vma value, address; 2107 unsigned int width; 2108 bfd_byte *start; 2109 struct eh_cie_fde *cie; 2110 2111 /* Skip length. */ 2112 cie = ent->u.fde.cie_inf; 2113 buf += 4; 2114 value = ((ent->new_offset + sec->output_offset + 4) 2115 - (cie->new_offset + cie->u.cie.u.sec->output_offset)); 2116 bfd_put_32 (abfd, value, buf); 2117 if (bfd_link_relocatable (info)) 2118 continue; 2119 buf += 4; 2120 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 2121 value = read_value (abfd, buf, width, 2122 get_DW_EH_PE_signed (ent->fde_encoding)); 2123 address = value; 2124 if (value) 2125 { 2126 switch (ent->fde_encoding & 0x70) 2127 { 2128 case DW_EH_PE_textrel: 2129 BFD_ASSERT (hdr_info == NULL); 2130 break; 2131 case DW_EH_PE_datarel: 2132 { 2133 switch (abfd->arch_info->arch) 2134 { 2135 case bfd_arch_ia64: 2136 BFD_ASSERT (elf_gp (abfd) != 0); 2137 address += elf_gp (abfd); 2138 break; 2139 default: 2140 _bfd_error_handler 2141 (_("DW_EH_PE_datarel unspecified" 2142 " for this architecture")); 2143 /* Fall thru */ 2144 case bfd_arch_frv: 2145 case bfd_arch_i386: 2146 case bfd_arch_nios2: 2147 BFD_ASSERT (htab->hgot != NULL 2148 && ((htab->hgot->root.type 2149 == bfd_link_hash_defined) 2150 || (htab->hgot->root.type 2151 == bfd_link_hash_defweak))); 2152 address 2153 += (htab->hgot->root.u.def.value 2154 + htab->hgot->root.u.def.section->output_offset 2155 + (htab->hgot->root.u.def.section->output_section 2156 ->vma)); 2157 break; 2158 } 2159 } 2160 break; 2161 case DW_EH_PE_pcrel: 2162 value += (bfd_vma) ent->offset - ent->new_offset; 2163 address += (sec->output_section->vma 2164 + sec->output_offset 2165 + ent->offset + 8); 2166 break; 2167 } 2168 if (ent->make_relative) 2169 value -= (sec->output_section->vma 2170 + sec->output_offset 2171 + ent->new_offset + 8); 2172 write_value (abfd, buf, value, width); 2173 } 2174 2175 start = buf; 2176 2177 if (hdr_info) 2178 { 2179 /* The address calculation may overflow, giving us a 2180 value greater than 4G on a 32-bit target when 2181 dwarf_vma is 64-bit. */ 2182 if (sizeof (address) > 4 && ptr_size == 4) 2183 address &= 0xffffffff; 2184 hdr_info->u.dwarf.array[hdr_info->array_count].initial_loc 2185 = address; 2186 hdr_info->u.dwarf.array[hdr_info->array_count].range 2187 = read_value (abfd, buf + width, width, FALSE); 2188 hdr_info->u.dwarf.array[hdr_info->array_count++].fde 2189 = (sec->output_section->vma 2190 + sec->output_offset 2191 + ent->new_offset); 2192 } 2193 2194 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel 2195 || cie->u.cie.make_lsda_relative) 2196 { 2197 buf += ent->lsda_offset; 2198 width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size); 2199 value = read_value (abfd, buf, width, 2200 get_DW_EH_PE_signed (ent->lsda_encoding)); 2201 if (value) 2202 { 2203 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel) 2204 value += (bfd_vma) ent->offset - ent->new_offset; 2205 else if (cie->u.cie.make_lsda_relative) 2206 value -= (sec->output_section->vma 2207 + sec->output_offset 2208 + ent->new_offset + 8 + ent->lsda_offset); 2209 write_value (abfd, buf, value, width); 2210 } 2211 } 2212 else if (ent->add_augmentation_size) 2213 { 2214 /* Skip the PC and length and insert a zero byte for the 2215 augmentation size. */ 2216 buf += width * 2; 2217 memmove (buf + 1, buf, end - buf); 2218 *buf = 0; 2219 } 2220 2221 if (ent->set_loc) 2222 { 2223 /* Adjust DW_CFA_set_loc. */ 2224 unsigned int cnt; 2225 bfd_vma new_offset; 2226 2227 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 2228 new_offset = ent->new_offset + 8 2229 + extra_augmentation_string_bytes (ent) 2230 + extra_augmentation_data_bytes (ent); 2231 2232 for (cnt = 1; cnt <= ent->set_loc[0]; cnt++) 2233 { 2234 buf = start + ent->set_loc[cnt]; 2235 2236 value = read_value (abfd, buf, width, 2237 get_DW_EH_PE_signed (ent->fde_encoding)); 2238 if (!value) 2239 continue; 2240 2241 if ((ent->fde_encoding & 0x70) == DW_EH_PE_pcrel) 2242 value += (bfd_vma) ent->offset + 8 - new_offset; 2243 if (ent->make_relative) 2244 value -= (sec->output_section->vma 2245 + sec->output_offset 2246 + new_offset + ent->set_loc[cnt]); 2247 write_value (abfd, buf, value, width); 2248 } 2249 } 2250 } 2251 } 2252 2253 /* FIXME: octets_per_byte. */ 2254 return bfd_set_section_contents (abfd, sec->output_section, 2255 contents, (file_ptr) sec->output_offset, 2256 sec->size); 2257 } 2258 2259 /* Helper function used to sort .eh_frame_hdr search table by increasing 2260 VMA of FDE initial location. */ 2261 2262 static int 2263 vma_compare (const void *a, const void *b) 2264 { 2265 const struct eh_frame_array_ent *p = (const struct eh_frame_array_ent *) a; 2266 const struct eh_frame_array_ent *q = (const struct eh_frame_array_ent *) b; 2267 if (p->initial_loc > q->initial_loc) 2268 return 1; 2269 if (p->initial_loc < q->initial_loc) 2270 return -1; 2271 if (p->range > q->range) 2272 return 1; 2273 if (p->range < q->range) 2274 return -1; 2275 return 0; 2276 } 2277 2278 /* Reorder .eh_frame_entry sections to match the associated text sections. 2279 This routine is called during the final linking step, just before writing 2280 the contents. At this stage, sections in the eh_frame_hdr_info are already 2281 sorted in order of increasing text section address and so we simply need 2282 to make the .eh_frame_entrys follow that same order. Note that it is 2283 invalid for a linker script to try to force a particular order of 2284 .eh_frame_entry sections. */ 2285 2286 bfd_boolean 2287 _bfd_elf_fixup_eh_frame_hdr (struct bfd_link_info *info) 2288 { 2289 asection *sec = NULL; 2290 asection *osec; 2291 struct eh_frame_hdr_info *hdr_info; 2292 unsigned int i; 2293 bfd_vma offset; 2294 struct bfd_link_order *p; 2295 2296 hdr_info = &elf_hash_table (info)->eh_info; 2297 2298 if (hdr_info->hdr_sec == NULL 2299 || info->eh_frame_hdr_type != COMPACT_EH_HDR 2300 || hdr_info->array_count == 0) 2301 return TRUE; 2302 2303 /* Change section output offsets to be in text section order. */ 2304 offset = 8; 2305 osec = hdr_info->u.compact.entries[0]->output_section; 2306 for (i = 0; i < hdr_info->array_count; i++) 2307 { 2308 sec = hdr_info->u.compact.entries[i]; 2309 if (sec->output_section != osec) 2310 { 2311 _bfd_error_handler 2312 (_("invalid output section for .eh_frame_entry: %pA"), 2313 sec->output_section); 2314 return FALSE; 2315 } 2316 sec->output_offset = offset; 2317 offset += sec->size; 2318 } 2319 2320 2321 /* Fix the link_order to match. */ 2322 for (p = sec->output_section->map_head.link_order; p != NULL; p = p->next) 2323 { 2324 if (p->type != bfd_indirect_link_order) 2325 abort(); 2326 2327 p->offset = p->u.indirect.section->output_offset; 2328 if (p->next != NULL) 2329 i--; 2330 } 2331 2332 if (i != 0) 2333 { 2334 _bfd_error_handler 2335 (_("invalid contents in %pA section"), osec); 2336 return FALSE; 2337 } 2338 2339 return TRUE; 2340 } 2341 2342 /* The .eh_frame_hdr format for Compact EH frames: 2343 ubyte version (2) 2344 ubyte eh_ref_enc (DW_EH_PE_* encoding of typinfo references) 2345 uint32_t count (Number of entries in table) 2346 [array from .eh_frame_entry sections] */ 2347 2348 static bfd_boolean 2349 write_compact_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 2350 { 2351 struct elf_link_hash_table *htab; 2352 struct eh_frame_hdr_info *hdr_info; 2353 asection *sec; 2354 const struct elf_backend_data *bed; 2355 bfd_vma count; 2356 bfd_byte contents[8]; 2357 unsigned int i; 2358 2359 htab = elf_hash_table (info); 2360 hdr_info = &htab->eh_info; 2361 sec = hdr_info->hdr_sec; 2362 2363 if (sec->size != 8) 2364 abort(); 2365 2366 for (i = 0; i < sizeof (contents); i++) 2367 contents[i] = 0; 2368 2369 contents[0] = COMPACT_EH_HDR; 2370 bed = get_elf_backend_data (abfd); 2371 2372 BFD_ASSERT (bed->compact_eh_encoding); 2373 contents[1] = (*bed->compact_eh_encoding) (info); 2374 2375 count = (sec->output_section->size - 8) / 8; 2376 bfd_put_32 (abfd, count, contents + 4); 2377 return bfd_set_section_contents (abfd, sec->output_section, contents, 2378 (file_ptr) sec->output_offset, sec->size); 2379 } 2380 2381 /* The .eh_frame_hdr format for DWARF frames: 2382 2383 ubyte version (currently 1) 2384 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of 2385 .eh_frame section) 2386 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count 2387 number (or DW_EH_PE_omit if there is no 2388 binary search table computed)) 2389 ubyte table_enc (DW_EH_PE_* encoding of binary search table, 2390 or DW_EH_PE_omit if not present. 2391 DW_EH_PE_datarel is using address of 2392 .eh_frame_hdr section start as base) 2393 [encoded] eh_frame_ptr (pointer to start of .eh_frame section) 2394 optionally followed by: 2395 [encoded] fde_count (total number of FDEs in .eh_frame section) 2396 fde_count x [encoded] initial_loc, fde 2397 (array of encoded pairs containing 2398 FDE initial_location field and FDE address, 2399 sorted by increasing initial_loc). */ 2400 2401 static bfd_boolean 2402 write_dwarf_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 2403 { 2404 struct elf_link_hash_table *htab; 2405 struct eh_frame_hdr_info *hdr_info; 2406 asection *sec; 2407 bfd_boolean retval = TRUE; 2408 2409 htab = elf_hash_table (info); 2410 hdr_info = &htab->eh_info; 2411 sec = hdr_info->hdr_sec; 2412 bfd_byte *contents; 2413 asection *eh_frame_sec; 2414 bfd_size_type size; 2415 bfd_vma encoded_eh_frame; 2416 2417 size = EH_FRAME_HDR_SIZE; 2418 if (hdr_info->u.dwarf.array 2419 && hdr_info->array_count == hdr_info->u.dwarf.fde_count) 2420 size += 4 + hdr_info->u.dwarf.fde_count * 8; 2421 contents = (bfd_byte *) bfd_malloc (size); 2422 if (contents == NULL) 2423 return FALSE; 2424 2425 eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame"); 2426 if (eh_frame_sec == NULL) 2427 { 2428 free (contents); 2429 return FALSE; 2430 } 2431 2432 memset (contents, 0, EH_FRAME_HDR_SIZE); 2433 /* Version. */ 2434 contents[0] = 1; 2435 /* .eh_frame offset. */ 2436 contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address 2437 (abfd, info, eh_frame_sec, 0, sec, 4, &encoded_eh_frame); 2438 2439 if (hdr_info->u.dwarf.array 2440 && hdr_info->array_count == hdr_info->u.dwarf.fde_count) 2441 { 2442 /* FDE count encoding. */ 2443 contents[2] = DW_EH_PE_udata4; 2444 /* Search table encoding. */ 2445 contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; 2446 } 2447 else 2448 { 2449 contents[2] = DW_EH_PE_omit; 2450 contents[3] = DW_EH_PE_omit; 2451 } 2452 bfd_put_32 (abfd, encoded_eh_frame, contents + 4); 2453 2454 if (contents[2] != DW_EH_PE_omit) 2455 { 2456 unsigned int i; 2457 bfd_boolean overlap, overflow; 2458 2459 bfd_put_32 (abfd, hdr_info->u.dwarf.fde_count, 2460 contents + EH_FRAME_HDR_SIZE); 2461 qsort (hdr_info->u.dwarf.array, hdr_info->u.dwarf.fde_count, 2462 sizeof (*hdr_info->u.dwarf.array), vma_compare); 2463 overlap = FALSE; 2464 overflow = FALSE; 2465 for (i = 0; i < hdr_info->u.dwarf.fde_count; i++) 2466 { 2467 bfd_vma val; 2468 2469 val = hdr_info->u.dwarf.array[i].initial_loc 2470 - sec->output_section->vma; 2471 val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000; 2472 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 2473 && (hdr_info->u.dwarf.array[i].initial_loc 2474 != sec->output_section->vma + val)) 2475 overflow = TRUE; 2476 bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 4); 2477 val = hdr_info->u.dwarf.array[i].fde - sec->output_section->vma; 2478 val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000; 2479 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 2480 && (hdr_info->u.dwarf.array[i].fde 2481 != sec->output_section->vma + val)) 2482 overflow = TRUE; 2483 bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 8); 2484 if (i != 0 2485 && (hdr_info->u.dwarf.array[i].initial_loc 2486 < (hdr_info->u.dwarf.array[i - 1].initial_loc 2487 + hdr_info->u.dwarf.array[i - 1].range))) 2488 overlap = TRUE; 2489 } 2490 if (overflow) 2491 _bfd_error_handler (_(".eh_frame_hdr entry overflow")); 2492 if (overlap) 2493 _bfd_error_handler (_(".eh_frame_hdr refers to overlapping FDEs")); 2494 if (overflow || overlap) 2495 { 2496 bfd_set_error (bfd_error_bad_value); 2497 retval = FALSE; 2498 } 2499 } 2500 2501 /* FIXME: octets_per_byte. */ 2502 if (!bfd_set_section_contents (abfd, sec->output_section, contents, 2503 (file_ptr) sec->output_offset, 2504 sec->size)) 2505 retval = FALSE; 2506 free (contents); 2507 2508 free (hdr_info->u.dwarf.array); 2509 return retval; 2510 } 2511 2512 /* Write out .eh_frame_hdr section. This must be called after 2513 _bfd_elf_write_section_eh_frame has been called on all input 2514 .eh_frame sections. */ 2515 2516 bfd_boolean 2517 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 2518 { 2519 struct elf_link_hash_table *htab; 2520 struct eh_frame_hdr_info *hdr_info; 2521 asection *sec; 2522 2523 htab = elf_hash_table (info); 2524 hdr_info = &htab->eh_info; 2525 sec = hdr_info->hdr_sec; 2526 2527 if (info->eh_frame_hdr_type == 0 || sec == NULL) 2528 return TRUE; 2529 2530 if (info->eh_frame_hdr_type == COMPACT_EH_HDR) 2531 return write_compact_eh_frame_hdr (abfd, info); 2532 else 2533 return write_dwarf_eh_frame_hdr (abfd, info); 2534 } 2535 2536 /* Return the width of FDE addresses. This is the default implementation. */ 2537 2538 unsigned int 2539 _bfd_elf_eh_frame_address_size (bfd *abfd, const asection *sec ATTRIBUTE_UNUSED) 2540 { 2541 return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4; 2542 } 2543 2544 /* Decide whether we can use a PC-relative encoding within the given 2545 EH frame section. This is the default implementation. */ 2546 2547 bfd_boolean 2548 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED, 2549 struct bfd_link_info *info ATTRIBUTE_UNUSED, 2550 asection *eh_frame_section ATTRIBUTE_UNUSED) 2551 { 2552 return TRUE; 2553 } 2554 2555 /* Select an encoding for the given address. Preference is given to 2556 PC-relative addressing modes. */ 2557 2558 bfd_byte 2559 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED, 2560 struct bfd_link_info *info ATTRIBUTE_UNUSED, 2561 asection *osec, bfd_vma offset, 2562 asection *loc_sec, bfd_vma loc_offset, 2563 bfd_vma *encoded) 2564 { 2565 *encoded = osec->vma + offset - 2566 (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset); 2567 return DW_EH_PE_pcrel | DW_EH_PE_sdata4; 2568 } 2569