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 if (sec_info) 1053 free (sec_info); 1054 success: 1055 if (ehbuf) 1056 free (ehbuf); 1057 if (local_cies) 1058 free (local_cies); 1059 #undef REQUIRE 1060 } 1061 1062 /* Order eh_frame_hdr entries by the VMA of their text section. */ 1063 1064 static int 1065 cmp_eh_frame_hdr (const void *a, const void *b) 1066 { 1067 bfd_vma text_a; 1068 bfd_vma text_b; 1069 asection *sec; 1070 1071 sec = *(asection *const *)a; 1072 sec = (asection *) elf_section_data (sec)->sec_info; 1073 text_a = sec->output_section->vma + sec->output_offset; 1074 sec = *(asection *const *)b; 1075 sec = (asection *) elf_section_data (sec)->sec_info; 1076 text_b = sec->output_section->vma + sec->output_offset; 1077 1078 if (text_a < text_b) 1079 return -1; 1080 return text_a > text_b; 1081 1082 } 1083 1084 /* Add space for a CANTUNWIND terminator to SEC if the text sections 1085 referenced by it and NEXT are not contiguous, or NEXT is NULL. */ 1086 1087 static void 1088 add_eh_frame_hdr_terminator (asection *sec, 1089 asection *next) 1090 { 1091 bfd_vma end; 1092 bfd_vma next_start; 1093 asection *text_sec; 1094 1095 if (next) 1096 { 1097 /* See if there is a gap (presumably a text section without unwind info) 1098 between these two entries. */ 1099 text_sec = (asection *) elf_section_data (sec)->sec_info; 1100 end = text_sec->output_section->vma + text_sec->output_offset 1101 + text_sec->size; 1102 text_sec = (asection *) elf_section_data (next)->sec_info; 1103 next_start = text_sec->output_section->vma + text_sec->output_offset; 1104 if (end == next_start) 1105 return; 1106 } 1107 1108 /* Add space for a CANTUNWIND terminator. */ 1109 if (!sec->rawsize) 1110 sec->rawsize = sec->size; 1111 1112 bfd_set_section_size (sec, sec->size + 8); 1113 } 1114 1115 /* Finish a pass over all .eh_frame_entry sections. */ 1116 1117 bfd_boolean 1118 _bfd_elf_end_eh_frame_parsing (struct bfd_link_info *info) 1119 { 1120 struct eh_frame_hdr_info *hdr_info; 1121 unsigned int i; 1122 1123 hdr_info = &elf_hash_table (info)->eh_info; 1124 1125 if (info->eh_frame_hdr_type != COMPACT_EH_HDR 1126 || hdr_info->array_count == 0) 1127 return FALSE; 1128 1129 bfd_elf_discard_eh_frame_entry (hdr_info); 1130 1131 qsort (hdr_info->u.compact.entries, hdr_info->array_count, 1132 sizeof (asection *), cmp_eh_frame_hdr); 1133 1134 for (i = 0; i < hdr_info->array_count - 1; i++) 1135 { 1136 add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i], 1137 hdr_info->u.compact.entries[i + 1]); 1138 } 1139 1140 /* Add a CANTUNWIND terminator after the last entry. */ 1141 add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i], NULL); 1142 return TRUE; 1143 } 1144 1145 /* Mark all relocations against CIE or FDE ENT, which occurs in 1146 .eh_frame section SEC. COOKIE describes the relocations in SEC; 1147 its "rel" field can be changed freely. */ 1148 1149 static bfd_boolean 1150 mark_entry (struct bfd_link_info *info, asection *sec, 1151 struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook, 1152 struct elf_reloc_cookie *cookie) 1153 { 1154 /* FIXME: octets_per_byte. */ 1155 for (cookie->rel = cookie->rels + ent->reloc_index; 1156 cookie->rel < cookie->relend 1157 && cookie->rel->r_offset < ent->offset + ent->size; 1158 cookie->rel++) 1159 if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie)) 1160 return FALSE; 1161 1162 return TRUE; 1163 } 1164 1165 /* Mark all the relocations against FDEs that relate to code in input 1166 section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose 1167 relocations are described by COOKIE. */ 1168 1169 bfd_boolean 1170 _bfd_elf_gc_mark_fdes (struct bfd_link_info *info, asection *sec, 1171 asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook, 1172 struct elf_reloc_cookie *cookie) 1173 { 1174 struct eh_cie_fde *fde, *cie; 1175 1176 for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section) 1177 { 1178 if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie)) 1179 return FALSE; 1180 1181 /* At this stage, all cie_inf fields point to local CIEs, so we 1182 can use the same cookie to refer to them. */ 1183 cie = fde->u.fde.cie_inf; 1184 if (cie != NULL && !cie->u.cie.gc_mark) 1185 { 1186 cie->u.cie.gc_mark = 1; 1187 if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie)) 1188 return FALSE; 1189 } 1190 } 1191 return TRUE; 1192 } 1193 1194 /* Input section SEC of ABFD is an .eh_frame section that contains the 1195 CIE described by CIE_INF. Return a version of CIE_INF that is going 1196 to be kept in the output, adding CIE_INF to the output if necessary. 1197 1198 HDR_INFO is the .eh_frame_hdr information and COOKIE describes the 1199 relocations in REL. */ 1200 1201 static struct eh_cie_fde * 1202 find_merged_cie (bfd *abfd, struct bfd_link_info *info, asection *sec, 1203 struct eh_frame_hdr_info *hdr_info, 1204 struct elf_reloc_cookie *cookie, 1205 struct eh_cie_fde *cie_inf) 1206 { 1207 unsigned long r_symndx; 1208 struct cie *cie, *new_cie; 1209 Elf_Internal_Rela *rel; 1210 void **loc; 1211 1212 /* Use CIE_INF if we have already decided to keep it. */ 1213 if (!cie_inf->removed) 1214 return cie_inf; 1215 1216 /* If we have merged CIE_INF with another CIE, use that CIE instead. */ 1217 if (cie_inf->u.cie.merged) 1218 return cie_inf->u.cie.u.merged_with; 1219 1220 cie = cie_inf->u.cie.u.full_cie; 1221 1222 /* Assume we will need to keep CIE_INF. */ 1223 cie_inf->removed = 0; 1224 cie_inf->u.cie.u.sec = sec; 1225 1226 /* If we are not merging CIEs, use CIE_INF. */ 1227 if (cie == NULL) 1228 return cie_inf; 1229 1230 if (cie->per_encoding != DW_EH_PE_omit) 1231 { 1232 bfd_boolean per_binds_local; 1233 1234 /* Work out the address of personality routine, or at least 1235 enough info that we could calculate the address had we made a 1236 final section layout. The symbol on the reloc is enough, 1237 either the hash for a global, or (bfd id, index) pair for a 1238 local. The assumption here is that no one uses addends on 1239 the reloc. */ 1240 rel = cookie->rels + cie->personality.reloc_index; 1241 memset (&cie->personality, 0, sizeof (cie->personality)); 1242 #ifdef BFD64 1243 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64) 1244 r_symndx = ELF64_R_SYM (rel->r_info); 1245 else 1246 #endif 1247 r_symndx = ELF32_R_SYM (rel->r_info); 1248 if (r_symndx >= cookie->locsymcount 1249 || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL) 1250 { 1251 struct elf_link_hash_entry *h; 1252 1253 r_symndx -= cookie->extsymoff; 1254 h = cookie->sym_hashes[r_symndx]; 1255 1256 while (h->root.type == bfd_link_hash_indirect 1257 || h->root.type == bfd_link_hash_warning) 1258 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1259 1260 cie->personality.h = h; 1261 per_binds_local = SYMBOL_REFERENCES_LOCAL (info, h); 1262 } 1263 else 1264 { 1265 Elf_Internal_Sym *sym; 1266 asection *sym_sec; 1267 1268 sym = &cookie->locsyms[r_symndx]; 1269 sym_sec = bfd_section_from_elf_index (abfd, sym->st_shndx); 1270 if (sym_sec == NULL) 1271 return cie_inf; 1272 1273 if (sym_sec->kept_section != NULL) 1274 sym_sec = sym_sec->kept_section; 1275 if (sym_sec->output_section == NULL) 1276 return cie_inf; 1277 1278 cie->local_personality = 1; 1279 cie->personality.sym.bfd_id = abfd->id; 1280 cie->personality.sym.index = r_symndx; 1281 per_binds_local = TRUE; 1282 } 1283 1284 if (per_binds_local 1285 && bfd_link_pic (info) 1286 && (cie->per_encoding & 0x70) == DW_EH_PE_absptr 1287 && (get_elf_backend_data (abfd) 1288 ->elf_backend_can_make_relative_eh_frame (abfd, info, sec))) 1289 { 1290 cie_inf->u.cie.make_per_encoding_relative = 1; 1291 cie_inf->u.cie.per_encoding_relative = 1; 1292 } 1293 } 1294 1295 /* See if we can merge this CIE with an earlier one. */ 1296 cie_compute_hash (cie); 1297 if (hdr_info->u.dwarf.cies == NULL) 1298 { 1299 hdr_info->u.dwarf.cies = htab_try_create (1, cie_hash, cie_eq, free); 1300 if (hdr_info->u.dwarf.cies == NULL) 1301 return cie_inf; 1302 } 1303 loc = htab_find_slot_with_hash (hdr_info->u.dwarf.cies, cie, 1304 cie->hash, INSERT); 1305 if (loc == NULL) 1306 return cie_inf; 1307 1308 new_cie = (struct cie *) *loc; 1309 if (new_cie == NULL) 1310 { 1311 /* Keep CIE_INF and record it in the hash table. */ 1312 new_cie = (struct cie *) malloc (sizeof (struct cie)); 1313 if (new_cie == NULL) 1314 return cie_inf; 1315 1316 memcpy (new_cie, cie, sizeof (struct cie)); 1317 *loc = new_cie; 1318 } 1319 else 1320 { 1321 /* Merge CIE_INF with NEW_CIE->CIE_INF. */ 1322 cie_inf->removed = 1; 1323 cie_inf->u.cie.merged = 1; 1324 cie_inf->u.cie.u.merged_with = new_cie->cie_inf; 1325 if (cie_inf->u.cie.make_lsda_relative) 1326 new_cie->cie_inf->u.cie.make_lsda_relative = 1; 1327 } 1328 return new_cie->cie_inf; 1329 } 1330 1331 /* For a given OFFSET in SEC, return the delta to the new location 1332 after .eh_frame editing. */ 1333 1334 static bfd_signed_vma 1335 offset_adjust (bfd_vma offset, const asection *sec) 1336 { 1337 struct eh_frame_sec_info *sec_info 1338 = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info; 1339 unsigned int lo, hi, mid; 1340 struct eh_cie_fde *ent = NULL; 1341 bfd_signed_vma delta; 1342 1343 lo = 0; 1344 hi = sec_info->count; 1345 if (hi == 0) 1346 return 0; 1347 1348 while (lo < hi) 1349 { 1350 mid = (lo + hi) / 2; 1351 ent = &sec_info->entry[mid]; 1352 if (offset < ent->offset) 1353 hi = mid; 1354 else if (mid + 1 >= hi) 1355 break; 1356 else if (offset >= ent[1].offset) 1357 lo = mid + 1; 1358 else 1359 break; 1360 } 1361 1362 if (!ent->removed) 1363 delta = (bfd_vma) ent->new_offset - (bfd_vma) ent->offset; 1364 else if (ent->cie && ent->u.cie.merged) 1365 { 1366 struct eh_cie_fde *cie = ent->u.cie.u.merged_with; 1367 delta = ((bfd_vma) cie->new_offset + cie->u.cie.u.sec->output_offset 1368 - (bfd_vma) ent->offset - sec->output_offset); 1369 } 1370 else 1371 { 1372 /* Is putting the symbol on the next entry best for a deleted 1373 CIE/FDE? */ 1374 struct eh_cie_fde *last = sec_info->entry + sec_info->count; 1375 delta = ((bfd_vma) next_cie_fde_offset (ent, last, sec) 1376 - (bfd_vma) ent->offset); 1377 return delta; 1378 } 1379 1380 /* Account for editing within this CIE/FDE. */ 1381 offset -= ent->offset; 1382 if (ent->cie) 1383 { 1384 unsigned int extra 1385 = ent->add_augmentation_size + ent->u.cie.add_fde_encoding; 1386 if (extra == 0 1387 || offset <= 9u + ent->u.cie.aug_str_len) 1388 return delta; 1389 delta += extra; 1390 if (offset <= 9u + ent->u.cie.aug_str_len + ent->u.cie.aug_data_len) 1391 return delta; 1392 delta += extra; 1393 } 1394 else 1395 { 1396 unsigned int ptr_size, width, extra = ent->add_augmentation_size; 1397 if (offset <= 12 || extra == 0) 1398 return delta; 1399 ptr_size = (get_elf_backend_data (sec->owner) 1400 ->elf_backend_eh_frame_address_size (sec->owner, sec)); 1401 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 1402 if (offset <= 8 + 2 * width) 1403 return delta; 1404 delta += extra; 1405 } 1406 1407 return delta; 1408 } 1409 1410 /* Adjust a global symbol defined in .eh_frame, so that it stays 1411 relative to its original CIE/FDE. It is assumed that a symbol 1412 defined at the beginning of a CIE/FDE belongs to that CIE/FDE 1413 rather than marking the end of the previous CIE/FDE. This matters 1414 when a CIE is merged with a previous CIE, since the symbol is 1415 moved to the merged CIE. */ 1416 1417 bfd_boolean 1418 _bfd_elf_adjust_eh_frame_global_symbol (struct elf_link_hash_entry *h, 1419 void *arg ATTRIBUTE_UNUSED) 1420 { 1421 asection *sym_sec; 1422 bfd_signed_vma delta; 1423 1424 if (h->root.type != bfd_link_hash_defined 1425 && h->root.type != bfd_link_hash_defweak) 1426 return TRUE; 1427 1428 sym_sec = h->root.u.def.section; 1429 if (sym_sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME 1430 || elf_section_data (sym_sec)->sec_info == NULL) 1431 return TRUE; 1432 1433 delta = offset_adjust (h->root.u.def.value, sym_sec); 1434 h->root.u.def.value += delta; 1435 1436 return TRUE; 1437 } 1438 1439 /* The same for all local symbols defined in .eh_frame. Returns true 1440 if any symbol was changed. */ 1441 1442 static int 1443 adjust_eh_frame_local_symbols (const asection *sec, 1444 struct elf_reloc_cookie *cookie) 1445 { 1446 unsigned int shndx; 1447 Elf_Internal_Sym *sym; 1448 Elf_Internal_Sym *end_sym; 1449 int adjusted = 0; 1450 1451 shndx = elf_section_data (sec)->this_idx; 1452 end_sym = cookie->locsyms + cookie->locsymcount; 1453 for (sym = cookie->locsyms + 1; sym < end_sym; ++sym) 1454 if (sym->st_info <= ELF_ST_INFO (STB_LOCAL, STT_OBJECT) 1455 && sym->st_shndx == shndx) 1456 { 1457 bfd_signed_vma delta = offset_adjust (sym->st_value, sec); 1458 1459 if (delta != 0) 1460 { 1461 adjusted = 1; 1462 sym->st_value += delta; 1463 } 1464 } 1465 return adjusted; 1466 } 1467 1468 /* This function is called for each input file before the .eh_frame 1469 section is relocated. It discards duplicate CIEs and FDEs for discarded 1470 functions. The function returns TRUE iff any entries have been 1471 deleted. */ 1472 1473 bfd_boolean 1474 _bfd_elf_discard_section_eh_frame 1475 (bfd *abfd, struct bfd_link_info *info, asection *sec, 1476 bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *), 1477 struct elf_reloc_cookie *cookie) 1478 { 1479 struct eh_cie_fde *ent; 1480 struct eh_frame_sec_info *sec_info; 1481 struct eh_frame_hdr_info *hdr_info; 1482 unsigned int ptr_size, offset, eh_alignment; 1483 int changed; 1484 1485 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME) 1486 return FALSE; 1487 1488 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info; 1489 if (sec_info == NULL) 1490 return FALSE; 1491 1492 ptr_size = (get_elf_backend_data (sec->owner) 1493 ->elf_backend_eh_frame_address_size (sec->owner, sec)); 1494 1495 hdr_info = &elf_hash_table (info)->eh_info; 1496 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent) 1497 if (ent->size == 4) 1498 /* There should only be one zero terminator, on the last input 1499 file supplying .eh_frame (crtend.o). Remove any others. */ 1500 ent->removed = sec->map_head.s != NULL; 1501 else if (!ent->cie && ent->u.fde.cie_inf != NULL) 1502 { 1503 bfd_boolean keep; 1504 if ((sec->flags & SEC_LINKER_CREATED) != 0 && cookie->rels == NULL) 1505 { 1506 unsigned int width 1507 = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 1508 bfd_vma value 1509 = read_value (abfd, sec->contents + ent->offset + 8 + width, 1510 width, get_DW_EH_PE_signed (ent->fde_encoding)); 1511 keep = value != 0; 1512 } 1513 else 1514 { 1515 cookie->rel = cookie->rels + ent->reloc_index; 1516 /* FIXME: octets_per_byte. */ 1517 BFD_ASSERT (cookie->rel < cookie->relend 1518 && cookie->rel->r_offset == ent->offset + 8); 1519 keep = !(*reloc_symbol_deleted_p) (ent->offset + 8, cookie); 1520 } 1521 if (keep) 1522 { 1523 if (bfd_link_pic (info) 1524 && (((ent->fde_encoding & 0x70) == DW_EH_PE_absptr 1525 && ent->make_relative == 0) 1526 || (ent->fde_encoding & 0x70) == DW_EH_PE_aligned)) 1527 { 1528 static int num_warnings_issued = 0; 1529 1530 /* If a shared library uses absolute pointers 1531 which we cannot turn into PC relative, 1532 don't create the binary search table, 1533 since it is affected by runtime relocations. */ 1534 hdr_info->u.dwarf.table = FALSE; 1535 /* Only warn if --eh-frame-hdr was specified. */ 1536 if (info->eh_frame_hdr_type != 0) 1537 { 1538 if (num_warnings_issued < 10) 1539 { 1540 _bfd_error_handler 1541 /* xgettext:c-format */ 1542 (_("FDE encoding in %pB(%pA) prevents .eh_frame_hdr" 1543 " table being created"), abfd, sec); 1544 num_warnings_issued ++; 1545 } 1546 else if (num_warnings_issued == 10) 1547 { 1548 _bfd_error_handler 1549 (_("further warnings about FDE encoding preventing .eh_frame_hdr generation dropped")); 1550 num_warnings_issued ++; 1551 } 1552 } 1553 } 1554 ent->removed = 0; 1555 hdr_info->u.dwarf.fde_count++; 1556 ent->u.fde.cie_inf = find_merged_cie (abfd, info, sec, hdr_info, 1557 cookie, ent->u.fde.cie_inf); 1558 } 1559 } 1560 1561 if (sec_info->cies) 1562 { 1563 free (sec_info->cies); 1564 sec_info->cies = NULL; 1565 } 1566 1567 /* It may be that some .eh_frame input section has greater alignment 1568 than other .eh_frame sections. In that case we run the risk of 1569 padding with zeros before that section, which would be seen as a 1570 zero terminator. Alignment padding must be added *inside* the 1571 last FDE instead. For other FDEs we align according to their 1572 encoding, in order to align FDE address range entries naturally. */ 1573 offset = 0; 1574 changed = 0; 1575 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent) 1576 if (!ent->removed) 1577 { 1578 eh_alignment = 4; 1579 if (ent->size == 4) 1580 ; 1581 else if (ent->cie) 1582 { 1583 if (ent->u.cie.per_encoding_aligned8) 1584 eh_alignment = 8; 1585 } 1586 else 1587 { 1588 eh_alignment = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 1589 if (eh_alignment < 4) 1590 eh_alignment = 4; 1591 } 1592 offset = (offset + eh_alignment - 1) & -eh_alignment; 1593 ent->new_offset = offset; 1594 if (ent->new_offset != ent->offset) 1595 changed = 1; 1596 offset += size_of_output_cie_fde (ent); 1597 } 1598 1599 eh_alignment = 4; 1600 offset = (offset + eh_alignment - 1) & -eh_alignment; 1601 sec->rawsize = sec->size; 1602 sec->size = offset; 1603 if (sec->size != sec->rawsize) 1604 changed = 1; 1605 1606 if (changed && adjust_eh_frame_local_symbols (sec, cookie)) 1607 { 1608 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1609 symtab_hdr->contents = (unsigned char *) cookie->locsyms; 1610 } 1611 return changed; 1612 } 1613 1614 /* This function is called for .eh_frame_hdr section after 1615 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame 1616 input sections. It finalizes the size of .eh_frame_hdr section. */ 1617 1618 bfd_boolean 1619 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 1620 { 1621 struct elf_link_hash_table *htab; 1622 struct eh_frame_hdr_info *hdr_info; 1623 asection *sec; 1624 1625 htab = elf_hash_table (info); 1626 hdr_info = &htab->eh_info; 1627 1628 if (!hdr_info->frame_hdr_is_compact && hdr_info->u.dwarf.cies != NULL) 1629 { 1630 htab_delete (hdr_info->u.dwarf.cies); 1631 hdr_info->u.dwarf.cies = NULL; 1632 } 1633 1634 sec = hdr_info->hdr_sec; 1635 if (sec == NULL) 1636 return FALSE; 1637 1638 if (info->eh_frame_hdr_type == COMPACT_EH_HDR) 1639 { 1640 /* For compact frames we only add the header. The actual table comes 1641 from the .eh_frame_entry sections. */ 1642 sec->size = 8; 1643 } 1644 else 1645 { 1646 sec->size = EH_FRAME_HDR_SIZE; 1647 if (hdr_info->u.dwarf.table) 1648 sec->size += 4 + hdr_info->u.dwarf.fde_count * 8; 1649 } 1650 1651 elf_eh_frame_hdr (abfd) = sec; 1652 return TRUE; 1653 } 1654 1655 /* Return true if there is at least one non-empty .eh_frame section in 1656 input files. Can only be called after ld has mapped input to 1657 output sections, and before sections are stripped. */ 1658 1659 bfd_boolean 1660 _bfd_elf_eh_frame_present (struct bfd_link_info *info) 1661 { 1662 asection *eh = bfd_get_section_by_name (info->output_bfd, ".eh_frame"); 1663 1664 if (eh == NULL) 1665 return FALSE; 1666 1667 /* Count only sections which have at least a single CIE or FDE. 1668 There cannot be any CIE or FDE <= 8 bytes. */ 1669 for (eh = eh->map_head.s; eh != NULL; eh = eh->map_head.s) 1670 if (eh->size > 8) 1671 return TRUE; 1672 1673 return FALSE; 1674 } 1675 1676 /* Return true if there is at least one .eh_frame_entry section in 1677 input files. */ 1678 1679 bfd_boolean 1680 _bfd_elf_eh_frame_entry_present (struct bfd_link_info *info) 1681 { 1682 asection *o; 1683 bfd *abfd; 1684 1685 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next) 1686 { 1687 for (o = abfd->sections; o; o = o->next) 1688 { 1689 const char *name = bfd_section_name (o); 1690 1691 if (strcmp (name, ".eh_frame_entry") 1692 && !bfd_is_abs_section (o->output_section)) 1693 return TRUE; 1694 } 1695 } 1696 return FALSE; 1697 } 1698 1699 /* This function is called from size_dynamic_sections. 1700 It needs to decide whether .eh_frame_hdr should be output or not, 1701 because when the dynamic symbol table has been sized it is too late 1702 to strip sections. */ 1703 1704 bfd_boolean 1705 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info) 1706 { 1707 struct elf_link_hash_table *htab; 1708 struct eh_frame_hdr_info *hdr_info; 1709 struct bfd_link_hash_entry *bh = NULL; 1710 struct elf_link_hash_entry *h; 1711 1712 htab = elf_hash_table (info); 1713 hdr_info = &htab->eh_info; 1714 if (hdr_info->hdr_sec == NULL) 1715 return TRUE; 1716 1717 if (bfd_is_abs_section (hdr_info->hdr_sec->output_section) 1718 || info->eh_frame_hdr_type == 0 1719 || (info->eh_frame_hdr_type == DWARF2_EH_HDR 1720 && !_bfd_elf_eh_frame_present (info)) 1721 || (info->eh_frame_hdr_type == COMPACT_EH_HDR 1722 && !_bfd_elf_eh_frame_entry_present (info))) 1723 { 1724 hdr_info->hdr_sec->flags |= SEC_EXCLUDE; 1725 hdr_info->hdr_sec = NULL; 1726 return TRUE; 1727 } 1728 1729 /* Add a hidden symbol so that systems without access to PHDRs can 1730 find the table. */ 1731 if (! (_bfd_generic_link_add_one_symbol 1732 (info, info->output_bfd, "__GNU_EH_FRAME_HDR", BSF_LOCAL, 1733 hdr_info->hdr_sec, 0, NULL, FALSE, FALSE, &bh))) 1734 return FALSE; 1735 1736 h = (struct elf_link_hash_entry *) bh; 1737 h->def_regular = 1; 1738 h->other = STV_HIDDEN; 1739 get_elf_backend_data 1740 (info->output_bfd)->elf_backend_hide_symbol (info, h, TRUE); 1741 1742 if (!hdr_info->frame_hdr_is_compact) 1743 hdr_info->u.dwarf.table = TRUE; 1744 return TRUE; 1745 } 1746 1747 /* Adjust an address in the .eh_frame section. Given OFFSET within 1748 SEC, this returns the new offset in the adjusted .eh_frame section, 1749 or -1 if the address refers to a CIE/FDE which has been removed 1750 or to offset with dynamic relocation which is no longer needed. */ 1751 1752 bfd_vma 1753 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED, 1754 struct bfd_link_info *info ATTRIBUTE_UNUSED, 1755 asection *sec, 1756 bfd_vma offset) 1757 { 1758 struct eh_frame_sec_info *sec_info; 1759 unsigned int lo, hi, mid; 1760 1761 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME) 1762 return offset; 1763 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info; 1764 1765 if (offset >= sec->rawsize) 1766 return offset - sec->rawsize + sec->size; 1767 1768 lo = 0; 1769 hi = sec_info->count; 1770 mid = 0; 1771 while (lo < hi) 1772 { 1773 mid = (lo + hi) / 2; 1774 if (offset < sec_info->entry[mid].offset) 1775 hi = mid; 1776 else if (offset 1777 >= sec_info->entry[mid].offset + sec_info->entry[mid].size) 1778 lo = mid + 1; 1779 else 1780 break; 1781 } 1782 1783 BFD_ASSERT (lo < hi); 1784 1785 /* FDE or CIE was removed. */ 1786 if (sec_info->entry[mid].removed) 1787 return (bfd_vma) -1; 1788 1789 /* If converting personality pointers to DW_EH_PE_pcrel, there will be 1790 no need for run-time relocation against the personality field. */ 1791 if (sec_info->entry[mid].cie 1792 && sec_info->entry[mid].u.cie.make_per_encoding_relative 1793 && offset == (sec_info->entry[mid].offset + 8 1794 + sec_info->entry[mid].u.cie.personality_offset)) 1795 return (bfd_vma) -2; 1796 1797 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time 1798 relocation against FDE's initial_location field. */ 1799 if (!sec_info->entry[mid].cie 1800 && sec_info->entry[mid].make_relative 1801 && offset == sec_info->entry[mid].offset + 8) 1802 return (bfd_vma) -2; 1803 1804 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need 1805 for run-time relocation against LSDA field. */ 1806 if (!sec_info->entry[mid].cie 1807 && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative 1808 && offset == (sec_info->entry[mid].offset + 8 1809 + sec_info->entry[mid].lsda_offset)) 1810 return (bfd_vma) -2; 1811 1812 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time 1813 relocation against DW_CFA_set_loc's arguments. */ 1814 if (sec_info->entry[mid].set_loc 1815 && sec_info->entry[mid].make_relative 1816 && (offset >= sec_info->entry[mid].offset + 8 1817 + sec_info->entry[mid].set_loc[1])) 1818 { 1819 unsigned int cnt; 1820 1821 for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++) 1822 if (offset == sec_info->entry[mid].offset + 8 1823 + sec_info->entry[mid].set_loc[cnt]) 1824 return (bfd_vma) -2; 1825 } 1826 1827 /* Any new augmentation bytes go before the first relocation. */ 1828 return (offset + sec_info->entry[mid].new_offset 1829 - sec_info->entry[mid].offset 1830 + extra_augmentation_string_bytes (sec_info->entry + mid) 1831 + extra_augmentation_data_bytes (sec_info->entry + mid)); 1832 } 1833 1834 /* Write out .eh_frame_entry section. Add CANTUNWIND terminator if needed. 1835 Also check that the contents look sane. */ 1836 1837 bfd_boolean 1838 _bfd_elf_write_section_eh_frame_entry (bfd *abfd, struct bfd_link_info *info, 1839 asection *sec, bfd_byte *contents) 1840 { 1841 const struct elf_backend_data *bed; 1842 bfd_byte cantunwind[8]; 1843 bfd_vma addr; 1844 bfd_vma last_addr; 1845 bfd_vma offset; 1846 asection *text_sec = (asection *) elf_section_data (sec)->sec_info; 1847 1848 if (!sec->rawsize) 1849 sec->rawsize = sec->size; 1850 1851 BFD_ASSERT (sec->sec_info_type == SEC_INFO_TYPE_EH_FRAME_ENTRY); 1852 1853 /* Check to make sure that the text section corresponding to this eh_frame_entry 1854 section has not been excluded. In particular, mips16 stub entries will be 1855 excluded outside of the normal process. */ 1856 if (sec->flags & SEC_EXCLUDE 1857 || text_sec->flags & SEC_EXCLUDE) 1858 return TRUE; 1859 1860 if (!bfd_set_section_contents (abfd, sec->output_section, contents, 1861 sec->output_offset, sec->rawsize)) 1862 return FALSE; 1863 1864 last_addr = bfd_get_signed_32 (abfd, contents); 1865 /* Check that all the entries are in order. */ 1866 for (offset = 8; offset < sec->rawsize; offset += 8) 1867 { 1868 addr = bfd_get_signed_32 (abfd, contents + offset) + offset; 1869 if (addr <= last_addr) 1870 { 1871 /* xgettext:c-format */ 1872 _bfd_error_handler (_("%pB: %pA not in order"), sec->owner, sec); 1873 return FALSE; 1874 } 1875 1876 last_addr = addr; 1877 } 1878 1879 addr = text_sec->output_section->vma + text_sec->output_offset 1880 + text_sec->size; 1881 addr &= ~1; 1882 addr -= (sec->output_section->vma + sec->output_offset + sec->rawsize); 1883 if (addr & 1) 1884 { 1885 /* xgettext:c-format */ 1886 _bfd_error_handler (_("%pB: %pA invalid input section size"), 1887 sec->owner, sec); 1888 bfd_set_error (bfd_error_bad_value); 1889 return FALSE; 1890 } 1891 if (last_addr >= addr + sec->rawsize) 1892 { 1893 /* xgettext:c-format */ 1894 _bfd_error_handler (_("%pB: %pA points past end of text section"), 1895 sec->owner, sec); 1896 bfd_set_error (bfd_error_bad_value); 1897 return FALSE; 1898 } 1899 1900 if (sec->size == sec->rawsize) 1901 return TRUE; 1902 1903 bed = get_elf_backend_data (abfd); 1904 BFD_ASSERT (sec->size == sec->rawsize + 8); 1905 BFD_ASSERT ((addr & 1) == 0); 1906 BFD_ASSERT (bed->cant_unwind_opcode); 1907 1908 bfd_put_32 (abfd, addr, cantunwind); 1909 bfd_put_32 (abfd, (*bed->cant_unwind_opcode) (info), cantunwind + 4); 1910 return bfd_set_section_contents (abfd, sec->output_section, cantunwind, 1911 sec->output_offset + sec->rawsize, 8); 1912 } 1913 1914 /* Write out .eh_frame section. This is called with the relocated 1915 contents. */ 1916 1917 bfd_boolean 1918 _bfd_elf_write_section_eh_frame (bfd *abfd, 1919 struct bfd_link_info *info, 1920 asection *sec, 1921 bfd_byte *contents) 1922 { 1923 struct eh_frame_sec_info *sec_info; 1924 struct elf_link_hash_table *htab; 1925 struct eh_frame_hdr_info *hdr_info; 1926 unsigned int ptr_size; 1927 struct eh_cie_fde *ent, *last_ent; 1928 1929 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME) 1930 /* FIXME: octets_per_byte. */ 1931 return bfd_set_section_contents (abfd, sec->output_section, contents, 1932 sec->output_offset, sec->size); 1933 1934 ptr_size = (get_elf_backend_data (abfd) 1935 ->elf_backend_eh_frame_address_size (abfd, sec)); 1936 BFD_ASSERT (ptr_size != 0); 1937 1938 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info; 1939 htab = elf_hash_table (info); 1940 hdr_info = &htab->eh_info; 1941 1942 if (hdr_info->u.dwarf.table && hdr_info->u.dwarf.array == NULL) 1943 { 1944 hdr_info->frame_hdr_is_compact = FALSE; 1945 hdr_info->u.dwarf.array = (struct eh_frame_array_ent *) 1946 bfd_malloc (hdr_info->u.dwarf.fde_count 1947 * sizeof (*hdr_info->u.dwarf.array)); 1948 } 1949 if (hdr_info->u.dwarf.array == NULL) 1950 hdr_info = NULL; 1951 1952 /* The new offsets can be bigger or smaller than the original offsets. 1953 We therefore need to make two passes over the section: one backward 1954 pass to move entries up and one forward pass to move entries down. 1955 The two passes won't interfere with each other because entries are 1956 not reordered */ 1957 for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;) 1958 if (!ent->removed && ent->new_offset > ent->offset) 1959 memmove (contents + ent->new_offset, contents + ent->offset, ent->size); 1960 1961 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent) 1962 if (!ent->removed && ent->new_offset < ent->offset) 1963 memmove (contents + ent->new_offset, contents + ent->offset, ent->size); 1964 1965 last_ent = sec_info->entry + sec_info->count; 1966 for (ent = sec_info->entry; ent < last_ent; ++ent) 1967 { 1968 unsigned char *buf, *end; 1969 unsigned int new_size; 1970 1971 if (ent->removed) 1972 continue; 1973 1974 if (ent->size == 4) 1975 { 1976 /* Any terminating FDE must be at the end of the section. */ 1977 BFD_ASSERT (ent == last_ent - 1); 1978 continue; 1979 } 1980 1981 buf = contents + ent->new_offset; 1982 end = buf + ent->size; 1983 new_size = next_cie_fde_offset (ent, last_ent, sec) - ent->new_offset; 1984 1985 /* Update the size. It may be shrinked. */ 1986 bfd_put_32 (abfd, new_size - 4, buf); 1987 1988 /* Filling the extra bytes with DW_CFA_nops. */ 1989 if (new_size != ent->size) 1990 memset (end, 0, new_size - ent->size); 1991 1992 if (ent->cie) 1993 { 1994 /* CIE */ 1995 if (ent->make_relative 1996 || ent->u.cie.make_lsda_relative 1997 || ent->u.cie.per_encoding_relative) 1998 { 1999 char *aug; 2000 unsigned int version, action, extra_string, extra_data; 2001 unsigned int per_width, per_encoding; 2002 2003 /* Need to find 'R' or 'L' augmentation's argument and modify 2004 DW_EH_PE_* value. */ 2005 action = ((ent->make_relative ? 1 : 0) 2006 | (ent->u.cie.make_lsda_relative ? 2 : 0) 2007 | (ent->u.cie.per_encoding_relative ? 4 : 0)); 2008 extra_string = extra_augmentation_string_bytes (ent); 2009 extra_data = extra_augmentation_data_bytes (ent); 2010 2011 /* Skip length, id. */ 2012 buf += 8; 2013 version = *buf++; 2014 aug = (char *) buf; 2015 buf += strlen (aug) + 1; 2016 skip_leb128 (&buf, end); 2017 skip_leb128 (&buf, end); 2018 if (version == 1) 2019 skip_bytes (&buf, end, 1); 2020 else 2021 skip_leb128 (&buf, end); 2022 if (*aug == 'z') 2023 { 2024 /* The uleb128 will always be a single byte for the kind 2025 of augmentation strings that we're prepared to handle. */ 2026 *buf++ += extra_data; 2027 aug++; 2028 } 2029 2030 /* Make room for the new augmentation string and data bytes. */ 2031 memmove (buf + extra_string + extra_data, buf, end - buf); 2032 memmove (aug + extra_string, aug, buf - (bfd_byte *) aug); 2033 buf += extra_string; 2034 end += extra_string + extra_data; 2035 2036 if (ent->add_augmentation_size) 2037 { 2038 *aug++ = 'z'; 2039 *buf++ = extra_data - 1; 2040 } 2041 if (ent->u.cie.add_fde_encoding) 2042 { 2043 BFD_ASSERT (action & 1); 2044 *aug++ = 'R'; 2045 *buf++ = make_pc_relative (DW_EH_PE_absptr, ptr_size); 2046 action &= ~1; 2047 } 2048 2049 while (action) 2050 switch (*aug++) 2051 { 2052 case 'L': 2053 if (action & 2) 2054 { 2055 BFD_ASSERT (*buf == ent->lsda_encoding); 2056 *buf = make_pc_relative (*buf, ptr_size); 2057 action &= ~2; 2058 } 2059 buf++; 2060 break; 2061 case 'P': 2062 if (ent->u.cie.make_per_encoding_relative) 2063 *buf = make_pc_relative (*buf, ptr_size); 2064 per_encoding = *buf++; 2065 per_width = get_DW_EH_PE_width (per_encoding, ptr_size); 2066 BFD_ASSERT (per_width != 0); 2067 BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel) 2068 == ent->u.cie.per_encoding_relative); 2069 if ((per_encoding & 0x70) == DW_EH_PE_aligned) 2070 buf = (contents 2071 + ((buf - contents + per_width - 1) 2072 & ~((bfd_size_type) per_width - 1))); 2073 if (action & 4) 2074 { 2075 bfd_vma val; 2076 2077 val = read_value (abfd, buf, per_width, 2078 get_DW_EH_PE_signed (per_encoding)); 2079 if (ent->u.cie.make_per_encoding_relative) 2080 val -= (sec->output_section->vma 2081 + sec->output_offset 2082 + (buf - contents)); 2083 else 2084 { 2085 val += (bfd_vma) ent->offset - ent->new_offset; 2086 val -= extra_string + extra_data; 2087 } 2088 write_value (abfd, buf, val, per_width); 2089 action &= ~4; 2090 } 2091 buf += per_width; 2092 break; 2093 case 'R': 2094 if (action & 1) 2095 { 2096 BFD_ASSERT (*buf == ent->fde_encoding); 2097 *buf = make_pc_relative (*buf, ptr_size); 2098 action &= ~1; 2099 } 2100 buf++; 2101 break; 2102 case 'S': 2103 break; 2104 default: 2105 BFD_FAIL (); 2106 } 2107 } 2108 } 2109 else 2110 { 2111 /* FDE */ 2112 bfd_vma value, address; 2113 unsigned int width; 2114 bfd_byte *start; 2115 struct eh_cie_fde *cie; 2116 2117 /* Skip length. */ 2118 cie = ent->u.fde.cie_inf; 2119 buf += 4; 2120 value = ((ent->new_offset + sec->output_offset + 4) 2121 - (cie->new_offset + cie->u.cie.u.sec->output_offset)); 2122 bfd_put_32 (abfd, value, buf); 2123 if (bfd_link_relocatable (info)) 2124 continue; 2125 buf += 4; 2126 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 2127 value = read_value (abfd, buf, width, 2128 get_DW_EH_PE_signed (ent->fde_encoding)); 2129 address = value; 2130 if (value) 2131 { 2132 switch (ent->fde_encoding & 0x70) 2133 { 2134 case DW_EH_PE_textrel: 2135 BFD_ASSERT (hdr_info == NULL); 2136 break; 2137 case DW_EH_PE_datarel: 2138 { 2139 switch (abfd->arch_info->arch) 2140 { 2141 case bfd_arch_ia64: 2142 BFD_ASSERT (elf_gp (abfd) != 0); 2143 address += elf_gp (abfd); 2144 break; 2145 default: 2146 _bfd_error_handler 2147 (_("DW_EH_PE_datarel unspecified" 2148 " for this architecture")); 2149 /* Fall thru */ 2150 case bfd_arch_frv: 2151 case bfd_arch_i386: 2152 BFD_ASSERT (htab->hgot != NULL 2153 && ((htab->hgot->root.type 2154 == bfd_link_hash_defined) 2155 || (htab->hgot->root.type 2156 == bfd_link_hash_defweak))); 2157 address 2158 += (htab->hgot->root.u.def.value 2159 + htab->hgot->root.u.def.section->output_offset 2160 + (htab->hgot->root.u.def.section->output_section 2161 ->vma)); 2162 break; 2163 } 2164 } 2165 break; 2166 case DW_EH_PE_pcrel: 2167 value += (bfd_vma) ent->offset - ent->new_offset; 2168 address += (sec->output_section->vma 2169 + sec->output_offset 2170 + ent->offset + 8); 2171 break; 2172 } 2173 if (ent->make_relative) 2174 value -= (sec->output_section->vma 2175 + sec->output_offset 2176 + ent->new_offset + 8); 2177 write_value (abfd, buf, value, width); 2178 } 2179 2180 start = buf; 2181 2182 if (hdr_info) 2183 { 2184 /* The address calculation may overflow, giving us a 2185 value greater than 4G on a 32-bit target when 2186 dwarf_vma is 64-bit. */ 2187 if (sizeof (address) > 4 && ptr_size == 4) 2188 address &= 0xffffffff; 2189 hdr_info->u.dwarf.array[hdr_info->array_count].initial_loc 2190 = address; 2191 hdr_info->u.dwarf.array[hdr_info->array_count].range 2192 = read_value (abfd, buf + width, width, FALSE); 2193 hdr_info->u.dwarf.array[hdr_info->array_count++].fde 2194 = (sec->output_section->vma 2195 + sec->output_offset 2196 + ent->new_offset); 2197 } 2198 2199 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel 2200 || cie->u.cie.make_lsda_relative) 2201 { 2202 buf += ent->lsda_offset; 2203 width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size); 2204 value = read_value (abfd, buf, width, 2205 get_DW_EH_PE_signed (ent->lsda_encoding)); 2206 if (value) 2207 { 2208 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel) 2209 value += (bfd_vma) ent->offset - ent->new_offset; 2210 else if (cie->u.cie.make_lsda_relative) 2211 value -= (sec->output_section->vma 2212 + sec->output_offset 2213 + ent->new_offset + 8 + ent->lsda_offset); 2214 write_value (abfd, buf, value, width); 2215 } 2216 } 2217 else if (ent->add_augmentation_size) 2218 { 2219 /* Skip the PC and length and insert a zero byte for the 2220 augmentation size. */ 2221 buf += width * 2; 2222 memmove (buf + 1, buf, end - buf); 2223 *buf = 0; 2224 } 2225 2226 if (ent->set_loc) 2227 { 2228 /* Adjust DW_CFA_set_loc. */ 2229 unsigned int cnt; 2230 bfd_vma new_offset; 2231 2232 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 2233 new_offset = ent->new_offset + 8 2234 + extra_augmentation_string_bytes (ent) 2235 + extra_augmentation_data_bytes (ent); 2236 2237 for (cnt = 1; cnt <= ent->set_loc[0]; cnt++) 2238 { 2239 buf = start + ent->set_loc[cnt]; 2240 2241 value = read_value (abfd, buf, width, 2242 get_DW_EH_PE_signed (ent->fde_encoding)); 2243 if (!value) 2244 continue; 2245 2246 if ((ent->fde_encoding & 0x70) == DW_EH_PE_pcrel) 2247 value += (bfd_vma) ent->offset + 8 - new_offset; 2248 if (ent->make_relative) 2249 value -= (sec->output_section->vma 2250 + sec->output_offset 2251 + new_offset + ent->set_loc[cnt]); 2252 write_value (abfd, buf, value, width); 2253 } 2254 } 2255 } 2256 } 2257 2258 /* FIXME: octets_per_byte. */ 2259 return bfd_set_section_contents (abfd, sec->output_section, 2260 contents, (file_ptr) sec->output_offset, 2261 sec->size); 2262 } 2263 2264 /* Helper function used to sort .eh_frame_hdr search table by increasing 2265 VMA of FDE initial location. */ 2266 2267 static int 2268 vma_compare (const void *a, const void *b) 2269 { 2270 const struct eh_frame_array_ent *p = (const struct eh_frame_array_ent *) a; 2271 const struct eh_frame_array_ent *q = (const struct eh_frame_array_ent *) b; 2272 if (p->initial_loc > q->initial_loc) 2273 return 1; 2274 if (p->initial_loc < q->initial_loc) 2275 return -1; 2276 if (p->range > q->range) 2277 return 1; 2278 if (p->range < q->range) 2279 return -1; 2280 return 0; 2281 } 2282 2283 /* Reorder .eh_frame_entry sections to match the associated text sections. 2284 This routine is called during the final linking step, just before writing 2285 the contents. At this stage, sections in the eh_frame_hdr_info are already 2286 sorted in order of increasing text section address and so we simply need 2287 to make the .eh_frame_entrys follow that same order. Note that it is 2288 invalid for a linker script to try to force a particular order of 2289 .eh_frame_entry sections. */ 2290 2291 bfd_boolean 2292 _bfd_elf_fixup_eh_frame_hdr (struct bfd_link_info *info) 2293 { 2294 asection *sec = NULL; 2295 asection *osec; 2296 struct eh_frame_hdr_info *hdr_info; 2297 unsigned int i; 2298 bfd_vma offset; 2299 struct bfd_link_order *p; 2300 2301 hdr_info = &elf_hash_table (info)->eh_info; 2302 2303 if (hdr_info->hdr_sec == NULL 2304 || info->eh_frame_hdr_type != COMPACT_EH_HDR 2305 || hdr_info->array_count == 0) 2306 return TRUE; 2307 2308 /* Change section output offsets to be in text section order. */ 2309 offset = 8; 2310 osec = hdr_info->u.compact.entries[0]->output_section; 2311 for (i = 0; i < hdr_info->array_count; i++) 2312 { 2313 sec = hdr_info->u.compact.entries[i]; 2314 if (sec->output_section != osec) 2315 { 2316 _bfd_error_handler 2317 (_("invalid output section for .eh_frame_entry: %pA"), 2318 sec->output_section); 2319 return FALSE; 2320 } 2321 sec->output_offset = offset; 2322 offset += sec->size; 2323 } 2324 2325 2326 /* Fix the link_order to match. */ 2327 for (p = sec->output_section->map_head.link_order; p != NULL; p = p->next) 2328 { 2329 if (p->type != bfd_indirect_link_order) 2330 abort(); 2331 2332 p->offset = p->u.indirect.section->output_offset; 2333 if (p->next != NULL) 2334 i--; 2335 } 2336 2337 if (i != 0) 2338 { 2339 _bfd_error_handler 2340 (_("invalid contents in %pA section"), osec); 2341 return FALSE; 2342 } 2343 2344 return TRUE; 2345 } 2346 2347 /* The .eh_frame_hdr format for Compact EH frames: 2348 ubyte version (2) 2349 ubyte eh_ref_enc (DW_EH_PE_* encoding of typinfo references) 2350 uint32_t count (Number of entries in table) 2351 [array from .eh_frame_entry sections] */ 2352 2353 static bfd_boolean 2354 write_compact_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 2355 { 2356 struct elf_link_hash_table *htab; 2357 struct eh_frame_hdr_info *hdr_info; 2358 asection *sec; 2359 const struct elf_backend_data *bed; 2360 bfd_vma count; 2361 bfd_byte contents[8]; 2362 unsigned int i; 2363 2364 htab = elf_hash_table (info); 2365 hdr_info = &htab->eh_info; 2366 sec = hdr_info->hdr_sec; 2367 2368 if (sec->size != 8) 2369 abort(); 2370 2371 for (i = 0; i < sizeof (contents); i++) 2372 contents[i] = 0; 2373 2374 contents[0] = COMPACT_EH_HDR; 2375 bed = get_elf_backend_data (abfd); 2376 2377 BFD_ASSERT (bed->compact_eh_encoding); 2378 contents[1] = (*bed->compact_eh_encoding) (info); 2379 2380 count = (sec->output_section->size - 8) / 8; 2381 bfd_put_32 (abfd, count, contents + 4); 2382 return bfd_set_section_contents (abfd, sec->output_section, contents, 2383 (file_ptr) sec->output_offset, sec->size); 2384 } 2385 2386 /* The .eh_frame_hdr format for DWARF frames: 2387 2388 ubyte version (currently 1) 2389 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of 2390 .eh_frame section) 2391 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count 2392 number (or DW_EH_PE_omit if there is no 2393 binary search table computed)) 2394 ubyte table_enc (DW_EH_PE_* encoding of binary search table, 2395 or DW_EH_PE_omit if not present. 2396 DW_EH_PE_datarel is using address of 2397 .eh_frame_hdr section start as base) 2398 [encoded] eh_frame_ptr (pointer to start of .eh_frame section) 2399 optionally followed by: 2400 [encoded] fde_count (total number of FDEs in .eh_frame section) 2401 fde_count x [encoded] initial_loc, fde 2402 (array of encoded pairs containing 2403 FDE initial_location field and FDE address, 2404 sorted by increasing initial_loc). */ 2405 2406 static bfd_boolean 2407 write_dwarf_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 2408 { 2409 struct elf_link_hash_table *htab; 2410 struct eh_frame_hdr_info *hdr_info; 2411 asection *sec; 2412 bfd_boolean retval = TRUE; 2413 2414 htab = elf_hash_table (info); 2415 hdr_info = &htab->eh_info; 2416 sec = hdr_info->hdr_sec; 2417 bfd_byte *contents; 2418 asection *eh_frame_sec; 2419 bfd_size_type size; 2420 bfd_vma encoded_eh_frame; 2421 2422 size = EH_FRAME_HDR_SIZE; 2423 if (hdr_info->u.dwarf.array 2424 && hdr_info->array_count == hdr_info->u.dwarf.fde_count) 2425 size += 4 + hdr_info->u.dwarf.fde_count * 8; 2426 contents = (bfd_byte *) bfd_malloc (size); 2427 if (contents == NULL) 2428 return FALSE; 2429 2430 eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame"); 2431 if (eh_frame_sec == NULL) 2432 { 2433 free (contents); 2434 return FALSE; 2435 } 2436 2437 memset (contents, 0, EH_FRAME_HDR_SIZE); 2438 /* Version. */ 2439 contents[0] = 1; 2440 /* .eh_frame offset. */ 2441 contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address 2442 (abfd, info, eh_frame_sec, 0, sec, 4, &encoded_eh_frame); 2443 2444 if (hdr_info->u.dwarf.array 2445 && hdr_info->array_count == hdr_info->u.dwarf.fde_count) 2446 { 2447 /* FDE count encoding. */ 2448 contents[2] = DW_EH_PE_udata4; 2449 /* Search table encoding. */ 2450 contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; 2451 } 2452 else 2453 { 2454 contents[2] = DW_EH_PE_omit; 2455 contents[3] = DW_EH_PE_omit; 2456 } 2457 bfd_put_32 (abfd, encoded_eh_frame, contents + 4); 2458 2459 if (contents[2] != DW_EH_PE_omit) 2460 { 2461 unsigned int i; 2462 bfd_boolean overlap, overflow; 2463 2464 bfd_put_32 (abfd, hdr_info->u.dwarf.fde_count, 2465 contents + EH_FRAME_HDR_SIZE); 2466 qsort (hdr_info->u.dwarf.array, hdr_info->u.dwarf.fde_count, 2467 sizeof (*hdr_info->u.dwarf.array), vma_compare); 2468 overlap = FALSE; 2469 overflow = FALSE; 2470 for (i = 0; i < hdr_info->u.dwarf.fde_count; i++) 2471 { 2472 bfd_vma val; 2473 2474 val = hdr_info->u.dwarf.array[i].initial_loc 2475 - sec->output_section->vma; 2476 val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000; 2477 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 2478 && (hdr_info->u.dwarf.array[i].initial_loc 2479 != sec->output_section->vma + val)) 2480 overflow = TRUE; 2481 bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 4); 2482 val = hdr_info->u.dwarf.array[i].fde - sec->output_section->vma; 2483 val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000; 2484 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 2485 && (hdr_info->u.dwarf.array[i].fde 2486 != sec->output_section->vma + val)) 2487 overflow = TRUE; 2488 bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 8); 2489 if (i != 0 2490 && (hdr_info->u.dwarf.array[i].initial_loc 2491 < (hdr_info->u.dwarf.array[i - 1].initial_loc 2492 + hdr_info->u.dwarf.array[i - 1].range))) 2493 overlap = TRUE; 2494 } 2495 if (overflow) 2496 _bfd_error_handler (_(".eh_frame_hdr entry overflow")); 2497 if (overlap) 2498 _bfd_error_handler (_(".eh_frame_hdr refers to overlapping FDEs")); 2499 if (overflow || overlap) 2500 { 2501 bfd_set_error (bfd_error_bad_value); 2502 retval = FALSE; 2503 } 2504 } 2505 2506 /* FIXME: octets_per_byte. */ 2507 if (!bfd_set_section_contents (abfd, sec->output_section, contents, 2508 (file_ptr) sec->output_offset, 2509 sec->size)) 2510 retval = FALSE; 2511 free (contents); 2512 2513 if (hdr_info->u.dwarf.array != NULL) 2514 free (hdr_info->u.dwarf.array); 2515 return retval; 2516 } 2517 2518 /* Write out .eh_frame_hdr section. This must be called after 2519 _bfd_elf_write_section_eh_frame has been called on all input 2520 .eh_frame sections. */ 2521 2522 bfd_boolean 2523 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 2524 { 2525 struct elf_link_hash_table *htab; 2526 struct eh_frame_hdr_info *hdr_info; 2527 asection *sec; 2528 2529 htab = elf_hash_table (info); 2530 hdr_info = &htab->eh_info; 2531 sec = hdr_info->hdr_sec; 2532 2533 if (info->eh_frame_hdr_type == 0 || sec == NULL) 2534 return TRUE; 2535 2536 if (info->eh_frame_hdr_type == COMPACT_EH_HDR) 2537 return write_compact_eh_frame_hdr (abfd, info); 2538 else 2539 return write_dwarf_eh_frame_hdr (abfd, info); 2540 } 2541 2542 /* Return the width of FDE addresses. This is the default implementation. */ 2543 2544 unsigned int 2545 _bfd_elf_eh_frame_address_size (bfd *abfd, const asection *sec ATTRIBUTE_UNUSED) 2546 { 2547 return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4; 2548 } 2549 2550 /* Decide whether we can use a PC-relative encoding within the given 2551 EH frame section. This is the default implementation. */ 2552 2553 bfd_boolean 2554 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED, 2555 struct bfd_link_info *info ATTRIBUTE_UNUSED, 2556 asection *eh_frame_section ATTRIBUTE_UNUSED) 2557 { 2558 return TRUE; 2559 } 2560 2561 /* Select an encoding for the given address. Preference is given to 2562 PC-relative addressing modes. */ 2563 2564 bfd_byte 2565 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED, 2566 struct bfd_link_info *info ATTRIBUTE_UNUSED, 2567 asection *osec, bfd_vma offset, 2568 asection *loc_sec, bfd_vma loc_offset, 2569 bfd_vma *encoded) 2570 { 2571 *encoded = osec->vma + offset - 2572 (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset); 2573 return DW_EH_PE_pcrel | DW_EH_PE_sdata4; 2574 } 2575