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