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