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