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