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