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