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