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