1/* .eh_frame section optimization. 2 Copyright (C) 2001-2017 Free Software Foundation, Inc. 3 Written by Jakub Jelinek <jakub@redhat.com>. 4 5 This file is part of BFD, the Binary File Descriptor library. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 20 MA 02110-1301, USA. */ 21 22#include "sysdep.h" 23#include "bfd.h" 24#include "libbfd.h" 25#include "elf-bfd.h" 26#include "dwarf2.h" 27 28#define EH_FRAME_HDR_SIZE 8 29 30struct 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 63static inline bfd_boolean 64read_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 75static inline bfd_boolean 76skip_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 90static bfd_boolean 91skip_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 104static bfd_boolean 105read_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 123static bfd_boolean 124read_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 142static 143int 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 167static bfd_vma 168read_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 202static void 203write_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 216static int 217cie_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 249static hashval_t 250cie_hash (const void *e) 251{ 252 const struct cie *c = (const struct cie *) e; 253 return c->hash; 254} 255 256static hashval_t 257cie_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 285static INLINE unsigned int 286extra_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 301static INLINE unsigned int 302extra_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 315static unsigned int 316size_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 332static bfd_boolean 333skip_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 412static bfd_byte * 413skip_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 436static unsigned char 437make_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 458static void 459bfd_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 479static void 480bfd_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 511bfd_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 564void 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 /* xgettext:c-format */ 928 (_("discarding zero address range FDE in %B(%A).\n"), 929 abfd, sec); 930 this_inf->u.fde.cie_inf = NULL; 931 } 932 933 /* Skip the augmentation size, if present. */ 934 if (cie->augmentation[0] == 'z') 935 REQUIRE (read_uleb128 (&buf, end, &length)); 936 else 937 length = 0; 938 939 /* Of the supported augmentation characters above, only 'L' 940 adds augmentation data to the FDE. This code would need to 941 be adjusted if any future augmentations do the same thing. */ 942 if (cie->lsda_encoding != DW_EH_PE_omit) 943 { 944 SKIP_RELOCS (buf); 945 if (cie->can_make_lsda_relative && GET_RELOC (buf)) 946 cie->cie_inf->u.cie.make_lsda_relative = 1; 947 this_inf->lsda_offset = buf - start; 948 /* If there's no 'z' augmentation, we don't know where the 949 CFA insns begin. Assume no padding. */ 950 if (cie->augmentation[0] != 'z') 951 length = end - buf; 952 } 953 954 /* Skip over the augmentation data. */ 955 REQUIRE (skip_bytes (&buf, end, length)); 956 insns = buf; 957 958 buf = last_fde + 4 + hdr_length; 959 960 /* For NULL RSEC (cleared FDE belonging to a discarded section) 961 the relocations are commonly cleared. We do not sanity check if 962 all these relocations are cleared as (1) relocations to 963 .gcc_except_table will remain uncleared (they will get dropped 964 with the drop of this unused FDE) and (2) BFD already safely drops 965 relocations of any type to .eh_frame by 966 elf_section_ignore_discarded_relocs. 967 TODO: The .gcc_except_table entries should be also filtered as 968 .eh_frame entries; or GCC could rather use COMDAT for them. */ 969 SKIP_RELOCS (buf); 970 } 971 972 /* Try to interpret the CFA instructions and find the first 973 padding nop. Shrink this_inf's size so that it doesn't 974 include the padding. */ 975 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size); 976 set_loc_count = 0; 977 insns_end = skip_non_nops (insns, end, length, &set_loc_count); 978 /* If we don't understand the CFA instructions, we can't know 979 what needs to be adjusted there. */ 980 if (insns_end == NULL 981 /* For the time being we don't support DW_CFA_set_loc in 982 CIE instructions. */ 983 || (set_loc_count && this_inf->cie)) 984 goto free_no_table; 985 this_inf->size -= end - insns_end; 986 if (insns_end != end && this_inf->cie) 987 { 988 cie->initial_insn_length -= end - insns_end; 989 cie->length -= end - insns_end; 990 } 991 if (set_loc_count 992 && ((cie->fde_encoding & 0x70) == DW_EH_PE_pcrel 993 || this_inf->make_relative)) 994 { 995 unsigned int cnt; 996 bfd_byte *p; 997 998 this_inf->set_loc = (unsigned int *) 999 bfd_malloc ((set_loc_count + 1) * sizeof (unsigned int)); 1000 REQUIRE (this_inf->set_loc); 1001 this_inf->set_loc[0] = set_loc_count; 1002 p = insns; 1003 cnt = 0; 1004 while (p < end) 1005 { 1006 if (*p == DW_CFA_set_loc) 1007 this_inf->set_loc[++cnt] = p + 1 - start; 1008 REQUIRE (skip_cfa_op (&p, end, length)); 1009 } 1010 } 1011 1012 this_inf->removed = 1; 1013 this_inf->fde_encoding = cie->fde_encoding; 1014 this_inf->lsda_encoding = cie->lsda_encoding; 1015 sec_info->count++; 1016 } 1017 BFD_ASSERT (sec_info->count == num_entries); 1018 BFD_ASSERT (cie_count == num_cies); 1019 1020 elf_section_data (sec)->sec_info = sec_info; 1021 sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME; 1022 if (!bfd_link_relocatable (info)) 1023 { 1024 /* Keep info for merging cies. */ 1025 sec_info->cies = local_cies; 1026 local_cies = NULL; 1027 } 1028 goto success; 1029 1030 free_no_table: 1031 (*info->callbacks->einfo) 1032 /* xgettext:c-format */ 1033 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"), 1034 abfd, sec); 1035 hdr_info->u.dwarf.table = FALSE; 1036 if (sec_info) 1037 free (sec_info); 1038 success: 1039 if (ehbuf) 1040 free (ehbuf); 1041 if (local_cies) 1042 free (local_cies); 1043#undef REQUIRE 1044} 1045 1046/* Order eh_frame_hdr entries by the VMA of their text section. */ 1047 1048static int 1049cmp_eh_frame_hdr (const void *a, const void *b) 1050{ 1051 bfd_vma text_a; 1052 bfd_vma text_b; 1053 asection *sec; 1054 1055 sec = *(asection *const *)a; 1056 sec = (asection *) elf_section_data (sec)->sec_info; 1057 text_a = sec->output_section->vma + sec->output_offset; 1058 sec = *(asection *const *)b; 1059 sec = (asection *) elf_section_data (sec)->sec_info; 1060 text_b = sec->output_section->vma + sec->output_offset; 1061 1062 if (text_a < text_b) 1063 return -1; 1064 return text_a > text_b; 1065 1066} 1067 1068/* Add space for a CANTUNWIND terminator to SEC if the text sections 1069 referenced by it and NEXT are not contiguous, or NEXT is NULL. */ 1070 1071static void 1072add_eh_frame_hdr_terminator (asection *sec, 1073 asection *next) 1074{ 1075 bfd_vma end; 1076 bfd_vma next_start; 1077 asection *text_sec; 1078 1079 if (next) 1080 { 1081 /* See if there is a gap (presumably a text section without unwind info) 1082 between these two entries. */ 1083 text_sec = (asection *) elf_section_data (sec)->sec_info; 1084 end = text_sec->output_section->vma + text_sec->output_offset 1085 + text_sec->size; 1086 text_sec = (asection *) elf_section_data (next)->sec_info; 1087 next_start = text_sec->output_section->vma + text_sec->output_offset; 1088 if (end == next_start) 1089 return; 1090 } 1091 1092 /* Add space for a CANTUNWIND terminator. */ 1093 if (!sec->rawsize) 1094 sec->rawsize = sec->size; 1095 1096 bfd_set_section_size (sec->owner, sec, sec->size + 8); 1097} 1098 1099/* Finish a pass over all .eh_frame_entry sections. */ 1100 1101bfd_boolean 1102_bfd_elf_end_eh_frame_parsing (struct bfd_link_info *info) 1103{ 1104 struct eh_frame_hdr_info *hdr_info; 1105 unsigned int i; 1106 1107 hdr_info = &elf_hash_table (info)->eh_info; 1108 1109 if (info->eh_frame_hdr_type != COMPACT_EH_HDR 1110 || hdr_info->array_count == 0) 1111 return FALSE; 1112 1113 bfd_elf_discard_eh_frame_entry (hdr_info); 1114 1115 qsort (hdr_info->u.compact.entries, hdr_info->array_count, 1116 sizeof (asection *), cmp_eh_frame_hdr); 1117 1118 for (i = 0; i < hdr_info->array_count - 1; i++) 1119 { 1120 add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i], 1121 hdr_info->u.compact.entries[i + 1]); 1122 } 1123 1124 /* Add a CANTUNWIND terminator after the last entry. */ 1125 add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i], NULL); 1126 return TRUE; 1127} 1128 1129/* Mark all relocations against CIE or FDE ENT, which occurs in 1130 .eh_frame section SEC. COOKIE describes the relocations in SEC; 1131 its "rel" field can be changed freely. */ 1132 1133static bfd_boolean 1134mark_entry (struct bfd_link_info *info, asection *sec, 1135 struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook, 1136 struct elf_reloc_cookie *cookie) 1137{ 1138 /* FIXME: octets_per_byte. */ 1139 for (cookie->rel = cookie->rels + ent->reloc_index; 1140 cookie->rel < cookie->relend 1141 && cookie->rel->r_offset < ent->offset + ent->size; 1142 cookie->rel++) 1143 if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie)) 1144 return FALSE; 1145 1146 return TRUE; 1147} 1148 1149/* Mark all the relocations against FDEs that relate to code in input 1150 section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose 1151 relocations are described by COOKIE. */ 1152 1153bfd_boolean 1154_bfd_elf_gc_mark_fdes (struct bfd_link_info *info, asection *sec, 1155 asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook, 1156 struct elf_reloc_cookie *cookie) 1157{ 1158 struct eh_cie_fde *fde, *cie; 1159 1160 for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section) 1161 { 1162 if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie)) 1163 return FALSE; 1164 1165 /* At this stage, all cie_inf fields point to local CIEs, so we 1166 can use the same cookie to refer to them. */ 1167 cie = fde->u.fde.cie_inf; 1168 if (cie != NULL && !cie->u.cie.gc_mark) 1169 { 1170 cie->u.cie.gc_mark = 1; 1171 if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie)) 1172 return FALSE; 1173 } 1174 } 1175 return TRUE; 1176} 1177 1178/* Input section SEC of ABFD is an .eh_frame section that contains the 1179 CIE described by CIE_INF. Return a version of CIE_INF that is going 1180 to be kept in the output, adding CIE_INF to the output if necessary. 1181 1182 HDR_INFO is the .eh_frame_hdr information and COOKIE describes the 1183 relocations in REL. */ 1184 1185static struct eh_cie_fde * 1186find_merged_cie (bfd *abfd, struct bfd_link_info *info, asection *sec, 1187 struct eh_frame_hdr_info *hdr_info, 1188 struct elf_reloc_cookie *cookie, 1189 struct eh_cie_fde *cie_inf) 1190{ 1191 unsigned long r_symndx; 1192 struct cie *cie, *new_cie; 1193 Elf_Internal_Rela *rel; 1194 void **loc; 1195 1196 /* Use CIE_INF if we have already decided to keep it. */ 1197 if (!cie_inf->removed) 1198 return cie_inf; 1199 1200 /* If we have merged CIE_INF with another CIE, use that CIE instead. */ 1201 if (cie_inf->u.cie.merged) 1202 return cie_inf->u.cie.u.merged_with; 1203 1204 cie = cie_inf->u.cie.u.full_cie; 1205 1206 /* Assume we will need to keep CIE_INF. */ 1207 cie_inf->removed = 0; 1208 cie_inf->u.cie.u.sec = sec; 1209 1210 /* If we are not merging CIEs, use CIE_INF. */ 1211 if (cie == NULL) 1212 return cie_inf; 1213 1214 if (cie->per_encoding != DW_EH_PE_omit) 1215 { 1216 bfd_boolean per_binds_local; 1217 1218 /* Work out the address of personality routine, or at least 1219 enough info that we could calculate the address had we made a 1220 final section layout. The symbol on the reloc is enough, 1221 either the hash for a global, or (bfd id, index) pair for a 1222 local. The assumption here is that no one uses addends on 1223 the reloc. */ 1224 rel = cookie->rels + cie->personality.reloc_index; 1225 memset (&cie->personality, 0, sizeof (cie->personality)); 1226#ifdef BFD64 1227 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64) 1228 r_symndx = ELF64_R_SYM (rel->r_info); 1229 else 1230#endif 1231 r_symndx = ELF32_R_SYM (rel->r_info); 1232 if (r_symndx >= cookie->locsymcount 1233 || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL) 1234 { 1235 struct elf_link_hash_entry *h; 1236 1237 r_symndx -= cookie->extsymoff; 1238 h = cookie->sym_hashes[r_symndx]; 1239 1240 while (h->root.type == bfd_link_hash_indirect 1241 || h->root.type == bfd_link_hash_warning) 1242 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1243 1244 cie->personality.h = h; 1245 per_binds_local = SYMBOL_REFERENCES_LOCAL (info, h); 1246 } 1247 else 1248 { 1249 Elf_Internal_Sym *sym; 1250 asection *sym_sec; 1251 1252 sym = &cookie->locsyms[r_symndx]; 1253 sym_sec = bfd_section_from_elf_index (abfd, sym->st_shndx); 1254 if (sym_sec == NULL) 1255 return cie_inf; 1256 1257 if (sym_sec->kept_section != NULL) 1258 sym_sec = sym_sec->kept_section; 1259 if (sym_sec->output_section == NULL) 1260 return cie_inf; 1261 1262 cie->local_personality = 1; 1263 cie->personality.sym.bfd_id = abfd->id; 1264 cie->personality.sym.index = r_symndx; 1265 per_binds_local = TRUE; 1266 } 1267 1268 if (per_binds_local 1269 && bfd_link_pic (info) 1270 && (cie->per_encoding & 0x70) == DW_EH_PE_absptr 1271 && (get_elf_backend_data (abfd) 1272 ->elf_backend_can_make_relative_eh_frame (abfd, info, sec))) 1273 { 1274 cie_inf->u.cie.make_per_encoding_relative = 1; 1275 cie_inf->u.cie.per_encoding_relative = 1; 1276 } 1277 } 1278 1279 /* See if we can merge this CIE with an earlier one. */ 1280 cie_compute_hash (cie); 1281 if (hdr_info->u.dwarf.cies == NULL) 1282 { 1283 hdr_info->u.dwarf.cies = htab_try_create (1, cie_hash, cie_eq, free); 1284 if (hdr_info->u.dwarf.cies == NULL) 1285 return cie_inf; 1286 } 1287 loc = htab_find_slot_with_hash (hdr_info->u.dwarf.cies, cie, 1288 cie->hash, INSERT); 1289 if (loc == NULL) 1290 return cie_inf; 1291 1292 new_cie = (struct cie *) *loc; 1293 if (new_cie == NULL) 1294 { 1295 /* Keep CIE_INF and record it in the hash table. */ 1296 new_cie = (struct cie *) malloc (sizeof (struct cie)); 1297 if (new_cie == NULL) 1298 return cie_inf; 1299 1300 memcpy (new_cie, cie, sizeof (struct cie)); 1301 *loc = new_cie; 1302 } 1303 else 1304 { 1305 /* Merge CIE_INF with NEW_CIE->CIE_INF. */ 1306 cie_inf->removed = 1; 1307 cie_inf->u.cie.merged = 1; 1308 cie_inf->u.cie.u.merged_with = new_cie->cie_inf; 1309 if (cie_inf->u.cie.make_lsda_relative) 1310 new_cie->cie_inf->u.cie.make_lsda_relative = 1; 1311 } 1312 return new_cie->cie_inf; 1313} 1314 1315/* This function is called for each input file before the .eh_frame 1316 section is relocated. It discards duplicate CIEs and FDEs for discarded 1317 functions. The function returns TRUE iff any entries have been 1318 deleted. */ 1319 1320bfd_boolean 1321_bfd_elf_discard_section_eh_frame 1322 (bfd *abfd, struct bfd_link_info *info, asection *sec, 1323 bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *), 1324 struct elf_reloc_cookie *cookie) 1325{ 1326 struct eh_cie_fde *ent; 1327 struct eh_frame_sec_info *sec_info; 1328 struct eh_frame_hdr_info *hdr_info; 1329 unsigned int ptr_size, offset; 1330 1331 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME) 1332 return FALSE; 1333 1334 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info; 1335 if (sec_info == NULL) 1336 return FALSE; 1337 1338 ptr_size = (get_elf_backend_data (sec->owner) 1339 ->elf_backend_eh_frame_address_size (sec->owner, sec)); 1340 1341 hdr_info = &elf_hash_table (info)->eh_info; 1342 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent) 1343 if (ent->size == 4) 1344 /* There should only be one zero terminator, on the last input 1345 file supplying .eh_frame (crtend.o). Remove any others. */ 1346 ent->removed = sec->map_head.s != NULL; 1347 else if (!ent->cie && ent->u.fde.cie_inf != NULL) 1348 { 1349 bfd_boolean keep; 1350 if ((sec->flags & SEC_LINKER_CREATED) != 0 && cookie->rels == NULL) 1351 { 1352 unsigned int width 1353 = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 1354 bfd_vma value 1355 = read_value (abfd, sec->contents + ent->offset + 8 + width, 1356 width, get_DW_EH_PE_signed (ent->fde_encoding)); 1357 keep = value != 0; 1358 } 1359 else 1360 { 1361 cookie->rel = cookie->rels + ent->reloc_index; 1362 /* FIXME: octets_per_byte. */ 1363 BFD_ASSERT (cookie->rel < cookie->relend 1364 && cookie->rel->r_offset == ent->offset + 8); 1365 keep = !(*reloc_symbol_deleted_p) (ent->offset + 8, cookie); 1366 } 1367 if (keep) 1368 { 1369 if (bfd_link_pic (info) 1370 && (((ent->fde_encoding & 0x70) == DW_EH_PE_absptr 1371 && ent->make_relative == 0) 1372 || (ent->fde_encoding & 0x70) == DW_EH_PE_aligned)) 1373 { 1374 static int num_warnings_issued = 0; 1375 1376 /* If a shared library uses absolute pointers 1377 which we cannot turn into PC relative, 1378 don't create the binary search table, 1379 since it is affected by runtime relocations. */ 1380 hdr_info->u.dwarf.table = FALSE; 1381 if (num_warnings_issued < 10) 1382 { 1383 (*info->callbacks->einfo) 1384 /* xgettext:c-format */ 1385 (_("%P: FDE encoding in %B(%A) prevents .eh_frame_hdr" 1386 " table being created.\n"), abfd, sec); 1387 num_warnings_issued ++; 1388 } 1389 else if (num_warnings_issued == 10) 1390 { 1391 (*info->callbacks->einfo) 1392 (_("%P: Further warnings about FDE encoding preventing .eh_frame_hdr generation dropped.\n")); 1393 num_warnings_issued ++; 1394 } 1395 } 1396 ent->removed = 0; 1397 hdr_info->u.dwarf.fde_count++; 1398 ent->u.fde.cie_inf = find_merged_cie (abfd, info, sec, hdr_info, 1399 cookie, ent->u.fde.cie_inf); 1400 } 1401 } 1402 1403 if (sec_info->cies) 1404 { 1405 free (sec_info->cies); 1406 sec_info->cies = NULL; 1407 } 1408 1409 offset = 0; 1410 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent) 1411 if (!ent->removed) 1412 { 1413 ent->new_offset = offset; 1414 offset += size_of_output_cie_fde (ent, ptr_size); 1415 } 1416 1417 sec->rawsize = sec->size; 1418 sec->size = offset; 1419 return offset != sec->rawsize; 1420} 1421 1422/* This function is called for .eh_frame_hdr section after 1423 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame 1424 input sections. It finalizes the size of .eh_frame_hdr section. */ 1425 1426bfd_boolean 1427_bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 1428{ 1429 struct elf_link_hash_table *htab; 1430 struct eh_frame_hdr_info *hdr_info; 1431 asection *sec; 1432 1433 htab = elf_hash_table (info); 1434 hdr_info = &htab->eh_info; 1435 1436 if (!hdr_info->frame_hdr_is_compact && hdr_info->u.dwarf.cies != NULL) 1437 { 1438 htab_delete (hdr_info->u.dwarf.cies); 1439 hdr_info->u.dwarf.cies = NULL; 1440 } 1441 1442 sec = hdr_info->hdr_sec; 1443 if (sec == NULL) 1444 return FALSE; 1445 1446 if (info->eh_frame_hdr_type == COMPACT_EH_HDR) 1447 { 1448 /* For compact frames we only add the header. The actual table comes 1449 from the .eh_frame_entry sections. */ 1450 sec->size = 8; 1451 } 1452 else 1453 { 1454 sec->size = EH_FRAME_HDR_SIZE; 1455 if (hdr_info->u.dwarf.table) 1456 sec->size += 4 + hdr_info->u.dwarf.fde_count * 8; 1457 } 1458 1459 elf_eh_frame_hdr (abfd) = sec; 1460 return TRUE; 1461} 1462 1463/* Return true if there is at least one non-empty .eh_frame section in 1464 input files. Can only be called after ld has mapped input to 1465 output sections, and before sections are stripped. */ 1466 1467bfd_boolean 1468_bfd_elf_eh_frame_present (struct bfd_link_info *info) 1469{ 1470 asection *eh = bfd_get_section_by_name (info->output_bfd, ".eh_frame"); 1471 1472 if (eh == NULL) 1473 return FALSE; 1474 1475 /* Count only sections which have at least a single CIE or FDE. 1476 There cannot be any CIE or FDE <= 8 bytes. */ 1477 for (eh = eh->map_head.s; eh != NULL; eh = eh->map_head.s) 1478 if (eh->size > 8) 1479 return TRUE; 1480 1481 return FALSE; 1482} 1483 1484/* Return true if there is at least one .eh_frame_entry section in 1485 input files. */ 1486 1487bfd_boolean 1488_bfd_elf_eh_frame_entry_present (struct bfd_link_info *info) 1489{ 1490 asection *o; 1491 bfd *abfd; 1492 1493 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next) 1494 { 1495 for (o = abfd->sections; o; o = o->next) 1496 { 1497 const char *name = bfd_get_section_name (abfd, o); 1498 1499 if (strcmp (name, ".eh_frame_entry") 1500 && !bfd_is_abs_section (o->output_section)) 1501 return TRUE; 1502 } 1503 } 1504 return FALSE; 1505} 1506 1507/* This function is called from size_dynamic_sections. 1508 It needs to decide whether .eh_frame_hdr should be output or not, 1509 because when the dynamic symbol table has been sized it is too late 1510 to strip sections. */ 1511 1512bfd_boolean 1513_bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info) 1514{ 1515 struct elf_link_hash_table *htab; 1516 struct eh_frame_hdr_info *hdr_info; 1517 struct bfd_link_hash_entry *bh = NULL; 1518 struct elf_link_hash_entry *h; 1519 1520 htab = elf_hash_table (info); 1521 hdr_info = &htab->eh_info; 1522 if (hdr_info->hdr_sec == NULL) 1523 return TRUE; 1524 1525 if (bfd_is_abs_section (hdr_info->hdr_sec->output_section) 1526 || info->eh_frame_hdr_type == 0 1527 || (info->eh_frame_hdr_type == DWARF2_EH_HDR 1528 && !_bfd_elf_eh_frame_present (info)) 1529 || (info->eh_frame_hdr_type == COMPACT_EH_HDR 1530 && !_bfd_elf_eh_frame_entry_present (info))) 1531 { 1532 hdr_info->hdr_sec->flags |= SEC_EXCLUDE; 1533 hdr_info->hdr_sec = NULL; 1534 return TRUE; 1535 } 1536 1537 /* Add a hidden symbol so that systems without access to PHDRs can 1538 find the table. */ 1539 if (! (_bfd_generic_link_add_one_symbol 1540 (info, info->output_bfd, "__GNU_EH_FRAME_HDR", BSF_LOCAL, 1541 hdr_info->hdr_sec, 0, NULL, FALSE, FALSE, &bh))) 1542 return FALSE; 1543 1544 h = (struct elf_link_hash_entry *) bh; 1545 h->def_regular = 1; 1546 h->other = STV_HIDDEN; 1547 get_elf_backend_data 1548 (info->output_bfd)->elf_backend_hide_symbol (info, h, TRUE); 1549 1550 if (!hdr_info->frame_hdr_is_compact) 1551 hdr_info->u.dwarf.table = TRUE; 1552 return TRUE; 1553} 1554 1555/* Adjust an address in the .eh_frame section. Given OFFSET within 1556 SEC, this returns the new offset in the adjusted .eh_frame section, 1557 or -1 if the address refers to a CIE/FDE which has been removed 1558 or to offset with dynamic relocation which is no longer needed. */ 1559 1560bfd_vma 1561_bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED, 1562 struct bfd_link_info *info ATTRIBUTE_UNUSED, 1563 asection *sec, 1564 bfd_vma offset) 1565{ 1566 struct eh_frame_sec_info *sec_info; 1567 unsigned int lo, hi, mid; 1568 1569 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME) 1570 return offset; 1571 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info; 1572 1573 if (offset >= sec->rawsize) 1574 return offset - sec->rawsize + sec->size; 1575 1576 lo = 0; 1577 hi = sec_info->count; 1578 mid = 0; 1579 while (lo < hi) 1580 { 1581 mid = (lo + hi) / 2; 1582 if (offset < sec_info->entry[mid].offset) 1583 hi = mid; 1584 else if (offset 1585 >= sec_info->entry[mid].offset + sec_info->entry[mid].size) 1586 lo = mid + 1; 1587 else 1588 break; 1589 } 1590 1591 BFD_ASSERT (lo < hi); 1592 1593 /* FDE or CIE was removed. */ 1594 if (sec_info->entry[mid].removed) 1595 return (bfd_vma) -1; 1596 1597 /* If converting personality pointers to DW_EH_PE_pcrel, there will be 1598 no need for run-time relocation against the personality field. */ 1599 if (sec_info->entry[mid].cie 1600 && sec_info->entry[mid].u.cie.make_per_encoding_relative 1601 && offset == (sec_info->entry[mid].offset + 8 1602 + sec_info->entry[mid].u.cie.personality_offset)) 1603 return (bfd_vma) -2; 1604 1605 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time 1606 relocation against FDE's initial_location field. */ 1607 if (!sec_info->entry[mid].cie 1608 && sec_info->entry[mid].make_relative 1609 && offset == sec_info->entry[mid].offset + 8) 1610 return (bfd_vma) -2; 1611 1612 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need 1613 for run-time relocation against LSDA field. */ 1614 if (!sec_info->entry[mid].cie 1615 && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative 1616 && offset == (sec_info->entry[mid].offset + 8 1617 + sec_info->entry[mid].lsda_offset)) 1618 return (bfd_vma) -2; 1619 1620 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time 1621 relocation against DW_CFA_set_loc's arguments. */ 1622 if (sec_info->entry[mid].set_loc 1623 && sec_info->entry[mid].make_relative 1624 && (offset >= sec_info->entry[mid].offset + 8 1625 + sec_info->entry[mid].set_loc[1])) 1626 { 1627 unsigned int cnt; 1628 1629 for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++) 1630 if (offset == sec_info->entry[mid].offset + 8 1631 + sec_info->entry[mid].set_loc[cnt]) 1632 return (bfd_vma) -2; 1633 } 1634 1635 /* Any new augmentation bytes go before the first relocation. */ 1636 return (offset + sec_info->entry[mid].new_offset 1637 - sec_info->entry[mid].offset 1638 + extra_augmentation_string_bytes (sec_info->entry + mid) 1639 + extra_augmentation_data_bytes (sec_info->entry + mid)); 1640} 1641 1642/* Write out .eh_frame_entry section. Add CANTUNWIND terminator if needed. 1643 Also check that the contents look sane. */ 1644 1645bfd_boolean 1646_bfd_elf_write_section_eh_frame_entry (bfd *abfd, struct bfd_link_info *info, 1647 asection *sec, bfd_byte *contents) 1648{ 1649 const struct elf_backend_data *bed; 1650 bfd_byte cantunwind[8]; 1651 bfd_vma addr; 1652 bfd_vma last_addr; 1653 bfd_vma offset; 1654 asection *text_sec = (asection *) elf_section_data (sec)->sec_info; 1655 1656 if (!sec->rawsize) 1657 sec->rawsize = sec->size; 1658 1659 BFD_ASSERT (sec->sec_info_type == SEC_INFO_TYPE_EH_FRAME_ENTRY); 1660 1661 /* Check to make sure that the text section corresponding to this eh_frame_entry 1662 section has not been excluded. In particular, mips16 stub entries will be 1663 excluded outside of the normal process. */ 1664 if (sec->flags & SEC_EXCLUDE 1665 || text_sec->flags & SEC_EXCLUDE) 1666 return TRUE; 1667 1668 if (!bfd_set_section_contents (abfd, sec->output_section, contents, 1669 sec->output_offset, sec->rawsize)) 1670 return FALSE; 1671 1672 last_addr = bfd_get_signed_32 (abfd, contents); 1673 /* Check that all the entries are in order. */ 1674 for (offset = 8; offset < sec->rawsize; offset += 8) 1675 { 1676 addr = bfd_get_signed_32 (abfd, contents + offset) + offset; 1677 if (addr <= last_addr) 1678 { 1679 /* xgettext:c-format */ 1680 _bfd_error_handler (_("%B: %s not in order"), sec->owner, sec->name); 1681 return FALSE; 1682 } 1683 1684 last_addr = addr; 1685 } 1686 1687 addr = text_sec->output_section->vma + text_sec->output_offset 1688 + text_sec->size; 1689 addr &= ~1; 1690 addr -= (sec->output_section->vma + sec->output_offset + sec->rawsize); 1691 if (addr & 1) 1692 { 1693 /* xgettext:c-format */ 1694 _bfd_error_handler (_("%B: %s invalid input section size"), 1695 sec->owner, sec->name); 1696 bfd_set_error (bfd_error_bad_value); 1697 return FALSE; 1698 } 1699 if (last_addr >= addr + sec->rawsize) 1700 { 1701 /* xgettext:c-format */ 1702 _bfd_error_handler (_("%B: %s points past end of text section"), 1703 sec->owner, sec->name); 1704 bfd_set_error (bfd_error_bad_value); 1705 return FALSE; 1706 } 1707 1708 if (sec->size == sec->rawsize) 1709 return TRUE; 1710 1711 bed = get_elf_backend_data (abfd); 1712 BFD_ASSERT (sec->size == sec->rawsize + 8); 1713 BFD_ASSERT ((addr & 1) == 0); 1714 BFD_ASSERT (bed->cant_unwind_opcode); 1715 1716 bfd_put_32 (abfd, addr, cantunwind); 1717 bfd_put_32 (abfd, (*bed->cant_unwind_opcode) (info), cantunwind + 4); 1718 return bfd_set_section_contents (abfd, sec->output_section, cantunwind, 1719 sec->output_offset + sec->rawsize, 8); 1720} 1721 1722/* Write out .eh_frame section. This is called with the relocated 1723 contents. */ 1724 1725bfd_boolean 1726_bfd_elf_write_section_eh_frame (bfd *abfd, 1727 struct bfd_link_info *info, 1728 asection *sec, 1729 bfd_byte *contents) 1730{ 1731 struct eh_frame_sec_info *sec_info; 1732 struct elf_link_hash_table *htab; 1733 struct eh_frame_hdr_info *hdr_info; 1734 unsigned int ptr_size; 1735 struct eh_cie_fde *ent; 1736 bfd_size_type sec_size; 1737 1738 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME) 1739 /* FIXME: octets_per_byte. */ 1740 return bfd_set_section_contents (abfd, sec->output_section, contents, 1741 sec->output_offset, sec->size); 1742 1743 ptr_size = (get_elf_backend_data (abfd) 1744 ->elf_backend_eh_frame_address_size (abfd, sec)); 1745 BFD_ASSERT (ptr_size != 0); 1746 1747 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info; 1748 htab = elf_hash_table (info); 1749 hdr_info = &htab->eh_info; 1750 1751 if (hdr_info->u.dwarf.table && hdr_info->u.dwarf.array == NULL) 1752 { 1753 hdr_info->frame_hdr_is_compact = FALSE; 1754 hdr_info->u.dwarf.array = (struct eh_frame_array_ent *) 1755 bfd_malloc (hdr_info->u.dwarf.fde_count 1756 * sizeof (*hdr_info->u.dwarf.array)); 1757 } 1758 if (hdr_info->u.dwarf.array == NULL) 1759 hdr_info = NULL; 1760 1761 /* The new offsets can be bigger or smaller than the original offsets. 1762 We therefore need to make two passes over the section: one backward 1763 pass to move entries up and one forward pass to move entries down. 1764 The two passes won't interfere with each other because entries are 1765 not reordered */ 1766 for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;) 1767 if (!ent->removed && ent->new_offset > ent->offset) 1768 memmove (contents + ent->new_offset, contents + ent->offset, ent->size); 1769 1770 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent) 1771 if (!ent->removed && ent->new_offset < ent->offset) 1772 memmove (contents + ent->new_offset, contents + ent->offset, ent->size); 1773 1774 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent) 1775 { 1776 unsigned char *buf, *end; 1777 unsigned int new_size; 1778 1779 if (ent->removed) 1780 continue; 1781 1782 if (ent->size == 4) 1783 { 1784 /* Any terminating FDE must be at the end of the section. */ 1785 BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1); 1786 continue; 1787 } 1788 1789 buf = contents + ent->new_offset; 1790 end = buf + ent->size; 1791 new_size = size_of_output_cie_fde (ent, ptr_size); 1792 1793 /* Update the size. It may be shrinked. */ 1794 bfd_put_32 (abfd, new_size - 4, buf); 1795 1796 /* Filling the extra bytes with DW_CFA_nops. */ 1797 if (new_size != ent->size) 1798 memset (end, 0, new_size - ent->size); 1799 1800 if (ent->cie) 1801 { 1802 /* CIE */ 1803 if (ent->make_relative 1804 || ent->u.cie.make_lsda_relative 1805 || ent->u.cie.per_encoding_relative) 1806 { 1807 char *aug; 1808 unsigned int action, extra_string, extra_data; 1809 unsigned int per_width, per_encoding; 1810 1811 /* Need to find 'R' or 'L' augmentation's argument and modify 1812 DW_EH_PE_* value. */ 1813 action = ((ent->make_relative ? 1 : 0) 1814 | (ent->u.cie.make_lsda_relative ? 2 : 0) 1815 | (ent->u.cie.per_encoding_relative ? 4 : 0)); 1816 extra_string = extra_augmentation_string_bytes (ent); 1817 extra_data = extra_augmentation_data_bytes (ent); 1818 1819 /* Skip length, id and version. */ 1820 buf += 9; 1821 aug = (char *) buf; 1822 buf += strlen (aug) + 1; 1823 skip_leb128 (&buf, end); 1824 skip_leb128 (&buf, end); 1825 skip_leb128 (&buf, end); 1826 if (*aug == 'z') 1827 { 1828 /* The uleb128 will always be a single byte for the kind 1829 of augmentation strings that we're prepared to handle. */ 1830 *buf++ += extra_data; 1831 aug++; 1832 } 1833 1834 /* Make room for the new augmentation string and data bytes. */ 1835 memmove (buf + extra_string + extra_data, buf, end - buf); 1836 memmove (aug + extra_string, aug, buf - (bfd_byte *) aug); 1837 buf += extra_string; 1838 end += extra_string + extra_data; 1839 1840 if (ent->add_augmentation_size) 1841 { 1842 *aug++ = 'z'; 1843 *buf++ = extra_data - 1; 1844 } 1845 if (ent->u.cie.add_fde_encoding) 1846 { 1847 BFD_ASSERT (action & 1); 1848 *aug++ = 'R'; 1849 *buf++ = make_pc_relative (DW_EH_PE_absptr, ptr_size); 1850 action &= ~1; 1851 } 1852 1853 while (action) 1854 switch (*aug++) 1855 { 1856 case 'L': 1857 if (action & 2) 1858 { 1859 BFD_ASSERT (*buf == ent->lsda_encoding); 1860 *buf = make_pc_relative (*buf, ptr_size); 1861 action &= ~2; 1862 } 1863 buf++; 1864 break; 1865 case 'P': 1866 if (ent->u.cie.make_per_encoding_relative) 1867 *buf = make_pc_relative (*buf, ptr_size); 1868 per_encoding = *buf++; 1869 per_width = get_DW_EH_PE_width (per_encoding, ptr_size); 1870 BFD_ASSERT (per_width != 0); 1871 BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel) 1872 == ent->u.cie.per_encoding_relative); 1873 if ((per_encoding & 0x70) == DW_EH_PE_aligned) 1874 buf = (contents 1875 + ((buf - contents + per_width - 1) 1876 & ~((bfd_size_type) per_width - 1))); 1877 if (action & 4) 1878 { 1879 bfd_vma val; 1880 1881 val = read_value (abfd, buf, per_width, 1882 get_DW_EH_PE_signed (per_encoding)); 1883 if (ent->u.cie.make_per_encoding_relative) 1884 val -= (sec->output_section->vma 1885 + sec->output_offset 1886 + (buf - contents)); 1887 else 1888 { 1889 val += (bfd_vma) ent->offset - ent->new_offset; 1890 val -= extra_string + extra_data; 1891 } 1892 write_value (abfd, buf, val, per_width); 1893 action &= ~4; 1894 } 1895 buf += per_width; 1896 break; 1897 case 'R': 1898 if (action & 1) 1899 { 1900 BFD_ASSERT (*buf == ent->fde_encoding); 1901 *buf = make_pc_relative (*buf, ptr_size); 1902 action &= ~1; 1903 } 1904 buf++; 1905 break; 1906 case 'S': 1907 break; 1908 default: 1909 BFD_FAIL (); 1910 } 1911 } 1912 } 1913 else 1914 { 1915 /* FDE */ 1916 bfd_vma value, address; 1917 unsigned int width; 1918 bfd_byte *start; 1919 struct eh_cie_fde *cie; 1920 1921 /* Skip length. */ 1922 cie = ent->u.fde.cie_inf; 1923 buf += 4; 1924 value = ((ent->new_offset + sec->output_offset + 4) 1925 - (cie->new_offset + cie->u.cie.u.sec->output_offset)); 1926 bfd_put_32 (abfd, value, buf); 1927 if (bfd_link_relocatable (info)) 1928 continue; 1929 buf += 4; 1930 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 1931 value = read_value (abfd, buf, width, 1932 get_DW_EH_PE_signed (ent->fde_encoding)); 1933 address = value; 1934 if (value) 1935 { 1936 switch (ent->fde_encoding & 0x70) 1937 { 1938 case DW_EH_PE_textrel: 1939 BFD_ASSERT (hdr_info == NULL); 1940 break; 1941 case DW_EH_PE_datarel: 1942 { 1943 switch (abfd->arch_info->arch) 1944 { 1945 case bfd_arch_ia64: 1946 BFD_ASSERT (elf_gp (abfd) != 0); 1947 address += elf_gp (abfd); 1948 break; 1949 default: 1950 (*info->callbacks->einfo) 1951 (_("%P: DW_EH_PE_datarel unspecified" 1952 " for this architecture.\n")); 1953 /* Fall thru */ 1954 case bfd_arch_frv: 1955 case bfd_arch_i386: 1956 BFD_ASSERT (htab->hgot != NULL 1957 && ((htab->hgot->root.type 1958 == bfd_link_hash_defined) 1959 || (htab->hgot->root.type 1960 == bfd_link_hash_defweak))); 1961 address 1962 += (htab->hgot->root.u.def.value 1963 + htab->hgot->root.u.def.section->output_offset 1964 + (htab->hgot->root.u.def.section->output_section 1965 ->vma)); 1966 break; 1967 } 1968 } 1969 break; 1970 case DW_EH_PE_pcrel: 1971 value += (bfd_vma) ent->offset - ent->new_offset; 1972 address += (sec->output_section->vma 1973 + sec->output_offset 1974 + ent->offset + 8); 1975 break; 1976 } 1977 if (ent->make_relative) 1978 value -= (sec->output_section->vma 1979 + sec->output_offset 1980 + ent->new_offset + 8); 1981 write_value (abfd, buf, value, width); 1982 } 1983 1984 start = buf; 1985 1986 if (hdr_info) 1987 { 1988 /* The address calculation may overflow, giving us a 1989 value greater than 4G on a 32-bit target when 1990 dwarf_vma is 64-bit. */ 1991 if (sizeof (address) > 4 && ptr_size == 4) 1992 address &= 0xffffffff; 1993 hdr_info->u.dwarf.array[hdr_info->array_count].initial_loc 1994 = address; 1995 hdr_info->u.dwarf.array[hdr_info->array_count].range 1996 = read_value (abfd, buf + width, width, FALSE); 1997 hdr_info->u.dwarf.array[hdr_info->array_count++].fde 1998 = (sec->output_section->vma 1999 + sec->output_offset 2000 + ent->new_offset); 2001 } 2002 2003 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel 2004 || cie->u.cie.make_lsda_relative) 2005 { 2006 buf += ent->lsda_offset; 2007 width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size); 2008 value = read_value (abfd, buf, width, 2009 get_DW_EH_PE_signed (ent->lsda_encoding)); 2010 if (value) 2011 { 2012 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel) 2013 value += (bfd_vma) ent->offset - ent->new_offset; 2014 else if (cie->u.cie.make_lsda_relative) 2015 value -= (sec->output_section->vma 2016 + sec->output_offset 2017 + ent->new_offset + 8 + ent->lsda_offset); 2018 write_value (abfd, buf, value, width); 2019 } 2020 } 2021 else if (ent->add_augmentation_size) 2022 { 2023 /* Skip the PC and length and insert a zero byte for the 2024 augmentation size. */ 2025 buf += width * 2; 2026 memmove (buf + 1, buf, end - buf); 2027 *buf = 0; 2028 } 2029 2030 if (ent->set_loc) 2031 { 2032 /* Adjust DW_CFA_set_loc. */ 2033 unsigned int cnt; 2034 bfd_vma new_offset; 2035 2036 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 2037 new_offset = ent->new_offset + 8 2038 + extra_augmentation_string_bytes (ent) 2039 + extra_augmentation_data_bytes (ent); 2040 2041 for (cnt = 1; cnt <= ent->set_loc[0]; cnt++) 2042 { 2043 buf = start + ent->set_loc[cnt]; 2044 2045 value = read_value (abfd, buf, width, 2046 get_DW_EH_PE_signed (ent->fde_encoding)); 2047 if (!value) 2048 continue; 2049 2050 if ((ent->fde_encoding & 0x70) == DW_EH_PE_pcrel) 2051 value += (bfd_vma) ent->offset + 8 - new_offset; 2052 if (ent->make_relative) 2053 value -= (sec->output_section->vma 2054 + sec->output_offset 2055 + new_offset + ent->set_loc[cnt]); 2056 write_value (abfd, buf, value, width); 2057 } 2058 } 2059 } 2060 } 2061 2062 /* We don't align the section to its section alignment since the 2063 runtime library only expects all CIE/FDE records aligned at 2064 the pointer size. _bfd_elf_discard_section_eh_frame should 2065 have padded CIE/FDE records to multiple of pointer size with 2066 size_of_output_cie_fde. */ 2067 sec_size = sec->size; 2068 if (sec_info->count != 0 2069 && sec_info->entry[sec_info->count - 1].size == 4) 2070 sec_size -= 4; 2071 if ((sec_size % ptr_size) != 0) 2072 abort (); 2073 2074 /* FIXME: octets_per_byte. */ 2075 return bfd_set_section_contents (abfd, sec->output_section, 2076 contents, (file_ptr) sec->output_offset, 2077 sec->size); 2078} 2079 2080/* Helper function used to sort .eh_frame_hdr search table by increasing 2081 VMA of FDE initial location. */ 2082 2083static int 2084vma_compare (const void *a, const void *b) 2085{ 2086 const struct eh_frame_array_ent *p = (const struct eh_frame_array_ent *) a; 2087 const struct eh_frame_array_ent *q = (const struct eh_frame_array_ent *) b; 2088 if (p->initial_loc > q->initial_loc) 2089 return 1; 2090 if (p->initial_loc < q->initial_loc) 2091 return -1; 2092 if (p->range > q->range) 2093 return 1; 2094 if (p->range < q->range) 2095 return -1; 2096 return 0; 2097} 2098 2099/* Reorder .eh_frame_entry sections to match the associated text sections. 2100 This routine is called during the final linking step, just before writing 2101 the contents. At this stage, sections in the eh_frame_hdr_info are already 2102 sorted in order of increasing text section address and so we simply need 2103 to make the .eh_frame_entrys follow that same order. Note that it is 2104 invalid for a linker script to try to force a particular order of 2105 .eh_frame_entry sections. */ 2106 2107bfd_boolean 2108_bfd_elf_fixup_eh_frame_hdr (struct bfd_link_info *info) 2109{ 2110 asection *sec = NULL; 2111 asection *osec; 2112 struct eh_frame_hdr_info *hdr_info; 2113 unsigned int i; 2114 bfd_vma offset; 2115 struct bfd_link_order *p; 2116 2117 hdr_info = &elf_hash_table (info)->eh_info; 2118 2119 if (hdr_info->hdr_sec == NULL 2120 || info->eh_frame_hdr_type != COMPACT_EH_HDR 2121 || hdr_info->array_count == 0) 2122 return TRUE; 2123 2124 /* Change section output offsets to be in text section order. */ 2125 offset = 8; 2126 osec = hdr_info->u.compact.entries[0]->output_section; 2127 for (i = 0; i < hdr_info->array_count; i++) 2128 { 2129 sec = hdr_info->u.compact.entries[i]; 2130 if (sec->output_section != osec) 2131 { 2132 _bfd_error_handler 2133 (_("Invalid output section for .eh_frame_entry: %s"), 2134 sec->output_section->name); 2135 return FALSE; 2136 } 2137 sec->output_offset = offset; 2138 offset += sec->size; 2139 } 2140 2141 2142 /* Fix the link_order to match. */ 2143 for (p = sec->output_section->map_head.link_order; p != NULL; p = p->next) 2144 { 2145 if (p->type != bfd_indirect_link_order) 2146 abort(); 2147 2148 p->offset = p->u.indirect.section->output_offset; 2149 if (p->next != NULL) 2150 i--; 2151 } 2152 2153 if (i != 0) 2154 { 2155 _bfd_error_handler 2156 (_("Invalid contents in %s section"), osec->name); 2157 return FALSE; 2158 } 2159 2160 return TRUE; 2161} 2162 2163/* The .eh_frame_hdr format for Compact EH frames: 2164 ubyte version (2) 2165 ubyte eh_ref_enc (DW_EH_PE_* encoding of typinfo references) 2166 uint32_t count (Number of entries in table) 2167 [array from .eh_frame_entry sections] */ 2168 2169static bfd_boolean 2170write_compact_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 2171{ 2172 struct elf_link_hash_table *htab; 2173 struct eh_frame_hdr_info *hdr_info; 2174 asection *sec; 2175 const struct elf_backend_data *bed; 2176 bfd_vma count; 2177 bfd_byte contents[8]; 2178 unsigned int i; 2179 2180 htab = elf_hash_table (info); 2181 hdr_info = &htab->eh_info; 2182 sec = hdr_info->hdr_sec; 2183 2184 if (sec->size != 8) 2185 abort(); 2186 2187 for (i = 0; i < sizeof (contents); i++) 2188 contents[i] = 0; 2189 2190 contents[0] = COMPACT_EH_HDR; 2191 bed = get_elf_backend_data (abfd); 2192 2193 BFD_ASSERT (bed->compact_eh_encoding); 2194 contents[1] = (*bed->compact_eh_encoding) (info); 2195 2196 count = (sec->output_section->size - 8) / 8; 2197 bfd_put_32 (abfd, count, contents + 4); 2198 return bfd_set_section_contents (abfd, sec->output_section, contents, 2199 (file_ptr) sec->output_offset, sec->size); 2200} 2201 2202/* The .eh_frame_hdr format for DWARF frames: 2203 2204 ubyte version (currently 1) 2205 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of 2206 .eh_frame section) 2207 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count 2208 number (or DW_EH_PE_omit if there is no 2209 binary search table computed)) 2210 ubyte table_enc (DW_EH_PE_* encoding of binary search table, 2211 or DW_EH_PE_omit if not present. 2212 DW_EH_PE_datarel is using address of 2213 .eh_frame_hdr section start as base) 2214 [encoded] eh_frame_ptr (pointer to start of .eh_frame section) 2215 optionally followed by: 2216 [encoded] fde_count (total number of FDEs in .eh_frame section) 2217 fde_count x [encoded] initial_loc, fde 2218 (array of encoded pairs containing 2219 FDE initial_location field and FDE address, 2220 sorted by increasing initial_loc). */ 2221 2222static bfd_boolean 2223write_dwarf_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 2224{ 2225 struct elf_link_hash_table *htab; 2226 struct eh_frame_hdr_info *hdr_info; 2227 asection *sec; 2228 bfd_boolean retval = TRUE; 2229 2230 htab = elf_hash_table (info); 2231 hdr_info = &htab->eh_info; 2232 sec = hdr_info->hdr_sec; 2233 bfd_byte *contents; 2234 asection *eh_frame_sec; 2235 bfd_size_type size; 2236 bfd_vma encoded_eh_frame; 2237 2238 size = EH_FRAME_HDR_SIZE; 2239 if (hdr_info->u.dwarf.array 2240 && hdr_info->array_count == hdr_info->u.dwarf.fde_count) 2241 size += 4 + hdr_info->u.dwarf.fde_count * 8; 2242 contents = (bfd_byte *) bfd_malloc (size); 2243 if (contents == NULL) 2244 return FALSE; 2245 2246 eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame"); 2247 if (eh_frame_sec == NULL) 2248 { 2249 free (contents); 2250 return FALSE; 2251 } 2252 2253 memset (contents, 0, EH_FRAME_HDR_SIZE); 2254 /* Version. */ 2255 contents[0] = 1; 2256 /* .eh_frame offset. */ 2257 contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address 2258 (abfd, info, eh_frame_sec, 0, sec, 4, &encoded_eh_frame); 2259 2260 if (hdr_info->u.dwarf.array 2261 && hdr_info->array_count == hdr_info->u.dwarf.fde_count) 2262 { 2263 /* FDE count encoding. */ 2264 contents[2] = DW_EH_PE_udata4; 2265 /* Search table encoding. */ 2266 contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; 2267 } 2268 else 2269 { 2270 contents[2] = DW_EH_PE_omit; 2271 contents[3] = DW_EH_PE_omit; 2272 } 2273 bfd_put_32 (abfd, encoded_eh_frame, contents + 4); 2274 2275 if (contents[2] != DW_EH_PE_omit) 2276 { 2277 unsigned int i; 2278 bfd_boolean overlap, overflow; 2279 2280 bfd_put_32 (abfd, hdr_info->u.dwarf.fde_count, 2281 contents + EH_FRAME_HDR_SIZE); 2282 qsort (hdr_info->u.dwarf.array, hdr_info->u.dwarf.fde_count, 2283 sizeof (*hdr_info->u.dwarf.array), vma_compare); 2284 overlap = FALSE; 2285 overflow = FALSE; 2286 for (i = 0; i < hdr_info->u.dwarf.fde_count; i++) 2287 { 2288 bfd_vma val; 2289 2290 val = hdr_info->u.dwarf.array[i].initial_loc 2291 - sec->output_section->vma; 2292 val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000; 2293 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 2294 && (hdr_info->u.dwarf.array[i].initial_loc 2295 != sec->output_section->vma + val)) 2296 overflow = TRUE; 2297 bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 4); 2298 val = hdr_info->u.dwarf.array[i].fde - sec->output_section->vma; 2299 val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000; 2300 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 2301 && (hdr_info->u.dwarf.array[i].fde 2302 != sec->output_section->vma + val)) 2303 overflow = TRUE; 2304 bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 8); 2305 if (i != 0 2306 && (hdr_info->u.dwarf.array[i].initial_loc 2307 < (hdr_info->u.dwarf.array[i - 1].initial_loc 2308 + hdr_info->u.dwarf.array[i - 1].range))) 2309 overlap = TRUE; 2310 } 2311 if (overflow) 2312 (*info->callbacks->einfo) (_("%P: .eh_frame_hdr entry overflow.\n")); 2313 if (overlap) 2314 (*info->callbacks->einfo) 2315 (_("%P: .eh_frame_hdr refers to overlapping FDEs.\n")); 2316 if (overflow || overlap) 2317 { 2318 bfd_set_error (bfd_error_bad_value); 2319 retval = FALSE; 2320 } 2321 } 2322 2323 /* FIXME: octets_per_byte. */ 2324 if (!bfd_set_section_contents (abfd, sec->output_section, contents, 2325 (file_ptr) sec->output_offset, 2326 sec->size)) 2327 retval = FALSE; 2328 free (contents); 2329 2330 if (hdr_info->u.dwarf.array != NULL) 2331 free (hdr_info->u.dwarf.array); 2332 return retval; 2333} 2334 2335/* Write out .eh_frame_hdr section. This must be called after 2336 _bfd_elf_write_section_eh_frame has been called on all input 2337 .eh_frame sections. */ 2338 2339bfd_boolean 2340_bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 2341{ 2342 struct elf_link_hash_table *htab; 2343 struct eh_frame_hdr_info *hdr_info; 2344 asection *sec; 2345 2346 htab = elf_hash_table (info); 2347 hdr_info = &htab->eh_info; 2348 sec = hdr_info->hdr_sec; 2349 2350 if (info->eh_frame_hdr_type == 0 || sec == NULL) 2351 return TRUE; 2352 2353 if (info->eh_frame_hdr_type == COMPACT_EH_HDR) 2354 return write_compact_eh_frame_hdr (abfd, info); 2355 else 2356 return write_dwarf_eh_frame_hdr (abfd, info); 2357} 2358 2359/* Return the width of FDE addresses. This is the default implementation. */ 2360 2361unsigned int 2362_bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED) 2363{ 2364 return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4; 2365} 2366 2367/* Decide whether we can use a PC-relative encoding within the given 2368 EH frame section. This is the default implementation. */ 2369 2370bfd_boolean 2371_bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED, 2372 struct bfd_link_info *info ATTRIBUTE_UNUSED, 2373 asection *eh_frame_section ATTRIBUTE_UNUSED) 2374{ 2375 return TRUE; 2376} 2377 2378/* Select an encoding for the given address. Preference is given to 2379 PC-relative addressing modes. */ 2380 2381bfd_byte 2382_bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED, 2383 struct bfd_link_info *info ATTRIBUTE_UNUSED, 2384 asection *osec, bfd_vma offset, 2385 asection *loc_sec, bfd_vma loc_offset, 2386 bfd_vma *encoded) 2387{ 2388 *encoded = osec->vma + offset - 2389 (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset); 2390 return DW_EH_PE_pcrel | DW_EH_PE_sdata4; 2391} 2392