1/* .eh_frame section optimization. 2 Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007 3 Free Software Foundation, Inc. 4 Written by Jakub Jelinek <jakub@redhat.com>. 5 6 This file is part of BFD, the Binary File Descriptor library. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 21 22#include "sysdep.h" 23#include "bfd.h" 24#include "libbfd.h" 25#include "elf-bfd.h" 26#include "elf/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 bfd_vma val; 44 } personality; 45 asection *output_sec; 46 struct eh_cie_fde *cie_inf; 47 unsigned char per_encoding; 48 unsigned char lsda_encoding; 49 unsigned char fde_encoding; 50 unsigned char initial_insn_length; 51 unsigned char make_relative; 52 unsigned char make_lsda_relative; 53 unsigned char initial_instructions[50]; 54}; 55 56 57 58/* If *ITER hasn't reached END yet, read the next byte into *RESULT and 59 move onto the next byte. Return true on success. */ 60 61static inline bfd_boolean 62read_byte (bfd_byte **iter, bfd_byte *end, unsigned char *result) 63{ 64 if (*iter >= end) 65 return FALSE; 66 *result = *((*iter)++); 67 return TRUE; 68} 69 70/* Move *ITER over LENGTH bytes, or up to END, whichever is closer. 71 Return true it was possible to move LENGTH bytes. */ 72 73static inline bfd_boolean 74skip_bytes (bfd_byte **iter, bfd_byte *end, bfd_size_type length) 75{ 76 if ((bfd_size_type) (end - *iter) < length) 77 { 78 *iter = end; 79 return FALSE; 80 } 81 *iter += length; 82 return TRUE; 83} 84 85/* Move *ITER over an leb128, stopping at END. Return true if the end 86 of the leb128 was found. */ 87 88static bfd_boolean 89skip_leb128 (bfd_byte **iter, bfd_byte *end) 90{ 91 unsigned char byte; 92 do 93 if (!read_byte (iter, end, &byte)) 94 return FALSE; 95 while (byte & 0x80); 96 return TRUE; 97} 98 99/* Like skip_leb128, but treat the leb128 as an unsigned value and 100 store it in *VALUE. */ 101 102static bfd_boolean 103read_uleb128 (bfd_byte **iter, bfd_byte *end, bfd_vma *value) 104{ 105 bfd_byte *start, *p; 106 107 start = *iter; 108 if (!skip_leb128 (iter, end)) 109 return FALSE; 110 111 p = *iter; 112 *value = *--p; 113 while (p > start) 114 *value = (*value << 7) | (*--p & 0x7f); 115 116 return TRUE; 117} 118 119/* Like read_uleb128, but for signed values. */ 120 121static bfd_boolean 122read_sleb128 (bfd_byte **iter, bfd_byte *end, bfd_signed_vma *value) 123{ 124 bfd_byte *start, *p; 125 126 start = *iter; 127 if (!skip_leb128 (iter, end)) 128 return FALSE; 129 130 p = *iter; 131 *value = ((*--p & 0x7f) ^ 0x40) - 0x40; 132 while (p > start) 133 *value = (*value << 7) | (*--p & 0x7f); 134 135 return TRUE; 136} 137 138/* Return 0 if either encoding is variable width, or not yet known to bfd. */ 139 140static 141int get_DW_EH_PE_width (int encoding, int ptr_size) 142{ 143 /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame 144 was added to bfd. */ 145 if ((encoding & 0x60) == 0x60) 146 return 0; 147 148 switch (encoding & 7) 149 { 150 case DW_EH_PE_udata2: return 2; 151 case DW_EH_PE_udata4: return 4; 152 case DW_EH_PE_udata8: return 8; 153 case DW_EH_PE_absptr: return ptr_size; 154 default: 155 break; 156 } 157 158 return 0; 159} 160 161#define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0) 162 163/* Read a width sized value from memory. */ 164 165static bfd_vma 166read_value (bfd *abfd, bfd_byte *buf, int width, int is_signed) 167{ 168 bfd_vma value; 169 170 switch (width) 171 { 172 case 2: 173 if (is_signed) 174 value = bfd_get_signed_16 (abfd, buf); 175 else 176 value = bfd_get_16 (abfd, buf); 177 break; 178 case 4: 179 if (is_signed) 180 value = bfd_get_signed_32 (abfd, buf); 181 else 182 value = bfd_get_32 (abfd, buf); 183 break; 184 case 8: 185 if (is_signed) 186 value = bfd_get_signed_64 (abfd, buf); 187 else 188 value = bfd_get_64 (abfd, buf); 189 break; 190 default: 191 BFD_FAIL (); 192 return 0; 193 } 194 195 return value; 196} 197 198/* Store a width sized value to memory. */ 199 200static void 201write_value (bfd *abfd, bfd_byte *buf, bfd_vma value, int width) 202{ 203 switch (width) 204 { 205 case 2: bfd_put_16 (abfd, value, buf); break; 206 case 4: bfd_put_32 (abfd, value, buf); break; 207 case 8: bfd_put_64 (abfd, value, buf); break; 208 default: BFD_FAIL (); 209 } 210} 211 212/* Return one if C1 and C2 CIEs can be merged. */ 213 214static int 215cie_eq (const void *e1, const void *e2) 216{ 217 const struct cie *c1 = e1; 218 const struct cie *c2 = e2; 219 220 if (c1->hash == c2->hash 221 && c1->length == c2->length 222 && c1->version == c2->version 223 && c1->local_personality == c2->local_personality 224 && strcmp (c1->augmentation, c2->augmentation) == 0 225 && strcmp (c1->augmentation, "eh") != 0 226 && c1->code_align == c2->code_align 227 && c1->data_align == c2->data_align 228 && c1->ra_column == c2->ra_column 229 && c1->augmentation_size == c2->augmentation_size 230 && memcmp (&c1->personality, &c2->personality, 231 sizeof (c1->personality)) == 0 232 && c1->output_sec == c2->output_sec 233 && c1->per_encoding == c2->per_encoding 234 && c1->lsda_encoding == c2->lsda_encoding 235 && c1->fde_encoding == c2->fde_encoding 236 && c1->initial_insn_length == c2->initial_insn_length 237 && memcmp (c1->initial_instructions, 238 c2->initial_instructions, 239 c1->initial_insn_length) == 0) 240 return 1; 241 242 return 0; 243} 244 245static hashval_t 246cie_hash (const void *e) 247{ 248 const struct cie *c = e; 249 return c->hash; 250} 251 252static hashval_t 253cie_compute_hash (struct cie *c) 254{ 255 hashval_t h = 0; 256 h = iterative_hash_object (c->length, h); 257 h = iterative_hash_object (c->version, h); 258 h = iterative_hash (c->augmentation, strlen (c->augmentation) + 1, h); 259 h = iterative_hash_object (c->code_align, h); 260 h = iterative_hash_object (c->data_align, h); 261 h = iterative_hash_object (c->ra_column, h); 262 h = iterative_hash_object (c->augmentation_size, h); 263 h = iterative_hash_object (c->personality, h); 264 h = iterative_hash_object (c->output_sec, h); 265 h = iterative_hash_object (c->per_encoding, h); 266 h = iterative_hash_object (c->lsda_encoding, h); 267 h = iterative_hash_object (c->fde_encoding, h); 268 h = iterative_hash_object (c->initial_insn_length, h); 269 h = iterative_hash (c->initial_instructions, c->initial_insn_length, h); 270 c->hash = h; 271 return h; 272} 273 274/* Return the number of extra bytes that we'll be inserting into 275 ENTRY's augmentation string. */ 276 277static INLINE unsigned int 278extra_augmentation_string_bytes (struct eh_cie_fde *entry) 279{ 280 unsigned int size = 0; 281 if (entry->cie) 282 { 283 if (entry->add_augmentation_size) 284 size++; 285 if (entry->add_fde_encoding) 286 size++; 287 } 288 return size; 289} 290 291/* Likewise ENTRY's augmentation data. */ 292 293static INLINE unsigned int 294extra_augmentation_data_bytes (struct eh_cie_fde *entry) 295{ 296 unsigned int size = 0; 297 if (entry->cie) 298 { 299 if (entry->add_augmentation_size) 300 size++; 301 if (entry->add_fde_encoding) 302 size++; 303 } 304 else 305 { 306 if (entry->cie_inf->add_augmentation_size) 307 size++; 308 } 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/* This function is called for each input file before the .eh_frame 434 section is relocated. It discards duplicate CIEs and FDEs for discarded 435 functions. The function returns TRUE iff any entries have been 436 deleted. */ 437 438bfd_boolean 439_bfd_elf_discard_section_eh_frame 440 (bfd *abfd, struct bfd_link_info *info, asection *sec, 441 bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *), 442 struct elf_reloc_cookie *cookie) 443{ 444#define REQUIRE(COND) \ 445 do \ 446 if (!(COND)) \ 447 goto free_no_table; \ 448 while (0) 449 450 bfd_byte *ehbuf = NULL, *buf; 451 bfd_byte *last_fde; 452 struct eh_cie_fde *ent, *this_inf; 453 unsigned int hdr_length, hdr_id; 454 struct extended_cie 455 { 456 struct cie cie; 457 unsigned int offset; 458 unsigned int usage_count; 459 unsigned int entry; 460 } *ecies = NULL, *ecie; 461 unsigned int ecie_count = 0, ecie_alloced = 0; 462 struct cie *cie; 463 struct elf_link_hash_table *htab; 464 struct eh_frame_hdr_info *hdr_info; 465 struct eh_frame_sec_info *sec_info = NULL; 466 unsigned int offset; 467 unsigned int ptr_size; 468 unsigned int entry_alloced; 469 470 if (sec->size == 0) 471 { 472 /* This file does not contain .eh_frame information. */ 473 return FALSE; 474 } 475 476 if (bfd_is_abs_section (sec->output_section)) 477 { 478 /* At least one of the sections is being discarded from the 479 link, so we should just ignore them. */ 480 return FALSE; 481 } 482 483 htab = elf_hash_table (info); 484 hdr_info = &htab->eh_info; 485 486 if (hdr_info->cies == NULL && !info->relocatable) 487 hdr_info->cies = htab_try_create (1, cie_hash, cie_eq, free); 488 489 /* Read the frame unwind information from abfd. */ 490 491 REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf)); 492 493 if (sec->size >= 4 494 && bfd_get_32 (abfd, ehbuf) == 0 495 && cookie->rel == cookie->relend) 496 { 497 /* Empty .eh_frame section. */ 498 free (ehbuf); 499 return FALSE; 500 } 501 502 /* If .eh_frame section size doesn't fit into int, we cannot handle 503 it (it would need to use 64-bit .eh_frame format anyway). */ 504 REQUIRE (sec->size == (unsigned int) sec->size); 505 506 ptr_size = (get_elf_backend_data (abfd) 507 ->elf_backend_eh_frame_address_size (abfd, sec)); 508 REQUIRE (ptr_size != 0); 509 510 buf = ehbuf; 511 sec_info = bfd_zmalloc (sizeof (struct eh_frame_sec_info) 512 + 99 * sizeof (struct eh_cie_fde)); 513 REQUIRE (sec_info); 514 515 entry_alloced = 100; 516 517#define ENSURE_NO_RELOCS(buf) \ 518 REQUIRE (!(cookie->rel < cookie->relend \ 519 && (cookie->rel->r_offset \ 520 < (bfd_size_type) ((buf) - ehbuf)) \ 521 && cookie->rel->r_info != 0)) 522 523#define SKIP_RELOCS(buf) \ 524 while (cookie->rel < cookie->relend \ 525 && (cookie->rel->r_offset \ 526 < (bfd_size_type) ((buf) - ehbuf))) \ 527 cookie->rel++ 528 529#define GET_RELOC(buf) \ 530 ((cookie->rel < cookie->relend \ 531 && (cookie->rel->r_offset \ 532 == (bfd_size_type) ((buf) - ehbuf))) \ 533 ? cookie->rel : NULL) 534 535 for (;;) 536 { 537 char *aug; 538 bfd_byte *start, *end, *insns, *insns_end; 539 bfd_size_type length; 540 unsigned int set_loc_count; 541 542 if (sec_info->count == entry_alloced) 543 { 544 sec_info = bfd_realloc (sec_info, 545 sizeof (struct eh_frame_sec_info) 546 + ((entry_alloced + 99) 547 * sizeof (struct eh_cie_fde))); 548 REQUIRE (sec_info); 549 550 memset (&sec_info->entry[entry_alloced], 0, 551 100 * sizeof (struct eh_cie_fde)); 552 entry_alloced += 100; 553 } 554 555 this_inf = sec_info->entry + sec_info->count; 556 last_fde = buf; 557 558 if ((bfd_size_type) (buf - ehbuf) == sec->size) 559 break; 560 561 /* Read the length of the entry. */ 562 REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4)); 563 hdr_length = bfd_get_32 (abfd, buf - 4); 564 565 /* 64-bit .eh_frame is not supported. */ 566 REQUIRE (hdr_length != 0xffffffff); 567 568 /* The CIE/FDE must be fully contained in this input section. */ 569 REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size); 570 end = buf + hdr_length; 571 572 this_inf->offset = last_fde - ehbuf; 573 this_inf->size = 4 + hdr_length; 574 575 if (hdr_length == 0) 576 { 577 /* A zero-length CIE should only be found at the end of 578 the section. */ 579 REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size); 580 ENSURE_NO_RELOCS (buf); 581 sec_info->count++; 582 break; 583 } 584 585 REQUIRE (skip_bytes (&buf, end, 4)); 586 hdr_id = bfd_get_32 (abfd, buf - 4); 587 588 if (hdr_id == 0) 589 { 590 unsigned int initial_insn_length; 591 592 /* CIE */ 593 this_inf->cie = 1; 594 595 if (ecie_count == ecie_alloced) 596 { 597 ecies = bfd_realloc (ecies, 598 (ecie_alloced + 20) * sizeof (*ecies)); 599 REQUIRE (ecies); 600 memset (&ecies[ecie_alloced], 0, 20 * sizeof (*ecies)); 601 ecie_alloced += 20; 602 } 603 604 cie = &ecies[ecie_count].cie; 605 ecies[ecie_count].offset = this_inf->offset; 606 ecies[ecie_count++].entry = sec_info->count; 607 cie->length = hdr_length; 608 start = buf; 609 REQUIRE (read_byte (&buf, end, &cie->version)); 610 611 /* Cannot handle unknown versions. */ 612 REQUIRE (cie->version == 1 || cie->version == 3); 613 REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation)); 614 615 strcpy (cie->augmentation, (char *) buf); 616 buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1; 617 ENSURE_NO_RELOCS (buf); 618 if (buf[0] == 'e' && buf[1] == 'h') 619 { 620 /* GCC < 3.0 .eh_frame CIE */ 621 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__ 622 is private to each CIE, so we don't need it for anything. 623 Just skip it. */ 624 REQUIRE (skip_bytes (&buf, end, ptr_size)); 625 SKIP_RELOCS (buf); 626 } 627 REQUIRE (read_uleb128 (&buf, end, &cie->code_align)); 628 REQUIRE (read_sleb128 (&buf, end, &cie->data_align)); 629 if (cie->version == 1) 630 { 631 REQUIRE (buf < end); 632 cie->ra_column = *buf++; 633 } 634 else 635 REQUIRE (read_uleb128 (&buf, end, &cie->ra_column)); 636 ENSURE_NO_RELOCS (buf); 637 cie->lsda_encoding = DW_EH_PE_omit; 638 cie->fde_encoding = DW_EH_PE_omit; 639 cie->per_encoding = DW_EH_PE_omit; 640 aug = cie->augmentation; 641 if (aug[0] != 'e' || aug[1] != 'h') 642 { 643 if (*aug == 'z') 644 { 645 aug++; 646 REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size)); 647 ENSURE_NO_RELOCS (buf); 648 } 649 650 while (*aug != '\0') 651 switch (*aug++) 652 { 653 case 'L': 654 REQUIRE (read_byte (&buf, end, &cie->lsda_encoding)); 655 ENSURE_NO_RELOCS (buf); 656 REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size)); 657 break; 658 case 'R': 659 REQUIRE (read_byte (&buf, end, &cie->fde_encoding)); 660 ENSURE_NO_RELOCS (buf); 661 REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size)); 662 break; 663 case 'S': 664 break; 665 case 'P': 666 { 667 int per_width; 668 669 REQUIRE (read_byte (&buf, end, &cie->per_encoding)); 670 per_width = get_DW_EH_PE_width (cie->per_encoding, 671 ptr_size); 672 REQUIRE (per_width); 673 if ((cie->per_encoding & 0xf0) == DW_EH_PE_aligned) 674 { 675 length = -(buf - ehbuf) & (per_width - 1); 676 REQUIRE (skip_bytes (&buf, end, length)); 677 } 678 ENSURE_NO_RELOCS (buf); 679 /* Ensure we have a reloc here. */ 680 if (GET_RELOC (buf) != NULL) 681 { 682 unsigned long r_symndx; 683 684#ifdef BFD64 685 if (ptr_size == 8) 686 r_symndx = ELF64_R_SYM (cookie->rel->r_info); 687 else 688#endif 689 r_symndx = ELF32_R_SYM (cookie->rel->r_info); 690 if (r_symndx >= cookie->locsymcount 691 || ELF_ST_BIND (cookie->locsyms[r_symndx] 692 .st_info) != STB_LOCAL) 693 { 694 struct elf_link_hash_entry *h; 695 696 r_symndx -= cookie->extsymoff; 697 h = cookie->sym_hashes[r_symndx]; 698 699 while (h->root.type == bfd_link_hash_indirect 700 || h->root.type == bfd_link_hash_warning) 701 h = (struct elf_link_hash_entry *) 702 h->root.u.i.link; 703 704 cie->personality.h = h; 705 } 706 else 707 { 708 Elf_Internal_Sym *sym; 709 asection *sym_sec; 710 bfd_vma val; 711 712 sym = &cookie->locsyms[r_symndx]; 713 sym_sec = (bfd_section_from_elf_index 714 (abfd, sym->st_shndx)); 715 if (sym_sec != NULL) 716 { 717 if (sym_sec->kept_section != NULL) 718 sym_sec = sym_sec->kept_section; 719 if (sym_sec->output_section != NULL) 720 { 721 val = (sym->st_value 722 + sym_sec->output_offset 723 + sym_sec->output_section->vma); 724 cie->personality.val = val; 725 cie->local_personality = 1; 726 } 727 } 728 } 729 730 /* Cope with MIPS-style composite relocations. */ 731 do 732 cookie->rel++; 733 while (GET_RELOC (buf) != NULL); 734 } 735 REQUIRE (skip_bytes (&buf, end, per_width)); 736 REQUIRE (cie->local_personality || cie->personality.h); 737 } 738 break; 739 default: 740 /* Unrecognized augmentation. Better bail out. */ 741 goto free_no_table; 742 } 743 } 744 745 /* For shared libraries, try to get rid of as many RELATIVE relocs 746 as possible. */ 747 if (info->shared 748 && (get_elf_backend_data (abfd) 749 ->elf_backend_can_make_relative_eh_frame 750 (abfd, info, sec))) 751 { 752 if ((cie->fde_encoding & 0xf0) == DW_EH_PE_absptr) 753 cie->make_relative = 1; 754 /* If the CIE doesn't already have an 'R' entry, it's fairly 755 easy to add one, provided that there's no aligned data 756 after the augmentation string. */ 757 else if (cie->fde_encoding == DW_EH_PE_omit 758 && (cie->per_encoding & 0xf0) != DW_EH_PE_aligned) 759 { 760 if (*cie->augmentation == 0) 761 this_inf->add_augmentation_size = 1; 762 this_inf->add_fde_encoding = 1; 763 cie->make_relative = 1; 764 } 765 } 766 767 if (info->shared 768 && (get_elf_backend_data (abfd) 769 ->elf_backend_can_make_lsda_relative_eh_frame 770 (abfd, info, sec)) 771 && (cie->lsda_encoding & 0xf0) == DW_EH_PE_absptr) 772 cie->make_lsda_relative = 1; 773 774 /* If FDE encoding was not specified, it defaults to 775 DW_EH_absptr. */ 776 if (cie->fde_encoding == DW_EH_PE_omit) 777 cie->fde_encoding = DW_EH_PE_absptr; 778 779 initial_insn_length = end - buf; 780 if (initial_insn_length <= sizeof (cie->initial_instructions)) 781 { 782 cie->initial_insn_length = initial_insn_length; 783 memcpy (cie->initial_instructions, buf, initial_insn_length); 784 } 785 insns = buf; 786 buf += initial_insn_length; 787 ENSURE_NO_RELOCS (buf); 788 } 789 else 790 { 791 /* Find the corresponding CIE. */ 792 unsigned int cie_offset = this_inf->offset + 4 - hdr_id; 793 for (ecie = ecies; ecie < ecies + ecie_count; ++ecie) 794 if (cie_offset == ecie->offset) 795 break; 796 797 /* Ensure this FDE references one of the CIEs in this input 798 section. */ 799 REQUIRE (ecie != ecies + ecie_count); 800 cie = &ecie->cie; 801 802 ENSURE_NO_RELOCS (buf); 803 REQUIRE (GET_RELOC (buf)); 804 805 if ((*reloc_symbol_deleted_p) (buf - ehbuf, cookie)) 806 /* This is a FDE against a discarded section. It should 807 be deleted. */ 808 this_inf->removed = 1; 809 else 810 { 811 if (info->shared 812 && (((cie->fde_encoding & 0xf0) == DW_EH_PE_absptr 813 && cie->make_relative == 0) 814 || (cie->fde_encoding & 0xf0) == DW_EH_PE_aligned)) 815 { 816 /* If a shared library uses absolute pointers 817 which we cannot turn into PC relative, 818 don't create the binary search table, 819 since it is affected by runtime relocations. */ 820 hdr_info->table = FALSE; 821 (*info->callbacks->einfo) 822 (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr" 823 " table being created.\n"), abfd, sec); 824 } 825 ecie->usage_count++; 826 hdr_info->fde_count++; 827 this_inf->cie_inf = (void *) (ecie - ecies); 828 } 829 830 /* Skip the initial location and address range. */ 831 start = buf; 832 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size); 833 REQUIRE (skip_bytes (&buf, end, 2 * length)); 834 835 /* Skip the augmentation size, if present. */ 836 if (cie->augmentation[0] == 'z') 837 REQUIRE (read_uleb128 (&buf, end, &length)); 838 else 839 length = 0; 840 841 /* Of the supported augmentation characters above, only 'L' 842 adds augmentation data to the FDE. This code would need to 843 be adjusted if any future augmentations do the same thing. */ 844 if (cie->lsda_encoding != DW_EH_PE_omit) 845 { 846 this_inf->lsda_offset = buf - start; 847 /* If there's no 'z' augmentation, we don't know where the 848 CFA insns begin. Assume no padding. */ 849 if (cie->augmentation[0] != 'z') 850 length = end - buf; 851 } 852 853 /* Skip over the augmentation data. */ 854 REQUIRE (skip_bytes (&buf, end, length)); 855 insns = buf; 856 857 buf = last_fde + 4 + hdr_length; 858 SKIP_RELOCS (buf); 859 } 860 861 /* Try to interpret the CFA instructions and find the first 862 padding nop. Shrink this_inf's size so that it doesn't 863 include the padding. */ 864 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size); 865 set_loc_count = 0; 866 insns_end = skip_non_nops (insns, end, length, &set_loc_count); 867 /* If we don't understand the CFA instructions, we can't know 868 what needs to be adjusted there. */ 869 if (insns_end == NULL 870 /* For the time being we don't support DW_CFA_set_loc in 871 CIE instructions. */ 872 || (set_loc_count && this_inf->cie)) 873 goto free_no_table; 874 this_inf->size -= end - insns_end; 875 if (insns_end != end && this_inf->cie) 876 { 877 cie->initial_insn_length -= end - insns_end; 878 cie->length -= end - insns_end; 879 } 880 if (set_loc_count 881 && ((cie->fde_encoding & 0xf0) == DW_EH_PE_pcrel 882 || cie->make_relative)) 883 { 884 unsigned int cnt; 885 bfd_byte *p; 886 887 this_inf->set_loc = bfd_malloc ((set_loc_count + 1) 888 * sizeof (unsigned int)); 889 REQUIRE (this_inf->set_loc); 890 this_inf->set_loc[0] = set_loc_count; 891 p = insns; 892 cnt = 0; 893 while (p < end) 894 { 895 if (*p == DW_CFA_set_loc) 896 this_inf->set_loc[++cnt] = p + 1 - start; 897 REQUIRE (skip_cfa_op (&p, end, length)); 898 } 899 } 900 901 this_inf->fde_encoding = cie->fde_encoding; 902 this_inf->lsda_encoding = cie->lsda_encoding; 903 sec_info->count++; 904 } 905 906 elf_section_data (sec)->sec_info = sec_info; 907 sec->sec_info_type = ELF_INFO_TYPE_EH_FRAME; 908 909 /* Look at all CIEs in this section and determine which can be 910 removed as unused, which can be merged with previous duplicate 911 CIEs and which need to be kept. */ 912 for (ecie = ecies; ecie < ecies + ecie_count; ++ecie) 913 { 914 if (ecie->usage_count == 0) 915 { 916 sec_info->entry[ecie->entry].removed = 1; 917 continue; 918 } 919 ecie->cie.output_sec = sec->output_section; 920 ecie->cie.cie_inf = sec_info->entry + ecie->entry; 921 cie_compute_hash (&ecie->cie); 922 if (hdr_info->cies != NULL) 923 { 924 void **loc = htab_find_slot_with_hash (hdr_info->cies, &ecie->cie, 925 ecie->cie.hash, INSERT); 926 if (loc != NULL) 927 { 928 if (*loc != HTAB_EMPTY_ENTRY) 929 { 930 sec_info->entry[ecie->entry].removed = 1; 931 ecie->cie.cie_inf = ((struct cie *) *loc)->cie_inf; 932 continue; 933 } 934 935 *loc = malloc (sizeof (struct cie)); 936 if (*loc == NULL) 937 *loc = HTAB_DELETED_ENTRY; 938 else 939 memcpy (*loc, &ecie->cie, sizeof (struct cie)); 940 } 941 } 942 ecie->cie.cie_inf->make_relative = ecie->cie.make_relative; 943 ecie->cie.cie_inf->make_lsda_relative = ecie->cie.make_lsda_relative; 944 ecie->cie.cie_inf->per_encoding_relative 945 = (ecie->cie.per_encoding & 0x70) == DW_EH_PE_pcrel; 946 } 947 948 /* Ok, now we can assign new offsets. */ 949 offset = 0; 950 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent) 951 if (!ent->removed) 952 { 953 if (!ent->cie) 954 { 955 ecie = ecies + (unsigned long) ent->cie_inf; 956 ent->cie_inf = ecie->cie.cie_inf; 957 } 958 ent->new_offset = offset; 959 offset += size_of_output_cie_fde (ent, ptr_size); 960 } 961 962 /* Resize the sec as needed. */ 963 sec->rawsize = sec->size; 964 sec->size = offset; 965 966 free (ehbuf); 967 if (ecies) 968 free (ecies); 969 return offset != sec->rawsize; 970 971free_no_table: 972 (*info->callbacks->einfo) 973 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"), 974 abfd, sec); 975 if (ehbuf) 976 free (ehbuf); 977 if (sec_info) 978 free (sec_info); 979 if (ecies) 980 free (ecies); 981 hdr_info->table = FALSE; 982 return FALSE; 983 984#undef REQUIRE 985} 986 987/* This function is called for .eh_frame_hdr section after 988 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame 989 input sections. It finalizes the size of .eh_frame_hdr section. */ 990 991bfd_boolean 992_bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 993{ 994 struct elf_link_hash_table *htab; 995 struct eh_frame_hdr_info *hdr_info; 996 asection *sec; 997 998 htab = elf_hash_table (info); 999 hdr_info = &htab->eh_info; 1000 1001 if (hdr_info->cies != NULL) 1002 { 1003 htab_delete (hdr_info->cies); 1004 hdr_info->cies = NULL; 1005 } 1006 1007 sec = hdr_info->hdr_sec; 1008 if (sec == NULL) 1009 return FALSE; 1010 1011 sec->size = EH_FRAME_HDR_SIZE; 1012 if (hdr_info->table) 1013 sec->size += 4 + hdr_info->fde_count * 8; 1014 1015 elf_tdata (abfd)->eh_frame_hdr = sec; 1016 return TRUE; 1017} 1018 1019/* This function is called from size_dynamic_sections. 1020 It needs to decide whether .eh_frame_hdr should be output or not, 1021 because when the dynamic symbol table has been sized it is too late 1022 to strip sections. */ 1023 1024bfd_boolean 1025_bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info) 1026{ 1027 asection *o; 1028 bfd *abfd; 1029 struct elf_link_hash_table *htab; 1030 struct eh_frame_hdr_info *hdr_info; 1031 1032 htab = elf_hash_table (info); 1033 hdr_info = &htab->eh_info; 1034 if (hdr_info->hdr_sec == NULL) 1035 return TRUE; 1036 1037 if (bfd_is_abs_section (hdr_info->hdr_sec->output_section)) 1038 { 1039 hdr_info->hdr_sec = NULL; 1040 return TRUE; 1041 } 1042 1043 abfd = NULL; 1044 if (info->eh_frame_hdr) 1045 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next) 1046 { 1047 /* Count only sections which have at least a single CIE or FDE. 1048 There cannot be any CIE or FDE <= 8 bytes. */ 1049 o = bfd_get_section_by_name (abfd, ".eh_frame"); 1050 if (o && o->size > 8 && !bfd_is_abs_section (o->output_section)) 1051 break; 1052 } 1053 1054 if (abfd == NULL) 1055 { 1056 hdr_info->hdr_sec->flags |= SEC_EXCLUDE; 1057 hdr_info->hdr_sec = NULL; 1058 return TRUE; 1059 } 1060 1061 hdr_info->table = TRUE; 1062 return TRUE; 1063} 1064 1065/* Adjust an address in the .eh_frame section. Given OFFSET within 1066 SEC, this returns the new offset in the adjusted .eh_frame section, 1067 or -1 if the address refers to a CIE/FDE which has been removed 1068 or to offset with dynamic relocation which is no longer needed. */ 1069 1070bfd_vma 1071_bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED, 1072 struct bfd_link_info *info, 1073 asection *sec, 1074 bfd_vma offset) 1075{ 1076 struct eh_frame_sec_info *sec_info; 1077 struct elf_link_hash_table *htab; 1078 struct eh_frame_hdr_info *hdr_info; 1079 unsigned int lo, hi, mid; 1080 1081 if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME) 1082 return offset; 1083 sec_info = elf_section_data (sec)->sec_info; 1084 1085 if (offset >= sec->rawsize) 1086 return offset - sec->rawsize + sec->size; 1087 1088 htab = elf_hash_table (info); 1089 hdr_info = &htab->eh_info; 1090 if (hdr_info->offsets_adjusted) 1091 offset += sec->output_offset; 1092 1093 lo = 0; 1094 hi = sec_info->count; 1095 mid = 0; 1096 while (lo < hi) 1097 { 1098 mid = (lo + hi) / 2; 1099 if (offset < sec_info->entry[mid].offset) 1100 hi = mid; 1101 else if (offset 1102 >= sec_info->entry[mid].offset + sec_info->entry[mid].size) 1103 lo = mid + 1; 1104 else 1105 break; 1106 } 1107 1108 BFD_ASSERT (lo < hi); 1109 1110 /* FDE or CIE was removed. */ 1111 if (sec_info->entry[mid].removed) 1112 return (bfd_vma) -1; 1113 1114 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time 1115 relocation against FDE's initial_location field. */ 1116 if (!sec_info->entry[mid].cie 1117 && sec_info->entry[mid].cie_inf->make_relative 1118 && offset == sec_info->entry[mid].offset + 8) 1119 return (bfd_vma) -2; 1120 1121 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need 1122 for run-time relocation against LSDA field. */ 1123 if (!sec_info->entry[mid].cie 1124 && sec_info->entry[mid].cie_inf->make_lsda_relative 1125 && (offset == (sec_info->entry[mid].offset + 8 1126 + sec_info->entry[mid].lsda_offset)) 1127 && (sec_info->entry[mid].cie_inf->need_lsda_relative 1128 || !hdr_info->offsets_adjusted)) 1129 { 1130 sec_info->entry[mid].cie_inf->need_lsda_relative = 1; 1131 return (bfd_vma) -2; 1132 } 1133 1134 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time 1135 relocation against DW_CFA_set_loc's arguments. */ 1136 if (sec_info->entry[mid].set_loc 1137 && (sec_info->entry[mid].cie 1138 ? sec_info->entry[mid].make_relative 1139 : sec_info->entry[mid].cie_inf->make_relative) 1140 && (offset >= sec_info->entry[mid].offset + 8 1141 + sec_info->entry[mid].set_loc[1])) 1142 { 1143 unsigned int cnt; 1144 1145 for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++) 1146 if (offset == sec_info->entry[mid].offset + 8 1147 + sec_info->entry[mid].set_loc[cnt]) 1148 return (bfd_vma) -2; 1149 } 1150 1151 if (hdr_info->offsets_adjusted) 1152 offset -= sec->output_offset; 1153 /* Any new augmentation bytes go before the first relocation. */ 1154 return (offset + sec_info->entry[mid].new_offset 1155 - sec_info->entry[mid].offset 1156 + extra_augmentation_string_bytes (sec_info->entry + mid) 1157 + extra_augmentation_data_bytes (sec_info->entry + mid)); 1158} 1159 1160/* Write out .eh_frame section. This is called with the relocated 1161 contents. */ 1162 1163bfd_boolean 1164_bfd_elf_write_section_eh_frame (bfd *abfd, 1165 struct bfd_link_info *info, 1166 asection *sec, 1167 bfd_byte *contents) 1168{ 1169 struct eh_frame_sec_info *sec_info; 1170 struct elf_link_hash_table *htab; 1171 struct eh_frame_hdr_info *hdr_info; 1172 unsigned int ptr_size; 1173 struct eh_cie_fde *ent; 1174 1175 if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME) 1176 return bfd_set_section_contents (abfd, sec->output_section, contents, 1177 sec->output_offset, sec->size); 1178 1179 ptr_size = (get_elf_backend_data (abfd) 1180 ->elf_backend_eh_frame_address_size (abfd, sec)); 1181 BFD_ASSERT (ptr_size != 0); 1182 1183 sec_info = elf_section_data (sec)->sec_info; 1184 htab = elf_hash_table (info); 1185 hdr_info = &htab->eh_info; 1186 1187 /* First convert all offsets to output section offsets, so that a 1188 CIE offset is valid if the CIE is used by a FDE from some other 1189 section. This can happen when duplicate CIEs are deleted in 1190 _bfd_elf_discard_section_eh_frame. We do all sections here because 1191 this function might not be called on sections in the same order as 1192 _bfd_elf_discard_section_eh_frame. */ 1193 if (!hdr_info->offsets_adjusted) 1194 { 1195 bfd *ibfd; 1196 asection *eh; 1197 struct eh_frame_sec_info *eh_inf; 1198 1199 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next) 1200 { 1201 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 1202 || (ibfd->flags & DYNAMIC) != 0) 1203 continue; 1204 1205 eh = bfd_get_section_by_name (ibfd, ".eh_frame"); 1206 if (eh == NULL || eh->sec_info_type != ELF_INFO_TYPE_EH_FRAME) 1207 continue; 1208 1209 eh_inf = elf_section_data (eh)->sec_info; 1210 for (ent = eh_inf->entry; ent < eh_inf->entry + eh_inf->count; ++ent) 1211 { 1212 ent->offset += eh->output_offset; 1213 ent->new_offset += eh->output_offset; 1214 } 1215 } 1216 hdr_info->offsets_adjusted = TRUE; 1217 } 1218 1219 if (hdr_info->table && hdr_info->array == NULL) 1220 hdr_info->array 1221 = bfd_malloc (hdr_info->fde_count * sizeof(*hdr_info->array)); 1222 if (hdr_info->array == NULL) 1223 hdr_info = NULL; 1224 1225 /* The new offsets can be bigger or smaller than the original offsets. 1226 We therefore need to make two passes over the section: one backward 1227 pass to move entries up and one forward pass to move entries down. 1228 The two passes won't interfere with each other because entries are 1229 not reordered */ 1230 for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;) 1231 if (!ent->removed && ent->new_offset > ent->offset) 1232 memmove (contents + ent->new_offset - sec->output_offset, 1233 contents + ent->offset - sec->output_offset, ent->size); 1234 1235 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent) 1236 if (!ent->removed && ent->new_offset < ent->offset) 1237 memmove (contents + ent->new_offset - sec->output_offset, 1238 contents + ent->offset - sec->output_offset, ent->size); 1239 1240 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent) 1241 { 1242 unsigned char *buf, *end; 1243 unsigned int new_size; 1244 1245 if (ent->removed) 1246 continue; 1247 1248 if (ent->size == 4) 1249 { 1250 /* Any terminating FDE must be at the end of the section. */ 1251 BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1); 1252 continue; 1253 } 1254 1255 buf = contents + ent->new_offset - sec->output_offset; 1256 end = buf + ent->size; 1257 new_size = size_of_output_cie_fde (ent, ptr_size); 1258 1259 /* Update the size. It may be shrinked. */ 1260 bfd_put_32 (abfd, new_size - 4, buf); 1261 1262 /* Filling the extra bytes with DW_CFA_nops. */ 1263 if (new_size != ent->size) 1264 memset (end, 0, new_size - ent->size); 1265 1266 if (ent->cie) 1267 { 1268 /* CIE */ 1269 if (ent->make_relative 1270 || ent->need_lsda_relative 1271 || ent->per_encoding_relative) 1272 { 1273 char *aug; 1274 unsigned int action, extra_string, extra_data; 1275 unsigned int per_width, per_encoding; 1276 1277 /* Need to find 'R' or 'L' augmentation's argument and modify 1278 DW_EH_PE_* value. */ 1279 action = ((ent->make_relative ? 1 : 0) 1280 | (ent->need_lsda_relative ? 2 : 0) 1281 | (ent->per_encoding_relative ? 4 : 0)); 1282 extra_string = extra_augmentation_string_bytes (ent); 1283 extra_data = extra_augmentation_data_bytes (ent); 1284 1285 /* Skip length, id and version. */ 1286 buf += 9; 1287 aug = (char *) buf; 1288 buf += strlen (aug) + 1; 1289 skip_leb128 (&buf, end); 1290 skip_leb128 (&buf, end); 1291 skip_leb128 (&buf, end); 1292 if (*aug == 'z') 1293 { 1294 /* The uleb128 will always be a single byte for the kind 1295 of augmentation strings that we're prepared to handle. */ 1296 *buf++ += extra_data; 1297 aug++; 1298 } 1299 1300 /* Make room for the new augmentation string and data bytes. */ 1301 memmove (buf + extra_string + extra_data, buf, end - buf); 1302 memmove (aug + extra_string, aug, buf - (bfd_byte *) aug); 1303 buf += extra_string; 1304 end += extra_string + extra_data; 1305 1306 if (ent->add_augmentation_size) 1307 { 1308 *aug++ = 'z'; 1309 *buf++ = extra_data - 1; 1310 } 1311 if (ent->add_fde_encoding) 1312 { 1313 BFD_ASSERT (action & 1); 1314 *aug++ = 'R'; 1315 *buf++ = DW_EH_PE_pcrel; 1316 action &= ~1; 1317 } 1318 1319 while (action) 1320 switch (*aug++) 1321 { 1322 case 'L': 1323 if (action & 2) 1324 { 1325 BFD_ASSERT (*buf == ent->lsda_encoding); 1326 *buf |= DW_EH_PE_pcrel; 1327 action &= ~2; 1328 } 1329 buf++; 1330 break; 1331 case 'P': 1332 per_encoding = *buf++; 1333 per_width = get_DW_EH_PE_width (per_encoding, ptr_size); 1334 BFD_ASSERT (per_width != 0); 1335 BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel) 1336 == ent->per_encoding_relative); 1337 if ((per_encoding & 0xf0) == DW_EH_PE_aligned) 1338 buf = (contents 1339 + ((buf - contents + per_width - 1) 1340 & ~((bfd_size_type) per_width - 1))); 1341 if (action & 4) 1342 { 1343 bfd_vma val; 1344 1345 val = read_value (abfd, buf, per_width, 1346 get_DW_EH_PE_signed (per_encoding)); 1347 val += ent->offset - ent->new_offset; 1348 val -= extra_string + extra_data; 1349 write_value (abfd, buf, val, per_width); 1350 action &= ~4; 1351 } 1352 buf += per_width; 1353 break; 1354 case 'R': 1355 if (action & 1) 1356 { 1357 BFD_ASSERT (*buf == ent->fde_encoding); 1358 *buf |= DW_EH_PE_pcrel; 1359 action &= ~1; 1360 } 1361 buf++; 1362 break; 1363 case 'S': 1364 break; 1365 default: 1366 BFD_FAIL (); 1367 } 1368 } 1369 } 1370 else 1371 { 1372 /* FDE */ 1373 bfd_vma value, address; 1374 unsigned int width; 1375 bfd_byte *start; 1376 1377 /* Skip length. */ 1378 buf += 4; 1379 value = ent->new_offset + 4 - ent->cie_inf->new_offset; 1380 bfd_put_32 (abfd, value, buf); 1381 buf += 4; 1382 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 1383 value = read_value (abfd, buf, width, 1384 get_DW_EH_PE_signed (ent->fde_encoding)); 1385 address = value; 1386 if (value) 1387 { 1388 switch (ent->fde_encoding & 0xf0) 1389 { 1390 case DW_EH_PE_indirect: 1391 case DW_EH_PE_textrel: 1392 BFD_ASSERT (hdr_info == NULL); 1393 break; 1394 case DW_EH_PE_datarel: 1395 { 1396 asection *got = bfd_get_section_by_name (abfd, ".got"); 1397 1398 BFD_ASSERT (got != NULL); 1399 address += got->vma; 1400 } 1401 break; 1402 case DW_EH_PE_pcrel: 1403 value += ent->offset - ent->new_offset; 1404 address += sec->output_section->vma + ent->offset + 8; 1405 break; 1406 } 1407 if (ent->cie_inf->make_relative) 1408 value -= sec->output_section->vma + ent->new_offset + 8; 1409 write_value (abfd, buf, value, width); 1410 } 1411 1412 start = buf; 1413 1414 if (hdr_info) 1415 { 1416 hdr_info->array[hdr_info->array_count].initial_loc = address; 1417 hdr_info->array[hdr_info->array_count++].fde 1418 = sec->output_section->vma + ent->new_offset; 1419 } 1420 1421 if ((ent->lsda_encoding & 0xf0) == DW_EH_PE_pcrel 1422 || ent->cie_inf->need_lsda_relative) 1423 { 1424 buf += ent->lsda_offset; 1425 width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size); 1426 value = read_value (abfd, buf, width, 1427 get_DW_EH_PE_signed (ent->lsda_encoding)); 1428 if (value) 1429 { 1430 if ((ent->lsda_encoding & 0xf0) == DW_EH_PE_pcrel) 1431 value += ent->offset - ent->new_offset; 1432 else if (ent->cie_inf->need_lsda_relative) 1433 value -= (sec->output_section->vma + ent->new_offset + 8 1434 + ent->lsda_offset); 1435 write_value (abfd, buf, value, width); 1436 } 1437 } 1438 else if (ent->cie_inf->add_augmentation_size) 1439 { 1440 /* Skip the PC and length and insert a zero byte for the 1441 augmentation size. */ 1442 buf += width * 2; 1443 memmove (buf + 1, buf, end - buf); 1444 *buf = 0; 1445 } 1446 1447 if (ent->set_loc) 1448 { 1449 /* Adjust DW_CFA_set_loc. */ 1450 unsigned int cnt, width; 1451 bfd_vma new_offset; 1452 1453 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 1454 new_offset = ent->new_offset + 8 1455 + extra_augmentation_string_bytes (ent) 1456 + extra_augmentation_data_bytes (ent); 1457 1458 for (cnt = 1; cnt <= ent->set_loc[0]; cnt++) 1459 { 1460 bfd_vma value; 1461 buf = start + ent->set_loc[cnt]; 1462 1463 value = read_value (abfd, buf, width, 1464 get_DW_EH_PE_signed (ent->fde_encoding)); 1465 if (!value) 1466 continue; 1467 1468 if ((ent->fde_encoding & 0xf0) == DW_EH_PE_pcrel) 1469 value += ent->offset + 8 - new_offset; 1470 if (ent->cie_inf->make_relative) 1471 value -= sec->output_section->vma + new_offset 1472 + ent->set_loc[cnt]; 1473 write_value (abfd, buf, value, width); 1474 } 1475 } 1476 } 1477 } 1478 1479 /* We don't align the section to its section alignment since the 1480 runtime library only expects all CIE/FDE records aligned at 1481 the pointer size. _bfd_elf_discard_section_eh_frame should 1482 have padded CIE/FDE records to multiple of pointer size with 1483 size_of_output_cie_fde. */ 1484 if ((sec->size % ptr_size) != 0) 1485 abort (); 1486 1487 return bfd_set_section_contents (abfd, sec->output_section, 1488 contents, (file_ptr) sec->output_offset, 1489 sec->size); 1490} 1491 1492/* Helper function used to sort .eh_frame_hdr search table by increasing 1493 VMA of FDE initial location. */ 1494 1495static int 1496vma_compare (const void *a, const void *b) 1497{ 1498 const struct eh_frame_array_ent *p = a; 1499 const struct eh_frame_array_ent *q = b; 1500 if (p->initial_loc > q->initial_loc) 1501 return 1; 1502 if (p->initial_loc < q->initial_loc) 1503 return -1; 1504 return 0; 1505} 1506 1507/* Write out .eh_frame_hdr section. This must be called after 1508 _bfd_elf_write_section_eh_frame has been called on all input 1509 .eh_frame sections. 1510 .eh_frame_hdr format: 1511 ubyte version (currently 1) 1512 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of 1513 .eh_frame section) 1514 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count 1515 number (or DW_EH_PE_omit if there is no 1516 binary search table computed)) 1517 ubyte table_enc (DW_EH_PE_* encoding of binary search table, 1518 or DW_EH_PE_omit if not present. 1519 DW_EH_PE_datarel is using address of 1520 .eh_frame_hdr section start as base) 1521 [encoded] eh_frame_ptr (pointer to start of .eh_frame section) 1522 optionally followed by: 1523 [encoded] fde_count (total number of FDEs in .eh_frame section) 1524 fde_count x [encoded] initial_loc, fde 1525 (array of encoded pairs containing 1526 FDE initial_location field and FDE address, 1527 sorted by increasing initial_loc). */ 1528 1529bfd_boolean 1530_bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 1531{ 1532 struct elf_link_hash_table *htab; 1533 struct eh_frame_hdr_info *hdr_info; 1534 asection *sec; 1535 bfd_byte *contents; 1536 asection *eh_frame_sec; 1537 bfd_size_type size; 1538 bfd_boolean retval; 1539 bfd_vma encoded_eh_frame; 1540 1541 htab = elf_hash_table (info); 1542 hdr_info = &htab->eh_info; 1543 sec = hdr_info->hdr_sec; 1544 if (sec == NULL) 1545 return TRUE; 1546 1547 size = EH_FRAME_HDR_SIZE; 1548 if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count) 1549 size += 4 + hdr_info->fde_count * 8; 1550 contents = bfd_malloc (size); 1551 if (contents == NULL) 1552 return FALSE; 1553 1554 eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame"); 1555 if (eh_frame_sec == NULL) 1556 { 1557 free (contents); 1558 return FALSE; 1559 } 1560 1561 memset (contents, 0, EH_FRAME_HDR_SIZE); 1562 contents[0] = 1; /* Version. */ 1563 contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address 1564 (abfd, info, eh_frame_sec, 0, sec, 4, 1565 &encoded_eh_frame); /* .eh_frame offset. */ 1566 1567 if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count) 1568 { 1569 contents[2] = DW_EH_PE_udata4; /* FDE count encoding. */ 1570 contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; /* Search table enc. */ 1571 } 1572 else 1573 { 1574 contents[2] = DW_EH_PE_omit; 1575 contents[3] = DW_EH_PE_omit; 1576 } 1577 bfd_put_32 (abfd, encoded_eh_frame, contents + 4); 1578 1579 if (contents[2] != DW_EH_PE_omit) 1580 { 1581 unsigned int i; 1582 1583 bfd_put_32 (abfd, hdr_info->fde_count, contents + EH_FRAME_HDR_SIZE); 1584 qsort (hdr_info->array, hdr_info->fde_count, sizeof (*hdr_info->array), 1585 vma_compare); 1586 for (i = 0; i < hdr_info->fde_count; i++) 1587 { 1588 bfd_put_32 (abfd, 1589 hdr_info->array[i].initial_loc 1590 - sec->output_section->vma, 1591 contents + EH_FRAME_HDR_SIZE + i * 8 + 4); 1592 bfd_put_32 (abfd, 1593 hdr_info->array[i].fde - sec->output_section->vma, 1594 contents + EH_FRAME_HDR_SIZE + i * 8 + 8); 1595 } 1596 } 1597 1598 retval = bfd_set_section_contents (abfd, sec->output_section, 1599 contents, (file_ptr) sec->output_offset, 1600 sec->size); 1601 free (contents); 1602 return retval; 1603} 1604 1605/* Return the width of FDE addresses. This is the default implementation. */ 1606 1607unsigned int 1608_bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED) 1609{ 1610 return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4; 1611} 1612 1613/* Decide whether we can use a PC-relative encoding within the given 1614 EH frame section. This is the default implementation. */ 1615 1616bfd_boolean 1617_bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED, 1618 struct bfd_link_info *info ATTRIBUTE_UNUSED, 1619 asection *eh_frame_section ATTRIBUTE_UNUSED) 1620{ 1621 return TRUE; 1622} 1623 1624/* Select an encoding for the given address. Preference is given to 1625 PC-relative addressing modes. */ 1626 1627bfd_byte 1628_bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED, 1629 struct bfd_link_info *info ATTRIBUTE_UNUSED, 1630 asection *osec, bfd_vma offset, 1631 asection *loc_sec, bfd_vma loc_offset, 1632 bfd_vma *encoded) 1633{ 1634 *encoded = osec->vma + offset - 1635 (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset); 1636 return DW_EH_PE_pcrel | DW_EH_PE_sdata4; 1637} 1638