elf-eh-frame.c revision 1.6
1 /* .eh_frame section optimization. 2 Copyright (C) 2001-2018 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 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 'L': 801 REQUIRE (read_byte (&buf, end, &cie->lsda_encoding)); 802 ENSURE_NO_RELOCS (buf); 803 REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size)); 804 break; 805 case 'R': 806 REQUIRE (read_byte (&buf, end, &cie->fde_encoding)); 807 ENSURE_NO_RELOCS (buf); 808 REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size)); 809 break; 810 case 'S': 811 break; 812 case 'P': 813 { 814 int per_width; 815 816 REQUIRE (read_byte (&buf, end, &cie->per_encoding)); 817 per_width = get_DW_EH_PE_width (cie->per_encoding, 818 ptr_size); 819 REQUIRE (per_width); 820 if ((cie->per_encoding & 0x70) == DW_EH_PE_aligned) 821 { 822 length = -(buf - ehbuf) & (per_width - 1); 823 REQUIRE (skip_bytes (&buf, end, length)); 824 if (per_width == 8) 825 this_inf->u.cie.per_encoding_aligned8 = 1; 826 } 827 this_inf->u.cie.personality_offset = buf - start; 828 ENSURE_NO_RELOCS (buf); 829 /* Ensure we have a reloc here. */ 830 REQUIRE (GET_RELOC (buf)); 831 cie->personality.reloc_index 832 = cookie->rel - cookie->rels; 833 /* Cope with MIPS-style composite relocations. */ 834 do 835 cookie->rel++; 836 while (GET_RELOC (buf) != NULL); 837 REQUIRE (skip_bytes (&buf, end, per_width)); 838 } 839 break; 840 default: 841 /* Unrecognized augmentation. Better bail out. */ 842 goto free_no_table; 843 } 844 } 845 this_inf->u.cie.aug_data_len 846 = buf - start - 1 - this_inf->u.cie.aug_str_len; 847 848 /* For shared libraries, try to get rid of as many RELATIVE relocs 849 as possible. */ 850 if (bfd_link_pic (info) 851 && (get_elf_backend_data (abfd) 852 ->elf_backend_can_make_relative_eh_frame 853 (abfd, info, sec))) 854 { 855 if ((cie->fde_encoding & 0x70) == DW_EH_PE_absptr) 856 this_inf->make_relative = 1; 857 /* If the CIE doesn't already have an 'R' entry, it's fairly 858 easy to add one, provided that there's no aligned data 859 after the augmentation string. */ 860 else if (cie->fde_encoding == DW_EH_PE_omit 861 && (cie->per_encoding & 0x70) != DW_EH_PE_aligned) 862 { 863 if (*cie->augmentation == 0) 864 this_inf->add_augmentation_size = 1; 865 this_inf->u.cie.add_fde_encoding = 1; 866 this_inf->make_relative = 1; 867 } 868 869 if ((cie->lsda_encoding & 0x70) == DW_EH_PE_absptr) 870 cie->can_make_lsda_relative = 1; 871 } 872 873 /* If FDE encoding was not specified, it defaults to 874 DW_EH_absptr. */ 875 if (cie->fde_encoding == DW_EH_PE_omit) 876 cie->fde_encoding = DW_EH_PE_absptr; 877 878 initial_insn_length = end - buf; 879 cie->initial_insn_length = initial_insn_length; 880 memcpy (cie->initial_instructions, buf, 881 initial_insn_length <= sizeof (cie->initial_instructions) 882 ? initial_insn_length : sizeof (cie->initial_instructions)); 883 insns = buf; 884 buf += initial_insn_length; 885 ENSURE_NO_RELOCS (buf); 886 887 if (!bfd_link_relocatable (info)) 888 { 889 /* Keep info for merging cies. */ 890 this_inf->u.cie.u.full_cie = cie; 891 this_inf->u.cie.per_encoding_relative 892 = (cie->per_encoding & 0x70) == DW_EH_PE_pcrel; 893 } 894 } 895 else 896 { 897 /* Find the corresponding CIE. */ 898 unsigned int cie_offset = this_inf->offset + 4 - hdr_id; 899 for (cie = local_cies; cie < local_cies + cie_count; cie++) 900 if (cie_offset == cie->cie_inf->offset) 901 break; 902 903 /* Ensure this FDE references one of the CIEs in this input 904 section. */ 905 REQUIRE (cie != local_cies + cie_count); 906 this_inf->u.fde.cie_inf = cie->cie_inf; 907 this_inf->make_relative = cie->cie_inf->make_relative; 908 this_inf->add_augmentation_size 909 = cie->cie_inf->add_augmentation_size; 910 911 ENSURE_NO_RELOCS (buf); 912 if ((sec->flags & SEC_LINKER_CREATED) == 0 || cookie->rels != NULL) 913 { 914 asection *rsec; 915 916 REQUIRE (GET_RELOC (buf)); 917 918 /* Chain together the FDEs for each section. */ 919 rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, 920 cookie, NULL); 921 /* RSEC will be NULL if FDE was cleared out as it was belonging to 922 a discarded SHT_GROUP. */ 923 if (rsec) 924 { 925 REQUIRE (rsec->owner == abfd); 926 this_inf->u.fde.next_for_section = elf_fde_list (rsec); 927 elf_fde_list (rsec) = this_inf; 928 } 929 } 930 931 /* Skip the initial location and address range. */ 932 start = buf; 933 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size); 934 REQUIRE (skip_bytes (&buf, end, 2 * length)); 935 936 SKIP_RELOCS (buf - length); 937 if (!GET_RELOC (buf - length) 938 && read_value (abfd, buf - length, length, FALSE) == 0) 939 { 940 (*info->callbacks->minfo) 941 /* xgettext:c-format */ 942 (_("discarding zero address range FDE in %pB(%pA).\n"), 943 abfd, sec); 944 this_inf->u.fde.cie_inf = NULL; 945 } 946 947 /* Skip the augmentation size, if present. */ 948 if (cie->augmentation[0] == 'z') 949 REQUIRE (read_uleb128 (&buf, end, &length)); 950 else 951 length = 0; 952 953 /* Of the supported augmentation characters above, only 'L' 954 adds augmentation data to the FDE. This code would need to 955 be adjusted if any future augmentations do the same thing. */ 956 if (cie->lsda_encoding != DW_EH_PE_omit) 957 { 958 SKIP_RELOCS (buf); 959 if (cie->can_make_lsda_relative && GET_RELOC (buf)) 960 cie->cie_inf->u.cie.make_lsda_relative = 1; 961 this_inf->lsda_offset = buf - start; 962 /* If there's no 'z' augmentation, we don't know where the 963 CFA insns begin. Assume no padding. */ 964 if (cie->augmentation[0] != 'z') 965 length = end - buf; 966 } 967 968 /* Skip over the augmentation data. */ 969 REQUIRE (skip_bytes (&buf, end, length)); 970 insns = buf; 971 972 buf = last_fde + 4 + hdr_length; 973 974 /* For NULL RSEC (cleared FDE belonging to a discarded section) 975 the relocations are commonly cleared. We do not sanity check if 976 all these relocations are cleared as (1) relocations to 977 .gcc_except_table will remain uncleared (they will get dropped 978 with the drop of this unused FDE) and (2) BFD already safely drops 979 relocations of any type to .eh_frame by 980 elf_section_ignore_discarded_relocs. 981 TODO: The .gcc_except_table entries should be also filtered as 982 .eh_frame entries; or GCC could rather use COMDAT for them. */ 983 SKIP_RELOCS (buf); 984 } 985 986 /* Try to interpret the CFA instructions and find the first 987 padding nop. Shrink this_inf's size so that it doesn't 988 include the padding. */ 989 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size); 990 set_loc_count = 0; 991 insns_end = skip_non_nops (insns, end, length, &set_loc_count); 992 /* If we don't understand the CFA instructions, we can't know 993 what needs to be adjusted there. */ 994 if (insns_end == NULL 995 /* For the time being we don't support DW_CFA_set_loc in 996 CIE instructions. */ 997 || (set_loc_count && this_inf->cie)) 998 goto free_no_table; 999 this_inf->size -= end - insns_end; 1000 if (insns_end != end && this_inf->cie) 1001 { 1002 cie->initial_insn_length -= end - insns_end; 1003 cie->length -= end - insns_end; 1004 } 1005 if (set_loc_count 1006 && ((cie->fde_encoding & 0x70) == DW_EH_PE_pcrel 1007 || this_inf->make_relative)) 1008 { 1009 unsigned int cnt; 1010 bfd_byte *p; 1011 1012 this_inf->set_loc = (unsigned int *) 1013 bfd_malloc ((set_loc_count + 1) * sizeof (unsigned int)); 1014 REQUIRE (this_inf->set_loc); 1015 this_inf->set_loc[0] = set_loc_count; 1016 p = insns; 1017 cnt = 0; 1018 while (p < end) 1019 { 1020 if (*p == DW_CFA_set_loc) 1021 this_inf->set_loc[++cnt] = p + 1 - start; 1022 REQUIRE (skip_cfa_op (&p, end, length)); 1023 } 1024 } 1025 1026 this_inf->removed = 1; 1027 this_inf->fde_encoding = cie->fde_encoding; 1028 this_inf->lsda_encoding = cie->lsda_encoding; 1029 sec_info->count++; 1030 } 1031 BFD_ASSERT (sec_info->count == num_entries); 1032 BFD_ASSERT (cie_count == num_cies); 1033 1034 elf_section_data (sec)->sec_info = sec_info; 1035 sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME; 1036 if (!bfd_link_relocatable (info)) 1037 { 1038 /* Keep info for merging cies. */ 1039 sec_info->cies = local_cies; 1040 local_cies = NULL; 1041 } 1042 goto success; 1043 1044 free_no_table: 1045 _bfd_error_handler 1046 /* xgettext:c-format */ 1047 (_("error in %pB(%pA); no .eh_frame_hdr table will be created"), 1048 abfd, sec); 1049 hdr_info->u.dwarf.table = FALSE; 1050 if (sec_info) 1051 free (sec_info); 1052 success: 1053 if (ehbuf) 1054 free (ehbuf); 1055 if (local_cies) 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->owner, sec, sec->size + 8); 1111 } 1112 1113 /* Finish a pass over all .eh_frame_entry sections. */ 1114 1115 bfd_boolean 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 bfd_boolean 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 bfd_boolean 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 bfd_boolean 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 bfd_boolean 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 unsigned int shndx; 1445 Elf_Internal_Sym *sym; 1446 Elf_Internal_Sym *end_sym; 1447 int adjusted = 0; 1448 1449 shndx = elf_section_data (sec)->this_idx; 1450 end_sym = cookie->locsyms + cookie->locsymcount; 1451 for (sym = cookie->locsyms + 1; sym < end_sym; ++sym) 1452 if (sym->st_info <= ELF_ST_INFO (STB_LOCAL, STT_OBJECT) 1453 && sym->st_shndx == shndx) 1454 { 1455 bfd_signed_vma delta = offset_adjust (sym->st_value, sec); 1456 1457 if (delta != 0) 1458 { 1459 adjusted = 1; 1460 sym->st_value += delta; 1461 } 1462 } 1463 return adjusted; 1464 } 1465 1466 /* This function is called for each input file before the .eh_frame 1467 section is relocated. It discards duplicate CIEs and FDEs for discarded 1468 functions. The function returns TRUE iff any entries have been 1469 deleted. */ 1470 1471 bfd_boolean 1472 _bfd_elf_discard_section_eh_frame 1473 (bfd *abfd, struct bfd_link_info *info, asection *sec, 1474 bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *), 1475 struct elf_reloc_cookie *cookie) 1476 { 1477 struct eh_cie_fde *ent; 1478 struct eh_frame_sec_info *sec_info; 1479 struct eh_frame_hdr_info *hdr_info; 1480 unsigned int ptr_size, offset, eh_alignment; 1481 int changed; 1482 1483 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME) 1484 return FALSE; 1485 1486 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info; 1487 if (sec_info == NULL) 1488 return FALSE; 1489 1490 ptr_size = (get_elf_backend_data (sec->owner) 1491 ->elf_backend_eh_frame_address_size (sec->owner, sec)); 1492 1493 hdr_info = &elf_hash_table (info)->eh_info; 1494 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent) 1495 if (ent->size == 4) 1496 /* There should only be one zero terminator, on the last input 1497 file supplying .eh_frame (crtend.o). Remove any others. */ 1498 ent->removed = sec->map_head.s != NULL; 1499 else if (!ent->cie && ent->u.fde.cie_inf != NULL) 1500 { 1501 bfd_boolean keep; 1502 if ((sec->flags & SEC_LINKER_CREATED) != 0 && cookie->rels == NULL) 1503 { 1504 unsigned int width 1505 = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 1506 bfd_vma value 1507 = read_value (abfd, sec->contents + ent->offset + 8 + width, 1508 width, get_DW_EH_PE_signed (ent->fde_encoding)); 1509 keep = value != 0; 1510 } 1511 else 1512 { 1513 cookie->rel = cookie->rels + ent->reloc_index; 1514 /* FIXME: octets_per_byte. */ 1515 BFD_ASSERT (cookie->rel < cookie->relend 1516 && cookie->rel->r_offset == ent->offset + 8); 1517 keep = !(*reloc_symbol_deleted_p) (ent->offset + 8, cookie); 1518 } 1519 if (keep) 1520 { 1521 if (bfd_link_pic (info) 1522 && (((ent->fde_encoding & 0x70) == DW_EH_PE_absptr 1523 && ent->make_relative == 0) 1524 || (ent->fde_encoding & 0x70) == DW_EH_PE_aligned)) 1525 { 1526 static int num_warnings_issued = 0; 1527 1528 /* If a shared library uses absolute pointers 1529 which we cannot turn into PC relative, 1530 don't create the binary search table, 1531 since it is affected by runtime relocations. */ 1532 hdr_info->u.dwarf.table = FALSE; 1533 if (num_warnings_issued < 10) 1534 { 1535 _bfd_error_handler 1536 /* xgettext:c-format */ 1537 (_("FDE encoding in %pB(%pA) prevents .eh_frame_hdr" 1538 " table being created"), abfd, sec); 1539 num_warnings_issued ++; 1540 } 1541 else if (num_warnings_issued == 10) 1542 { 1543 _bfd_error_handler 1544 (_("further warnings about FDE encoding preventing .eh_frame_hdr generation dropped")); 1545 num_warnings_issued ++; 1546 } 1547 } 1548 ent->removed = 0; 1549 hdr_info->u.dwarf.fde_count++; 1550 ent->u.fde.cie_inf = find_merged_cie (abfd, info, sec, hdr_info, 1551 cookie, ent->u.fde.cie_inf); 1552 } 1553 } 1554 1555 if (sec_info->cies) 1556 { 1557 free (sec_info->cies); 1558 sec_info->cies = NULL; 1559 } 1560 1561 /* It may be that some .eh_frame input section has greater alignment 1562 than other .eh_frame sections. In that case we run the risk of 1563 padding with zeros before that section, which would be seen as a 1564 zero terminator. Alignment padding must be added *inside* the 1565 last FDE instead. For other FDEs we align according to their 1566 encoding, in order to align FDE address range entries naturally. */ 1567 offset = 0; 1568 changed = 0; 1569 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent) 1570 if (!ent->removed) 1571 { 1572 eh_alignment = 4; 1573 if (ent->size == 4) 1574 ; 1575 else if (ent->cie) 1576 { 1577 if (ent->u.cie.per_encoding_aligned8) 1578 eh_alignment = 8; 1579 } 1580 else 1581 { 1582 eh_alignment = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 1583 if (eh_alignment < 4) 1584 eh_alignment = 4; 1585 } 1586 offset = (offset + eh_alignment - 1) & -eh_alignment; 1587 ent->new_offset = offset; 1588 if (ent->new_offset != ent->offset) 1589 changed = 1; 1590 offset += size_of_output_cie_fde (ent); 1591 } 1592 1593 eh_alignment = 4; 1594 offset = (offset + eh_alignment - 1) & -eh_alignment; 1595 sec->rawsize = sec->size; 1596 sec->size = offset; 1597 if (sec->size != sec->rawsize) 1598 changed = 1; 1599 1600 if (changed && adjust_eh_frame_local_symbols (sec, cookie)) 1601 { 1602 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1603 symtab_hdr->contents = (unsigned char *) cookie->locsyms; 1604 } 1605 return changed; 1606 } 1607 1608 /* This function is called for .eh_frame_hdr section after 1609 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame 1610 input sections. It finalizes the size of .eh_frame_hdr section. */ 1611 1612 bfd_boolean 1613 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 1614 { 1615 struct elf_link_hash_table *htab; 1616 struct eh_frame_hdr_info *hdr_info; 1617 asection *sec; 1618 1619 htab = elf_hash_table (info); 1620 hdr_info = &htab->eh_info; 1621 1622 if (!hdr_info->frame_hdr_is_compact && hdr_info->u.dwarf.cies != NULL) 1623 { 1624 htab_delete (hdr_info->u.dwarf.cies); 1625 hdr_info->u.dwarf.cies = NULL; 1626 } 1627 1628 sec = hdr_info->hdr_sec; 1629 if (sec == NULL) 1630 return FALSE; 1631 1632 if (info->eh_frame_hdr_type == COMPACT_EH_HDR) 1633 { 1634 /* For compact frames we only add the header. The actual table comes 1635 from the .eh_frame_entry sections. */ 1636 sec->size = 8; 1637 } 1638 else 1639 { 1640 sec->size = EH_FRAME_HDR_SIZE; 1641 if (hdr_info->u.dwarf.table) 1642 sec->size += 4 + hdr_info->u.dwarf.fde_count * 8; 1643 } 1644 1645 elf_eh_frame_hdr (abfd) = sec; 1646 return TRUE; 1647 } 1648 1649 /* Return true if there is at least one non-empty .eh_frame section in 1650 input files. Can only be called after ld has mapped input to 1651 output sections, and before sections are stripped. */ 1652 1653 bfd_boolean 1654 _bfd_elf_eh_frame_present (struct bfd_link_info *info) 1655 { 1656 asection *eh = bfd_get_section_by_name (info->output_bfd, ".eh_frame"); 1657 1658 if (eh == NULL) 1659 return FALSE; 1660 1661 /* Count only sections which have at least a single CIE or FDE. 1662 There cannot be any CIE or FDE <= 8 bytes. */ 1663 for (eh = eh->map_head.s; eh != NULL; eh = eh->map_head.s) 1664 if (eh->size > 8) 1665 return TRUE; 1666 1667 return FALSE; 1668 } 1669 1670 /* Return true if there is at least one .eh_frame_entry section in 1671 input files. */ 1672 1673 bfd_boolean 1674 _bfd_elf_eh_frame_entry_present (struct bfd_link_info *info) 1675 { 1676 asection *o; 1677 bfd *abfd; 1678 1679 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next) 1680 { 1681 for (o = abfd->sections; o; o = o->next) 1682 { 1683 const char *name = bfd_get_section_name (abfd, o); 1684 1685 if (strcmp (name, ".eh_frame_entry") 1686 && !bfd_is_abs_section (o->output_section)) 1687 return TRUE; 1688 } 1689 } 1690 return FALSE; 1691 } 1692 1693 /* This function is called from size_dynamic_sections. 1694 It needs to decide whether .eh_frame_hdr should be output or not, 1695 because when the dynamic symbol table has been sized it is too late 1696 to strip sections. */ 1697 1698 bfd_boolean 1699 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info) 1700 { 1701 struct elf_link_hash_table *htab; 1702 struct eh_frame_hdr_info *hdr_info; 1703 struct bfd_link_hash_entry *bh = NULL; 1704 struct elf_link_hash_entry *h; 1705 1706 htab = elf_hash_table (info); 1707 hdr_info = &htab->eh_info; 1708 if (hdr_info->hdr_sec == NULL) 1709 return TRUE; 1710 1711 if (bfd_is_abs_section (hdr_info->hdr_sec->output_section) 1712 || info->eh_frame_hdr_type == 0 1713 || (info->eh_frame_hdr_type == DWARF2_EH_HDR 1714 && !_bfd_elf_eh_frame_present (info)) 1715 || (info->eh_frame_hdr_type == COMPACT_EH_HDR 1716 && !_bfd_elf_eh_frame_entry_present (info))) 1717 { 1718 hdr_info->hdr_sec->flags |= SEC_EXCLUDE; 1719 hdr_info->hdr_sec = NULL; 1720 return TRUE; 1721 } 1722 1723 /* Add a hidden symbol so that systems without access to PHDRs can 1724 find the table. */ 1725 if (! (_bfd_generic_link_add_one_symbol 1726 (info, info->output_bfd, "__GNU_EH_FRAME_HDR", BSF_LOCAL, 1727 hdr_info->hdr_sec, 0, NULL, FALSE, FALSE, &bh))) 1728 return FALSE; 1729 1730 h = (struct elf_link_hash_entry *) bh; 1731 h->def_regular = 1; 1732 h->other = STV_HIDDEN; 1733 get_elf_backend_data 1734 (info->output_bfd)->elf_backend_hide_symbol (info, h, TRUE); 1735 1736 if (!hdr_info->frame_hdr_is_compact) 1737 hdr_info->u.dwarf.table = TRUE; 1738 return TRUE; 1739 } 1740 1741 /* Adjust an address in the .eh_frame section. Given OFFSET within 1742 SEC, this returns the new offset in the adjusted .eh_frame section, 1743 or -1 if the address refers to a CIE/FDE which has been removed 1744 or to offset with dynamic relocation which is no longer needed. */ 1745 1746 bfd_vma 1747 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED, 1748 struct bfd_link_info *info ATTRIBUTE_UNUSED, 1749 asection *sec, 1750 bfd_vma offset) 1751 { 1752 struct eh_frame_sec_info *sec_info; 1753 unsigned int lo, hi, mid; 1754 1755 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME) 1756 return offset; 1757 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info; 1758 1759 if (offset >= sec->rawsize) 1760 return offset - sec->rawsize + sec->size; 1761 1762 lo = 0; 1763 hi = sec_info->count; 1764 mid = 0; 1765 while (lo < hi) 1766 { 1767 mid = (lo + hi) / 2; 1768 if (offset < sec_info->entry[mid].offset) 1769 hi = mid; 1770 else if (offset 1771 >= sec_info->entry[mid].offset + sec_info->entry[mid].size) 1772 lo = mid + 1; 1773 else 1774 break; 1775 } 1776 1777 BFD_ASSERT (lo < hi); 1778 1779 /* FDE or CIE was removed. */ 1780 if (sec_info->entry[mid].removed) 1781 return (bfd_vma) -1; 1782 1783 /* If converting personality pointers to DW_EH_PE_pcrel, there will be 1784 no need for run-time relocation against the personality field. */ 1785 if (sec_info->entry[mid].cie 1786 && sec_info->entry[mid].u.cie.make_per_encoding_relative 1787 && offset == (sec_info->entry[mid].offset + 8 1788 + sec_info->entry[mid].u.cie.personality_offset)) 1789 return (bfd_vma) -2; 1790 1791 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time 1792 relocation against FDE's initial_location field. */ 1793 if (!sec_info->entry[mid].cie 1794 && sec_info->entry[mid].make_relative 1795 && offset == sec_info->entry[mid].offset + 8) 1796 return (bfd_vma) -2; 1797 1798 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need 1799 for run-time relocation against LSDA field. */ 1800 if (!sec_info->entry[mid].cie 1801 && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative 1802 && offset == (sec_info->entry[mid].offset + 8 1803 + sec_info->entry[mid].lsda_offset)) 1804 return (bfd_vma) -2; 1805 1806 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time 1807 relocation against DW_CFA_set_loc's arguments. */ 1808 if (sec_info->entry[mid].set_loc 1809 && sec_info->entry[mid].make_relative 1810 && (offset >= sec_info->entry[mid].offset + 8 1811 + sec_info->entry[mid].set_loc[1])) 1812 { 1813 unsigned int cnt; 1814 1815 for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++) 1816 if (offset == sec_info->entry[mid].offset + 8 1817 + sec_info->entry[mid].set_loc[cnt]) 1818 return (bfd_vma) -2; 1819 } 1820 1821 /* Any new augmentation bytes go before the first relocation. */ 1822 return (offset + sec_info->entry[mid].new_offset 1823 - sec_info->entry[mid].offset 1824 + extra_augmentation_string_bytes (sec_info->entry + mid) 1825 + extra_augmentation_data_bytes (sec_info->entry + mid)); 1826 } 1827 1828 /* Write out .eh_frame_entry section. Add CANTUNWIND terminator if needed. 1829 Also check that the contents look sane. */ 1830 1831 bfd_boolean 1832 _bfd_elf_write_section_eh_frame_entry (bfd *abfd, struct bfd_link_info *info, 1833 asection *sec, bfd_byte *contents) 1834 { 1835 const struct elf_backend_data *bed; 1836 bfd_byte cantunwind[8]; 1837 bfd_vma addr; 1838 bfd_vma last_addr; 1839 bfd_vma offset; 1840 asection *text_sec = (asection *) elf_section_data (sec)->sec_info; 1841 1842 if (!sec->rawsize) 1843 sec->rawsize = sec->size; 1844 1845 BFD_ASSERT (sec->sec_info_type == SEC_INFO_TYPE_EH_FRAME_ENTRY); 1846 1847 /* Check to make sure that the text section corresponding to this eh_frame_entry 1848 section has not been excluded. In particular, mips16 stub entries will be 1849 excluded outside of the normal process. */ 1850 if (sec->flags & SEC_EXCLUDE 1851 || text_sec->flags & SEC_EXCLUDE) 1852 return TRUE; 1853 1854 if (!bfd_set_section_contents (abfd, sec->output_section, contents, 1855 sec->output_offset, sec->rawsize)) 1856 return FALSE; 1857 1858 last_addr = bfd_get_signed_32 (abfd, contents); 1859 /* Check that all the entries are in order. */ 1860 for (offset = 8; offset < sec->rawsize; offset += 8) 1861 { 1862 addr = bfd_get_signed_32 (abfd, contents + offset) + offset; 1863 if (addr <= last_addr) 1864 { 1865 /* xgettext:c-format */ 1866 _bfd_error_handler (_("%pB: %pA not in order"), sec->owner, sec); 1867 return FALSE; 1868 } 1869 1870 last_addr = addr; 1871 } 1872 1873 addr = text_sec->output_section->vma + text_sec->output_offset 1874 + text_sec->size; 1875 addr &= ~1; 1876 addr -= (sec->output_section->vma + sec->output_offset + sec->rawsize); 1877 if (addr & 1) 1878 { 1879 /* xgettext:c-format */ 1880 _bfd_error_handler (_("%pB: %pA invalid input section size"), 1881 sec->owner, sec); 1882 bfd_set_error (bfd_error_bad_value); 1883 return FALSE; 1884 } 1885 if (last_addr >= addr + sec->rawsize) 1886 { 1887 /* xgettext:c-format */ 1888 _bfd_error_handler (_("%pB: %pA points past end of text section"), 1889 sec->owner, sec); 1890 bfd_set_error (bfd_error_bad_value); 1891 return FALSE; 1892 } 1893 1894 if (sec->size == sec->rawsize) 1895 return TRUE; 1896 1897 bed = get_elf_backend_data (abfd); 1898 BFD_ASSERT (sec->size == sec->rawsize + 8); 1899 BFD_ASSERT ((addr & 1) == 0); 1900 BFD_ASSERT (bed->cant_unwind_opcode); 1901 1902 bfd_put_32 (abfd, addr, cantunwind); 1903 bfd_put_32 (abfd, (*bed->cant_unwind_opcode) (info), cantunwind + 4); 1904 return bfd_set_section_contents (abfd, sec->output_section, cantunwind, 1905 sec->output_offset + sec->rawsize, 8); 1906 } 1907 1908 /* Write out .eh_frame section. This is called with the relocated 1909 contents. */ 1910 1911 bfd_boolean 1912 _bfd_elf_write_section_eh_frame (bfd *abfd, 1913 struct bfd_link_info *info, 1914 asection *sec, 1915 bfd_byte *contents) 1916 { 1917 struct eh_frame_sec_info *sec_info; 1918 struct elf_link_hash_table *htab; 1919 struct eh_frame_hdr_info *hdr_info; 1920 unsigned int ptr_size; 1921 struct eh_cie_fde *ent, *last_ent; 1922 1923 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME) 1924 /* FIXME: octets_per_byte. */ 1925 return bfd_set_section_contents (abfd, sec->output_section, contents, 1926 sec->output_offset, sec->size); 1927 1928 ptr_size = (get_elf_backend_data (abfd) 1929 ->elf_backend_eh_frame_address_size (abfd, sec)); 1930 BFD_ASSERT (ptr_size != 0); 1931 1932 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info; 1933 htab = elf_hash_table (info); 1934 hdr_info = &htab->eh_info; 1935 1936 if (hdr_info->u.dwarf.table && hdr_info->u.dwarf.array == NULL) 1937 { 1938 hdr_info->frame_hdr_is_compact = FALSE; 1939 hdr_info->u.dwarf.array = (struct eh_frame_array_ent *) 1940 bfd_malloc (hdr_info->u.dwarf.fde_count 1941 * sizeof (*hdr_info->u.dwarf.array)); 1942 } 1943 if (hdr_info->u.dwarf.array == NULL) 1944 hdr_info = NULL; 1945 1946 /* The new offsets can be bigger or smaller than the original offsets. 1947 We therefore need to make two passes over the section: one backward 1948 pass to move entries up and one forward pass to move entries down. 1949 The two passes won't interfere with each other because entries are 1950 not reordered */ 1951 for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;) 1952 if (!ent->removed && ent->new_offset > ent->offset) 1953 memmove (contents + ent->new_offset, contents + ent->offset, ent->size); 1954 1955 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent) 1956 if (!ent->removed && ent->new_offset < ent->offset) 1957 memmove (contents + ent->new_offset, contents + ent->offset, ent->size); 1958 1959 last_ent = sec_info->entry + sec_info->count; 1960 for (ent = sec_info->entry; ent < last_ent; ++ent) 1961 { 1962 unsigned char *buf, *end; 1963 unsigned int new_size; 1964 1965 if (ent->removed) 1966 continue; 1967 1968 if (ent->size == 4) 1969 { 1970 /* Any terminating FDE must be at the end of the section. */ 1971 BFD_ASSERT (ent == last_ent - 1); 1972 continue; 1973 } 1974 1975 buf = contents + ent->new_offset; 1976 end = buf + ent->size; 1977 new_size = next_cie_fde_offset (ent, last_ent, sec) - ent->new_offset; 1978 1979 /* Update the size. It may be shrinked. */ 1980 bfd_put_32 (abfd, new_size - 4, buf); 1981 1982 /* Filling the extra bytes with DW_CFA_nops. */ 1983 if (new_size != ent->size) 1984 memset (end, 0, new_size - ent->size); 1985 1986 if (ent->cie) 1987 { 1988 /* CIE */ 1989 if (ent->make_relative 1990 || ent->u.cie.make_lsda_relative 1991 || ent->u.cie.per_encoding_relative) 1992 { 1993 char *aug; 1994 unsigned int action, extra_string, extra_data; 1995 unsigned int per_width, per_encoding; 1996 1997 /* Need to find 'R' or 'L' augmentation's argument and modify 1998 DW_EH_PE_* value. */ 1999 action = ((ent->make_relative ? 1 : 0) 2000 | (ent->u.cie.make_lsda_relative ? 2 : 0) 2001 | (ent->u.cie.per_encoding_relative ? 4 : 0)); 2002 extra_string = extra_augmentation_string_bytes (ent); 2003 extra_data = extra_augmentation_data_bytes (ent); 2004 2005 /* Skip length, id and version. */ 2006 buf += 9; 2007 aug = (char *) buf; 2008 buf += strlen (aug) + 1; 2009 skip_leb128 (&buf, end); 2010 skip_leb128 (&buf, end); 2011 skip_leb128 (&buf, end); 2012 if (*aug == 'z') 2013 { 2014 /* The uleb128 will always be a single byte for the kind 2015 of augmentation strings that we're prepared to handle. */ 2016 *buf++ += extra_data; 2017 aug++; 2018 } 2019 2020 /* Make room for the new augmentation string and data bytes. */ 2021 memmove (buf + extra_string + extra_data, buf, end - buf); 2022 memmove (aug + extra_string, aug, buf - (bfd_byte *) aug); 2023 buf += extra_string; 2024 end += extra_string + extra_data; 2025 2026 if (ent->add_augmentation_size) 2027 { 2028 *aug++ = 'z'; 2029 *buf++ = extra_data - 1; 2030 } 2031 if (ent->u.cie.add_fde_encoding) 2032 { 2033 BFD_ASSERT (action & 1); 2034 *aug++ = 'R'; 2035 *buf++ = make_pc_relative (DW_EH_PE_absptr, ptr_size); 2036 action &= ~1; 2037 } 2038 2039 while (action) 2040 switch (*aug++) 2041 { 2042 case 'L': 2043 if (action & 2) 2044 { 2045 BFD_ASSERT (*buf == ent->lsda_encoding); 2046 *buf = make_pc_relative (*buf, ptr_size); 2047 action &= ~2; 2048 } 2049 buf++; 2050 break; 2051 case 'P': 2052 if (ent->u.cie.make_per_encoding_relative) 2053 *buf = make_pc_relative (*buf, ptr_size); 2054 per_encoding = *buf++; 2055 per_width = get_DW_EH_PE_width (per_encoding, ptr_size); 2056 BFD_ASSERT (per_width != 0); 2057 BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel) 2058 == ent->u.cie.per_encoding_relative); 2059 if ((per_encoding & 0x70) == DW_EH_PE_aligned) 2060 buf = (contents 2061 + ((buf - contents + per_width - 1) 2062 & ~((bfd_size_type) per_width - 1))); 2063 if (action & 4) 2064 { 2065 bfd_vma val; 2066 2067 val = read_value (abfd, buf, per_width, 2068 get_DW_EH_PE_signed (per_encoding)); 2069 if (ent->u.cie.make_per_encoding_relative) 2070 val -= (sec->output_section->vma 2071 + sec->output_offset 2072 + (buf - contents)); 2073 else 2074 { 2075 val += (bfd_vma) ent->offset - ent->new_offset; 2076 val -= extra_string + extra_data; 2077 } 2078 write_value (abfd, buf, val, per_width); 2079 action &= ~4; 2080 } 2081 buf += per_width; 2082 break; 2083 case 'R': 2084 if (action & 1) 2085 { 2086 BFD_ASSERT (*buf == ent->fde_encoding); 2087 *buf = make_pc_relative (*buf, ptr_size); 2088 action &= ~1; 2089 } 2090 buf++; 2091 break; 2092 case 'S': 2093 break; 2094 default: 2095 BFD_FAIL (); 2096 } 2097 } 2098 } 2099 else 2100 { 2101 /* FDE */ 2102 bfd_vma value, address; 2103 unsigned int width; 2104 bfd_byte *start; 2105 struct eh_cie_fde *cie; 2106 2107 /* Skip length. */ 2108 cie = ent->u.fde.cie_inf; 2109 buf += 4; 2110 value = ((ent->new_offset + sec->output_offset + 4) 2111 - (cie->new_offset + cie->u.cie.u.sec->output_offset)); 2112 bfd_put_32 (abfd, value, buf); 2113 if (bfd_link_relocatable (info)) 2114 continue; 2115 buf += 4; 2116 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 2117 value = read_value (abfd, buf, width, 2118 get_DW_EH_PE_signed (ent->fde_encoding)); 2119 address = value; 2120 if (value) 2121 { 2122 switch (ent->fde_encoding & 0x70) 2123 { 2124 case DW_EH_PE_textrel: 2125 BFD_ASSERT (hdr_info == NULL); 2126 break; 2127 case DW_EH_PE_datarel: 2128 { 2129 switch (abfd->arch_info->arch) 2130 { 2131 case bfd_arch_ia64: 2132 BFD_ASSERT (elf_gp (abfd) != 0); 2133 address += elf_gp (abfd); 2134 break; 2135 default: 2136 _bfd_error_handler 2137 (_("DW_EH_PE_datarel unspecified" 2138 " for this architecture")); 2139 /* Fall thru */ 2140 case bfd_arch_frv: 2141 case bfd_arch_i386: 2142 BFD_ASSERT (htab->hgot != NULL 2143 && ((htab->hgot->root.type 2144 == bfd_link_hash_defined) 2145 || (htab->hgot->root.type 2146 == bfd_link_hash_defweak))); 2147 address 2148 += (htab->hgot->root.u.def.value 2149 + htab->hgot->root.u.def.section->output_offset 2150 + (htab->hgot->root.u.def.section->output_section 2151 ->vma)); 2152 break; 2153 } 2154 } 2155 break; 2156 case DW_EH_PE_pcrel: 2157 value += (bfd_vma) ent->offset - ent->new_offset; 2158 address += (sec->output_section->vma 2159 + sec->output_offset 2160 + ent->offset + 8); 2161 break; 2162 } 2163 if (ent->make_relative) 2164 value -= (sec->output_section->vma 2165 + sec->output_offset 2166 + ent->new_offset + 8); 2167 write_value (abfd, buf, value, width); 2168 } 2169 2170 start = buf; 2171 2172 if (hdr_info) 2173 { 2174 /* The address calculation may overflow, giving us a 2175 value greater than 4G on a 32-bit target when 2176 dwarf_vma is 64-bit. */ 2177 if (sizeof (address) > 4 && ptr_size == 4) 2178 address &= 0xffffffff; 2179 hdr_info->u.dwarf.array[hdr_info->array_count].initial_loc 2180 = address; 2181 hdr_info->u.dwarf.array[hdr_info->array_count].range 2182 = read_value (abfd, buf + width, width, FALSE); 2183 hdr_info->u.dwarf.array[hdr_info->array_count++].fde 2184 = (sec->output_section->vma 2185 + sec->output_offset 2186 + ent->new_offset); 2187 } 2188 2189 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel 2190 || cie->u.cie.make_lsda_relative) 2191 { 2192 buf += ent->lsda_offset; 2193 width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size); 2194 value = read_value (abfd, buf, width, 2195 get_DW_EH_PE_signed (ent->lsda_encoding)); 2196 if (value) 2197 { 2198 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel) 2199 value += (bfd_vma) ent->offset - ent->new_offset; 2200 else if (cie->u.cie.make_lsda_relative) 2201 value -= (sec->output_section->vma 2202 + sec->output_offset 2203 + ent->new_offset + 8 + ent->lsda_offset); 2204 write_value (abfd, buf, value, width); 2205 } 2206 } 2207 else if (ent->add_augmentation_size) 2208 { 2209 /* Skip the PC and length and insert a zero byte for the 2210 augmentation size. */ 2211 buf += width * 2; 2212 memmove (buf + 1, buf, end - buf); 2213 *buf = 0; 2214 } 2215 2216 if (ent->set_loc) 2217 { 2218 /* Adjust DW_CFA_set_loc. */ 2219 unsigned int cnt; 2220 bfd_vma new_offset; 2221 2222 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 2223 new_offset = ent->new_offset + 8 2224 + extra_augmentation_string_bytes (ent) 2225 + extra_augmentation_data_bytes (ent); 2226 2227 for (cnt = 1; cnt <= ent->set_loc[0]; cnt++) 2228 { 2229 buf = start + ent->set_loc[cnt]; 2230 2231 value = read_value (abfd, buf, width, 2232 get_DW_EH_PE_signed (ent->fde_encoding)); 2233 if (!value) 2234 continue; 2235 2236 if ((ent->fde_encoding & 0x70) == DW_EH_PE_pcrel) 2237 value += (bfd_vma) ent->offset + 8 - new_offset; 2238 if (ent->make_relative) 2239 value -= (sec->output_section->vma 2240 + sec->output_offset 2241 + new_offset + ent->set_loc[cnt]); 2242 write_value (abfd, buf, value, width); 2243 } 2244 } 2245 } 2246 } 2247 2248 /* FIXME: octets_per_byte. */ 2249 return bfd_set_section_contents (abfd, sec->output_section, 2250 contents, (file_ptr) sec->output_offset, 2251 sec->size); 2252 } 2253 2254 /* Helper function used to sort .eh_frame_hdr search table by increasing 2255 VMA of FDE initial location. */ 2256 2257 static int 2258 vma_compare (const void *a, const void *b) 2259 { 2260 const struct eh_frame_array_ent *p = (const struct eh_frame_array_ent *) a; 2261 const struct eh_frame_array_ent *q = (const struct eh_frame_array_ent *) b; 2262 if (p->initial_loc > q->initial_loc) 2263 return 1; 2264 if (p->initial_loc < q->initial_loc) 2265 return -1; 2266 if (p->range > q->range) 2267 return 1; 2268 if (p->range < q->range) 2269 return -1; 2270 return 0; 2271 } 2272 2273 /* Reorder .eh_frame_entry sections to match the associated text sections. 2274 This routine is called during the final linking step, just before writing 2275 the contents. At this stage, sections in the eh_frame_hdr_info are already 2276 sorted in order of increasing text section address and so we simply need 2277 to make the .eh_frame_entrys follow that same order. Note that it is 2278 invalid for a linker script to try to force a particular order of 2279 .eh_frame_entry sections. */ 2280 2281 bfd_boolean 2282 _bfd_elf_fixup_eh_frame_hdr (struct bfd_link_info *info) 2283 { 2284 asection *sec = NULL; 2285 asection *osec; 2286 struct eh_frame_hdr_info *hdr_info; 2287 unsigned int i; 2288 bfd_vma offset; 2289 struct bfd_link_order *p; 2290 2291 hdr_info = &elf_hash_table (info)->eh_info; 2292 2293 if (hdr_info->hdr_sec == NULL 2294 || info->eh_frame_hdr_type != COMPACT_EH_HDR 2295 || hdr_info->array_count == 0) 2296 return TRUE; 2297 2298 /* Change section output offsets to be in text section order. */ 2299 offset = 8; 2300 osec = hdr_info->u.compact.entries[0]->output_section; 2301 for (i = 0; i < hdr_info->array_count; i++) 2302 { 2303 sec = hdr_info->u.compact.entries[i]; 2304 if (sec->output_section != osec) 2305 { 2306 _bfd_error_handler 2307 (_("invalid output section for .eh_frame_entry: %pA"), 2308 sec->output_section); 2309 return FALSE; 2310 } 2311 sec->output_offset = offset; 2312 offset += sec->size; 2313 } 2314 2315 2316 /* Fix the link_order to match. */ 2317 for (p = sec->output_section->map_head.link_order; p != NULL; p = p->next) 2318 { 2319 if (p->type != bfd_indirect_link_order) 2320 abort(); 2321 2322 p->offset = p->u.indirect.section->output_offset; 2323 if (p->next != NULL) 2324 i--; 2325 } 2326 2327 if (i != 0) 2328 { 2329 _bfd_error_handler 2330 (_("invalid contents in %pA section"), osec); 2331 return FALSE; 2332 } 2333 2334 return TRUE; 2335 } 2336 2337 /* The .eh_frame_hdr format for Compact EH frames: 2338 ubyte version (2) 2339 ubyte eh_ref_enc (DW_EH_PE_* encoding of typinfo references) 2340 uint32_t count (Number of entries in table) 2341 [array from .eh_frame_entry sections] */ 2342 2343 static bfd_boolean 2344 write_compact_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 2345 { 2346 struct elf_link_hash_table *htab; 2347 struct eh_frame_hdr_info *hdr_info; 2348 asection *sec; 2349 const struct elf_backend_data *bed; 2350 bfd_vma count; 2351 bfd_byte contents[8]; 2352 unsigned int i; 2353 2354 htab = elf_hash_table (info); 2355 hdr_info = &htab->eh_info; 2356 sec = hdr_info->hdr_sec; 2357 2358 if (sec->size != 8) 2359 abort(); 2360 2361 for (i = 0; i < sizeof (contents); i++) 2362 contents[i] = 0; 2363 2364 contents[0] = COMPACT_EH_HDR; 2365 bed = get_elf_backend_data (abfd); 2366 2367 BFD_ASSERT (bed->compact_eh_encoding); 2368 contents[1] = (*bed->compact_eh_encoding) (info); 2369 2370 count = (sec->output_section->size - 8) / 8; 2371 bfd_put_32 (abfd, count, contents + 4); 2372 return bfd_set_section_contents (abfd, sec->output_section, contents, 2373 (file_ptr) sec->output_offset, sec->size); 2374 } 2375 2376 /* The .eh_frame_hdr format for DWARF frames: 2377 2378 ubyte version (currently 1) 2379 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of 2380 .eh_frame section) 2381 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count 2382 number (or DW_EH_PE_omit if there is no 2383 binary search table computed)) 2384 ubyte table_enc (DW_EH_PE_* encoding of binary search table, 2385 or DW_EH_PE_omit if not present. 2386 DW_EH_PE_datarel is using address of 2387 .eh_frame_hdr section start as base) 2388 [encoded] eh_frame_ptr (pointer to start of .eh_frame section) 2389 optionally followed by: 2390 [encoded] fde_count (total number of FDEs in .eh_frame section) 2391 fde_count x [encoded] initial_loc, fde 2392 (array of encoded pairs containing 2393 FDE initial_location field and FDE address, 2394 sorted by increasing initial_loc). */ 2395 2396 static bfd_boolean 2397 write_dwarf_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 2398 { 2399 struct elf_link_hash_table *htab; 2400 struct eh_frame_hdr_info *hdr_info; 2401 asection *sec; 2402 bfd_boolean retval = TRUE; 2403 2404 htab = elf_hash_table (info); 2405 hdr_info = &htab->eh_info; 2406 sec = hdr_info->hdr_sec; 2407 bfd_byte *contents; 2408 asection *eh_frame_sec; 2409 bfd_size_type size; 2410 bfd_vma encoded_eh_frame; 2411 2412 size = EH_FRAME_HDR_SIZE; 2413 if (hdr_info->u.dwarf.array 2414 && hdr_info->array_count == hdr_info->u.dwarf.fde_count) 2415 size += 4 + hdr_info->u.dwarf.fde_count * 8; 2416 contents = (bfd_byte *) bfd_malloc (size); 2417 if (contents == NULL) 2418 return FALSE; 2419 2420 eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame"); 2421 if (eh_frame_sec == NULL) 2422 { 2423 free (contents); 2424 return FALSE; 2425 } 2426 2427 memset (contents, 0, EH_FRAME_HDR_SIZE); 2428 /* Version. */ 2429 contents[0] = 1; 2430 /* .eh_frame offset. */ 2431 contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address 2432 (abfd, info, eh_frame_sec, 0, sec, 4, &encoded_eh_frame); 2433 2434 if (hdr_info->u.dwarf.array 2435 && hdr_info->array_count == hdr_info->u.dwarf.fde_count) 2436 { 2437 /* FDE count encoding. */ 2438 contents[2] = DW_EH_PE_udata4; 2439 /* Search table encoding. */ 2440 contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; 2441 } 2442 else 2443 { 2444 contents[2] = DW_EH_PE_omit; 2445 contents[3] = DW_EH_PE_omit; 2446 } 2447 bfd_put_32 (abfd, encoded_eh_frame, contents + 4); 2448 2449 if (contents[2] != DW_EH_PE_omit) 2450 { 2451 unsigned int i; 2452 bfd_boolean overlap, overflow; 2453 2454 bfd_put_32 (abfd, hdr_info->u.dwarf.fde_count, 2455 contents + EH_FRAME_HDR_SIZE); 2456 qsort (hdr_info->u.dwarf.array, hdr_info->u.dwarf.fde_count, 2457 sizeof (*hdr_info->u.dwarf.array), vma_compare); 2458 overlap = FALSE; 2459 overflow = FALSE; 2460 for (i = 0; i < hdr_info->u.dwarf.fde_count; i++) 2461 { 2462 bfd_vma val; 2463 2464 val = hdr_info->u.dwarf.array[i].initial_loc 2465 - sec->output_section->vma; 2466 val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000; 2467 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 2468 && (hdr_info->u.dwarf.array[i].initial_loc 2469 != sec->output_section->vma + val)) 2470 overflow = TRUE; 2471 bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 4); 2472 val = hdr_info->u.dwarf.array[i].fde - 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].fde 2476 != sec->output_section->vma + val)) 2477 overflow = TRUE; 2478 bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 8); 2479 if (i != 0 2480 && (hdr_info->u.dwarf.array[i].initial_loc 2481 < (hdr_info->u.dwarf.array[i - 1].initial_loc 2482 + hdr_info->u.dwarf.array[i - 1].range))) 2483 overlap = TRUE; 2484 } 2485 if (overflow) 2486 _bfd_error_handler (_(".eh_frame_hdr entry overflow")); 2487 if (overlap) 2488 _bfd_error_handler (_(".eh_frame_hdr refers to overlapping FDEs")); 2489 if (overflow || overlap) 2490 { 2491 bfd_set_error (bfd_error_bad_value); 2492 retval = FALSE; 2493 } 2494 } 2495 2496 /* FIXME: octets_per_byte. */ 2497 if (!bfd_set_section_contents (abfd, sec->output_section, contents, 2498 (file_ptr) sec->output_offset, 2499 sec->size)) 2500 retval = FALSE; 2501 free (contents); 2502 2503 if (hdr_info->u.dwarf.array != NULL) 2504 free (hdr_info->u.dwarf.array); 2505 return retval; 2506 } 2507 2508 /* Write out .eh_frame_hdr section. This must be called after 2509 _bfd_elf_write_section_eh_frame has been called on all input 2510 .eh_frame sections. */ 2511 2512 bfd_boolean 2513 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 2514 { 2515 struct elf_link_hash_table *htab; 2516 struct eh_frame_hdr_info *hdr_info; 2517 asection *sec; 2518 2519 htab = elf_hash_table (info); 2520 hdr_info = &htab->eh_info; 2521 sec = hdr_info->hdr_sec; 2522 2523 if (info->eh_frame_hdr_type == 0 || sec == NULL) 2524 return TRUE; 2525 2526 if (info->eh_frame_hdr_type == COMPACT_EH_HDR) 2527 return write_compact_eh_frame_hdr (abfd, info); 2528 else 2529 return write_dwarf_eh_frame_hdr (abfd, info); 2530 } 2531 2532 /* Return the width of FDE addresses. This is the default implementation. */ 2533 2534 unsigned int 2535 _bfd_elf_eh_frame_address_size (bfd *abfd, const asection *sec ATTRIBUTE_UNUSED) 2536 { 2537 return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4; 2538 } 2539 2540 /* Decide whether we can use a PC-relative encoding within the given 2541 EH frame section. This is the default implementation. */ 2542 2543 bfd_boolean 2544 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED, 2545 struct bfd_link_info *info ATTRIBUTE_UNUSED, 2546 asection *eh_frame_section ATTRIBUTE_UNUSED) 2547 { 2548 return TRUE; 2549 } 2550 2551 /* Select an encoding for the given address. Preference is given to 2552 PC-relative addressing modes. */ 2553 2554 bfd_byte 2555 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED, 2556 struct bfd_link_info *info ATTRIBUTE_UNUSED, 2557 asection *osec, bfd_vma offset, 2558 asection *loc_sec, bfd_vma loc_offset, 2559 bfd_vma *encoded) 2560 { 2561 *encoded = osec->vma + offset - 2562 (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset); 2563 return DW_EH_PE_pcrel | DW_EH_PE_sdata4; 2564 } 2565
Indexes created Mon May 04 00:23:20 UTC 2026