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