elf-eh-frame.c revision 1.11
1 /* .eh_frame section optimization. 2 Copyright (C) 2001-2024 Free Software Foundation, Inc. 3 Written by Jakub Jelinek <jakub (at) 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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->flags & SEC_HAS_CONTENTS) == 0 606 || sec->sec_info_type != SEC_INFO_TYPE_NONE) 607 { 608 /* This file does not contain .eh_frame information. */ 609 return; 610 } 611 612 if (bfd_is_abs_section (sec->output_section)) 613 { 614 /* At least one of the sections is being discarded from the 615 link, so we should just ignore them. */ 616 return; 617 } 618 619 /* Read the frame unwind information from abfd. */ 620 621 REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf)); 622 623 /* If .eh_frame section size doesn't fit into int, we cannot handle 624 it (it would need to use 64-bit .eh_frame format anyway). */ 625 REQUIRE (sec->size == (unsigned int) sec->size); 626 627 ptr_size = (get_elf_backend_data (abfd) 628 ->elf_backend_eh_frame_address_size (abfd, sec)); 629 REQUIRE (ptr_size != 0); 630 631 /* Go through the section contents and work out how many FDEs and 632 CIEs there are. */ 633 buf = ehbuf; 634 end = ehbuf + sec->size; 635 num_cies = 0; 636 num_entries = 0; 637 while (buf != end) 638 { 639 num_entries++; 640 641 /* Read the length of the entry. */ 642 REQUIRE (skip_bytes (&buf, end, 4)); 643 hdr_length = bfd_get_32 (abfd, buf - 4); 644 645 /* 64-bit .eh_frame is not supported. */ 646 REQUIRE (hdr_length != 0xffffffff); 647 if (hdr_length == 0) 648 break; 649 650 REQUIRE (skip_bytes (&buf, end, 4)); 651 hdr_id = bfd_get_32 (abfd, buf - 4); 652 if (hdr_id == 0) 653 num_cies++; 654 655 REQUIRE (skip_bytes (&buf, end, hdr_length - 4)); 656 } 657 658 sec_info = (struct eh_frame_sec_info *) 659 bfd_zmalloc (sizeof (struct eh_frame_sec_info) 660 + (num_entries - 1) * sizeof (struct eh_cie_fde)); 661 REQUIRE (sec_info); 662 663 /* We need to have a "struct cie" for each CIE in this section. */ 664 if (num_cies) 665 { 666 local_cies = (struct cie *) bfd_zmalloc (num_cies * sizeof (*local_cies)); 667 REQUIRE (local_cies); 668 } 669 670 /* FIXME: octets_per_byte. */ 671 #define ENSURE_NO_RELOCS(buf) \ 672 while (cookie->rel < cookie->relend \ 673 && (cookie->rel->r_offset \ 674 < (bfd_size_type) ((buf) - ehbuf))) \ 675 { \ 676 REQUIRE (cookie->rel->r_info == 0); \ 677 cookie->rel++; \ 678 } 679 680 /* FIXME: octets_per_byte. */ 681 #define SKIP_RELOCS(buf) \ 682 while (cookie->rel < cookie->relend \ 683 && (cookie->rel->r_offset \ 684 < (bfd_size_type) ((buf) - ehbuf))) \ 685 cookie->rel++ 686 687 /* FIXME: octets_per_byte. */ 688 #define GET_RELOC(buf) \ 689 ((cookie->rel < cookie->relend \ 690 && (cookie->rel->r_offset \ 691 == (bfd_size_type) ((buf) - ehbuf))) \ 692 ? cookie->rel : NULL) 693 694 buf = ehbuf; 695 cie_count = 0; 696 gc_mark_hook = get_elf_backend_data (abfd)->gc_mark_hook; 697 while ((bfd_size_type) (buf - ehbuf) != sec->size) 698 { 699 char *aug; 700 bfd_byte *start, *insns, *insns_end; 701 bfd_size_type length; 702 unsigned int set_loc_count; 703 704 this_inf = sec_info->entry + sec_info->count; 705 last_fde = buf; 706 707 /* Read the length of the entry. */ 708 REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4)); 709 hdr_length = bfd_get_32 (abfd, buf - 4); 710 711 /* The CIE/FDE must be fully contained in this input section. */ 712 REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size); 713 end = buf + hdr_length; 714 715 this_inf->offset = last_fde - ehbuf; 716 this_inf->size = 4 + hdr_length; 717 this_inf->reloc_index = cookie->rel - cookie->rels; 718 719 if (hdr_length == 0) 720 { 721 /* A zero-length CIE should only be found at the end of 722 the section, but allow multiple terminators. */ 723 while (skip_bytes (&buf, ehbuf + sec->size, 4)) 724 REQUIRE (bfd_get_32 (abfd, buf - 4) == 0); 725 REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size); 726 ENSURE_NO_RELOCS (buf); 727 sec_info->count++; 728 break; 729 } 730 731 REQUIRE (skip_bytes (&buf, end, 4)); 732 hdr_id = bfd_get_32 (abfd, buf - 4); 733 734 if (hdr_id == 0) 735 { 736 unsigned int initial_insn_length; 737 738 /* CIE */ 739 this_inf->cie = 1; 740 741 /* Point CIE to one of the section-local cie structures. */ 742 cie = local_cies + cie_count++; 743 744 cie->cie_inf = this_inf; 745 cie->length = hdr_length; 746 start = buf; 747 REQUIRE (read_byte (&buf, end, &cie->version)); 748 749 /* Cannot handle unknown versions. */ 750 REQUIRE (cie->version == 1 751 || cie->version == 3 752 || cie->version == 4); 753 REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation)); 754 755 strcpy (cie->augmentation, (char *) buf); 756 buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1; 757 this_inf->u.cie.aug_str_len = buf - start - 1; 758 ENSURE_NO_RELOCS (buf); 759 if (buf[0] == 'e' && buf[1] == 'h') 760 { 761 /* GCC < 3.0 .eh_frame CIE */ 762 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__ 763 is private to each CIE, so we don't need it for anything. 764 Just skip it. */ 765 REQUIRE (skip_bytes (&buf, end, ptr_size)); 766 SKIP_RELOCS (buf); 767 } 768 if (cie->version >= 4) 769 { 770 REQUIRE (buf + 1 < end); 771 REQUIRE (buf[0] == ptr_size); 772 REQUIRE (buf[1] == 0); 773 buf += 2; 774 } 775 REQUIRE (read_uleb128 (&buf, end, &cie->code_align)); 776 REQUIRE (read_sleb128 (&buf, end, &cie->data_align)); 777 if (cie->version == 1) 778 { 779 REQUIRE (buf < end); 780 cie->ra_column = *buf++; 781 } 782 else 783 REQUIRE (read_uleb128 (&buf, end, &cie->ra_column)); 784 ENSURE_NO_RELOCS (buf); 785 cie->lsda_encoding = DW_EH_PE_omit; 786 cie->fde_encoding = DW_EH_PE_omit; 787 cie->per_encoding = DW_EH_PE_omit; 788 aug = cie->augmentation; 789 if (aug[0] != 'e' || aug[1] != 'h') 790 { 791 if (*aug == 'z') 792 { 793 aug++; 794 REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size)); 795 ENSURE_NO_RELOCS (buf); 796 } 797 798 while (*aug != '\0') 799 switch (*aug++) 800 { 801 case 'B': 802 break; 803 case 'L': 804 REQUIRE (read_byte (&buf, end, &cie->lsda_encoding)); 805 ENSURE_NO_RELOCS (buf); 806 REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size)); 807 break; 808 case 'R': 809 REQUIRE (read_byte (&buf, end, &cie->fde_encoding)); 810 ENSURE_NO_RELOCS (buf); 811 REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size)); 812 break; 813 case 'S': 814 break; 815 case 'P': 816 { 817 int per_width; 818 819 REQUIRE (read_byte (&buf, end, &cie->per_encoding)); 820 per_width = get_DW_EH_PE_width (cie->per_encoding, 821 ptr_size); 822 REQUIRE (per_width); 823 if ((cie->per_encoding & 0x70) == DW_EH_PE_aligned) 824 { 825 length = -(buf - ehbuf) & (per_width - 1); 826 REQUIRE (skip_bytes (&buf, end, length)); 827 if (per_width == 8) 828 this_inf->u.cie.per_encoding_aligned8 = 1; 829 } 830 this_inf->u.cie.personality_offset = buf - start; 831 ENSURE_NO_RELOCS (buf); 832 /* Ensure we have a reloc here. */ 833 REQUIRE (GET_RELOC (buf)); 834 cie->personality.reloc_index 835 = cookie->rel - cookie->rels; 836 /* Cope with MIPS-style composite relocations. */ 837 do 838 cookie->rel++; 839 while (GET_RELOC (buf) != NULL); 840 REQUIRE (skip_bytes (&buf, end, per_width)); 841 } 842 break; 843 default: 844 /* Unrecognized augmentation. Better bail out. */ 845 goto free_no_table; 846 } 847 } 848 this_inf->u.cie.aug_data_len 849 = buf - start - 1 - this_inf->u.cie.aug_str_len; 850 851 /* For shared libraries, try to get rid of as many RELATIVE relocs 852 as possible. */ 853 if (bfd_link_pic (info) 854 && (get_elf_backend_data (abfd) 855 ->elf_backend_can_make_relative_eh_frame 856 (abfd, info, sec))) 857 { 858 if ((cie->fde_encoding & 0x70) == DW_EH_PE_absptr) 859 this_inf->make_relative = 1; 860 /* If the CIE doesn't already have an 'R' entry, it's fairly 861 easy to add one, provided that there's no aligned data 862 after the augmentation string. */ 863 else if (cie->fde_encoding == DW_EH_PE_omit 864 && (cie->per_encoding & 0x70) != DW_EH_PE_aligned) 865 { 866 if (*cie->augmentation == 0) 867 this_inf->add_augmentation_size = 1; 868 this_inf->u.cie.add_fde_encoding = 1; 869 this_inf->make_relative = 1; 870 } 871 872 if ((cie->lsda_encoding & 0x70) == DW_EH_PE_absptr) 873 cie->can_make_lsda_relative = 1; 874 } 875 876 /* If FDE encoding was not specified, it defaults to 877 DW_EH_absptr. */ 878 if (cie->fde_encoding == DW_EH_PE_omit) 879 cie->fde_encoding = DW_EH_PE_absptr; 880 881 initial_insn_length = end - buf; 882 cie->initial_insn_length = initial_insn_length; 883 memcpy (cie->initial_instructions, buf, 884 initial_insn_length <= sizeof (cie->initial_instructions) 885 ? initial_insn_length : sizeof (cie->initial_instructions)); 886 insns = buf; 887 buf += initial_insn_length; 888 ENSURE_NO_RELOCS (buf); 889 890 if (!bfd_link_relocatable (info)) 891 { 892 /* Keep info for merging cies. */ 893 this_inf->u.cie.u.full_cie = cie; 894 this_inf->u.cie.per_encoding_relative 895 = (cie->per_encoding & 0x70) == DW_EH_PE_pcrel; 896 } 897 } 898 else 899 { 900 /* Find the corresponding CIE. */ 901 unsigned int cie_offset = this_inf->offset + 4 - hdr_id; 902 for (cie = local_cies; cie < local_cies + cie_count; cie++) 903 if (cie_offset == cie->cie_inf->offset) 904 break; 905 906 /* Ensure this FDE references one of the CIEs in this input 907 section. */ 908 REQUIRE (cie != local_cies + cie_count); 909 this_inf->u.fde.cie_inf = cie->cie_inf; 910 this_inf->make_relative = cie->cie_inf->make_relative; 911 this_inf->add_augmentation_size 912 = cie->cie_inf->add_augmentation_size; 913 914 ENSURE_NO_RELOCS (buf); 915 if ((sec->flags & SEC_LINKER_CREATED) == 0 || cookie->rels != NULL) 916 { 917 asection *rsec; 918 919 REQUIRE (GET_RELOC (buf)); 920 921 /* Chain together the FDEs for each section. */ 922 rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, 923 cookie, NULL); 924 /* RSEC will be NULL if FDE was cleared out as it was belonging to 925 a discarded SHT_GROUP. */ 926 if (rsec) 927 { 928 REQUIRE (rsec->owner == abfd); 929 this_inf->u.fde.next_for_section = elf_fde_list (rsec); 930 elf_fde_list (rsec) = this_inf; 931 } 932 } 933 934 /* Skip the initial location and address range. */ 935 start = buf; 936 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size); 937 REQUIRE (skip_bytes (&buf, end, 2 * length)); 938 939 SKIP_RELOCS (buf - length); 940 if (!GET_RELOC (buf - length) 941 && read_value (abfd, buf - length, length, false) == 0) 942 { 943 (*info->callbacks->minfo) 944 /* xgettext:c-format */ 945 (_("discarding zero address range FDE in %pB(%pA).\n"), 946 abfd, sec); 947 this_inf->u.fde.cie_inf = NULL; 948 } 949 950 /* Skip the augmentation size, if present. */ 951 if (cie->augmentation[0] == 'z') 952 REQUIRE (read_uleb128 (&buf, end, &length)); 953 else 954 length = 0; 955 956 /* Of the supported augmentation characters above, only 'L' 957 adds augmentation data to the FDE. This code would need to 958 be adjusted if any future augmentations do the same thing. */ 959 if (cie->lsda_encoding != DW_EH_PE_omit) 960 { 961 SKIP_RELOCS (buf); 962 if (cie->can_make_lsda_relative && GET_RELOC (buf)) 963 cie->cie_inf->u.cie.make_lsda_relative = 1; 964 this_inf->lsda_offset = buf - start; 965 /* If there's no 'z' augmentation, we don't know where the 966 CFA insns begin. Assume no padding. */ 967 if (cie->augmentation[0] != 'z') 968 length = end - buf; 969 } 970 971 /* Skip over the augmentation data. */ 972 REQUIRE (skip_bytes (&buf, end, length)); 973 insns = buf; 974 975 buf = last_fde + 4 + hdr_length; 976 977 /* For NULL RSEC (cleared FDE belonging to a discarded section) 978 the relocations are commonly cleared. We do not sanity check if 979 all these relocations are cleared as (1) relocations to 980 .gcc_except_table will remain uncleared (they will get dropped 981 with the drop of this unused FDE) and (2) BFD already safely drops 982 relocations of any type to .eh_frame by 983 elf_section_ignore_discarded_relocs. 984 TODO: The .gcc_except_table entries should be also filtered as 985 .eh_frame entries; or GCC could rather use COMDAT for them. */ 986 SKIP_RELOCS (buf); 987 } 988 989 /* Try to interpret the CFA instructions and find the first 990 padding nop. Shrink this_inf's size so that it doesn't 991 include the padding. */ 992 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size); 993 set_loc_count = 0; 994 insns_end = skip_non_nops (insns, end, length, &set_loc_count); 995 /* If we don't understand the CFA instructions, we can't know 996 what needs to be adjusted there. */ 997 if (insns_end == NULL 998 /* For the time being we don't support DW_CFA_set_loc in 999 CIE instructions. */ 1000 || (set_loc_count && this_inf->cie)) 1001 goto free_no_table; 1002 this_inf->size -= end - insns_end; 1003 if (insns_end != end && this_inf->cie) 1004 { 1005 cie->initial_insn_length -= end - insns_end; 1006 cie->length -= end - insns_end; 1007 } 1008 if (set_loc_count 1009 && ((cie->fde_encoding & 0x70) == DW_EH_PE_pcrel 1010 || this_inf->make_relative)) 1011 { 1012 unsigned int cnt; 1013 bfd_byte *p; 1014 1015 this_inf->set_loc = (unsigned int *) 1016 bfd_malloc ((set_loc_count + 1) * sizeof (unsigned int)); 1017 REQUIRE (this_inf->set_loc); 1018 this_inf->set_loc[0] = set_loc_count; 1019 p = insns; 1020 cnt = 0; 1021 while (p < end) 1022 { 1023 if (*p == DW_CFA_set_loc) 1024 this_inf->set_loc[++cnt] = p + 1 - start; 1025 REQUIRE (skip_cfa_op (&p, end, length)); 1026 } 1027 } 1028 1029 this_inf->removed = 1; 1030 this_inf->fde_encoding = cie->fde_encoding; 1031 this_inf->lsda_encoding = cie->lsda_encoding; 1032 sec_info->count++; 1033 } 1034 BFD_ASSERT (sec_info->count == num_entries); 1035 BFD_ASSERT (cie_count == num_cies); 1036 1037 elf_section_data (sec)->sec_info = sec_info; 1038 sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME; 1039 if (!bfd_link_relocatable (info)) 1040 { 1041 /* Keep info for merging cies. */ 1042 sec_info->cies = local_cies; 1043 local_cies = NULL; 1044 } 1045 goto success; 1046 1047 free_no_table: 1048 _bfd_error_handler 1049 /* xgettext:c-format */ 1050 (_("error in %pB(%pA); no .eh_frame_hdr table will be created"), 1051 abfd, sec); 1052 hdr_info->u.dwarf.table = false; 1053 free (sec_info); 1054 success: 1055 free (ehbuf); 1056 free (local_cies); 1057 #undef REQUIRE 1058 } 1059 1060 /* Order eh_frame_hdr entries by the VMA of their text section. */ 1061 1062 static int 1063 cmp_eh_frame_hdr (const void *a, const void *b) 1064 { 1065 bfd_vma text_a; 1066 bfd_vma text_b; 1067 asection *sec; 1068 1069 sec = *(asection *const *)a; 1070 sec = (asection *) elf_section_data (sec)->sec_info; 1071 text_a = sec->output_section->vma + sec->output_offset; 1072 sec = *(asection *const *)b; 1073 sec = (asection *) elf_section_data (sec)->sec_info; 1074 text_b = sec->output_section->vma + sec->output_offset; 1075 1076 if (text_a < text_b) 1077 return -1; 1078 return text_a > text_b; 1079 1080 } 1081 1082 /* Add space for a CANTUNWIND terminator to SEC if the text sections 1083 referenced by it and NEXT are not contiguous, or NEXT is NULL. */ 1084 1085 static void 1086 add_eh_frame_hdr_terminator (asection *sec, 1087 asection *next) 1088 { 1089 bfd_vma end; 1090 bfd_vma next_start; 1091 asection *text_sec; 1092 1093 if (next) 1094 { 1095 /* See if there is a gap (presumably a text section without unwind info) 1096 between these two entries. */ 1097 text_sec = (asection *) elf_section_data (sec)->sec_info; 1098 end = text_sec->output_section->vma + text_sec->output_offset 1099 + text_sec->size; 1100 text_sec = (asection *) elf_section_data (next)->sec_info; 1101 next_start = text_sec->output_section->vma + text_sec->output_offset; 1102 if (end == next_start) 1103 return; 1104 } 1105 1106 /* Add space for a CANTUNWIND terminator. */ 1107 if (!sec->rawsize) 1108 sec->rawsize = sec->size; 1109 1110 bfd_set_section_size (sec, sec->size + 8); 1111 } 1112 1113 /* Finish a pass over all .eh_frame_entry sections. */ 1114 1115 bool 1116 _bfd_elf_end_eh_frame_parsing (struct bfd_link_info *info) 1117 { 1118 struct eh_frame_hdr_info *hdr_info; 1119 unsigned int i; 1120 1121 hdr_info = &elf_hash_table (info)->eh_info; 1122 1123 if (info->eh_frame_hdr_type != COMPACT_EH_HDR 1124 || hdr_info->array_count == 0) 1125 return false; 1126 1127 bfd_elf_discard_eh_frame_entry (hdr_info); 1128 1129 qsort (hdr_info->u.compact.entries, hdr_info->array_count, 1130 sizeof (asection *), cmp_eh_frame_hdr); 1131 1132 for (i = 0; i < hdr_info->array_count - 1; i++) 1133 { 1134 add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i], 1135 hdr_info->u.compact.entries[i + 1]); 1136 } 1137 1138 /* Add a CANTUNWIND terminator after the last entry. */ 1139 add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i], NULL); 1140 return true; 1141 } 1142 1143 /* Mark all relocations against CIE or FDE ENT, which occurs in 1144 .eh_frame section SEC. COOKIE describes the relocations in SEC; 1145 its "rel" field can be changed freely. */ 1146 1147 static bool 1148 mark_entry (struct bfd_link_info *info, asection *sec, 1149 struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook, 1150 struct elf_reloc_cookie *cookie) 1151 { 1152 /* FIXME: octets_per_byte. */ 1153 for (cookie->rel = cookie->rels + ent->reloc_index; 1154 cookie->rel < cookie->relend 1155 && cookie->rel->r_offset < ent->offset + ent->size; 1156 cookie->rel++) 1157 if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie)) 1158 return false; 1159 1160 return true; 1161 } 1162 1163 /* Mark all the relocations against FDEs that relate to code in input 1164 section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose 1165 relocations are described by COOKIE. */ 1166 1167 bool 1168 _bfd_elf_gc_mark_fdes (struct bfd_link_info *info, asection *sec, 1169 asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook, 1170 struct elf_reloc_cookie *cookie) 1171 { 1172 struct eh_cie_fde *fde, *cie; 1173 1174 for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section) 1175 { 1176 if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie)) 1177 return false; 1178 1179 /* At this stage, all cie_inf fields point to local CIEs, so we 1180 can use the same cookie to refer to them. */ 1181 cie = fde->u.fde.cie_inf; 1182 if (cie != NULL && !cie->u.cie.gc_mark) 1183 { 1184 cie->u.cie.gc_mark = 1; 1185 if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie)) 1186 return false; 1187 } 1188 } 1189 return true; 1190 } 1191 1192 /* Input section SEC of ABFD is an .eh_frame section that contains the 1193 CIE described by CIE_INF. Return a version of CIE_INF that is going 1194 to be kept in the output, adding CIE_INF to the output if necessary. 1195 1196 HDR_INFO is the .eh_frame_hdr information and COOKIE describes the 1197 relocations in REL. */ 1198 1199 static struct eh_cie_fde * 1200 find_merged_cie (bfd *abfd, struct bfd_link_info *info, asection *sec, 1201 struct eh_frame_hdr_info *hdr_info, 1202 struct elf_reloc_cookie *cookie, 1203 struct eh_cie_fde *cie_inf) 1204 { 1205 unsigned long r_symndx; 1206 struct cie *cie, *new_cie; 1207 Elf_Internal_Rela *rel; 1208 void **loc; 1209 1210 /* Use CIE_INF if we have already decided to keep it. */ 1211 if (!cie_inf->removed) 1212 return cie_inf; 1213 1214 /* If we have merged CIE_INF with another CIE, use that CIE instead. */ 1215 if (cie_inf->u.cie.merged) 1216 return cie_inf->u.cie.u.merged_with; 1217 1218 cie = cie_inf->u.cie.u.full_cie; 1219 1220 /* Assume we will need to keep CIE_INF. */ 1221 cie_inf->removed = 0; 1222 cie_inf->u.cie.u.sec = sec; 1223 1224 /* If we are not merging CIEs, use CIE_INF. */ 1225 if (cie == NULL) 1226 return cie_inf; 1227 1228 if (cie->per_encoding != DW_EH_PE_omit) 1229 { 1230 bool per_binds_local; 1231 1232 /* Work out the address of personality routine, or at least 1233 enough info that we could calculate the address had we made a 1234 final section layout. The symbol on the reloc is enough, 1235 either the hash for a global, or (bfd id, index) pair for a 1236 local. The assumption here is that no one uses addends on 1237 the reloc. */ 1238 rel = cookie->rels + cie->personality.reloc_index; 1239 memset (&cie->personality, 0, sizeof (cie->personality)); 1240 #ifdef BFD64 1241 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64) 1242 r_symndx = ELF64_R_SYM (rel->r_info); 1243 else 1244 #endif 1245 r_symndx = ELF32_R_SYM (rel->r_info); 1246 if (r_symndx >= cookie->locsymcount 1247 || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL) 1248 { 1249 struct elf_link_hash_entry *h; 1250 1251 r_symndx -= cookie->extsymoff; 1252 h = cookie->sym_hashes[r_symndx]; 1253 1254 while (h->root.type == bfd_link_hash_indirect 1255 || h->root.type == bfd_link_hash_warning) 1256 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1257 1258 cie->personality.h = h; 1259 per_binds_local = SYMBOL_REFERENCES_LOCAL (info, h); 1260 } 1261 else 1262 { 1263 Elf_Internal_Sym *sym; 1264 asection *sym_sec; 1265 1266 sym = &cookie->locsyms[r_symndx]; 1267 sym_sec = bfd_section_from_elf_index (abfd, sym->st_shndx); 1268 if (sym_sec == NULL) 1269 return cie_inf; 1270 1271 if (sym_sec->kept_section != NULL) 1272 sym_sec = sym_sec->kept_section; 1273 if (sym_sec->output_section == NULL) 1274 return cie_inf; 1275 1276 cie->local_personality = 1; 1277 cie->personality.sym.bfd_id = abfd->id; 1278 cie->personality.sym.index = r_symndx; 1279 per_binds_local = true; 1280 } 1281 1282 if (per_binds_local 1283 && bfd_link_pic (info) 1284 && (cie->per_encoding & 0x70) == DW_EH_PE_absptr 1285 && (get_elf_backend_data (abfd) 1286 ->elf_backend_can_make_relative_eh_frame (abfd, info, sec))) 1287 { 1288 cie_inf->u.cie.make_per_encoding_relative = 1; 1289 cie_inf->u.cie.per_encoding_relative = 1; 1290 } 1291 } 1292 1293 /* See if we can merge this CIE with an earlier one. */ 1294 cie_compute_hash (cie); 1295 if (hdr_info->u.dwarf.cies == NULL) 1296 { 1297 hdr_info->u.dwarf.cies = htab_try_create (1, cie_hash, cie_eq, free); 1298 if (hdr_info->u.dwarf.cies == NULL) 1299 return cie_inf; 1300 } 1301 loc = htab_find_slot_with_hash (hdr_info->u.dwarf.cies, cie, 1302 cie->hash, INSERT); 1303 if (loc == NULL) 1304 return cie_inf; 1305 1306 new_cie = (struct cie *) *loc; 1307 if (new_cie == NULL) 1308 { 1309 /* Keep CIE_INF and record it in the hash table. */ 1310 new_cie = (struct cie *) malloc (sizeof (struct cie)); 1311 if (new_cie == NULL) 1312 return cie_inf; 1313 1314 memcpy (new_cie, cie, sizeof (struct cie)); 1315 *loc = new_cie; 1316 } 1317 else 1318 { 1319 /* Merge CIE_INF with NEW_CIE->CIE_INF. */ 1320 cie_inf->removed = 1; 1321 cie_inf->u.cie.merged = 1; 1322 cie_inf->u.cie.u.merged_with = new_cie->cie_inf; 1323 if (cie_inf->u.cie.make_lsda_relative) 1324 new_cie->cie_inf->u.cie.make_lsda_relative = 1; 1325 } 1326 return new_cie->cie_inf; 1327 } 1328 1329 /* For a given OFFSET in SEC, return the delta to the new location 1330 after .eh_frame editing. */ 1331 1332 static bfd_signed_vma 1333 offset_adjust (bfd_vma offset, const asection *sec) 1334 { 1335 struct eh_frame_sec_info *sec_info 1336 = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info; 1337 unsigned int lo, hi, mid; 1338 struct eh_cie_fde *ent = NULL; 1339 bfd_signed_vma delta; 1340 1341 lo = 0; 1342 hi = sec_info->count; 1343 if (hi == 0) 1344 return 0; 1345 1346 while (lo < hi) 1347 { 1348 mid = (lo + hi) / 2; 1349 ent = &sec_info->entry[mid]; 1350 if (offset < ent->offset) 1351 hi = mid; 1352 else if (mid + 1 >= hi) 1353 break; 1354 else if (offset >= ent[1].offset) 1355 lo = mid + 1; 1356 else 1357 break; 1358 } 1359 1360 if (!ent->removed) 1361 delta = (bfd_vma) ent->new_offset - (bfd_vma) ent->offset; 1362 else if (ent->cie && ent->u.cie.merged) 1363 { 1364 struct eh_cie_fde *cie = ent->u.cie.u.merged_with; 1365 delta = ((bfd_vma) cie->new_offset + cie->u.cie.u.sec->output_offset 1366 - (bfd_vma) ent->offset - sec->output_offset); 1367 } 1368 else 1369 { 1370 /* Is putting the symbol on the next entry best for a deleted 1371 CIE/FDE? */ 1372 struct eh_cie_fde *last = sec_info->entry + sec_info->count; 1373 delta = ((bfd_vma) next_cie_fde_offset (ent, last, sec) 1374 - (bfd_vma) ent->offset); 1375 return delta; 1376 } 1377 1378 /* Account for editing within this CIE/FDE. */ 1379 offset -= ent->offset; 1380 if (ent->cie) 1381 { 1382 unsigned int extra 1383 = ent->add_augmentation_size + ent->u.cie.add_fde_encoding; 1384 if (extra == 0 1385 || offset <= 9u + ent->u.cie.aug_str_len) 1386 return delta; 1387 delta += extra; 1388 if (offset <= 9u + ent->u.cie.aug_str_len + ent->u.cie.aug_data_len) 1389 return delta; 1390 delta += extra; 1391 } 1392 else 1393 { 1394 unsigned int ptr_size, width, extra = ent->add_augmentation_size; 1395 if (offset <= 12 || extra == 0) 1396 return delta; 1397 ptr_size = (get_elf_backend_data (sec->owner) 1398 ->elf_backend_eh_frame_address_size (sec->owner, sec)); 1399 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 1400 if (offset <= 8 + 2 * width) 1401 return delta; 1402 delta += extra; 1403 } 1404 1405 return delta; 1406 } 1407 1408 /* Adjust a global symbol defined in .eh_frame, so that it stays 1409 relative to its original CIE/FDE. It is assumed that a symbol 1410 defined at the beginning of a CIE/FDE belongs to that CIE/FDE 1411 rather than marking the end of the previous CIE/FDE. This matters 1412 when a CIE is merged with a previous CIE, since the symbol is 1413 moved to the merged CIE. */ 1414 1415 bool 1416 _bfd_elf_adjust_eh_frame_global_symbol (struct elf_link_hash_entry *h, 1417 void *arg ATTRIBUTE_UNUSED) 1418 { 1419 asection *sym_sec; 1420 bfd_signed_vma delta; 1421 1422 if (h->root.type != bfd_link_hash_defined 1423 && h->root.type != bfd_link_hash_defweak) 1424 return true; 1425 1426 sym_sec = h->root.u.def.section; 1427 if (sym_sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME 1428 || elf_section_data (sym_sec)->sec_info == NULL) 1429 return true; 1430 1431 delta = offset_adjust (h->root.u.def.value, sym_sec); 1432 h->root.u.def.value += delta; 1433 1434 return true; 1435 } 1436 1437 /* The same for all local symbols defined in .eh_frame. Returns true 1438 if any symbol was changed. */ 1439 1440 static int 1441 adjust_eh_frame_local_symbols (const asection *sec, 1442 struct elf_reloc_cookie *cookie) 1443 { 1444 int adjusted = 0; 1445 1446 if (cookie->locsymcount > 1) 1447 { 1448 unsigned int shndx = elf_section_data (sec)->this_idx; 1449 Elf_Internal_Sym *end_sym = cookie->locsyms + cookie->locsymcount; 1450 Elf_Internal_Sym *sym; 1451 1452 for (sym = cookie->locsyms + 1; sym < end_sym; ++sym) 1453 if (sym->st_info <= ELF_ST_INFO (STB_LOCAL, STT_OBJECT) 1454 && sym->st_shndx == shndx) 1455 { 1456 bfd_signed_vma delta = offset_adjust (sym->st_value, sec); 1457 1458 if (delta != 0) 1459 { 1460 adjusted = 1; 1461 sym->st_value += delta; 1462 } 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 bool 1474 _bfd_elf_discard_section_eh_frame 1475 (bfd *abfd, struct bfd_link_info *info, asection *sec, 1476 bool (*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 bool 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 free (sec_info->cies); 1562 sec_info->cies = NULL; 1563 1564 /* It may be that some .eh_frame input section has greater alignment 1565 than other .eh_frame sections. In that case we run the risk of 1566 padding with zeros before that section, which would be seen as a 1567 zero terminator. Alignment padding must be added *inside* the 1568 last FDE instead. For other FDEs we align according to their 1569 encoding, in order to align FDE address range entries naturally. */ 1570 offset = 0; 1571 changed = 0; 1572 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent) 1573 if (!ent->removed) 1574 { 1575 eh_alignment = 4; 1576 if (ent->size == 4) 1577 ; 1578 else if (ent->cie) 1579 { 1580 if (ent->u.cie.per_encoding_aligned8) 1581 eh_alignment = 8; 1582 } 1583 else 1584 { 1585 eh_alignment = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 1586 if (eh_alignment < 4) 1587 eh_alignment = 4; 1588 } 1589 offset = (offset + eh_alignment - 1) & -eh_alignment; 1590 ent->new_offset = offset; 1591 if (ent->new_offset != ent->offset) 1592 changed = 1; 1593 offset += size_of_output_cie_fde (ent); 1594 } 1595 1596 eh_alignment = 4; 1597 offset = (offset + eh_alignment - 1) & -eh_alignment; 1598 sec->rawsize = sec->size; 1599 sec->size = offset; 1600 if (sec->size != sec->rawsize) 1601 changed = 1; 1602 1603 if (changed && adjust_eh_frame_local_symbols (sec, cookie)) 1604 { 1605 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1606 symtab_hdr->contents = (unsigned char *) cookie->locsyms; 1607 } 1608 return changed; 1609 } 1610 1611 /* This function is called for .eh_frame_hdr section after 1612 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame 1613 input sections. It finalizes the size of .eh_frame_hdr section. */ 1614 1615 bool 1616 _bfd_elf_discard_section_eh_frame_hdr (struct bfd_link_info *info) 1617 { 1618 struct elf_link_hash_table *htab; 1619 struct eh_frame_hdr_info *hdr_info; 1620 asection *sec; 1621 1622 htab = elf_hash_table (info); 1623 hdr_info = &htab->eh_info; 1624 1625 if (!hdr_info->frame_hdr_is_compact && hdr_info->u.dwarf.cies != NULL) 1626 { 1627 htab_delete (hdr_info->u.dwarf.cies); 1628 hdr_info->u.dwarf.cies = NULL; 1629 } 1630 1631 sec = hdr_info->hdr_sec; 1632 if (sec == NULL) 1633 return false; 1634 1635 if (info->eh_frame_hdr_type == COMPACT_EH_HDR) 1636 { 1637 /* For compact frames we only add the header. The actual table comes 1638 from the .eh_frame_entry sections. */ 1639 sec->size = 8; 1640 } 1641 else 1642 { 1643 sec->size = EH_FRAME_HDR_SIZE; 1644 if (hdr_info->u.dwarf.table) 1645 sec->size += 4 + hdr_info->u.dwarf.fde_count * 8; 1646 } 1647 1648 return true; 1649 } 1650 1651 /* Return true if there is at least one non-empty .eh_frame section in 1652 input files. Can only be called after ld has mapped input to 1653 output sections, and before sections are stripped. */ 1654 1655 bool 1656 _bfd_elf_eh_frame_present (struct bfd_link_info *info) 1657 { 1658 asection *eh = bfd_get_section_by_name (info->output_bfd, ".eh_frame"); 1659 1660 if (eh == NULL) 1661 return false; 1662 1663 /* Count only sections which have at least a single CIE or FDE. 1664 There cannot be any CIE or FDE <= 8 bytes. */ 1665 for (eh = eh->map_head.s; eh != NULL; eh = eh->map_head.s) 1666 if (eh->size > 8) 1667 return true; 1668 1669 return false; 1670 } 1671 1672 /* Return true if there is at least one .eh_frame_entry section in 1673 input files. */ 1674 1675 bool 1676 _bfd_elf_eh_frame_entry_present (struct bfd_link_info *info) 1677 { 1678 asection *o; 1679 bfd *abfd; 1680 1681 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next) 1682 { 1683 for (o = abfd->sections; o; o = o->next) 1684 { 1685 const char *name = bfd_section_name (o); 1686 1687 if (strcmp (name, ".eh_frame_entry") 1688 && !bfd_is_abs_section (o->output_section)) 1689 return true; 1690 } 1691 } 1692 return false; 1693 } 1694 1695 /* This function is called from size_dynamic_sections. 1696 It needs to decide whether .eh_frame_hdr should be output or not, 1697 because when the dynamic symbol table has been sized it is too late 1698 to strip sections. */ 1699 1700 bool 1701 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info) 1702 { 1703 struct elf_link_hash_table *htab; 1704 struct eh_frame_hdr_info *hdr_info; 1705 struct bfd_link_hash_entry *bh = NULL; 1706 struct elf_link_hash_entry *h; 1707 1708 htab = elf_hash_table (info); 1709 hdr_info = &htab->eh_info; 1710 if (hdr_info->hdr_sec == NULL) 1711 return true; 1712 1713 if (bfd_is_abs_section (hdr_info->hdr_sec->output_section) 1714 || info->eh_frame_hdr_type == 0 1715 || (info->eh_frame_hdr_type == DWARF2_EH_HDR 1716 && !_bfd_elf_eh_frame_present (info)) 1717 || (info->eh_frame_hdr_type == COMPACT_EH_HDR 1718 && !_bfd_elf_eh_frame_entry_present (info))) 1719 { 1720 hdr_info->hdr_sec->flags |= SEC_EXCLUDE; 1721 hdr_info->hdr_sec = NULL; 1722 return true; 1723 } 1724 1725 /* Add a hidden symbol so that systems without access to PHDRs can 1726 find the table. */ 1727 if (! (_bfd_generic_link_add_one_symbol 1728 (info, info->output_bfd, "__GNU_EH_FRAME_HDR", BSF_LOCAL, 1729 hdr_info->hdr_sec, 0, NULL, false, false, &bh))) 1730 return false; 1731 1732 h = (struct elf_link_hash_entry *) bh; 1733 h->def_regular = 1; 1734 h->other = STV_HIDDEN; 1735 get_elf_backend_data 1736 (info->output_bfd)->elf_backend_hide_symbol (info, h, true); 1737 1738 if (!hdr_info->frame_hdr_is_compact) 1739 hdr_info->u.dwarf.table = true; 1740 return true; 1741 } 1742 1743 /* Adjust an address in the .eh_frame section. Given OFFSET within 1744 SEC, this returns the new offset in the adjusted .eh_frame section, 1745 or -1 if the address refers to a CIE/FDE which has been removed 1746 or to offset with dynamic relocation which is no longer needed. */ 1747 1748 bfd_vma 1749 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED, 1750 struct bfd_link_info *info ATTRIBUTE_UNUSED, 1751 asection *sec, 1752 bfd_vma offset) 1753 { 1754 struct eh_frame_sec_info *sec_info; 1755 unsigned int lo, hi, mid; 1756 1757 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME) 1758 return offset; 1759 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info; 1760 1761 if (offset >= sec->rawsize) 1762 return offset - sec->rawsize + sec->size; 1763 1764 lo = 0; 1765 hi = sec_info->count; 1766 mid = 0; 1767 while (lo < hi) 1768 { 1769 mid = (lo + hi) / 2; 1770 if (offset < sec_info->entry[mid].offset) 1771 hi = mid; 1772 else if (offset 1773 >= sec_info->entry[mid].offset + sec_info->entry[mid].size) 1774 lo = mid + 1; 1775 else 1776 break; 1777 } 1778 1779 BFD_ASSERT (lo < hi); 1780 1781 /* FDE or CIE was removed. */ 1782 if (sec_info->entry[mid].removed) 1783 return (bfd_vma) -1; 1784 1785 /* If converting personality pointers to DW_EH_PE_pcrel, there will be 1786 no need for run-time relocation against the personality field. */ 1787 if (sec_info->entry[mid].cie 1788 && sec_info->entry[mid].u.cie.make_per_encoding_relative 1789 && offset == (sec_info->entry[mid].offset + 8 1790 + sec_info->entry[mid].u.cie.personality_offset)) 1791 return (bfd_vma) -2; 1792 1793 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time 1794 relocation against FDE's initial_location field. */ 1795 if (!sec_info->entry[mid].cie 1796 && sec_info->entry[mid].make_relative 1797 && offset == sec_info->entry[mid].offset + 8) 1798 return (bfd_vma) -2; 1799 1800 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need 1801 for run-time relocation against LSDA field. */ 1802 if (!sec_info->entry[mid].cie 1803 && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative 1804 && offset == (sec_info->entry[mid].offset + 8 1805 + sec_info->entry[mid].lsda_offset)) 1806 return (bfd_vma) -2; 1807 1808 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time 1809 relocation against DW_CFA_set_loc's arguments. */ 1810 if (sec_info->entry[mid].set_loc 1811 && sec_info->entry[mid].make_relative 1812 && (offset >= sec_info->entry[mid].offset + 8 1813 + sec_info->entry[mid].set_loc[1])) 1814 { 1815 unsigned int cnt; 1816 1817 for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++) 1818 if (offset == sec_info->entry[mid].offset + 8 1819 + sec_info->entry[mid].set_loc[cnt]) 1820 return (bfd_vma) -2; 1821 } 1822 1823 /* Any new augmentation bytes go before the first relocation. */ 1824 return (offset + sec_info->entry[mid].new_offset 1825 - sec_info->entry[mid].offset 1826 + extra_augmentation_string_bytes (sec_info->entry + mid) 1827 + extra_augmentation_data_bytes (sec_info->entry + mid)); 1828 } 1829 1830 /* Write out .eh_frame_entry section. Add CANTUNWIND terminator if needed. 1831 Also check that the contents look sane. */ 1832 1833 bool 1834 _bfd_elf_write_section_eh_frame_entry (bfd *abfd, struct bfd_link_info *info, 1835 asection *sec, bfd_byte *contents) 1836 { 1837 const struct elf_backend_data *bed; 1838 bfd_byte cantunwind[8]; 1839 bfd_vma addr; 1840 bfd_vma last_addr; 1841 bfd_vma offset; 1842 asection *text_sec = (asection *) elf_section_data (sec)->sec_info; 1843 1844 if (!sec->rawsize) 1845 sec->rawsize = sec->size; 1846 1847 BFD_ASSERT (sec->sec_info_type == SEC_INFO_TYPE_EH_FRAME_ENTRY); 1848 1849 /* Check to make sure that the text section corresponding to this eh_frame_entry 1850 section has not been excluded. In particular, mips16 stub entries will be 1851 excluded outside of the normal process. */ 1852 if (sec->flags & SEC_EXCLUDE 1853 || text_sec->flags & SEC_EXCLUDE) 1854 return true; 1855 1856 if (!bfd_set_section_contents (abfd, sec->output_section, contents, 1857 sec->output_offset, sec->rawsize)) 1858 return false; 1859 1860 last_addr = bfd_get_signed_32 (abfd, contents); 1861 /* Check that all the entries are in order. */ 1862 for (offset = 8; offset < sec->rawsize; offset += 8) 1863 { 1864 addr = bfd_get_signed_32 (abfd, contents + offset) + offset; 1865 if (addr <= last_addr) 1866 { 1867 /* xgettext:c-format */ 1868 _bfd_error_handler (_("%pB: %pA not in order"), sec->owner, sec); 1869 return false; 1870 } 1871 1872 last_addr = addr; 1873 } 1874 1875 addr = text_sec->output_section->vma + text_sec->output_offset 1876 + text_sec->size; 1877 addr &= ~1; 1878 addr -= (sec->output_section->vma + sec->output_offset + sec->rawsize); 1879 if (addr & 1) 1880 { 1881 /* xgettext:c-format */ 1882 _bfd_error_handler (_("%pB: %pA invalid input section size"), 1883 sec->owner, sec); 1884 bfd_set_error (bfd_error_bad_value); 1885 return false; 1886 } 1887 if (last_addr >= addr + sec->rawsize) 1888 { 1889 /* xgettext:c-format */ 1890 _bfd_error_handler (_("%pB: %pA points past end of text section"), 1891 sec->owner, sec); 1892 bfd_set_error (bfd_error_bad_value); 1893 return false; 1894 } 1895 1896 if (sec->size == sec->rawsize) 1897 return true; 1898 1899 bed = get_elf_backend_data (abfd); 1900 BFD_ASSERT (sec->size == sec->rawsize + 8); 1901 BFD_ASSERT ((addr & 1) == 0); 1902 BFD_ASSERT (bed->cant_unwind_opcode); 1903 1904 bfd_put_32 (abfd, addr, cantunwind); 1905 bfd_put_32 (abfd, (*bed->cant_unwind_opcode) (info), cantunwind + 4); 1906 return bfd_set_section_contents (abfd, sec->output_section, cantunwind, 1907 sec->output_offset + sec->rawsize, 8); 1908 } 1909 1910 /* Write out .eh_frame section. This is called with the relocated 1911 contents. */ 1912 1913 bool 1914 _bfd_elf_write_section_eh_frame (bfd *abfd, 1915 struct bfd_link_info *info, 1916 asection *sec, 1917 bfd_byte *contents) 1918 { 1919 struct eh_frame_sec_info *sec_info; 1920 struct elf_link_hash_table *htab; 1921 struct eh_frame_hdr_info *hdr_info; 1922 unsigned int ptr_size; 1923 struct eh_cie_fde *ent, *last_ent; 1924 1925 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME) 1926 /* FIXME: octets_per_byte. */ 1927 return bfd_set_section_contents (abfd, sec->output_section, contents, 1928 sec->output_offset, sec->size); 1929 1930 ptr_size = (get_elf_backend_data (abfd) 1931 ->elf_backend_eh_frame_address_size (abfd, sec)); 1932 BFD_ASSERT (ptr_size != 0); 1933 1934 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info; 1935 htab = elf_hash_table (info); 1936 hdr_info = &htab->eh_info; 1937 1938 if (hdr_info->u.dwarf.table && hdr_info->u.dwarf.array == NULL) 1939 { 1940 hdr_info->frame_hdr_is_compact = false; 1941 hdr_info->u.dwarf.array = (struct eh_frame_array_ent *) 1942 bfd_malloc (hdr_info->u.dwarf.fde_count 1943 * sizeof (*hdr_info->u.dwarf.array)); 1944 } 1945 if (hdr_info->u.dwarf.array == NULL) 1946 hdr_info = NULL; 1947 1948 /* The new offsets can be bigger or smaller than the original offsets. 1949 We therefore need to make two passes over the section: one backward 1950 pass to move entries up and one forward pass to move entries down. 1951 The two passes won't interfere with each other because entries are 1952 not reordered */ 1953 for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;) 1954 if (!ent->removed && ent->new_offset > ent->offset) 1955 memmove (contents + ent->new_offset, contents + ent->offset, ent->size); 1956 1957 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent) 1958 if (!ent->removed && ent->new_offset < ent->offset) 1959 memmove (contents + ent->new_offset, contents + ent->offset, ent->size); 1960 1961 last_ent = sec_info->entry + sec_info->count; 1962 for (ent = sec_info->entry; ent < last_ent; ++ent) 1963 { 1964 unsigned char *buf, *end; 1965 unsigned int new_size; 1966 1967 if (ent->removed) 1968 continue; 1969 1970 if (ent->size == 4) 1971 { 1972 /* Any terminating FDE must be at the end of the section. */ 1973 BFD_ASSERT (ent == last_ent - 1); 1974 continue; 1975 } 1976 1977 buf = contents + ent->new_offset; 1978 end = buf + ent->size; 1979 new_size = next_cie_fde_offset (ent, last_ent, sec) - ent->new_offset; 1980 1981 /* Update the size. It may be shrinked. */ 1982 bfd_put_32 (abfd, new_size - 4, buf); 1983 1984 /* Filling the extra bytes with DW_CFA_nops. */ 1985 if (new_size != ent->size) 1986 memset (end, 0, new_size - ent->size); 1987 1988 if (ent->cie) 1989 { 1990 /* CIE */ 1991 if (ent->make_relative 1992 || ent->u.cie.make_lsda_relative 1993 || ent->u.cie.per_encoding_relative) 1994 { 1995 char *aug; 1996 unsigned int version, action, extra_string, extra_data; 1997 unsigned int per_width, per_encoding; 1998 1999 /* Need to find 'R' or 'L' augmentation's argument and modify 2000 DW_EH_PE_* value. */ 2001 action = ((ent->make_relative ? 1 : 0) 2002 | (ent->u.cie.make_lsda_relative ? 2 : 0) 2003 | (ent->u.cie.per_encoding_relative ? 4 : 0)); 2004 extra_string = extra_augmentation_string_bytes (ent); 2005 extra_data = extra_augmentation_data_bytes (ent); 2006 2007 /* Skip length, id. */ 2008 buf += 8; 2009 version = *buf++; 2010 aug = (char *) buf; 2011 buf += strlen (aug) + 1; 2012 skip_leb128 (&buf, end); 2013 skip_leb128 (&buf, end); 2014 if (version == 1) 2015 skip_bytes (&buf, end, 1); 2016 else 2017 skip_leb128 (&buf, end); 2018 if (*aug == 'z') 2019 { 2020 /* The uleb128 will always be a single byte for the kind 2021 of augmentation strings that we're prepared to handle. */ 2022 *buf++ += extra_data; 2023 aug++; 2024 } 2025 2026 /* Make room for the new augmentation string and data bytes. */ 2027 memmove (buf + extra_string + extra_data, buf, end - buf); 2028 memmove (aug + extra_string, aug, buf - (bfd_byte *) aug); 2029 buf += extra_string; 2030 end += extra_string + extra_data; 2031 2032 if (ent->add_augmentation_size) 2033 { 2034 *aug++ = 'z'; 2035 *buf++ = extra_data - 1; 2036 } 2037 if (ent->u.cie.add_fde_encoding) 2038 { 2039 BFD_ASSERT (action & 1); 2040 *aug++ = 'R'; 2041 *buf++ = make_pc_relative (DW_EH_PE_absptr, ptr_size); 2042 action &= ~1; 2043 } 2044 2045 while (action) 2046 switch (*aug++) 2047 { 2048 case 'L': 2049 if (action & 2) 2050 { 2051 BFD_ASSERT (*buf == ent->lsda_encoding); 2052 *buf = make_pc_relative (*buf, ptr_size); 2053 action &= ~2; 2054 } 2055 buf++; 2056 break; 2057 case 'P': 2058 if (ent->u.cie.make_per_encoding_relative) 2059 *buf = make_pc_relative (*buf, ptr_size); 2060 per_encoding = *buf++; 2061 per_width = get_DW_EH_PE_width (per_encoding, ptr_size); 2062 BFD_ASSERT (per_width != 0); 2063 BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel) 2064 == ent->u.cie.per_encoding_relative); 2065 if ((per_encoding & 0x70) == DW_EH_PE_aligned) 2066 buf = (contents 2067 + ((buf - contents + per_width - 1) 2068 & ~((bfd_size_type) per_width - 1))); 2069 if (action & 4) 2070 { 2071 bfd_vma val; 2072 2073 val = read_value (abfd, buf, per_width, 2074 get_DW_EH_PE_signed (per_encoding)); 2075 if (ent->u.cie.make_per_encoding_relative) 2076 val -= (sec->output_section->vma 2077 + sec->output_offset 2078 + (buf - contents)); 2079 else 2080 { 2081 val += (bfd_vma) ent->offset - ent->new_offset; 2082 val -= extra_string + extra_data; 2083 } 2084 write_value (abfd, buf, val, per_width); 2085 action &= ~4; 2086 } 2087 buf += per_width; 2088 break; 2089 case 'R': 2090 if (action & 1) 2091 { 2092 BFD_ASSERT (*buf == ent->fde_encoding); 2093 *buf = make_pc_relative (*buf, ptr_size); 2094 action &= ~1; 2095 } 2096 buf++; 2097 break; 2098 case 'S': 2099 break; 2100 default: 2101 BFD_FAIL (); 2102 } 2103 } 2104 } 2105 else 2106 { 2107 /* FDE */ 2108 bfd_vma value, address; 2109 unsigned int width; 2110 bfd_byte *start; 2111 struct eh_cie_fde *cie; 2112 2113 /* Skip length. */ 2114 cie = ent->u.fde.cie_inf; 2115 buf += 4; 2116 value = ((ent->new_offset + sec->output_offset + 4) 2117 - (cie->new_offset + cie->u.cie.u.sec->output_offset)); 2118 bfd_put_32 (abfd, value, buf); 2119 if (bfd_link_relocatable (info)) 2120 continue; 2121 buf += 4; 2122 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 2123 value = read_value (abfd, buf, width, 2124 get_DW_EH_PE_signed (ent->fde_encoding)); 2125 address = value; 2126 if (value) 2127 { 2128 switch (ent->fde_encoding & 0x70) 2129 { 2130 case DW_EH_PE_textrel: 2131 BFD_ASSERT (hdr_info == NULL); 2132 break; 2133 case DW_EH_PE_datarel: 2134 { 2135 switch (abfd->arch_info->arch) 2136 { 2137 case bfd_arch_ia64: 2138 BFD_ASSERT (elf_gp (abfd) != 0); 2139 address += elf_gp (abfd); 2140 break; 2141 default: 2142 _bfd_error_handler 2143 (_("DW_EH_PE_datarel unspecified" 2144 " for this architecture")); 2145 /* Fall thru */ 2146 case bfd_arch_frv: 2147 case bfd_arch_i386: 2148 case bfd_arch_nios2: 2149 BFD_ASSERT (htab->hgot != NULL 2150 && ((htab->hgot->root.type 2151 == bfd_link_hash_defined) 2152 || (htab->hgot->root.type 2153 == bfd_link_hash_defweak))); 2154 address 2155 += (htab->hgot->root.u.def.value 2156 + htab->hgot->root.u.def.section->output_offset 2157 + (htab->hgot->root.u.def.section->output_section 2158 ->vma)); 2159 break; 2160 } 2161 } 2162 break; 2163 case DW_EH_PE_pcrel: 2164 value += (bfd_vma) ent->offset - ent->new_offset; 2165 address += (sec->output_section->vma 2166 + sec->output_offset 2167 + ent->offset + 8); 2168 break; 2169 } 2170 if (ent->make_relative) 2171 value -= (sec->output_section->vma 2172 + sec->output_offset 2173 + ent->new_offset + 8); 2174 write_value (abfd, buf, value, width); 2175 } 2176 2177 start = buf; 2178 2179 if (hdr_info) 2180 { 2181 /* The address calculation may overflow, giving us a 2182 value greater than 4G on a 32-bit target when 2183 dwarf_vma is 64-bit. */ 2184 if (sizeof (address) > 4 && ptr_size == 4) 2185 address &= 0xffffffff; 2186 hdr_info->u.dwarf.array[hdr_info->array_count].initial_loc 2187 = address; 2188 hdr_info->u.dwarf.array[hdr_info->array_count].range 2189 = read_value (abfd, buf + width, width, false); 2190 hdr_info->u.dwarf.array[hdr_info->array_count++].fde 2191 = (sec->output_section->vma 2192 + sec->output_offset 2193 + ent->new_offset); 2194 } 2195 2196 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel 2197 || cie->u.cie.make_lsda_relative) 2198 { 2199 buf += ent->lsda_offset; 2200 width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size); 2201 value = read_value (abfd, buf, width, 2202 get_DW_EH_PE_signed (ent->lsda_encoding)); 2203 if (value) 2204 { 2205 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel) 2206 value += (bfd_vma) ent->offset - ent->new_offset; 2207 else if (cie->u.cie.make_lsda_relative) 2208 value -= (sec->output_section->vma 2209 + sec->output_offset 2210 + ent->new_offset + 8 + ent->lsda_offset); 2211 write_value (abfd, buf, value, width); 2212 } 2213 } 2214 else if (ent->add_augmentation_size) 2215 { 2216 /* Skip the PC and length and insert a zero byte for the 2217 augmentation size. */ 2218 buf += width * 2; 2219 memmove (buf + 1, buf, end - buf); 2220 *buf = 0; 2221 } 2222 2223 if (ent->set_loc) 2224 { 2225 /* Adjust DW_CFA_set_loc. */ 2226 unsigned int cnt; 2227 bfd_vma new_offset; 2228 2229 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 2230 new_offset = ent->new_offset + 8 2231 + extra_augmentation_string_bytes (ent) 2232 + extra_augmentation_data_bytes (ent); 2233 2234 for (cnt = 1; cnt <= ent->set_loc[0]; cnt++) 2235 { 2236 buf = start + ent->set_loc[cnt]; 2237 2238 value = read_value (abfd, buf, width, 2239 get_DW_EH_PE_signed (ent->fde_encoding)); 2240 if (!value) 2241 continue; 2242 2243 if ((ent->fde_encoding & 0x70) == DW_EH_PE_pcrel) 2244 value += (bfd_vma) ent->offset + 8 - new_offset; 2245 if (ent->make_relative) 2246 value -= (sec->output_section->vma 2247 + sec->output_offset 2248 + new_offset + ent->set_loc[cnt]); 2249 write_value (abfd, buf, value, width); 2250 } 2251 } 2252 } 2253 } 2254 2255 /* FIXME: octets_per_byte. */ 2256 return bfd_set_section_contents (abfd, sec->output_section, 2257 contents, (file_ptr) sec->output_offset, 2258 sec->size); 2259 } 2260 2261 /* Helper function used to sort .eh_frame_hdr search table by increasing 2262 VMA of FDE initial location. */ 2263 2264 static int 2265 vma_compare (const void *a, const void *b) 2266 { 2267 const struct eh_frame_array_ent *p = (const struct eh_frame_array_ent *) a; 2268 const struct eh_frame_array_ent *q = (const struct eh_frame_array_ent *) b; 2269 if (p->initial_loc > q->initial_loc) 2270 return 1; 2271 if (p->initial_loc < q->initial_loc) 2272 return -1; 2273 if (p->range > q->range) 2274 return 1; 2275 if (p->range < q->range) 2276 return -1; 2277 return 0; 2278 } 2279 2280 /* Reorder .eh_frame_entry sections to match the associated text sections. 2281 This routine is called during the final linking step, just before writing 2282 the contents. At this stage, sections in the eh_frame_hdr_info are already 2283 sorted in order of increasing text section address and so we simply need 2284 to make the .eh_frame_entrys follow that same order. Note that it is 2285 invalid for a linker script to try to force a particular order of 2286 .eh_frame_entry sections. */ 2287 2288 bool 2289 _bfd_elf_fixup_eh_frame_hdr (struct bfd_link_info *info) 2290 { 2291 asection *sec = NULL; 2292 asection *osec; 2293 struct eh_frame_hdr_info *hdr_info; 2294 unsigned int i; 2295 bfd_vma offset; 2296 struct bfd_link_order *p; 2297 2298 hdr_info = &elf_hash_table (info)->eh_info; 2299 2300 if (hdr_info->hdr_sec == NULL 2301 || info->eh_frame_hdr_type != COMPACT_EH_HDR 2302 || hdr_info->array_count == 0) 2303 return true; 2304 2305 /* Change section output offsets to be in text section order. */ 2306 offset = 8; 2307 osec = hdr_info->u.compact.entries[0]->output_section; 2308 for (i = 0; i < hdr_info->array_count; i++) 2309 { 2310 sec = hdr_info->u.compact.entries[i]; 2311 if (sec->output_section != osec) 2312 { 2313 _bfd_error_handler 2314 (_("invalid output section for .eh_frame_entry: %pA"), 2315 sec->output_section); 2316 return false; 2317 } 2318 sec->output_offset = offset; 2319 offset += sec->size; 2320 } 2321 2322 2323 /* Fix the link_order to match. */ 2324 for (p = sec->output_section->map_head.link_order; p != NULL; p = p->next) 2325 { 2326 if (p->type != bfd_indirect_link_order) 2327 abort(); 2328 2329 p->offset = p->u.indirect.section->output_offset; 2330 if (p->next != NULL) 2331 i--; 2332 } 2333 2334 if (i != 0) 2335 { 2336 _bfd_error_handler 2337 (_("invalid contents in %pA section"), osec); 2338 return false; 2339 } 2340 2341 return true; 2342 } 2343 2344 /* The .eh_frame_hdr format for Compact EH frames: 2345 ubyte version (2) 2346 ubyte eh_ref_enc (DW_EH_PE_* encoding of typinfo references) 2347 uint32_t count (Number of entries in table) 2348 [array from .eh_frame_entry sections] */ 2349 2350 static bool 2351 write_compact_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 2352 { 2353 struct elf_link_hash_table *htab; 2354 struct eh_frame_hdr_info *hdr_info; 2355 asection *sec; 2356 const struct elf_backend_data *bed; 2357 bfd_vma count; 2358 bfd_byte contents[8]; 2359 unsigned int i; 2360 2361 htab = elf_hash_table (info); 2362 hdr_info = &htab->eh_info; 2363 sec = hdr_info->hdr_sec; 2364 2365 if (sec->size != 8) 2366 abort(); 2367 2368 for (i = 0; i < sizeof (contents); i++) 2369 contents[i] = 0; 2370 2371 contents[0] = COMPACT_EH_HDR; 2372 bed = get_elf_backend_data (abfd); 2373 2374 BFD_ASSERT (bed->compact_eh_encoding); 2375 contents[1] = (*bed->compact_eh_encoding) (info); 2376 2377 count = (sec->output_section->size - 8) / 8; 2378 bfd_put_32 (abfd, count, contents + 4); 2379 return bfd_set_section_contents (abfd, sec->output_section, contents, 2380 (file_ptr) sec->output_offset, sec->size); 2381 } 2382 2383 /* The .eh_frame_hdr format for DWARF frames: 2384 2385 ubyte version (currently 1) 2386 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of 2387 .eh_frame section) 2388 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count 2389 number (or DW_EH_PE_omit if there is no 2390 binary search table computed)) 2391 ubyte table_enc (DW_EH_PE_* encoding of binary search table, 2392 or DW_EH_PE_omit if not present. 2393 DW_EH_PE_datarel is using address of 2394 .eh_frame_hdr section start as base) 2395 [encoded] eh_frame_ptr (pointer to start of .eh_frame section) 2396 optionally followed by: 2397 [encoded] fde_count (total number of FDEs in .eh_frame section) 2398 fde_count x [encoded] initial_loc, fde 2399 (array of encoded pairs containing 2400 FDE initial_location field and FDE address, 2401 sorted by increasing initial_loc). */ 2402 2403 static bool 2404 write_dwarf_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 2405 { 2406 struct elf_link_hash_table *htab; 2407 struct eh_frame_hdr_info *hdr_info; 2408 asection *sec; 2409 bool retval = true; 2410 2411 htab = elf_hash_table (info); 2412 hdr_info = &htab->eh_info; 2413 sec = hdr_info->hdr_sec; 2414 bfd_byte *contents; 2415 asection *eh_frame_sec; 2416 bfd_size_type size; 2417 bfd_vma encoded_eh_frame; 2418 2419 size = EH_FRAME_HDR_SIZE; 2420 if (hdr_info->u.dwarf.array 2421 && hdr_info->array_count == hdr_info->u.dwarf.fde_count) 2422 size += 4 + hdr_info->u.dwarf.fde_count * 8; 2423 contents = (bfd_byte *) bfd_malloc (size); 2424 if (contents == NULL) 2425 return false; 2426 2427 eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame"); 2428 if (eh_frame_sec == NULL) 2429 { 2430 free (contents); 2431 return false; 2432 } 2433 2434 memset (contents, 0, EH_FRAME_HDR_SIZE); 2435 /* Version. */ 2436 contents[0] = 1; 2437 /* .eh_frame offset. */ 2438 contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address 2439 (abfd, info, eh_frame_sec, 0, sec, 4, &encoded_eh_frame); 2440 2441 if (hdr_info->u.dwarf.array 2442 && hdr_info->array_count == hdr_info->u.dwarf.fde_count) 2443 { 2444 /* FDE count encoding. */ 2445 contents[2] = DW_EH_PE_udata4; 2446 /* Search table encoding. */ 2447 contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; 2448 } 2449 else 2450 { 2451 contents[2] = DW_EH_PE_omit; 2452 contents[3] = DW_EH_PE_omit; 2453 } 2454 bfd_put_32 (abfd, encoded_eh_frame, contents + 4); 2455 2456 if (contents[2] != DW_EH_PE_omit) 2457 { 2458 unsigned int i; 2459 bool overlap, overflow; 2460 2461 bfd_put_32 (abfd, hdr_info->u.dwarf.fde_count, 2462 contents + EH_FRAME_HDR_SIZE); 2463 qsort (hdr_info->u.dwarf.array, hdr_info->u.dwarf.fde_count, 2464 sizeof (*hdr_info->u.dwarf.array), vma_compare); 2465 overlap = false; 2466 overflow = false; 2467 for (i = 0; i < hdr_info->u.dwarf.fde_count; i++) 2468 { 2469 bfd_vma val; 2470 2471 val = hdr_info->u.dwarf.array[i].initial_loc 2472 - sec->output_section->vma; 2473 val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000; 2474 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 2475 && (hdr_info->u.dwarf.array[i].initial_loc 2476 != sec->output_section->vma + val)) 2477 overflow = true; 2478 bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 4); 2479 val = hdr_info->u.dwarf.array[i].fde - sec->output_section->vma; 2480 val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000; 2481 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 2482 && (hdr_info->u.dwarf.array[i].fde 2483 != sec->output_section->vma + val)) 2484 overflow = true; 2485 bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 8); 2486 if (i != 0 2487 && (hdr_info->u.dwarf.array[i].initial_loc 2488 < (hdr_info->u.dwarf.array[i - 1].initial_loc 2489 + hdr_info->u.dwarf.array[i - 1].range))) 2490 overlap = true; 2491 } 2492 if (overflow) 2493 _bfd_error_handler (_(".eh_frame_hdr entry overflow")); 2494 if (overlap) 2495 _bfd_error_handler (_(".eh_frame_hdr refers to overlapping FDEs")); 2496 if (overflow || overlap) 2497 { 2498 bfd_set_error (bfd_error_bad_value); 2499 retval = false; 2500 } 2501 } 2502 2503 /* FIXME: octets_per_byte. */ 2504 if (!bfd_set_section_contents (abfd, sec->output_section, contents, 2505 (file_ptr) sec->output_offset, 2506 sec->size)) 2507 retval = false; 2508 free (contents); 2509 2510 free (hdr_info->u.dwarf.array); 2511 return retval; 2512 } 2513 2514 /* Write out .eh_frame_hdr section. This must be called after 2515 _bfd_elf_write_section_eh_frame has been called on all input 2516 .eh_frame sections. */ 2517 2518 bool 2519 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 2520 { 2521 struct elf_link_hash_table *htab; 2522 struct eh_frame_hdr_info *hdr_info; 2523 asection *sec; 2524 2525 htab = elf_hash_table (info); 2526 hdr_info = &htab->eh_info; 2527 sec = hdr_info->hdr_sec; 2528 2529 if (info->eh_frame_hdr_type == 0 || sec == NULL) 2530 return true; 2531 2532 if (info->eh_frame_hdr_type == COMPACT_EH_HDR) 2533 return write_compact_eh_frame_hdr (abfd, info); 2534 else 2535 return write_dwarf_eh_frame_hdr (abfd, info); 2536 } 2537 2538 /* Return the width of FDE addresses. This is the default implementation. */ 2539 2540 unsigned int 2541 _bfd_elf_eh_frame_address_size (bfd *abfd, const asection *sec ATTRIBUTE_UNUSED) 2542 { 2543 return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4; 2544 } 2545 2546 /* Decide whether we can use a PC-relative encoding within the given 2547 EH frame section. This is the default implementation. */ 2548 2549 bool 2550 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED, 2551 struct bfd_link_info *info ATTRIBUTE_UNUSED, 2552 asection *eh_frame_section ATTRIBUTE_UNUSED) 2553 { 2554 return true; 2555 } 2556 2557 /* Select an encoding for the given address. Preference is given to 2558 PC-relative addressing modes. */ 2559 2560 bfd_byte 2561 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED, 2562 struct bfd_link_info *info ATTRIBUTE_UNUSED, 2563 asection *osec, bfd_vma offset, 2564 asection *loc_sec, bfd_vma loc_offset, 2565 bfd_vma *encoded) 2566 { 2567 *encoded = osec->vma + offset - 2568 (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset); 2569 return DW_EH_PE_pcrel | DW_EH_PE_sdata4; 2570 } 2571
Indexes created Sat Apr 25 00:22:52 UTC 2026