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 29 struct 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 56 static inline bfd_boolean 57 read_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 68 static inline bfd_boolean 69 skip_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 83 static bfd_boolean 84 skip_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 97 static bfd_boolean 98 read_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 116 static bfd_boolean 117 read_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 135 static 136 int 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 160 static bfd_vma 161 read_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 195 static void 196 write_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 209 static int 210 cie_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 238 static hashval_t 239 cie_hash (const void *e) 240 { 241 const struct cie *c = e; 242 return c->hash; 243 } 244 245 static hashval_t 246 cie_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 270 static INLINE unsigned int 271 extra_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 286 static INLINE unsigned int 287 extra_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 308 static unsigned int 309 size_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 325 static bfd_boolean 326 skip_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 405 static bfd_byte * 406 skip_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 431 bfd_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 if (sec->size == 0) 931 sec->flags |= SEC_EXCLUDE; 932 933 free (ehbuf); 934 if (ecies) 935 free (ecies); 936 return offset != sec->rawsize; 937 938 free_no_table: 939 if (ehbuf) 940 free (ehbuf); 941 if (sec_info) 942 free (sec_info); 943 if (ecies) 944 free (ecies); 945 hdr_info->table = FALSE; 946 return FALSE; 947 948 #undef REQUIRE 949 } 950 951 /* This function is called for .eh_frame_hdr section after 952 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame 953 input sections. It finalizes the size of .eh_frame_hdr section. */ 954 955 bfd_boolean 956 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 957 { 958 struct elf_link_hash_table *htab; 959 struct eh_frame_hdr_info *hdr_info; 960 asection *sec; 961 962 htab = elf_hash_table (info); 963 hdr_info = &htab->eh_info; 964 965 if (hdr_info->cies != NULL) 966 { 967 htab_delete (hdr_info->cies); 968 hdr_info->cies = NULL; 969 } 970 971 sec = hdr_info->hdr_sec; 972 if (sec == NULL) 973 return FALSE; 974 975 sec->size = EH_FRAME_HDR_SIZE; 976 if (hdr_info->table) 977 sec->size += 4 + hdr_info->fde_count * 8; 978 979 /* Request program headers to be recalculated. */ 980 elf_tdata (abfd)->program_header_size = 0; 981 elf_tdata (abfd)->eh_frame_hdr = sec; 982 return TRUE; 983 } 984 985 /* This function is called from size_dynamic_sections. 986 It needs to decide whether .eh_frame_hdr should be output or not, 987 because when the dynamic symbol table has been sized it is too late 988 to strip sections. */ 989 990 bfd_boolean 991 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info) 992 { 993 asection *o; 994 bfd *abfd; 995 struct elf_link_hash_table *htab; 996 struct eh_frame_hdr_info *hdr_info; 997 998 htab = elf_hash_table (info); 999 hdr_info = &htab->eh_info; 1000 if (hdr_info->hdr_sec == NULL) 1001 return TRUE; 1002 1003 if (bfd_is_abs_section (hdr_info->hdr_sec->output_section)) 1004 { 1005 hdr_info->hdr_sec = NULL; 1006 return TRUE; 1007 } 1008 1009 abfd = NULL; 1010 if (info->eh_frame_hdr) 1011 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next) 1012 { 1013 /* Count only sections which have at least a single CIE or FDE. 1014 There cannot be any CIE or FDE <= 8 bytes. */ 1015 o = bfd_get_section_by_name (abfd, ".eh_frame"); 1016 if (o && o->size > 8 && !bfd_is_abs_section (o->output_section)) 1017 break; 1018 } 1019 1020 if (abfd == NULL) 1021 { 1022 hdr_info->hdr_sec->flags |= SEC_EXCLUDE; 1023 hdr_info->hdr_sec = NULL; 1024 return TRUE; 1025 } 1026 1027 hdr_info->table = TRUE; 1028 return TRUE; 1029 } 1030 1031 /* Adjust an address in the .eh_frame section. Given OFFSET within 1032 SEC, this returns the new offset in the adjusted .eh_frame section, 1033 or -1 if the address refers to a CIE/FDE which has been removed 1034 or to offset with dynamic relocation which is no longer needed. */ 1035 1036 bfd_vma 1037 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED, 1038 struct bfd_link_info *info, 1039 asection *sec, 1040 bfd_vma offset) 1041 { 1042 struct eh_frame_sec_info *sec_info; 1043 struct elf_link_hash_table *htab; 1044 struct eh_frame_hdr_info *hdr_info; 1045 unsigned int lo, hi, mid; 1046 1047 if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME) 1048 return offset; 1049 sec_info = elf_section_data (sec)->sec_info; 1050 1051 if (offset >= sec->rawsize) 1052 return offset - sec->rawsize + sec->size; 1053 1054 htab = elf_hash_table (info); 1055 hdr_info = &htab->eh_info; 1056 if (hdr_info->offsets_adjusted) 1057 offset += sec->output_offset; 1058 1059 lo = 0; 1060 hi = sec_info->count; 1061 mid = 0; 1062 while (lo < hi) 1063 { 1064 mid = (lo + hi) / 2; 1065 if (offset < sec_info->entry[mid].offset) 1066 hi = mid; 1067 else if (offset 1068 >= sec_info->entry[mid].offset + sec_info->entry[mid].size) 1069 lo = mid + 1; 1070 else 1071 break; 1072 } 1073 1074 BFD_ASSERT (lo < hi); 1075 1076 /* FDE or CIE was removed. */ 1077 if (sec_info->entry[mid].removed) 1078 return (bfd_vma) -1; 1079 1080 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time 1081 relocation against FDE's initial_location field. */ 1082 if (!sec_info->entry[mid].cie 1083 && sec_info->entry[mid].cie_inf->make_relative 1084 && offset == sec_info->entry[mid].offset + 8) 1085 return (bfd_vma) -2; 1086 1087 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need 1088 for run-time relocation against LSDA field. */ 1089 if (!sec_info->entry[mid].cie 1090 && sec_info->entry[mid].cie_inf->make_lsda_relative 1091 && (offset == (sec_info->entry[mid].offset + 8 1092 + sec_info->entry[mid].lsda_offset)) 1093 && (sec_info->entry[mid].cie_inf->need_lsda_relative 1094 || !hdr_info->offsets_adjusted)) 1095 { 1096 sec_info->entry[mid].cie_inf->need_lsda_relative = 1; 1097 return (bfd_vma) -2; 1098 } 1099 1100 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time 1101 relocation against DW_CFA_set_loc's arguments. */ 1102 if (sec_info->entry[mid].set_loc 1103 && (sec_info->entry[mid].cie 1104 ? sec_info->entry[mid].make_relative 1105 : sec_info->entry[mid].cie_inf->make_relative) 1106 && (offset >= sec_info->entry[mid].offset + 8 1107 + sec_info->entry[mid].set_loc[1])) 1108 { 1109 unsigned int cnt; 1110 1111 for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++) 1112 if (offset == sec_info->entry[mid].offset + 8 1113 + sec_info->entry[mid].set_loc[cnt]) 1114 return (bfd_vma) -2; 1115 } 1116 1117 if (hdr_info->offsets_adjusted) 1118 offset -= sec->output_offset; 1119 /* Any new augmentation bytes go before the first relocation. */ 1120 return (offset + sec_info->entry[mid].new_offset 1121 - sec_info->entry[mid].offset 1122 + extra_augmentation_string_bytes (sec_info->entry + mid) 1123 + extra_augmentation_data_bytes (sec_info->entry + mid)); 1124 } 1125 1126 /* Write out .eh_frame section. This is called with the relocated 1127 contents. */ 1128 1129 bfd_boolean 1130 _bfd_elf_write_section_eh_frame (bfd *abfd, 1131 struct bfd_link_info *info, 1132 asection *sec, 1133 bfd_byte *contents) 1134 { 1135 struct eh_frame_sec_info *sec_info; 1136 struct elf_link_hash_table *htab; 1137 struct eh_frame_hdr_info *hdr_info; 1138 unsigned int ptr_size; 1139 struct eh_cie_fde *ent; 1140 1141 if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME) 1142 return bfd_set_section_contents (abfd, sec->output_section, contents, 1143 sec->output_offset, sec->size); 1144 1145 ptr_size = (get_elf_backend_data (abfd) 1146 ->elf_backend_eh_frame_address_size (abfd, sec)); 1147 BFD_ASSERT (ptr_size != 0); 1148 1149 sec_info = elf_section_data (sec)->sec_info; 1150 htab = elf_hash_table (info); 1151 hdr_info = &htab->eh_info; 1152 1153 /* First convert all offsets to output section offsets, so that a 1154 CIE offset is valid if the CIE is used by a FDE from some other 1155 section. This can happen when duplicate CIEs are deleted in 1156 _bfd_elf_discard_section_eh_frame. We do all sections here because 1157 this function might not be called on sections in the same order as 1158 _bfd_elf_discard_section_eh_frame. */ 1159 if (!hdr_info->offsets_adjusted) 1160 { 1161 bfd *ibfd; 1162 asection *eh; 1163 struct eh_frame_sec_info *eh_inf; 1164 1165 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next) 1166 { 1167 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 1168 || (ibfd->flags & DYNAMIC) != 0) 1169 continue; 1170 1171 eh = bfd_get_section_by_name (ibfd, ".eh_frame"); 1172 if (eh == NULL || eh->sec_info_type != ELF_INFO_TYPE_EH_FRAME) 1173 continue; 1174 1175 eh_inf = elf_section_data (eh)->sec_info; 1176 for (ent = eh_inf->entry; ent < eh_inf->entry + eh_inf->count; ++ent) 1177 { 1178 ent->offset += eh->output_offset; 1179 ent->new_offset += eh->output_offset; 1180 } 1181 } 1182 hdr_info->offsets_adjusted = TRUE; 1183 } 1184 1185 if (hdr_info->table && hdr_info->array == NULL) 1186 hdr_info->array 1187 = bfd_malloc (hdr_info->fde_count * sizeof(*hdr_info->array)); 1188 if (hdr_info->array == NULL) 1189 hdr_info = NULL; 1190 1191 /* The new offsets can be bigger or smaller than the original offsets. 1192 We therefore need to make two passes over the section: one backward 1193 pass to move entries up and one forward pass to move entries down. 1194 The two passes won't interfere with each other because entries are 1195 not reordered */ 1196 for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;) 1197 if (!ent->removed && ent->new_offset > ent->offset) 1198 memmove (contents + ent->new_offset - sec->output_offset, 1199 contents + ent->offset - sec->output_offset, ent->size); 1200 1201 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent) 1202 if (!ent->removed && ent->new_offset < ent->offset) 1203 memmove (contents + ent->new_offset - sec->output_offset, 1204 contents + ent->offset - sec->output_offset, ent->size); 1205 1206 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent) 1207 { 1208 unsigned char *buf, *end; 1209 unsigned int new_size; 1210 1211 if (ent->removed) 1212 continue; 1213 1214 if (ent->size == 4) 1215 { 1216 /* Any terminating FDE must be at the end of the section. */ 1217 BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1); 1218 continue; 1219 } 1220 1221 buf = contents + ent->new_offset - sec->output_offset; 1222 end = buf + ent->size; 1223 new_size = size_of_output_cie_fde (ent, ptr_size); 1224 1225 /* Update the size. It may be shrinked. */ 1226 bfd_put_32 (abfd, new_size - 4, buf); 1227 1228 /* Filling the extra bytes with DW_CFA_nops. */ 1229 if (new_size != ent->size) 1230 memset (end, 0, new_size - ent->size); 1231 1232 if (ent->cie) 1233 { 1234 /* CIE */ 1235 if (ent->make_relative 1236 || ent->need_lsda_relative 1237 || ent->per_encoding_relative) 1238 { 1239 char *aug; 1240 unsigned int action, extra_string, extra_data; 1241 unsigned int per_width, per_encoding; 1242 1243 /* Need to find 'R' or 'L' augmentation's argument and modify 1244 DW_EH_PE_* value. */ 1245 action = ((ent->make_relative ? 1 : 0) 1246 | (ent->need_lsda_relative ? 2 : 0) 1247 | (ent->per_encoding_relative ? 4 : 0)); 1248 extra_string = extra_augmentation_string_bytes (ent); 1249 extra_data = extra_augmentation_data_bytes (ent); 1250 1251 /* Skip length, id and version. */ 1252 buf += 9; 1253 aug = (char *) buf; 1254 buf += strlen (aug) + 1; 1255 skip_leb128 (&buf, end); 1256 skip_leb128 (&buf, end); 1257 skip_leb128 (&buf, end); 1258 if (*aug == 'z') 1259 { 1260 /* The uleb128 will always be a single byte for the kind 1261 of augmentation strings that we're prepared to handle. */ 1262 *buf++ += extra_data; 1263 aug++; 1264 } 1265 1266 /* Make room for the new augmentation string and data bytes. */ 1267 memmove (buf + extra_string + extra_data, buf, end - buf); 1268 memmove (aug + extra_string, aug, buf - (bfd_byte *) aug); 1269 buf += extra_string; 1270 end += extra_string + extra_data; 1271 1272 if (ent->add_augmentation_size) 1273 { 1274 *aug++ = 'z'; 1275 *buf++ = extra_data - 1; 1276 } 1277 if (ent->add_fde_encoding) 1278 { 1279 BFD_ASSERT (action & 1); 1280 *aug++ = 'R'; 1281 *buf++ = DW_EH_PE_pcrel; 1282 action &= ~1; 1283 } 1284 1285 while (action) 1286 switch (*aug++) 1287 { 1288 case 'L': 1289 if (action & 2) 1290 { 1291 BFD_ASSERT (*buf == ent->lsda_encoding); 1292 *buf |= DW_EH_PE_pcrel; 1293 action &= ~2; 1294 } 1295 buf++; 1296 break; 1297 case 'P': 1298 per_encoding = *buf++; 1299 per_width = get_DW_EH_PE_width (per_encoding, ptr_size); 1300 BFD_ASSERT (per_width != 0); 1301 BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel) 1302 == ent->per_encoding_relative); 1303 if ((per_encoding & 0xf0) == DW_EH_PE_aligned) 1304 buf = (contents 1305 + ((buf - contents + per_width - 1) 1306 & ~((bfd_size_type) per_width - 1))); 1307 if (action & 4) 1308 { 1309 bfd_vma val; 1310 1311 val = read_value (abfd, buf, per_width, 1312 get_DW_EH_PE_signed (per_encoding)); 1313 val += ent->offset - ent->new_offset; 1314 val -= extra_string + extra_data; 1315 write_value (abfd, buf, val, per_width); 1316 action &= ~4; 1317 } 1318 buf += per_width; 1319 break; 1320 case 'R': 1321 if (action & 1) 1322 { 1323 BFD_ASSERT (*buf == ent->fde_encoding); 1324 *buf |= DW_EH_PE_pcrel; 1325 action &= ~1; 1326 } 1327 buf++; 1328 break; 1329 case 'S': 1330 break; 1331 default: 1332 BFD_FAIL (); 1333 } 1334 } 1335 } 1336 else 1337 { 1338 /* FDE */ 1339 bfd_vma value, address; 1340 unsigned int width; 1341 bfd_byte *start; 1342 1343 /* Skip length. */ 1344 buf += 4; 1345 value = ent->new_offset + 4 - ent->cie_inf->new_offset; 1346 bfd_put_32 (abfd, value, buf); 1347 buf += 4; 1348 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 1349 value = read_value (abfd, buf, width, 1350 get_DW_EH_PE_signed (ent->fde_encoding)); 1351 address = value; 1352 if (value) 1353 { 1354 switch (ent->fde_encoding & 0xf0) 1355 { 1356 case DW_EH_PE_indirect: 1357 case DW_EH_PE_textrel: 1358 BFD_ASSERT (hdr_info == NULL); 1359 break; 1360 case DW_EH_PE_datarel: 1361 { 1362 asection *got = bfd_get_section_by_name (abfd, ".got"); 1363 1364 BFD_ASSERT (got != NULL); 1365 address += got->vma; 1366 } 1367 break; 1368 case DW_EH_PE_pcrel: 1369 value += ent->offset - ent->new_offset; 1370 address += sec->output_section->vma + ent->offset + 8; 1371 break; 1372 } 1373 if (ent->cie_inf->make_relative) 1374 value -= sec->output_section->vma + ent->new_offset + 8; 1375 write_value (abfd, buf, value, width); 1376 } 1377 1378 start = buf; 1379 1380 if (hdr_info) 1381 { 1382 hdr_info->array[hdr_info->array_count].initial_loc = address; 1383 hdr_info->array[hdr_info->array_count++].fde 1384 = sec->output_section->vma + ent->new_offset; 1385 } 1386 1387 if ((ent->lsda_encoding & 0xf0) == DW_EH_PE_pcrel 1388 || ent->cie_inf->need_lsda_relative) 1389 { 1390 buf += ent->lsda_offset; 1391 width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size); 1392 value = read_value (abfd, buf, width, 1393 get_DW_EH_PE_signed (ent->lsda_encoding)); 1394 if (value) 1395 { 1396 if ((ent->lsda_encoding & 0xf0) == DW_EH_PE_pcrel) 1397 value += ent->offset - ent->new_offset; 1398 else if (ent->cie_inf->need_lsda_relative) 1399 value -= (sec->output_section->vma + ent->new_offset + 8 1400 + ent->lsda_offset); 1401 write_value (abfd, buf, value, width); 1402 } 1403 } 1404 else if (ent->cie_inf->add_augmentation_size) 1405 { 1406 /* Skip the PC and length and insert a zero byte for the 1407 augmentation size. */ 1408 buf += width * 2; 1409 memmove (buf + 1, buf, end - buf); 1410 *buf = 0; 1411 } 1412 1413 if (ent->set_loc) 1414 { 1415 /* Adjust DW_CFA_set_loc. */ 1416 unsigned int cnt, width; 1417 bfd_vma new_offset; 1418 1419 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 1420 new_offset = ent->new_offset + 8 1421 + extra_augmentation_string_bytes (ent) 1422 + extra_augmentation_data_bytes (ent); 1423 1424 for (cnt = 1; cnt <= ent->set_loc[0]; cnt++) 1425 { 1426 bfd_vma value; 1427 buf = start + ent->set_loc[cnt]; 1428 1429 value = read_value (abfd, buf, width, 1430 get_DW_EH_PE_signed (ent->fde_encoding)); 1431 if (!value) 1432 continue; 1433 1434 if ((ent->fde_encoding & 0xf0) == DW_EH_PE_pcrel) 1435 value += ent->offset + 8 - new_offset; 1436 if (ent->cie_inf->make_relative) 1437 value -= sec->output_section->vma + new_offset 1438 + ent->set_loc[cnt]; 1439 write_value (abfd, buf, value, width); 1440 } 1441 } 1442 } 1443 } 1444 1445 /* We don't align the section to its section alignment since the 1446 runtime library only expects all CIE/FDE records aligned at 1447 the pointer size. _bfd_elf_discard_section_eh_frame should 1448 have padded CIE/FDE records to multiple of pointer size with 1449 size_of_output_cie_fde. */ 1450 if ((sec->size % ptr_size) != 0) 1451 abort (); 1452 1453 return bfd_set_section_contents (abfd, sec->output_section, 1454 contents, (file_ptr) sec->output_offset, 1455 sec->size); 1456 } 1457 1458 /* Helper function used to sort .eh_frame_hdr search table by increasing 1459 VMA of FDE initial location. */ 1460 1461 static int 1462 vma_compare (const void *a, const void *b) 1463 { 1464 const struct eh_frame_array_ent *p = a; 1465 const struct eh_frame_array_ent *q = b; 1466 if (p->initial_loc > q->initial_loc) 1467 return 1; 1468 if (p->initial_loc < q->initial_loc) 1469 return -1; 1470 return 0; 1471 } 1472 1473 /* Write out .eh_frame_hdr section. This must be called after 1474 _bfd_elf_write_section_eh_frame has been called on all input 1475 .eh_frame sections. 1476 .eh_frame_hdr format: 1477 ubyte version (currently 1) 1478 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of 1479 .eh_frame section) 1480 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count 1481 number (or DW_EH_PE_omit if there is no 1482 binary search table computed)) 1483 ubyte table_enc (DW_EH_PE_* encoding of binary search table, 1484 or DW_EH_PE_omit if not present. 1485 DW_EH_PE_datarel is using address of 1486 .eh_frame_hdr section start as base) 1487 [encoded] eh_frame_ptr (pointer to start of .eh_frame section) 1488 optionally followed by: 1489 [encoded] fde_count (total number of FDEs in .eh_frame section) 1490 fde_count x [encoded] initial_loc, fde 1491 (array of encoded pairs containing 1492 FDE initial_location field and FDE address, 1493 sorted by increasing initial_loc). */ 1494 1495 bfd_boolean 1496 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 1497 { 1498 struct elf_link_hash_table *htab; 1499 struct eh_frame_hdr_info *hdr_info; 1500 asection *sec; 1501 bfd_byte *contents; 1502 asection *eh_frame_sec; 1503 bfd_size_type size; 1504 bfd_boolean retval; 1505 bfd_vma encoded_eh_frame; 1506 1507 htab = elf_hash_table (info); 1508 hdr_info = &htab->eh_info; 1509 sec = hdr_info->hdr_sec; 1510 if (sec == NULL) 1511 return TRUE; 1512 1513 size = EH_FRAME_HDR_SIZE; 1514 if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count) 1515 size += 4 + hdr_info->fde_count * 8; 1516 contents = bfd_malloc (size); 1517 if (contents == NULL) 1518 return FALSE; 1519 1520 eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame"); 1521 if (eh_frame_sec == NULL) 1522 { 1523 free (contents); 1524 return FALSE; 1525 } 1526 1527 memset (contents, 0, EH_FRAME_HDR_SIZE); 1528 contents[0] = 1; /* Version. */ 1529 contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address 1530 (abfd, info, eh_frame_sec, 0, sec, 4, 1531 &encoded_eh_frame); /* .eh_frame offset. */ 1532 1533 if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count) 1534 { 1535 contents[2] = DW_EH_PE_udata4; /* FDE count encoding. */ 1536 contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; /* Search table enc. */ 1537 } 1538 else 1539 { 1540 contents[2] = DW_EH_PE_omit; 1541 contents[3] = DW_EH_PE_omit; 1542 } 1543 bfd_put_32 (abfd, encoded_eh_frame, contents + 4); 1544 1545 if (contents[2] != DW_EH_PE_omit) 1546 { 1547 unsigned int i; 1548 1549 bfd_put_32 (abfd, hdr_info->fde_count, contents + EH_FRAME_HDR_SIZE); 1550 qsort (hdr_info->array, hdr_info->fde_count, sizeof (*hdr_info->array), 1551 vma_compare); 1552 for (i = 0; i < hdr_info->fde_count; i++) 1553 { 1554 bfd_put_32 (abfd, 1555 hdr_info->array[i].initial_loc 1556 - sec->output_section->vma, 1557 contents + EH_FRAME_HDR_SIZE + i * 8 + 4); 1558 bfd_put_32 (abfd, 1559 hdr_info->array[i].fde - sec->output_section->vma, 1560 contents + EH_FRAME_HDR_SIZE + i * 8 + 8); 1561 } 1562 } 1563 1564 retval = bfd_set_section_contents (abfd, sec->output_section, 1565 contents, (file_ptr) sec->output_offset, 1566 sec->size); 1567 free (contents); 1568 return retval; 1569 } 1570 1571 /* Return the width of FDE addresses. This is the default implementation. */ 1572 1573 unsigned int 1574 _bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED) 1575 { 1576 return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4; 1577 } 1578 1579 /* Decide whether we can use a PC-relative encoding within the given 1580 EH frame section. This is the default implementation. */ 1581 1582 bfd_boolean 1583 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED, 1584 struct bfd_link_info *info ATTRIBUTE_UNUSED, 1585 asection *eh_frame_section ATTRIBUTE_UNUSED) 1586 { 1587 return TRUE; 1588 } 1589 1590 /* Select an encoding for the given address. Preference is given to 1591 PC-relative addressing modes. */ 1592 1593 bfd_byte 1594 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED, 1595 struct bfd_link_info *info ATTRIBUTE_UNUSED, 1596 asection *osec, bfd_vma offset, 1597 asection *loc_sec, bfd_vma loc_offset, 1598 bfd_vma *encoded) 1599 { 1600 *encoded = osec->vma + offset - 1601 (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset); 1602 return DW_EH_PE_pcrel | DW_EH_PE_sdata4; 1603 } 1604