1 /* .eh_frame section optimization. 2 Copyright (C) 2001-2026 Free Software Foundation, Inc. 3 Written by Jakub Jelinek <jakub (at) redhat.com>. 4 5 This file is part of BFD, the Binary File Descriptor library. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 20 MA 02110-1301, USA. */ 21 22 #include "sysdep.h" 23 #include "bfd.h" 24 #include "libbfd.h" 25 #include "elf-bfd.h" 26 #include "dwarf2.h" 27 28 #define EH_FRAME_HDR_SIZE 8 29 30 struct cie 31 { 32 unsigned int length; 33 unsigned int hash; 34 unsigned char version; 35 unsigned char local_personality; 36 char augmentation[20]; 37 bfd_vma code_align; 38 bfd_signed_vma data_align; 39 bfd_vma ra_column; 40 bfd_vma augmentation_size; 41 union { 42 struct elf_link_hash_entry *h; 43 struct { 44 unsigned int bfd_id; 45 unsigned int index; 46 } sym; 47 unsigned int reloc_index; 48 } personality; 49 struct eh_cie_fde *cie_inf; 50 unsigned char per_encoding; 51 unsigned char lsda_encoding; 52 unsigned char fde_encoding; 53 unsigned char initial_insn_length; 54 unsigned char can_make_lsda_relative; 55 unsigned char initial_instructions[50]; 56 }; 57 58 59 60 /* If *ITER hasn't reached END yet, read the next byte into *RESULT and 61 move onto the next byte. Return true on success. */ 62 63 static inline bool 64 read_byte (bfd_byte **iter, bfd_byte *end, unsigned char *result) 65 { 66 if (*iter >= end) 67 return false; 68 *result = *((*iter)++); 69 return true; 70 } 71 72 /* Move *ITER over LENGTH bytes, or up to END, whichever is closer. 73 Return true it was possible to move LENGTH bytes. */ 74 75 static inline bool 76 skip_bytes (bfd_byte **iter, bfd_byte *end, bfd_size_type length) 77 { 78 if ((bfd_size_type) (end - *iter) < length) 79 { 80 *iter = end; 81 return false; 82 } 83 *iter += length; 84 return true; 85 } 86 87 /* Move *ITER over an leb128, stopping at END. Return true if the end 88 of the leb128 was found. */ 89 90 static bool 91 skip_leb128 (bfd_byte **iter, bfd_byte *end) 92 { 93 unsigned char byte; 94 do 95 if (!read_byte (iter, end, &byte)) 96 return false; 97 while (byte & 0x80); 98 return true; 99 } 100 101 /* Like skip_leb128, but treat the leb128 as an unsigned value and 102 store it in *VALUE. */ 103 104 static bool 105 read_uleb128 (bfd_byte **iter, bfd_byte *end, bfd_vma *value) 106 { 107 bfd_byte *start, *p; 108 109 start = *iter; 110 if (!skip_leb128 (iter, end)) 111 return false; 112 113 p = *iter; 114 *value = *--p; 115 while (p > start) 116 *value = (*value << 7) | (*--p & 0x7f); 117 118 return true; 119 } 120 121 /* Like read_uleb128, but for signed values. */ 122 123 static bool 124 read_sleb128 (bfd_byte **iter, bfd_byte *end, bfd_signed_vma *value) 125 { 126 bfd_byte *start, *p; 127 128 start = *iter; 129 if (!skip_leb128 (iter, end)) 130 return false; 131 132 p = *iter; 133 *value = ((*--p & 0x7f) ^ 0x40) - 0x40; 134 while (p > start) 135 *value = (*value << 7) | (*--p & 0x7f); 136 137 return true; 138 } 139 140 /* Return 0 if either encoding is variable width, or not yet known to bfd. */ 141 142 static 143 int get_DW_EH_PE_width (int encoding, int ptr_size) 144 { 145 /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame 146 was added to bfd. */ 147 if ((encoding & 0x60) == 0x60) 148 return 0; 149 150 switch (encoding & 7) 151 { 152 case DW_EH_PE_udata2: return 2; 153 case DW_EH_PE_udata4: return 4; 154 case DW_EH_PE_udata8: return 8; 155 case DW_EH_PE_absptr: return ptr_size; 156 default: 157 break; 158 } 159 160 return 0; 161 } 162 163 #define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0) 164 165 /* Read a width sized value from memory. */ 166 167 static bfd_vma 168 read_value (bfd *abfd, bfd_byte *buf, int width, int is_signed) 169 { 170 bfd_vma value; 171 172 switch (width) 173 { 174 case 2: 175 if (is_signed) 176 value = bfd_get_signed_16 (abfd, buf); 177 else 178 value = bfd_get_16 (abfd, buf); 179 break; 180 case 4: 181 if (is_signed) 182 value = bfd_get_signed_32 (abfd, buf); 183 else 184 value = bfd_get_32 (abfd, buf); 185 break; 186 case 8: 187 if (is_signed) 188 value = bfd_get_signed_64 (abfd, buf); 189 else 190 value = bfd_get_64 (abfd, buf); 191 break; 192 default: 193 BFD_FAIL (); 194 return 0; 195 } 196 197 return value; 198 } 199 200 /* Store a width sized value to memory. */ 201 202 static void 203 write_value (bfd *abfd, bfd_byte *buf, bfd_vma value, int width) 204 { 205 switch (width) 206 { 207 case 2: bfd_put_16 (abfd, value, buf); break; 208 case 4: bfd_put_32 (abfd, value, buf); break; 209 case 8: bfd_put_64 (abfd, value, buf); break; 210 default: BFD_FAIL (); 211 } 212 } 213 214 /* Return one if C1 and C2 CIEs can be merged. */ 215 216 static int 217 cie_eq (const void *e1, const void *e2) 218 { 219 const struct cie *c1 = (const struct cie *) e1; 220 const struct cie *c2 = (const struct cie *) e2; 221 222 if (c1->hash == c2->hash 223 && c1->length == c2->length 224 && c1->version == c2->version 225 && c1->local_personality == c2->local_personality 226 && strcmp (c1->augmentation, c2->augmentation) == 0 227 && strcmp (c1->augmentation, "eh") != 0 228 && c1->code_align == c2->code_align 229 && c1->data_align == c2->data_align 230 && c1->ra_column == c2->ra_column 231 && c1->augmentation_size == c2->augmentation_size 232 && memcmp (&c1->personality, &c2->personality, 233 sizeof (c1->personality)) == 0 234 && (c1->cie_inf->u.cie.u.sec->output_section 235 == c2->cie_inf->u.cie.u.sec->output_section) 236 && c1->per_encoding == c2->per_encoding 237 && c1->lsda_encoding == c2->lsda_encoding 238 && c1->fde_encoding == c2->fde_encoding 239 && c1->initial_insn_length == c2->initial_insn_length 240 && c1->initial_insn_length <= sizeof (c1->initial_instructions) 241 && memcmp (c1->initial_instructions, 242 c2->initial_instructions, 243 c1->initial_insn_length) == 0) 244 return 1; 245 246 return 0; 247 } 248 249 static hashval_t 250 cie_hash (const void *e) 251 { 252 const struct cie *c = (const struct cie *) e; 253 return c->hash; 254 } 255 256 static hashval_t 257 cie_compute_hash (struct cie *c) 258 { 259 hashval_t h = 0; 260 size_t len; 261 h = iterative_hash_object (c->length, h); 262 h = iterative_hash_object (c->version, h); 263 h = iterative_hash (c->augmentation, strlen (c->augmentation) + 1, h); 264 h = iterative_hash_object (c->code_align, h); 265 h = iterative_hash_object (c->data_align, h); 266 h = iterative_hash_object (c->ra_column, h); 267 h = iterative_hash_object (c->augmentation_size, h); 268 h = iterative_hash_object (c->personality, h); 269 h = iterative_hash_object (c->cie_inf->u.cie.u.sec->output_section, h); 270 h = iterative_hash_object (c->per_encoding, h); 271 h = iterative_hash_object (c->lsda_encoding, h); 272 h = iterative_hash_object (c->fde_encoding, h); 273 h = iterative_hash_object (c->initial_insn_length, h); 274 len = c->initial_insn_length; 275 if (len > sizeof (c->initial_instructions)) 276 len = sizeof (c->initial_instructions); 277 h = iterative_hash (c->initial_instructions, len, h); 278 c->hash = h; 279 return h; 280 } 281 282 /* Return the number of extra bytes that we'll be inserting into 283 ENTRY's augmentation string. */ 284 285 static inline unsigned int 286 extra_augmentation_string_bytes (struct eh_cie_fde *entry) 287 { 288 unsigned int size = 0; 289 if (entry->cie) 290 { 291 if (entry->add_augmentation_size) 292 size++; 293 if (entry->u.cie.add_fde_encoding) 294 size++; 295 } 296 return size; 297 } 298 299 /* Likewise ENTRY's augmentation data. */ 300 301 static inline unsigned int 302 extra_augmentation_data_bytes (struct eh_cie_fde *entry) 303 { 304 unsigned int size = 0; 305 if (entry->add_augmentation_size) 306 size++; 307 if (entry->cie && entry->u.cie.add_fde_encoding) 308 size++; 309 return size; 310 } 311 312 /* Return the size that ENTRY will have in the output. */ 313 314 static unsigned int 315 size_of_output_cie_fde (struct eh_cie_fde *entry) 316 { 317 if (entry->removed) 318 return 0; 319 if (entry->size == 4) 320 return 4; 321 return (entry->size 322 + extra_augmentation_string_bytes (entry) 323 + extra_augmentation_data_bytes (entry)); 324 } 325 326 /* Return the offset of the FDE or CIE after ENT. */ 327 328 static unsigned int 329 next_cie_fde_offset (const struct eh_cie_fde *ent, 330 const struct eh_cie_fde *last, 331 const asection *sec) 332 { 333 while (++ent < last) 334 { 335 if (!ent->removed) 336 return ent->new_offset; 337 } 338 return sec->size; 339 } 340 341 /* Assume that the bytes between *ITER and END are CFA instructions. 342 Try to move *ITER past the first instruction and return true on 343 success. ENCODED_PTR_WIDTH gives the width of pointer entries. */ 344 345 static bool 346 skip_cfa_op (bfd_byte **iter, bfd_byte *end, unsigned int encoded_ptr_width) 347 { 348 bfd_byte op = 0; 349 bfd_vma length; 350 351 if (!read_byte (iter, end, &op)) 352 return false; 353 354 switch (op & 0xc0 ? op & 0xc0 : op) 355 { 356 case DW_CFA_nop: 357 case DW_CFA_advance_loc: 358 case DW_CFA_restore: 359 case DW_CFA_remember_state: 360 case DW_CFA_restore_state: 361 case DW_CFA_GNU_window_save: 362 case DW_CFA_AARCH64_negate_ra_state_with_pc: 363 /* No arguments. */ 364 return true; 365 366 case DW_CFA_offset: 367 case DW_CFA_restore_extended: 368 case DW_CFA_undefined: 369 case DW_CFA_same_value: 370 case DW_CFA_def_cfa_register: 371 case DW_CFA_def_cfa_offset: 372 case DW_CFA_def_cfa_offset_sf: 373 case DW_CFA_GNU_args_size: 374 /* One leb128 argument. */ 375 return skip_leb128 (iter, end); 376 377 case DW_CFA_val_offset: 378 case DW_CFA_val_offset_sf: 379 case DW_CFA_offset_extended: 380 case DW_CFA_register: 381 case DW_CFA_def_cfa: 382 case DW_CFA_offset_extended_sf: 383 case DW_CFA_GNU_negative_offset_extended: 384 case DW_CFA_def_cfa_sf: 385 /* Two leb128 arguments. */ 386 return (skip_leb128 (iter, end) 387 && skip_leb128 (iter, end)); 388 389 case DW_CFA_def_cfa_expression: 390 /* A variable-length argument. */ 391 return (read_uleb128 (iter, end, &length) 392 && skip_bytes (iter, end, length)); 393 394 case DW_CFA_expression: 395 case DW_CFA_val_expression: 396 /* A leb128 followed by a variable-length argument. */ 397 return (skip_leb128 (iter, end) 398 && read_uleb128 (iter, end, &length) 399 && skip_bytes (iter, end, length)); 400 401 case DW_CFA_set_loc: 402 return skip_bytes (iter, end, encoded_ptr_width); 403 404 case DW_CFA_advance_loc1: 405 return skip_bytes (iter, end, 1); 406 407 case DW_CFA_advance_loc2: 408 return skip_bytes (iter, end, 2); 409 410 case DW_CFA_advance_loc4: 411 return skip_bytes (iter, end, 4); 412 413 case DW_CFA_MIPS_advance_loc8: 414 return skip_bytes (iter, end, 8); 415 416 default: 417 return false; 418 } 419 } 420 421 /* Try to interpret the bytes between BUF and END as CFA instructions. 422 If every byte makes sense, return a pointer to the first DW_CFA_nop 423 padding byte, or END if there is no padding. Return null otherwise. 424 ENCODED_PTR_WIDTH is as for skip_cfa_op. */ 425 426 static bfd_byte * 427 skip_non_nops (bfd_byte *buf, bfd_byte *end, unsigned int encoded_ptr_width, 428 unsigned int *set_loc_count) 429 { 430 bfd_byte *last; 431 432 last = buf; 433 while (buf < end) 434 if (*buf == DW_CFA_nop) 435 buf++; 436 else 437 { 438 if (*buf == DW_CFA_set_loc) 439 ++*set_loc_count; 440 if (!skip_cfa_op (&buf, end, encoded_ptr_width)) 441 return 0; 442 last = buf; 443 } 444 return last; 445 } 446 447 /* Convert absolute encoding ENCODING into PC-relative form. 448 SIZE is the size of a pointer. */ 449 450 static unsigned char 451 make_pc_relative (unsigned char encoding, unsigned int ptr_size) 452 { 453 if ((encoding & 0x7f) == DW_EH_PE_absptr) 454 switch (ptr_size) 455 { 456 case 2: 457 encoding |= DW_EH_PE_sdata2; 458 break; 459 case 4: 460 encoding |= DW_EH_PE_sdata4; 461 break; 462 case 8: 463 encoding |= DW_EH_PE_sdata8; 464 break; 465 } 466 return encoding | DW_EH_PE_pcrel; 467 } 468 469 /* Examine each .eh_frame_entry section and discard those 470 those that are marked SEC_EXCLUDE. */ 471 472 static void 473 bfd_elf_discard_eh_frame_entry (struct eh_frame_hdr_info *hdr_info) 474 { 475 unsigned int i; 476 for (i = 0; i < hdr_info->array_count; i++) 477 { 478 if (hdr_info->u.compact.entries[i]->flags & SEC_EXCLUDE) 479 { 480 unsigned int j; 481 for (j = i + 1; j < hdr_info->array_count; j++) 482 hdr_info->u.compact.entries[j-1] = hdr_info->u.compact.entries[j]; 483 484 hdr_info->array_count--; 485 hdr_info->u.compact.entries[hdr_info->array_count] = NULL; 486 i--; 487 } 488 } 489 } 490 491 /* Add a .eh_frame_entry section. */ 492 493 static void 494 bfd_elf_record_eh_frame_entry (struct eh_frame_hdr_info *hdr_info, 495 asection *sec) 496 { 497 if (hdr_info->array_count == hdr_info->u.compact.allocated_entries) 498 { 499 if (hdr_info->u.compact.allocated_entries == 0) 500 { 501 hdr_info->frame_hdr_is_compact = true; 502 hdr_info->u.compact.allocated_entries = 2; 503 hdr_info->u.compact.entries = 504 bfd_malloc (hdr_info->u.compact.allocated_entries 505 * sizeof (hdr_info->u.compact.entries[0])); 506 } 507 else 508 { 509 hdr_info->u.compact.allocated_entries *= 2; 510 hdr_info->u.compact.entries = 511 bfd_realloc (hdr_info->u.compact.entries, 512 hdr_info->u.compact.allocated_entries 513 * sizeof (hdr_info->u.compact.entries[0])); 514 } 515 516 BFD_ASSERT (hdr_info->u.compact.entries); 517 } 518 519 hdr_info->u.compact.entries[hdr_info->array_count++] = sec; 520 } 521 522 /* Parse a .eh_frame_entry section. Figure out which text section it 523 references. */ 524 525 bool 526 _bfd_elf_parse_eh_frame_entry (struct bfd_link_info *info, 527 asection *sec, struct elf_reloc_cookie *cookie) 528 { 529 struct elf_link_hash_table *htab; 530 struct eh_frame_hdr_info *hdr_info; 531 unsigned long r_symndx; 532 asection *text_sec; 533 534 htab = elf_hash_table (info); 535 hdr_info = &htab->eh_info; 536 537 if (sec->size == 0 538 || sec->sec_info_type != SEC_INFO_TYPE_NONE) 539 { 540 return true; 541 } 542 543 if (sec->output_section && bfd_is_abs_section (sec->output_section)) 544 { 545 /* At least one of the sections is being discarded from the 546 link, so we should just ignore them. */ 547 return true; 548 } 549 550 if (cookie->rel == cookie->relend) 551 return false; 552 553 /* The first relocation is the function start. */ 554 r_symndx = cookie->rel->r_info >> cookie->r_sym_shift; 555 if (r_symndx == STN_UNDEF) 556 return false; 557 558 text_sec = _bfd_elf_section_for_symbol (cookie, r_symndx); 559 560 if (text_sec == NULL) 561 return false; 562 563 elf_section_eh_frame_entry (text_sec) = sec; 564 if (text_sec->output_section 565 && bfd_is_abs_section (text_sec->output_section)) 566 sec->flags |= SEC_EXCLUDE; 567 568 sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME_ENTRY; 569 sec->sec_info = text_sec; 570 bfd_elf_record_eh_frame_entry (hdr_info, sec); 571 return true; 572 } 573 574 /* Try to parse .eh_frame section SEC, which belongs to ABFD. Store the 575 information in the section's sec_info field on success. COOKIE 576 describes the relocations in SEC. */ 577 578 void 579 _bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info, 580 asection *sec, struct elf_reloc_cookie *cookie) 581 { 582 #define REQUIRE(COND) \ 583 do \ 584 if (!(COND)) \ 585 goto free_no_table; \ 586 while (0) 587 588 bfd_byte *ehbuf = NULL, *buf, *end; 589 bfd_byte *last_fde; 590 struct eh_cie_fde *this_inf; 591 unsigned int hdr_length, hdr_id; 592 unsigned int cie_count; 593 struct cie *cie, *local_cies = NULL; 594 struct elf_link_hash_table *htab; 595 struct eh_frame_hdr_info *hdr_info; 596 struct eh_frame_sec_info *sec_info = NULL; 597 unsigned int ptr_size; 598 unsigned int num_cies; 599 unsigned int num_entries; 600 elf_gc_mark_hook_fn gc_mark_hook; 601 602 htab = elf_hash_table (info); 603 hdr_info = &htab->eh_info; 604 605 if (sec->size == 0 606 || (sec->flags & SEC_HAS_CONTENTS) == 0 607 || sec->sec_info_type != SEC_INFO_TYPE_NONE) 608 { 609 /* This file does not contain .eh_frame information or 610 .eh_frame has already been parsed, as can happen with 611 --gc-sections. */ 612 return; 613 } 614 615 if (bfd_is_abs_section (sec->output_section)) 616 { 617 /* At least one of the sections is being discarded from the 618 link, so we should just ignore them. */ 619 return; 620 } 621 622 /* Read the frame unwind information from abfd. */ 623 624 REQUIRE (_bfd_elf_mmap_section_contents (abfd, sec, &ehbuf)); 625 626 /* If .eh_frame section size doesn't fit into int, we cannot handle 627 it (it would need to use 64-bit .eh_frame format anyway). */ 628 REQUIRE (sec->size == (unsigned int) sec->size); 629 630 ptr_size = (get_elf_backend_data (abfd) 631 ->elf_backend_eh_frame_address_size (abfd, sec)); 632 REQUIRE (ptr_size != 0); 633 634 /* Go through the section contents and work out how many FDEs and 635 CIEs there are. */ 636 buf = ehbuf; 637 end = ehbuf + sec->size; 638 num_cies = 0; 639 num_entries = 0; 640 while (buf != end) 641 { 642 num_entries++; 643 644 /* Read the length of the entry. */ 645 REQUIRE (skip_bytes (&buf, end, 4)); 646 hdr_length = bfd_get_32 (abfd, buf - 4); 647 648 /* 64-bit .eh_frame is not supported. */ 649 REQUIRE (hdr_length != 0xffffffff); 650 if (hdr_length == 0) 651 break; 652 653 REQUIRE (skip_bytes (&buf, end, 4)); 654 hdr_id = bfd_get_32 (abfd, buf - 4); 655 if (hdr_id == 0) 656 num_cies++; 657 658 REQUIRE (skip_bytes (&buf, end, hdr_length - 4)); 659 } 660 661 sec_info = bfd_zalloc (abfd, 662 (sizeof (struct eh_frame_sec_info) 663 + (num_entries - 1) * sizeof (struct eh_cie_fde))); 664 REQUIRE (sec_info); 665 666 /* We need to have a "struct cie" for each CIE in this section. */ 667 if (num_cies) 668 { 669 local_cies = (struct cie *) bfd_zmalloc (num_cies * sizeof (*local_cies)); 670 REQUIRE (local_cies); 671 } 672 673 /* FIXME: octets_per_byte. */ 674 #define ENSURE_NO_RELOCS(buf) \ 675 while (cookie->rel < cookie->relend \ 676 && (cookie->rel->r_offset \ 677 < (bfd_size_type) ((buf) - ehbuf))) \ 678 { \ 679 REQUIRE (cookie->rel->r_info == 0); \ 680 cookie->rel++; \ 681 } 682 683 /* FIXME: octets_per_byte. */ 684 #define SKIP_RELOCS(buf) \ 685 while (cookie->rel < cookie->relend \ 686 && (cookie->rel->r_offset \ 687 < (bfd_size_type) ((buf) - ehbuf))) \ 688 cookie->rel++ 689 690 /* FIXME: octets_per_byte. */ 691 #define GET_RELOC(buf) \ 692 ((cookie->rel < cookie->relend \ 693 && (cookie->rel->r_offset \ 694 == (bfd_size_type) ((buf) - ehbuf))) \ 695 ? cookie->rel : NULL) 696 697 buf = ehbuf; 698 cie_count = 0; 699 gc_mark_hook = get_elf_backend_data (abfd)->gc_mark_hook; 700 while ((bfd_size_type) (buf - ehbuf) != sec->size) 701 { 702 char *aug; 703 bfd_byte *start, *insns, *insns_end; 704 bfd_size_type length; 705 unsigned int set_loc_count; 706 707 this_inf = sec_info->entry + sec_info->count; 708 last_fde = buf; 709 710 /* Read the length of the entry. */ 711 REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4)); 712 hdr_length = bfd_get_32 (abfd, buf - 4); 713 714 /* The CIE/FDE must be fully contained in this input section. */ 715 REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size); 716 end = buf + hdr_length; 717 718 this_inf->offset = last_fde - ehbuf; 719 this_inf->size = 4 + hdr_length; 720 this_inf->reloc_index = cookie->rel - cookie->rels; 721 722 if (hdr_length == 0) 723 { 724 /* A zero-length CIE should only be found at the end of 725 the section, but allow multiple terminators. */ 726 while (skip_bytes (&buf, ehbuf + sec->size, 4)) 727 REQUIRE (bfd_get_32 (abfd, buf - 4) == 0); 728 REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size); 729 ENSURE_NO_RELOCS (buf); 730 sec_info->count++; 731 break; 732 } 733 734 REQUIRE (skip_bytes (&buf, end, 4)); 735 hdr_id = bfd_get_32 (abfd, buf - 4); 736 737 if (hdr_id == 0) 738 { 739 unsigned int initial_insn_length; 740 char *null_byte; 741 742 /* CIE */ 743 this_inf->cie = 1; 744 745 /* Point CIE to one of the section-local cie structures. */ 746 cie = local_cies + cie_count++; 747 748 cie->cie_inf = this_inf; 749 cie->length = hdr_length; 750 start = buf; 751 REQUIRE (read_byte (&buf, end, &cie->version)); 752 753 /* Cannot handle unknown versions. */ 754 REQUIRE (cie->version == 1 755 || cie->version == 3 756 || cie->version == 4); 757 null_byte = memchr ((char *) buf, 0, end - buf); 758 REQUIRE (null_byte != NULL); 759 REQUIRE ((size_t) (null_byte - (char *) buf) 760 < sizeof (cie->augmentation)); 761 762 strcpy (cie->augmentation, (char *) buf); 763 buf = (bfd_byte *) null_byte + 1; 764 REQUIRE (buf + 1 < end); 765 this_inf->u.cie.aug_str_len = buf - start - 1; 766 ENSURE_NO_RELOCS (buf); 767 if (buf[0] == 'e' && buf[1] == 'h') 768 { 769 /* GCC < 3.0 .eh_frame CIE */ 770 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__ 771 is private to each CIE, so we don't need it for anything. 772 Just skip it. */ 773 REQUIRE (skip_bytes (&buf, end, ptr_size)); 774 SKIP_RELOCS (buf); 775 } 776 if (cie->version >= 4) 777 { 778 REQUIRE (buf + 1 < end); 779 REQUIRE (buf[0] == ptr_size); 780 REQUIRE (buf[1] == 0); 781 buf += 2; 782 } 783 REQUIRE (read_uleb128 (&buf, end, &cie->code_align)); 784 REQUIRE (read_sleb128 (&buf, end, &cie->data_align)); 785 if (cie->version == 1) 786 { 787 REQUIRE (buf < end); 788 cie->ra_column = *buf++; 789 } 790 else 791 REQUIRE (read_uleb128 (&buf, end, &cie->ra_column)); 792 ENSURE_NO_RELOCS (buf); 793 cie->lsda_encoding = DW_EH_PE_omit; 794 cie->fde_encoding = DW_EH_PE_omit; 795 cie->per_encoding = DW_EH_PE_omit; 796 aug = cie->augmentation; 797 if (aug[0] != 'e' || aug[1] != 'h') 798 { 799 if (*aug == 'z') 800 { 801 aug++; 802 REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size)); 803 ENSURE_NO_RELOCS (buf); 804 } 805 806 while (*aug != '\0') 807 switch (*aug++) 808 { 809 case 'B': 810 case 'G': 811 if (abfd->arch_info->arch != bfd_arch_aarch64) 812 goto unrecognized; 813 break; 814 case 'L': 815 REQUIRE (read_byte (&buf, end, &cie->lsda_encoding)); 816 ENSURE_NO_RELOCS (buf); 817 REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size)); 818 break; 819 case 'R': 820 REQUIRE (read_byte (&buf, end, &cie->fde_encoding)); 821 ENSURE_NO_RELOCS (buf); 822 REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size)); 823 break; 824 case 'S': 825 break; 826 case 'P': 827 { 828 int per_width; 829 830 REQUIRE (read_byte (&buf, end, &cie->per_encoding)); 831 per_width = get_DW_EH_PE_width (cie->per_encoding, 832 ptr_size); 833 REQUIRE (per_width); 834 if ((cie->per_encoding & 0x70) == DW_EH_PE_aligned) 835 { 836 length = -(buf - ehbuf) & (per_width - 1); 837 REQUIRE (skip_bytes (&buf, end, length)); 838 if (per_width == 8) 839 this_inf->u.cie.per_encoding_aligned8 = 1; 840 } 841 this_inf->u.cie.personality_offset = buf - start; 842 ENSURE_NO_RELOCS (buf); 843 /* Ensure we have a reloc here. */ 844 REQUIRE (GET_RELOC (buf)); 845 cie->personality.reloc_index 846 = cookie->rel - cookie->rels; 847 /* Cope with MIPS-style composite relocations. */ 848 do 849 cookie->rel++; 850 while (GET_RELOC (buf) != NULL); 851 REQUIRE (skip_bytes (&buf, end, per_width)); 852 } 853 break; 854 unrecognized: 855 default: 856 /* Unrecognized augmentation. Better bail out. */ 857 goto free_no_table; 858 } 859 } 860 this_inf->u.cie.aug_data_len 861 = buf - start - 1 - this_inf->u.cie.aug_str_len; 862 863 /* For shared libraries, try to get rid of as many RELATIVE relocs 864 as possible. */ 865 if (bfd_link_pic (info) 866 && (get_elf_backend_data (abfd) 867 ->elf_backend_can_make_relative_eh_frame 868 (abfd, info, sec))) 869 { 870 if ((cie->fde_encoding & 0x70) == DW_EH_PE_absptr) 871 this_inf->make_relative = 1; 872 /* If the CIE doesn't already have an 'R' entry, it's fairly 873 easy to add one, provided that there's no aligned data 874 after the augmentation string. */ 875 else if (cie->fde_encoding == DW_EH_PE_omit 876 && (cie->per_encoding & 0x70) != DW_EH_PE_aligned) 877 { 878 if (*cie->augmentation == 0) 879 this_inf->add_augmentation_size = 1; 880 this_inf->u.cie.add_fde_encoding = 1; 881 this_inf->make_relative = 1; 882 } 883 884 if ((cie->lsda_encoding & 0x70) == DW_EH_PE_absptr) 885 cie->can_make_lsda_relative = 1; 886 } 887 888 /* If FDE encoding was not specified, it defaults to 889 DW_EH_absptr. */ 890 if (cie->fde_encoding == DW_EH_PE_omit) 891 cie->fde_encoding = DW_EH_PE_absptr; 892 893 initial_insn_length = end - buf; 894 cie->initial_insn_length = initial_insn_length; 895 memcpy (cie->initial_instructions, buf, 896 initial_insn_length <= sizeof (cie->initial_instructions) 897 ? initial_insn_length : sizeof (cie->initial_instructions)); 898 insns = buf; 899 buf += initial_insn_length; 900 ENSURE_NO_RELOCS (buf); 901 902 if (!bfd_link_relocatable (info)) 903 { 904 /* Keep info for merging cies. */ 905 this_inf->u.cie.u.full_cie = cie; 906 this_inf->u.cie.per_encoding_relative 907 = (cie->per_encoding & 0x70) == DW_EH_PE_pcrel; 908 } 909 } 910 else 911 { 912 /* Find the corresponding CIE. */ 913 unsigned int cie_offset = this_inf->offset + 4 - hdr_id; 914 for (cie = local_cies; cie < local_cies + cie_count; cie++) 915 if (cie_offset == cie->cie_inf->offset) 916 break; 917 918 /* Ensure this FDE references one of the CIEs in this input 919 section. */ 920 REQUIRE (cie != local_cies + cie_count); 921 this_inf->u.fde.cie_inf = cie->cie_inf; 922 this_inf->make_relative = cie->cie_inf->make_relative; 923 this_inf->add_augmentation_size 924 = cie->cie_inf->add_augmentation_size; 925 926 ENSURE_NO_RELOCS (buf); 927 if ((sec->flags & SEC_LINKER_CREATED) == 0 || cookie->rels != NULL) 928 { 929 asection *rsec; 930 931 REQUIRE (GET_RELOC (buf)); 932 933 /* Chain together the FDEs for each section. */ 934 rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, 935 cookie, NULL); 936 /* RSEC will be NULL if FDE was cleared out as it was belonging to 937 a discarded SHT_GROUP. */ 938 if (rsec) 939 { 940 REQUIRE (rsec->owner == abfd); 941 this_inf->u.fde.next_for_section = elf_fde_list (rsec); 942 elf_fde_list (rsec) = this_inf; 943 } 944 } 945 946 /* Skip the initial location and address range. */ 947 start = buf; 948 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size); 949 REQUIRE (skip_bytes (&buf, end, 2 * length)); 950 951 SKIP_RELOCS (buf - length); 952 if (!GET_RELOC (buf - length) 953 && read_value (abfd, buf - length, length, false) == 0) 954 { 955 (*info->callbacks->minfo) 956 /* xgettext:c-format */ 957 (_("discarding zero address range FDE in %pB(%pA).\n"), 958 abfd, sec); 959 this_inf->u.fde.cie_inf = NULL; 960 } 961 962 /* Skip the augmentation size, if present. */ 963 if (cie->augmentation[0] == 'z') 964 REQUIRE (read_uleb128 (&buf, end, &length)); 965 else 966 length = 0; 967 968 /* Of the supported augmentation characters above, only 'L' 969 adds augmentation data to the FDE. This code would need to 970 be adjusted if any future augmentations do the same thing. */ 971 if (cie->lsda_encoding != DW_EH_PE_omit) 972 { 973 SKIP_RELOCS (buf); 974 if (cie->can_make_lsda_relative && GET_RELOC (buf)) 975 cie->cie_inf->u.cie.make_lsda_relative = 1; 976 this_inf->lsda_offset = buf - start; 977 /* If there's no 'z' augmentation, we don't know where the 978 CFA insns begin. Assume no padding. */ 979 if (cie->augmentation[0] != 'z') 980 length = end - buf; 981 } 982 983 /* Skip over the augmentation data. */ 984 REQUIRE (skip_bytes (&buf, end, length)); 985 insns = buf; 986 987 buf = last_fde + 4 + hdr_length; 988 989 /* For NULL RSEC (cleared FDE belonging to a discarded section) 990 the relocations are commonly cleared. We do not sanity check if 991 all these relocations are cleared as (1) relocations to 992 .gcc_except_table will remain uncleared (they will get dropped 993 with the drop of this unused FDE) and (2) BFD already safely drops 994 relocations of any type to .eh_frame by 995 elf_section_ignore_discarded_relocs. 996 TODO: The .gcc_except_table entries should be also filtered as 997 .eh_frame entries; or GCC could rather use COMDAT for them. */ 998 SKIP_RELOCS (buf); 999 } 1000 1001 /* Try to interpret the CFA instructions and find the first 1002 padding nop. Shrink this_inf's size so that it doesn't 1003 include the padding. */ 1004 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size); 1005 set_loc_count = 0; 1006 insns_end = skip_non_nops (insns, end, length, &set_loc_count); 1007 /* If we don't understand the CFA instructions, we can't know 1008 what needs to be adjusted there. */ 1009 if (insns_end == NULL 1010 /* For the time being we don't support DW_CFA_set_loc in 1011 CIE instructions. */ 1012 || (set_loc_count && this_inf->cie)) 1013 goto free_no_table; 1014 this_inf->size -= end - insns_end; 1015 if (insns_end != end && this_inf->cie) 1016 { 1017 cie->initial_insn_length -= end - insns_end; 1018 cie->length -= end - insns_end; 1019 } 1020 if (set_loc_count 1021 && ((cie->fde_encoding & 0x70) == DW_EH_PE_pcrel 1022 || this_inf->make_relative)) 1023 { 1024 unsigned int cnt; 1025 bfd_byte *p; 1026 1027 this_inf->set_loc 1028 = bfd_alloc (abfd, (set_loc_count + 1) * sizeof (unsigned int)); 1029 REQUIRE (this_inf->set_loc); 1030 this_inf->set_loc[0] = set_loc_count; 1031 p = insns; 1032 cnt = 0; 1033 while (p < end) 1034 { 1035 if (*p == DW_CFA_set_loc) 1036 this_inf->set_loc[++cnt] = p + 1 - start; 1037 REQUIRE (skip_cfa_op (&p, end, length)); 1038 } 1039 } 1040 1041 this_inf->removed = 1; 1042 this_inf->fde_encoding = cie->fde_encoding; 1043 this_inf->lsda_encoding = cie->lsda_encoding; 1044 sec_info->count++; 1045 } 1046 BFD_ASSERT (sec_info->count == num_entries); 1047 BFD_ASSERT (cie_count == num_cies); 1048 1049 sec->sec_info = sec_info; 1050 sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME; 1051 if (!bfd_link_relocatable (info)) 1052 { 1053 /* Keep info for merging cies. */ 1054 sec_info->cies = local_cies; 1055 local_cies = NULL; 1056 } 1057 goto success; 1058 1059 free_no_table: 1060 _bfd_error_handler 1061 /* xgettext:c-format */ 1062 (_("error in %pB(%pA); no .eh_frame_hdr table will be created"), 1063 abfd, sec); 1064 hdr_info->u.dwarf.table = false; 1065 success: 1066 _bfd_elf_munmap_section_contents (sec, ehbuf); 1067 free (local_cies); 1068 #undef REQUIRE 1069 } 1070 1071 /* Order eh_frame_hdr entries by the VMA of their text section. */ 1072 1073 static int 1074 cmp_eh_frame_hdr (const void *a, const void *b) 1075 { 1076 bfd_vma text_a; 1077 bfd_vma text_b; 1078 asection *sec; 1079 1080 sec = *(asection *const *)a; 1081 sec = sec->sec_info; 1082 text_a = sec->output_section->vma + sec->output_offset; 1083 sec = *(asection *const *)b; 1084 sec = sec->sec_info; 1085 text_b = sec->output_section->vma + sec->output_offset; 1086 1087 if (text_a < text_b) 1088 return -1; 1089 return text_a > text_b; 1090 1091 } 1092 1093 /* Add space for a CANTUNWIND terminator to SEC if the text sections 1094 referenced by it and NEXT are not contiguous, or NEXT is NULL. */ 1095 1096 static void 1097 add_eh_frame_hdr_terminator (asection *sec, 1098 asection *next) 1099 { 1100 bfd_vma end; 1101 bfd_vma next_start; 1102 asection *text_sec; 1103 1104 if (next) 1105 { 1106 /* See if there is a gap (presumably a text section without unwind info) 1107 between these two entries. */ 1108 text_sec = sec->sec_info; 1109 end = text_sec->output_section->vma + text_sec->output_offset 1110 + text_sec->size; 1111 text_sec = next->sec_info; 1112 next_start = text_sec->output_section->vma + text_sec->output_offset; 1113 if (end == next_start) 1114 return; 1115 } 1116 1117 /* Add space for a CANTUNWIND terminator. */ 1118 if (!sec->rawsize) 1119 sec->rawsize = sec->size; 1120 1121 bfd_set_section_size (sec, sec->size + 8); 1122 } 1123 1124 /* Finish a pass over all .eh_frame_entry sections. */ 1125 1126 bool 1127 _bfd_elf_end_eh_frame_parsing (struct bfd_link_info *info) 1128 { 1129 struct eh_frame_hdr_info *hdr_info; 1130 unsigned int i; 1131 1132 hdr_info = &elf_hash_table (info)->eh_info; 1133 1134 if (info->eh_frame_hdr_type != COMPACT_EH_HDR 1135 || hdr_info->array_count == 0) 1136 return false; 1137 1138 bfd_elf_discard_eh_frame_entry (hdr_info); 1139 1140 qsort (hdr_info->u.compact.entries, hdr_info->array_count, 1141 sizeof (asection *), cmp_eh_frame_hdr); 1142 1143 for (i = 0; i < hdr_info->array_count - 1; i++) 1144 { 1145 add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i], 1146 hdr_info->u.compact.entries[i + 1]); 1147 } 1148 1149 /* Add a CANTUNWIND terminator after the last entry. */ 1150 add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i], NULL); 1151 return true; 1152 } 1153 1154 /* Mark all relocations against CIE or FDE ENT, which occurs in 1155 .eh_frame section SEC. COOKIE describes the relocations in SEC; 1156 its "rel" field can be changed freely. */ 1157 1158 static bool 1159 mark_entry (struct bfd_link_info *info, asection *sec, 1160 struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook, 1161 struct elf_reloc_cookie *cookie) 1162 { 1163 /* FIXME: octets_per_byte. */ 1164 for (cookie->rel = cookie->rels + ent->reloc_index; 1165 cookie->rel < cookie->relend 1166 && cookie->rel->r_offset < ent->offset + ent->size; 1167 cookie->rel++) 1168 if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie)) 1169 return false; 1170 1171 return true; 1172 } 1173 1174 /* Mark all the relocations against FDEs that relate to code in input 1175 section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose 1176 relocations are described by COOKIE. */ 1177 1178 bool 1179 _bfd_elf_gc_mark_fdes (struct bfd_link_info *info, asection *sec, 1180 asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook, 1181 struct elf_reloc_cookie *cookie) 1182 { 1183 struct eh_cie_fde *fde, *cie; 1184 1185 for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section) 1186 { 1187 if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie)) 1188 return false; 1189 1190 /* At this stage, all cie_inf fields point to local CIEs, so we 1191 can use the same cookie to refer to them. */ 1192 cie = fde->u.fde.cie_inf; 1193 if (cie != NULL && !cie->u.cie.gc_mark) 1194 { 1195 cie->u.cie.gc_mark = 1; 1196 if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie)) 1197 return false; 1198 } 1199 } 1200 return true; 1201 } 1202 1203 /* Input section SEC of ABFD is an .eh_frame section that contains the 1204 CIE described by CIE_INF. Return a version of CIE_INF that is going 1205 to be kept in the output, adding CIE_INF to the output if necessary. 1206 1207 HDR_INFO is the .eh_frame_hdr information and COOKIE describes the 1208 relocations in REL. */ 1209 1210 static struct eh_cie_fde * 1211 find_merged_cie (bfd *abfd, struct bfd_link_info *info, asection *sec, 1212 struct eh_frame_hdr_info *hdr_info, 1213 struct elf_reloc_cookie *cookie, 1214 struct eh_cie_fde *cie_inf) 1215 { 1216 unsigned long r_symndx; 1217 struct cie *cie, *new_cie; 1218 Elf_Internal_Rela *rel; 1219 void **loc; 1220 1221 /* Use CIE_INF if we have already decided to keep it. */ 1222 if (!cie_inf->removed) 1223 return cie_inf; 1224 1225 /* If we have merged CIE_INF with another CIE, use that CIE instead. */ 1226 if (cie_inf->u.cie.merged) 1227 return cie_inf->u.cie.u.merged_with; 1228 1229 cie = cie_inf->u.cie.u.full_cie; 1230 1231 /* Assume we will need to keep CIE_INF. */ 1232 cie_inf->removed = 0; 1233 cie_inf->u.cie.u.sec = sec; 1234 1235 /* If we are not merging CIEs, use CIE_INF. */ 1236 if (cie == NULL) 1237 return cie_inf; 1238 1239 if (cie->per_encoding != DW_EH_PE_omit) 1240 { 1241 struct elf_link_hash_entry *h; 1242 bool per_binds_local; 1243 1244 /* Work out the address of personality routine, or at least 1245 enough info that we could calculate the address had we made a 1246 final section layout. The symbol on the reloc is enough, 1247 either the hash for a global, or (bfd id, index) pair for a 1248 local. The assumption here is that no one uses addends on 1249 the reloc. */ 1250 rel = cookie->rels + cie->personality.reloc_index; 1251 memset (&cie->personality, 0, sizeof (cie->personality)); 1252 #ifdef BFD64 1253 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64) 1254 r_symndx = ELF64_R_SYM (rel->r_info); 1255 else 1256 #endif 1257 r_symndx = ELF32_R_SYM (rel->r_info); 1258 1259 if (r_symndx > cookie->num_sym) 1260 return cie_inf; 1261 h = NULL; 1262 if (r_symndx >= cookie->extsymoff) 1263 h = elf_sym_hashes (cookie->abfd)[r_symndx - cookie->extsymoff]; 1264 1265 if (h != NULL) 1266 { 1267 while (h->root.type == bfd_link_hash_indirect 1268 || h->root.type == bfd_link_hash_warning) 1269 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1270 1271 cie->personality.h = h; 1272 per_binds_local = SYMBOL_REFERENCES_LOCAL (info, h); 1273 } 1274 else 1275 { 1276 asection *sym_sec = _bfd_get_local_sym_section (cookie, r_symndx); 1277 if (sym_sec == NULL) 1278 return cie_inf; 1279 1280 if (sym_sec->kept_section != NULL) 1281 sym_sec = sym_sec->kept_section; 1282 if (sym_sec->output_section == NULL) 1283 return cie_inf; 1284 1285 cie->local_personality = 1; 1286 cie->personality.sym.bfd_id = abfd->id; 1287 cie->personality.sym.index = r_symndx; 1288 per_binds_local = true; 1289 } 1290 1291 if (per_binds_local 1292 && bfd_link_pic (info) 1293 && (cie->per_encoding & 0x70) == DW_EH_PE_absptr 1294 && (get_elf_backend_data (abfd) 1295 ->elf_backend_can_make_relative_eh_frame (abfd, info, sec))) 1296 { 1297 cie_inf->u.cie.make_per_encoding_relative = 1; 1298 cie_inf->u.cie.per_encoding_relative = 1; 1299 } 1300 } 1301 1302 /* See if we can merge this CIE with an earlier one. */ 1303 cie_compute_hash (cie); 1304 if (hdr_info->u.dwarf.cies == NULL) 1305 { 1306 hdr_info->u.dwarf.cies = htab_try_create (1, cie_hash, cie_eq, free); 1307 if (hdr_info->u.dwarf.cies == NULL) 1308 return cie_inf; 1309 } 1310 loc = htab_find_slot_with_hash (hdr_info->u.dwarf.cies, cie, 1311 cie->hash, INSERT); 1312 if (loc == NULL) 1313 return cie_inf; 1314 1315 new_cie = (struct cie *) *loc; 1316 if (new_cie == NULL) 1317 { 1318 /* Keep CIE_INF and record it in the hash table. */ 1319 new_cie = bfd_malloc (sizeof (*new_cie)); 1320 if (new_cie == NULL) 1321 return cie_inf; 1322 1323 memcpy (new_cie, cie, sizeof (struct cie)); 1324 *loc = new_cie; 1325 } 1326 else 1327 { 1328 /* Merge CIE_INF with NEW_CIE->CIE_INF. */ 1329 cie_inf->removed = 1; 1330 cie_inf->u.cie.merged = 1; 1331 cie_inf->u.cie.u.merged_with = new_cie->cie_inf; 1332 if (cie_inf->u.cie.make_lsda_relative) 1333 new_cie->cie_inf->u.cie.make_lsda_relative = 1; 1334 } 1335 return new_cie->cie_inf; 1336 } 1337 1338 /* For a given OFFSET in SEC, return the delta to the new location 1339 after .eh_frame editing. */ 1340 1341 static bfd_signed_vma 1342 offset_adjust (bfd_vma offset, const asection *sec) 1343 { 1344 struct eh_frame_sec_info *sec_info = sec->sec_info; 1345 unsigned int lo, hi, mid; 1346 struct eh_cie_fde *ent = NULL; 1347 bfd_signed_vma delta; 1348 1349 lo = 0; 1350 hi = sec_info->count; 1351 if (hi == 0) 1352 return 0; 1353 1354 while (lo < hi) 1355 { 1356 mid = (lo + hi) / 2; 1357 ent = &sec_info->entry[mid]; 1358 if (offset < ent->offset) 1359 hi = mid; 1360 else if (mid + 1 >= hi) 1361 break; 1362 else if (offset >= ent[1].offset) 1363 lo = mid + 1; 1364 else 1365 break; 1366 } 1367 1368 if (!ent->removed) 1369 delta = (bfd_vma) ent->new_offset - (bfd_vma) ent->offset; 1370 else if (ent->cie && ent->u.cie.merged) 1371 { 1372 struct eh_cie_fde *cie = ent->u.cie.u.merged_with; 1373 delta = ((bfd_vma) cie->new_offset + cie->u.cie.u.sec->output_offset 1374 - (bfd_vma) ent->offset - sec->output_offset); 1375 } 1376 else 1377 { 1378 /* Is putting the symbol on the next entry best for a deleted 1379 CIE/FDE? */ 1380 struct eh_cie_fde *last = sec_info->entry + sec_info->count; 1381 delta = ((bfd_vma) next_cie_fde_offset (ent, last, sec) 1382 - (bfd_vma) ent->offset); 1383 return delta; 1384 } 1385 1386 /* Account for editing within this CIE/FDE. */ 1387 offset -= ent->offset; 1388 if (ent->cie) 1389 { 1390 unsigned int extra 1391 = ent->add_augmentation_size + ent->u.cie.add_fde_encoding; 1392 if (extra == 0 1393 || offset <= 9u + ent->u.cie.aug_str_len) 1394 return delta; 1395 delta += extra; 1396 if (offset <= 9u + ent->u.cie.aug_str_len + ent->u.cie.aug_data_len) 1397 return delta; 1398 delta += extra; 1399 } 1400 else 1401 { 1402 unsigned int ptr_size, width, extra = ent->add_augmentation_size; 1403 if (offset <= 12 || extra == 0) 1404 return delta; 1405 ptr_size = (get_elf_backend_data (sec->owner) 1406 ->elf_backend_eh_frame_address_size (sec->owner, sec)); 1407 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 1408 if (offset <= 8 + 2 * width) 1409 return delta; 1410 delta += extra; 1411 } 1412 1413 return delta; 1414 } 1415 1416 /* Adjust a global symbol defined in .eh_frame, so that it stays 1417 relative to its original CIE/FDE. It is assumed that a symbol 1418 defined at the beginning of a CIE/FDE belongs to that CIE/FDE 1419 rather than marking the end of the previous CIE/FDE. This matters 1420 when a CIE is merged with a previous CIE, since the symbol is 1421 moved to the merged CIE. */ 1422 1423 bool 1424 _bfd_elf_adjust_eh_frame_global_symbol (struct elf_link_hash_entry *h, 1425 void *arg ATTRIBUTE_UNUSED) 1426 { 1427 asection *sym_sec; 1428 bfd_signed_vma delta; 1429 1430 if (h->root.type != bfd_link_hash_defined 1431 && h->root.type != bfd_link_hash_defweak) 1432 return true; 1433 1434 sym_sec = h->root.u.def.section; 1435 if (sym_sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME 1436 || sym_sec->sec_info == NULL) 1437 return true; 1438 1439 delta = offset_adjust (h->root.u.def.value, sym_sec); 1440 h->root.u.def.value += delta; 1441 1442 return true; 1443 } 1444 1445 /* The same for all local symbols defined in .eh_frame. Returns the 1446 local symbols if any symbol was changed. */ 1447 1448 static Elf_Internal_Sym * 1449 adjust_eh_frame_local_symbols (const asection *sec, 1450 struct elf_reloc_cookie *cookie) 1451 { 1452 bfd *abfd = cookie->abfd; 1453 unsigned int *loc_shndx = elf_loc_shndx (abfd); 1454 unsigned int shndx = elf_section_data (sec)->this_idx; 1455 1456 if (loc_shndx != NULL) 1457 { 1458 unsigned int i; 1459 1460 for (i = 1; i < cookie->locsymcount; i++) 1461 if (loc_shndx[i] == shndx) 1462 break; 1463 if (i >= cookie->locsymcount) 1464 return NULL; 1465 } 1466 1467 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd); 1468 Elf_Internal_Sym *locsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, 1469 cookie->locsymcount, 0, 1470 NULL, NULL, NULL); 1471 if (locsyms == NULL) 1472 return NULL; 1473 1474 bool adjusted = false; 1475 Elf_Internal_Sym *sym; 1476 Elf_Internal_Sym *end_sym = locsyms + cookie->locsymcount; 1477 for (sym = locsyms + 1; sym < end_sym; ++sym) 1478 if (sym->st_info <= ELF_ST_INFO (STB_LOCAL, STT_OBJECT) 1479 && sym->st_shndx == shndx) 1480 { 1481 bfd_signed_vma delta = offset_adjust (sym->st_value, sec); 1482 1483 if (delta != 0) 1484 { 1485 adjusted = true; 1486 sym->st_value += delta; 1487 } 1488 } 1489 if (adjusted) 1490 return locsyms; 1491 free (locsyms); 1492 return NULL; 1493 } 1494 1495 /* This function is called for each input file before the .eh_frame 1496 section is relocated. It discards duplicate CIEs and FDEs for 1497 discarded functions. The function returns 0 when no changes are 1498 made, 1 when .eh_frame data has been edited and 2 when the editing 1499 results in a section size change. */ 1500 1501 int 1502 _bfd_elf_discard_section_eh_frame 1503 (bfd *abfd, struct bfd_link_info *info, asection *sec, 1504 bool (*reloc_symbol_deleted_p) (bfd_vma, void *), 1505 struct elf_reloc_cookie *cookie) 1506 { 1507 struct eh_cie_fde *ent; 1508 struct eh_frame_sec_info *sec_info; 1509 struct eh_frame_hdr_info *hdr_info; 1510 unsigned int ptr_size, offset, eh_alignment; 1511 int changed; 1512 1513 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME) 1514 return false; 1515 1516 sec_info = sec->sec_info; 1517 if (sec_info == NULL) 1518 return false; 1519 1520 ptr_size = (get_elf_backend_data (sec->owner) 1521 ->elf_backend_eh_frame_address_size (sec->owner, sec)); 1522 1523 hdr_info = &elf_hash_table (info)->eh_info; 1524 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent) 1525 if (ent->size == 4) 1526 /* There should only be one zero terminator, on the last input 1527 file supplying .eh_frame (crtend.o). Remove any others. */ 1528 ent->removed = sec->map_head.s != NULL; 1529 else if (!ent->cie && ent->u.fde.cie_inf != NULL) 1530 { 1531 bool keep; 1532 if ((sec->flags & SEC_LINKER_CREATED) != 0 && cookie->rels == NULL) 1533 { 1534 unsigned int width 1535 = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 1536 bfd_vma value 1537 = read_value (abfd, sec->contents + ent->offset + 8 + width, 1538 width, get_DW_EH_PE_signed (ent->fde_encoding)); 1539 keep = value != 0; 1540 } 1541 else 1542 { 1543 cookie->rel = cookie->rels + ent->reloc_index; 1544 /* FIXME: octets_per_byte. */ 1545 BFD_ASSERT (cookie->rel < cookie->relend 1546 && cookie->rel->r_offset == ent->offset + 8); 1547 keep = !(*reloc_symbol_deleted_p) (ent->offset + 8, cookie); 1548 } 1549 if (keep) 1550 { 1551 if (bfd_link_pic (info) 1552 && (((ent->fde_encoding & 0x70) == DW_EH_PE_absptr 1553 && ent->make_relative == 0) 1554 || (ent->fde_encoding & 0x70) == DW_EH_PE_aligned)) 1555 { 1556 static int num_warnings_issued = 0; 1557 1558 /* If a shared library uses absolute pointers 1559 which we cannot turn into PC relative, 1560 don't create the binary search table, 1561 since it is affected by runtime relocations. */ 1562 hdr_info->u.dwarf.table = false; 1563 /* Only warn if --eh-frame-hdr was specified. */ 1564 if (info->eh_frame_hdr_type != 0) 1565 { 1566 if (num_warnings_issued < 10) 1567 { 1568 _bfd_error_handler 1569 /* xgettext:c-format */ 1570 (_("FDE encoding in %pB(%pA) prevents .eh_frame_hdr" 1571 " table being created"), abfd, sec); 1572 num_warnings_issued ++; 1573 } 1574 else if (num_warnings_issued == 10) 1575 { 1576 _bfd_error_handler 1577 (_("further warnings about FDE encoding preventing .eh_frame_hdr generation dropped")); 1578 num_warnings_issued ++; 1579 } 1580 } 1581 } 1582 ent->removed = 0; 1583 hdr_info->u.dwarf.fde_count++; 1584 ent->u.fde.cie_inf = find_merged_cie (abfd, info, sec, hdr_info, 1585 cookie, ent->u.fde.cie_inf); 1586 } 1587 } 1588 1589 free (sec_info->cies); 1590 sec_info->cies = NULL; 1591 1592 /* It may be that some .eh_frame input section has greater alignment 1593 than other .eh_frame sections. In that case we run the risk of 1594 padding with zeros before that section, which would be seen as a 1595 zero terminator. Alignment padding must be added *inside* the 1596 last FDE instead. For other FDEs we align according to their 1597 encoding, in order to align FDE address range entries naturally. */ 1598 offset = 0; 1599 changed = 0; 1600 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent) 1601 if (!ent->removed) 1602 { 1603 eh_alignment = 4; 1604 if (ent->size == 4) 1605 ; 1606 else if (ent->cie) 1607 { 1608 if (ent->u.cie.per_encoding_aligned8) 1609 eh_alignment = 8; 1610 } 1611 else 1612 { 1613 eh_alignment = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 1614 if (eh_alignment < 4) 1615 eh_alignment = 4; 1616 } 1617 offset = (offset + eh_alignment - 1) & -eh_alignment; 1618 ent->new_offset = offset; 1619 if (ent->new_offset != ent->offset) 1620 changed = 1; 1621 offset += size_of_output_cie_fde (ent); 1622 } 1623 1624 eh_alignment = 4; 1625 offset = (offset + eh_alignment - 1) & -eh_alignment; 1626 if (sec->rawsize == 0) 1627 sec->rawsize = sec->size; 1628 if (sec->size != offset) 1629 changed = 2; 1630 sec->size = offset; 1631 1632 if (changed) 1633 { 1634 Elf_Internal_Sym *locsyms = adjust_eh_frame_local_symbols (sec, cookie); 1635 if (locsyms != NULL) 1636 { 1637 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd); 1638 symtab_hdr->contents = (unsigned char *) locsyms; 1639 } 1640 } 1641 return changed; 1642 } 1643 1644 /* This function is called for .eh_frame_hdr section after 1645 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame 1646 input sections. It finalizes the size of .eh_frame_hdr section. */ 1647 1648 bool 1649 _bfd_elf_discard_section_eh_frame_hdr (struct bfd_link_info *info) 1650 { 1651 struct elf_link_hash_table *htab; 1652 struct eh_frame_hdr_info *hdr_info; 1653 asection *sec; 1654 1655 htab = elf_hash_table (info); 1656 hdr_info = &htab->eh_info; 1657 1658 if (!hdr_info->frame_hdr_is_compact && hdr_info->u.dwarf.cies != NULL) 1659 { 1660 htab_delete (hdr_info->u.dwarf.cies); 1661 hdr_info->u.dwarf.cies = NULL; 1662 } 1663 1664 if (info->eh_frame_hdr_type == 0 1665 || bfd_link_relocatable (info)) 1666 return false; 1667 1668 sec = hdr_info->hdr_sec; 1669 if (sec == NULL) 1670 return false; 1671 1672 if (info->eh_frame_hdr_type == COMPACT_EH_HDR) 1673 { 1674 /* For compact frames we only add the header. The actual table comes 1675 from the .eh_frame_entry sections. */ 1676 sec->size = 8; 1677 } 1678 else 1679 { 1680 sec->size = EH_FRAME_HDR_SIZE; 1681 if (hdr_info->u.dwarf.table) 1682 sec->size += 4 + hdr_info->u.dwarf.fde_count * 8; 1683 } 1684 1685 return true; 1686 } 1687 1688 /* Return true if there is at least one non-empty .eh_frame section in 1689 input files. Can only be called after ld has mapped input to 1690 output sections, and before sections are stripped. */ 1691 1692 bool 1693 _bfd_elf_eh_frame_present (struct bfd_link_info *info) 1694 { 1695 asection *eh = bfd_get_section_by_name (info->output_bfd, ".eh_frame"); 1696 1697 if (eh == NULL) 1698 return false; 1699 1700 /* Count only sections which have at least a single CIE or FDE. 1701 There cannot be any CIE or FDE <= 8 bytes. */ 1702 for (eh = eh->map_head.s; eh != NULL; eh = eh->map_head.s) 1703 if (eh->size > 8) 1704 return true; 1705 1706 return false; 1707 } 1708 1709 /* Return true if there is at least one .eh_frame_entry section in 1710 input files. */ 1711 1712 bool 1713 _bfd_elf_eh_frame_entry_present (struct bfd_link_info *info) 1714 { 1715 asection *o; 1716 bfd *abfd; 1717 1718 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next) 1719 { 1720 for (o = abfd->sections; o; o = o->next) 1721 { 1722 const char *name = bfd_section_name (o); 1723 1724 if (strcmp (name, ".eh_frame_entry") 1725 && !bfd_is_abs_section (o->output_section)) 1726 return true; 1727 } 1728 } 1729 return false; 1730 } 1731 1732 /* This function is called from size_dynamic_sections. 1733 It needs to decide whether .eh_frame_hdr should be output or not, 1734 because when the dynamic symbol table has been sized it is too late 1735 to strip sections. */ 1736 1737 bool 1738 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info) 1739 { 1740 struct elf_link_hash_table *htab; 1741 struct eh_frame_hdr_info *hdr_info; 1742 struct bfd_link_hash_entry *bh = NULL; 1743 struct elf_link_hash_entry *h; 1744 1745 htab = elf_hash_table (info); 1746 hdr_info = &htab->eh_info; 1747 if (hdr_info->hdr_sec == NULL) 1748 return true; 1749 1750 if (bfd_is_abs_section (hdr_info->hdr_sec->output_section) 1751 || info->eh_frame_hdr_type == 0 1752 || (info->eh_frame_hdr_type == DWARF2_EH_HDR 1753 && !_bfd_elf_eh_frame_present (info)) 1754 || (info->eh_frame_hdr_type == COMPACT_EH_HDR 1755 && !_bfd_elf_eh_frame_entry_present (info))) 1756 { 1757 hdr_info->hdr_sec->flags |= SEC_EXCLUDE; 1758 hdr_info->hdr_sec = NULL; 1759 return true; 1760 } 1761 1762 /* Add a hidden symbol so that systems without access to PHDRs can 1763 find the table. */ 1764 if (! (_bfd_generic_link_add_one_symbol 1765 (info, info->output_bfd, "__GNU_EH_FRAME_HDR", BSF_LOCAL, 1766 hdr_info->hdr_sec, 0, NULL, false, false, &bh))) 1767 return false; 1768 1769 h = (struct elf_link_hash_entry *) bh; 1770 h->def_regular = 1; 1771 h->other = STV_HIDDEN; 1772 get_elf_backend_data 1773 (info->output_bfd)->elf_backend_hide_symbol (info, h, true); 1774 1775 if (!hdr_info->frame_hdr_is_compact) 1776 hdr_info->u.dwarf.table = true; 1777 return true; 1778 } 1779 1780 /* Adjust an address in the .eh_frame section. Given OFFSET within 1781 SEC, this returns the new offset in the adjusted .eh_frame section, 1782 or -1 if the address refers to a CIE/FDE which has been removed 1783 or to offset with dynamic relocation which is no longer needed. */ 1784 1785 bfd_vma 1786 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED, 1787 struct bfd_link_info *info ATTRIBUTE_UNUSED, 1788 asection *sec, 1789 bfd_vma offset) 1790 { 1791 struct eh_frame_sec_info *sec_info; 1792 unsigned int lo, hi, mid; 1793 1794 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME) 1795 return offset; 1796 sec_info = sec->sec_info; 1797 1798 if (offset >= sec->rawsize) 1799 return offset - sec->rawsize + sec->size; 1800 1801 lo = 0; 1802 hi = sec_info->count; 1803 mid = 0; 1804 while (lo < hi) 1805 { 1806 mid = (lo + hi) / 2; 1807 if (offset < sec_info->entry[mid].offset) 1808 hi = mid; 1809 else if (offset 1810 >= sec_info->entry[mid].offset + sec_info->entry[mid].size) 1811 lo = mid + 1; 1812 else 1813 break; 1814 } 1815 1816 BFD_ASSERT (lo < hi); 1817 1818 /* FDE or CIE was removed. */ 1819 if (sec_info->entry[mid].removed) 1820 return (bfd_vma) -1; 1821 1822 /* If converting personality pointers to DW_EH_PE_pcrel, there will be 1823 no need for run-time relocation against the personality field. */ 1824 if (sec_info->entry[mid].cie 1825 && sec_info->entry[mid].u.cie.make_per_encoding_relative 1826 && offset == (sec_info->entry[mid].offset + 8 1827 + sec_info->entry[mid].u.cie.personality_offset)) 1828 return (bfd_vma) -2; 1829 1830 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time 1831 relocation against FDE's initial_location field. */ 1832 if (!sec_info->entry[mid].cie 1833 && sec_info->entry[mid].make_relative 1834 && offset == sec_info->entry[mid].offset + 8) 1835 return (bfd_vma) -2; 1836 1837 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need 1838 for run-time relocation against LSDA field. */ 1839 if (!sec_info->entry[mid].cie 1840 && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative 1841 && offset == (sec_info->entry[mid].offset + 8 1842 + sec_info->entry[mid].lsda_offset)) 1843 return (bfd_vma) -2; 1844 1845 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time 1846 relocation against DW_CFA_set_loc's arguments. */ 1847 if (sec_info->entry[mid].set_loc 1848 && sec_info->entry[mid].make_relative 1849 && (offset >= sec_info->entry[mid].offset + 8 1850 + sec_info->entry[mid].set_loc[1])) 1851 { 1852 unsigned int cnt; 1853 1854 for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++) 1855 if (offset == sec_info->entry[mid].offset + 8 1856 + sec_info->entry[mid].set_loc[cnt]) 1857 return (bfd_vma) -2; 1858 } 1859 1860 /* Any new augmentation bytes go before the first relocation. */ 1861 return (offset + sec_info->entry[mid].new_offset 1862 - sec_info->entry[mid].offset 1863 + extra_augmentation_string_bytes (sec_info->entry + mid) 1864 + extra_augmentation_data_bytes (sec_info->entry + mid)); 1865 } 1866 1867 /* Write out .eh_frame_entry section. Add CANTUNWIND terminator if needed. 1868 Also check that the contents look sane. */ 1869 1870 bool 1871 _bfd_elf_write_section_eh_frame_entry (bfd *abfd, struct bfd_link_info *info, 1872 asection *sec, bfd_byte *contents) 1873 { 1874 elf_backend_data *bed; 1875 bfd_byte cantunwind[8]; 1876 bfd_vma addr; 1877 bfd_vma last_addr; 1878 bfd_vma offset; 1879 asection *text_sec = sec->sec_info; 1880 1881 if (!sec->rawsize) 1882 sec->rawsize = sec->size; 1883 1884 BFD_ASSERT (sec->sec_info_type == SEC_INFO_TYPE_EH_FRAME_ENTRY); 1885 1886 /* Check to make sure that the text section corresponding to this eh_frame_entry 1887 section has not been excluded. In particular, mips16 stub entries will be 1888 excluded outside of the normal process. */ 1889 if (sec->flags & SEC_EXCLUDE 1890 || text_sec->flags & SEC_EXCLUDE) 1891 return true; 1892 1893 if (!bfd_set_section_contents (abfd, sec->output_section, contents, 1894 sec->output_offset, sec->rawsize)) 1895 return false; 1896 1897 last_addr = bfd_get_signed_32 (abfd, contents); 1898 /* Check that all the entries are in order. */ 1899 for (offset = 8; offset < sec->rawsize; offset += 8) 1900 { 1901 addr = bfd_get_signed_32 (abfd, contents + offset) + offset; 1902 if (addr <= last_addr) 1903 { 1904 /* xgettext:c-format */ 1905 _bfd_error_handler (_("%pB: %pA not in order"), sec->owner, sec); 1906 return false; 1907 } 1908 1909 last_addr = addr; 1910 } 1911 1912 addr = text_sec->output_section->vma + text_sec->output_offset 1913 + text_sec->size; 1914 addr &= ~1; 1915 addr -= (sec->output_section->vma + sec->output_offset + sec->rawsize); 1916 if (addr & 1) 1917 { 1918 /* xgettext:c-format */ 1919 _bfd_error_handler (_("%pB: %pA invalid input section size"), 1920 sec->owner, sec); 1921 bfd_set_error (bfd_error_bad_value); 1922 return false; 1923 } 1924 if (last_addr >= addr + sec->rawsize) 1925 { 1926 /* xgettext:c-format */ 1927 _bfd_error_handler (_("%pB: %pA points past end of text section"), 1928 sec->owner, sec); 1929 bfd_set_error (bfd_error_bad_value); 1930 return false; 1931 } 1932 1933 if (sec->size == sec->rawsize) 1934 return true; 1935 1936 bed = get_elf_backend_data (abfd); 1937 BFD_ASSERT (sec->size == sec->rawsize + 8); 1938 BFD_ASSERT ((addr & 1) == 0); 1939 BFD_ASSERT (bed->cant_unwind_opcode); 1940 1941 bfd_put_32 (abfd, addr, cantunwind); 1942 bfd_put_32 (abfd, (*bed->cant_unwind_opcode) (info), cantunwind + 4); 1943 return bfd_set_section_contents (abfd, sec->output_section, cantunwind, 1944 sec->output_offset + sec->rawsize, 8); 1945 } 1946 1947 /* Write out .eh_frame section. This is called with the relocated 1948 contents. */ 1949 1950 bool 1951 _bfd_elf_write_section_eh_frame (bfd *abfd, 1952 struct bfd_link_info *info, 1953 asection *sec, 1954 bfd_byte *contents) 1955 { 1956 struct eh_frame_sec_info *sec_info; 1957 struct elf_link_hash_table *htab; 1958 struct eh_frame_hdr_info *hdr_info; 1959 unsigned int ptr_size; 1960 struct eh_cie_fde *ent, *last_ent; 1961 1962 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME) 1963 /* FIXME: octets_per_byte. */ 1964 return bfd_set_section_contents (abfd, sec->output_section, contents, 1965 sec->output_offset, sec->size); 1966 1967 ptr_size = (get_elf_backend_data (abfd) 1968 ->elf_backend_eh_frame_address_size (abfd, sec)); 1969 BFD_ASSERT (ptr_size != 0); 1970 1971 sec_info = sec->sec_info; 1972 htab = elf_hash_table (info); 1973 hdr_info = &htab->eh_info; 1974 1975 if (hdr_info->u.dwarf.table && hdr_info->u.dwarf.array == NULL) 1976 { 1977 hdr_info->frame_hdr_is_compact = false; 1978 hdr_info->u.dwarf.array = (struct eh_frame_array_ent *) 1979 bfd_malloc (hdr_info->u.dwarf.fde_count 1980 * sizeof (*hdr_info->u.dwarf.array)); 1981 } 1982 if (hdr_info->u.dwarf.array == NULL) 1983 hdr_info = NULL; 1984 1985 /* The new offsets can be bigger or smaller than the original offsets. 1986 We therefore need to make two passes over the section: one backward 1987 pass to move entries up and one forward pass to move entries down. 1988 The two passes won't interfere with each other because entries are 1989 not reordered */ 1990 for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;) 1991 if (!ent->removed && ent->new_offset > ent->offset) 1992 memmove (contents + ent->new_offset, contents + ent->offset, ent->size); 1993 1994 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent) 1995 if (!ent->removed && ent->new_offset < ent->offset) 1996 memmove (contents + ent->new_offset, contents + ent->offset, ent->size); 1997 1998 last_ent = sec_info->entry + sec_info->count; 1999 for (ent = sec_info->entry; ent < last_ent; ++ent) 2000 { 2001 unsigned char *buf, *end; 2002 unsigned int new_size; 2003 2004 if (ent->removed) 2005 continue; 2006 2007 if (ent->size == 4) 2008 { 2009 /* Any terminating FDE must be at the end of the section. */ 2010 BFD_ASSERT (ent == last_ent - 1); 2011 continue; 2012 } 2013 2014 buf = contents + ent->new_offset; 2015 end = buf + ent->size; 2016 new_size = next_cie_fde_offset (ent, last_ent, sec) - ent->new_offset; 2017 2018 /* Update the size. It may be shrinked. */ 2019 bfd_put_32 (abfd, new_size - 4, buf); 2020 2021 /* Filling the extra bytes with DW_CFA_nops. */ 2022 if (new_size != ent->size) 2023 memset (end, 0, new_size - ent->size); 2024 2025 if (ent->cie) 2026 { 2027 /* CIE */ 2028 if (ent->make_relative 2029 || ent->u.cie.make_lsda_relative 2030 || ent->u.cie.per_encoding_relative) 2031 { 2032 char *aug; 2033 unsigned int version, action, extra_string, extra_data; 2034 unsigned int per_width, per_encoding; 2035 2036 /* Need to find 'R' or 'L' augmentation's argument and modify 2037 DW_EH_PE_* value. */ 2038 action = ((ent->make_relative ? 1 : 0) 2039 | (ent->u.cie.make_lsda_relative ? 2 : 0) 2040 | (ent->u.cie.per_encoding_relative ? 4 : 0)); 2041 extra_string = extra_augmentation_string_bytes (ent); 2042 extra_data = extra_augmentation_data_bytes (ent); 2043 2044 /* Skip length, id. */ 2045 buf += 8; 2046 version = *buf++; 2047 aug = (char *) buf; 2048 buf += strlen (aug) + 1; 2049 skip_leb128 (&buf, end); 2050 skip_leb128 (&buf, end); 2051 if (version == 1) 2052 skip_bytes (&buf, end, 1); 2053 else 2054 skip_leb128 (&buf, end); 2055 if (*aug == 'z') 2056 { 2057 /* The uleb128 will always be a single byte for the kind 2058 of augmentation strings that we're prepared to handle. */ 2059 *buf++ += extra_data; 2060 aug++; 2061 } 2062 2063 /* Make room for the new augmentation string and data bytes. */ 2064 memmove (buf + extra_string + extra_data, buf, end - buf); 2065 memmove (aug + extra_string, aug, buf - (bfd_byte *) aug); 2066 buf += extra_string; 2067 end += extra_string + extra_data; 2068 2069 if (ent->add_augmentation_size) 2070 { 2071 *aug++ = 'z'; 2072 *buf++ = extra_data - 1; 2073 } 2074 if (ent->u.cie.add_fde_encoding) 2075 { 2076 BFD_ASSERT (action & 1); 2077 *aug++ = 'R'; 2078 *buf++ = make_pc_relative (DW_EH_PE_absptr, ptr_size); 2079 action &= ~1; 2080 } 2081 2082 while (action) 2083 switch (*aug++) 2084 { 2085 case 'L': 2086 if (action & 2) 2087 { 2088 BFD_ASSERT (*buf == ent->lsda_encoding); 2089 *buf = make_pc_relative (*buf, ptr_size); 2090 action &= ~2; 2091 } 2092 buf++; 2093 break; 2094 case 'P': 2095 if (ent->u.cie.make_per_encoding_relative) 2096 *buf = make_pc_relative (*buf, ptr_size); 2097 per_encoding = *buf++; 2098 per_width = get_DW_EH_PE_width (per_encoding, ptr_size); 2099 BFD_ASSERT (per_width != 0); 2100 BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel) 2101 == ent->u.cie.per_encoding_relative); 2102 if ((per_encoding & 0x70) == DW_EH_PE_aligned) 2103 buf = (contents 2104 + ((buf - contents + per_width - 1) 2105 & ~((bfd_size_type) per_width - 1))); 2106 if (action & 4) 2107 { 2108 bfd_vma val; 2109 2110 val = read_value (abfd, buf, per_width, 2111 get_DW_EH_PE_signed (per_encoding)); 2112 if (ent->u.cie.make_per_encoding_relative) 2113 val -= (sec->output_section->vma 2114 + sec->output_offset 2115 + (buf - contents)); 2116 else 2117 { 2118 val += (bfd_vma) ent->offset - ent->new_offset; 2119 val -= extra_string + extra_data; 2120 } 2121 write_value (abfd, buf, val, per_width); 2122 action &= ~4; 2123 } 2124 buf += per_width; 2125 break; 2126 case 'R': 2127 if (action & 1) 2128 { 2129 BFD_ASSERT (*buf == ent->fde_encoding); 2130 *buf = make_pc_relative (*buf, ptr_size); 2131 action &= ~1; 2132 } 2133 buf++; 2134 break; 2135 case 'S': 2136 break; 2137 default: 2138 BFD_FAIL (); 2139 } 2140 } 2141 } 2142 else 2143 { 2144 /* FDE */ 2145 bfd_vma value, address; 2146 unsigned int width; 2147 bfd_byte *start; 2148 struct eh_cie_fde *cie; 2149 2150 /* Skip length. */ 2151 cie = ent->u.fde.cie_inf; 2152 buf += 4; 2153 value = ((ent->new_offset + sec->output_offset + 4) 2154 - (cie->new_offset + cie->u.cie.u.sec->output_offset)); 2155 bfd_put_32 (abfd, value, buf); 2156 if (bfd_link_relocatable (info)) 2157 continue; 2158 buf += 4; 2159 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 2160 value = read_value (abfd, buf, width, 2161 get_DW_EH_PE_signed (ent->fde_encoding)); 2162 address = value; 2163 if (value) 2164 { 2165 switch (ent->fde_encoding & 0x70) 2166 { 2167 case DW_EH_PE_textrel: 2168 BFD_ASSERT (hdr_info == NULL); 2169 break; 2170 case DW_EH_PE_datarel: 2171 { 2172 switch (abfd->arch_info->arch) 2173 { 2174 case bfd_arch_ia64: 2175 BFD_ASSERT (elf_gp (abfd) != 0); 2176 address += elf_gp (abfd); 2177 break; 2178 default: 2179 _bfd_error_handler 2180 (_("DW_EH_PE_datarel unspecified" 2181 " for this architecture")); 2182 /* Fall thru */ 2183 case bfd_arch_frv: 2184 case bfd_arch_i386: 2185 BFD_ASSERT (htab->hgot != NULL 2186 && ((htab->hgot->root.type 2187 == bfd_link_hash_defined) 2188 || (htab->hgot->root.type 2189 == bfd_link_hash_defweak))); 2190 address 2191 += (htab->hgot->root.u.def.value 2192 + htab->hgot->root.u.def.section->output_offset 2193 + (htab->hgot->root.u.def.section->output_section 2194 ->vma)); 2195 break; 2196 } 2197 } 2198 break; 2199 case DW_EH_PE_pcrel: 2200 value += (bfd_vma) ent->offset - ent->new_offset; 2201 address += (sec->output_section->vma 2202 + sec->output_offset 2203 + ent->offset + 8); 2204 break; 2205 } 2206 if (ent->make_relative) 2207 value -= (sec->output_section->vma 2208 + sec->output_offset 2209 + ent->new_offset + 8); 2210 write_value (abfd, buf, value, width); 2211 } 2212 2213 start = buf; 2214 2215 if (hdr_info) 2216 { 2217 /* The address calculation may overflow, giving us a 2218 value greater than 4G on a 32-bit target when 2219 dwarf_vma is 64-bit. */ 2220 if (sizeof (address) > 4 && ptr_size == 4) 2221 address &= 0xffffffff; 2222 hdr_info->u.dwarf.array[hdr_info->array_count].initial_loc 2223 = address; 2224 hdr_info->u.dwarf.array[hdr_info->array_count].range 2225 = read_value (abfd, buf + width, width, false); 2226 hdr_info->u.dwarf.array[hdr_info->array_count++].fde 2227 = (sec->output_section->vma 2228 + sec->output_offset 2229 + ent->new_offset); 2230 } 2231 2232 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel 2233 || cie->u.cie.make_lsda_relative) 2234 { 2235 buf += ent->lsda_offset; 2236 width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size); 2237 value = read_value (abfd, buf, width, 2238 get_DW_EH_PE_signed (ent->lsda_encoding)); 2239 if (value) 2240 { 2241 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel) 2242 value += (bfd_vma) ent->offset - ent->new_offset; 2243 else if (cie->u.cie.make_lsda_relative) 2244 value -= (sec->output_section->vma 2245 + sec->output_offset 2246 + ent->new_offset + 8 + ent->lsda_offset); 2247 write_value (abfd, buf, value, width); 2248 } 2249 } 2250 else if (ent->add_augmentation_size) 2251 { 2252 /* Skip the PC and length and insert a zero byte for the 2253 augmentation size. */ 2254 buf += width * 2; 2255 memmove (buf + 1, buf, end - buf); 2256 *buf = 0; 2257 } 2258 2259 if (ent->set_loc) 2260 { 2261 /* Adjust DW_CFA_set_loc. */ 2262 unsigned int cnt; 2263 bfd_vma new_offset; 2264 2265 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size); 2266 new_offset = ent->new_offset + 8 2267 + extra_augmentation_string_bytes (ent) 2268 + extra_augmentation_data_bytes (ent); 2269 2270 for (cnt = 1; cnt <= ent->set_loc[0]; cnt++) 2271 { 2272 buf = start + ent->set_loc[cnt]; 2273 2274 value = read_value (abfd, buf, width, 2275 get_DW_EH_PE_signed (ent->fde_encoding)); 2276 if (!value) 2277 continue; 2278 2279 if ((ent->fde_encoding & 0x70) == DW_EH_PE_pcrel) 2280 value += (bfd_vma) ent->offset + 8 - new_offset; 2281 if (ent->make_relative) 2282 value -= (sec->output_section->vma 2283 + sec->output_offset 2284 + new_offset + ent->set_loc[cnt]); 2285 write_value (abfd, buf, value, width); 2286 } 2287 } 2288 } 2289 } 2290 2291 /* FIXME: octets_per_byte. */ 2292 return bfd_set_section_contents (abfd, sec->output_section, 2293 contents, (file_ptr) sec->output_offset, 2294 sec->size); 2295 } 2296 2297 /* A handy wrapper for writing linker generated .eh_frame sections 2298 with contents that may need to be extended beyond the initial size 2299 allocated. */ 2300 2301 bool 2302 _bfd_elf_write_linker_section_eh_frame (bfd *obfd, struct bfd_link_info *info, 2303 asection *sec, bfd_byte *bigbuf) 2304 { 2305 bfd_size_type initial_size = sec->rawsize != 0 ? sec->rawsize : sec->size; 2306 memcpy (bigbuf, sec->contents, initial_size); 2307 if (!_bfd_elf_write_section_eh_frame (obfd, info, sec, bigbuf)) 2308 return false; 2309 if (sec->size > initial_size) 2310 { 2311 if (sec->alloced) 2312 sec->contents = bfd_alloc (sec->owner, sec->size); 2313 else 2314 { 2315 free (sec->contents); 2316 sec->contents = bfd_malloc (sec->size); 2317 } 2318 if (sec->contents == NULL) 2319 return false; 2320 } 2321 memcpy (sec->contents, bigbuf, sec->size); 2322 return true; 2323 } 2324 2325 /* Helper function used to sort .eh_frame_hdr search table by increasing 2326 VMA of FDE initial location. */ 2327 2328 static int 2329 vma_compare (const void *a, const void *b) 2330 { 2331 const struct eh_frame_array_ent *p = (const struct eh_frame_array_ent *) a; 2332 const struct eh_frame_array_ent *q = (const struct eh_frame_array_ent *) b; 2333 if (p->initial_loc > q->initial_loc) 2334 return 1; 2335 if (p->initial_loc < q->initial_loc) 2336 return -1; 2337 if (p->range > q->range) 2338 return 1; 2339 if (p->range < q->range) 2340 return -1; 2341 return 0; 2342 } 2343 2344 /* Reorder .eh_frame_entry sections to match the associated text sections. 2345 This routine is called during the final linking step, just before writing 2346 the contents. At this stage, sections in the eh_frame_hdr_info are already 2347 sorted in order of increasing text section address and so we simply need 2348 to make the .eh_frame_entrys follow that same order. Note that it is 2349 invalid for a linker script to try to force a particular order of 2350 .eh_frame_entry sections. */ 2351 2352 bool 2353 _bfd_elf_fixup_eh_frame_hdr (struct bfd_link_info *info) 2354 { 2355 asection *sec = NULL; 2356 asection *osec; 2357 struct eh_frame_hdr_info *hdr_info; 2358 unsigned int i; 2359 bfd_vma offset; 2360 struct bfd_link_order *p; 2361 2362 hdr_info = &elf_hash_table (info)->eh_info; 2363 2364 if (hdr_info->hdr_sec == NULL 2365 || info->eh_frame_hdr_type != COMPACT_EH_HDR 2366 || hdr_info->array_count == 0) 2367 return true; 2368 2369 /* Change section output offsets to be in text section order. */ 2370 offset = 8; 2371 osec = hdr_info->u.compact.entries[0]->output_section; 2372 for (i = 0; i < hdr_info->array_count; i++) 2373 { 2374 sec = hdr_info->u.compact.entries[i]; 2375 if (sec->output_section != osec) 2376 { 2377 _bfd_error_handler 2378 (_("invalid output section for .eh_frame_entry: %pA"), 2379 sec->output_section); 2380 return false; 2381 } 2382 sec->output_offset = offset; 2383 offset += sec->size; 2384 } 2385 2386 2387 /* Fix the link_order to match. */ 2388 for (p = sec->output_section->map_head.link_order; p != NULL; p = p->next) 2389 { 2390 if (p->type != bfd_indirect_link_order) 2391 abort(); 2392 2393 p->offset = p->u.indirect.section->output_offset; 2394 if (p->next != NULL) 2395 i--; 2396 } 2397 2398 if (i != 0) 2399 { 2400 _bfd_error_handler 2401 (_("invalid contents in %pA section"), osec); 2402 return false; 2403 } 2404 2405 return true; 2406 } 2407 2408 /* The .eh_frame_hdr format for Compact EH frames: 2409 ubyte version (2) 2410 ubyte eh_ref_enc (DW_EH_PE_* encoding of typinfo references) 2411 uint32_t count (Number of entries in table) 2412 [array from .eh_frame_entry sections] */ 2413 2414 static bool 2415 write_compact_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 2416 { 2417 struct elf_link_hash_table *htab; 2418 struct eh_frame_hdr_info *hdr_info; 2419 asection *sec; 2420 elf_backend_data *bed; 2421 bfd_vma count; 2422 bfd_byte contents[8]; 2423 unsigned int i; 2424 2425 htab = elf_hash_table (info); 2426 hdr_info = &htab->eh_info; 2427 sec = hdr_info->hdr_sec; 2428 2429 if (sec->size != 8) 2430 abort(); 2431 2432 for (i = 0; i < sizeof (contents); i++) 2433 contents[i] = 0; 2434 2435 contents[0] = COMPACT_EH_HDR; 2436 bed = get_elf_backend_data (abfd); 2437 2438 BFD_ASSERT (bed->compact_eh_encoding); 2439 contents[1] = (*bed->compact_eh_encoding) (info); 2440 2441 count = (sec->output_section->size - 8) / 8; 2442 bfd_put_32 (abfd, count, contents + 4); 2443 return bfd_set_section_contents (abfd, sec->output_section, contents, 2444 (file_ptr) sec->output_offset, sec->size); 2445 } 2446 2447 /* The .eh_frame_hdr format for DWARF frames: 2448 2449 ubyte version (currently 1) 2450 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of 2451 .eh_frame section) 2452 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count 2453 number (or DW_EH_PE_omit if there is no 2454 binary search table computed)) 2455 ubyte table_enc (DW_EH_PE_* encoding of binary search table, 2456 or DW_EH_PE_omit if not present. 2457 DW_EH_PE_datarel is using address of 2458 .eh_frame_hdr section start as base) 2459 [encoded] eh_frame_ptr (pointer to start of .eh_frame section) 2460 optionally followed by: 2461 [encoded] fde_count (total number of FDEs in .eh_frame section) 2462 fde_count x [encoded] initial_loc, fde 2463 (array of encoded pairs containing 2464 FDE initial_location field and FDE address, 2465 sorted by increasing initial_loc). */ 2466 2467 static bool 2468 write_dwarf_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 2469 { 2470 struct elf_link_hash_table *htab; 2471 struct eh_frame_hdr_info *hdr_info; 2472 asection *sec; 2473 bool retval = false; 2474 2475 htab = elf_hash_table (info); 2476 hdr_info = &htab->eh_info; 2477 sec = hdr_info->hdr_sec; 2478 bfd_byte *contents; 2479 asection *eh_frame_sec; 2480 bfd_size_type size; 2481 bfd_vma encoded_eh_frame; 2482 2483 size = EH_FRAME_HDR_SIZE; 2484 if (hdr_info->u.dwarf.array 2485 && hdr_info->array_count == hdr_info->u.dwarf.fde_count) 2486 size += 4 + hdr_info->u.dwarf.fde_count * 8; 2487 contents = (bfd_byte *) bfd_malloc (size); 2488 if (contents == NULL) 2489 goto out; 2490 2491 eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame"); 2492 if (eh_frame_sec == NULL) 2493 goto out; 2494 2495 memset (contents, 0, EH_FRAME_HDR_SIZE); 2496 /* Version. */ 2497 contents[0] = 1; 2498 /* .eh_frame offset. */ 2499 contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address 2500 (abfd, info, eh_frame_sec, 0, sec, 4, &encoded_eh_frame); 2501 2502 if (hdr_info->u.dwarf.array 2503 && hdr_info->array_count == hdr_info->u.dwarf.fde_count) 2504 { 2505 /* FDE count encoding. */ 2506 contents[2] = DW_EH_PE_udata4; 2507 /* Search table encoding. */ 2508 contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; 2509 } 2510 else 2511 { 2512 contents[2] = DW_EH_PE_omit; 2513 contents[3] = DW_EH_PE_omit; 2514 } 2515 bfd_put_32 (abfd, encoded_eh_frame, contents + 4); 2516 2517 retval = true; 2518 if (contents[2] != DW_EH_PE_omit) 2519 { 2520 unsigned int i; 2521 bool overlap, overflow; 2522 2523 bfd_put_32 (abfd, hdr_info->u.dwarf.fde_count, 2524 contents + EH_FRAME_HDR_SIZE); 2525 qsort (hdr_info->u.dwarf.array, hdr_info->u.dwarf.fde_count, 2526 sizeof (*hdr_info->u.dwarf.array), vma_compare); 2527 overlap = false; 2528 overflow = false; 2529 for (i = 0; i < hdr_info->u.dwarf.fde_count; i++) 2530 { 2531 bfd_vma val; 2532 2533 val = hdr_info->u.dwarf.array[i].initial_loc 2534 - sec->output_section->vma; 2535 val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000; 2536 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 2537 && (hdr_info->u.dwarf.array[i].initial_loc 2538 != sec->output_section->vma + val)) 2539 overflow = true; 2540 bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 4); 2541 val = hdr_info->u.dwarf.array[i].fde - sec->output_section->vma; 2542 val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000; 2543 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 2544 && (hdr_info->u.dwarf.array[i].fde 2545 != sec->output_section->vma + val)) 2546 overflow = true; 2547 bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 8); 2548 if (i != 0 2549 && (hdr_info->u.dwarf.array[i].initial_loc 2550 < (hdr_info->u.dwarf.array[i - 1].initial_loc 2551 + hdr_info->u.dwarf.array[i - 1].range))) 2552 overlap = true; 2553 } 2554 if (overflow) 2555 _bfd_error_handler (_(".eh_frame_hdr entry overflow")); 2556 if (overlap) 2557 _bfd_error_handler (_(".eh_frame_hdr refers to overlapping FDEs")); 2558 if (overflow || overlap) 2559 { 2560 bfd_set_error (bfd_error_bad_value); 2561 retval = false; 2562 } 2563 } 2564 2565 /* FIXME: octets_per_byte. */ 2566 if (!bfd_set_section_contents (abfd, sec->output_section, contents, 2567 (file_ptr) sec->output_offset, 2568 size)) 2569 retval = false; 2570 out: 2571 free (contents); 2572 free (hdr_info->u.dwarf.array); 2573 hdr_info->u.dwarf.array = NULL; 2574 return retval; 2575 } 2576 2577 /* Write out .eh_frame_hdr section. This must be called after 2578 _bfd_elf_write_section_eh_frame has been called on all input 2579 .eh_frame sections. */ 2580 2581 bool 2582 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info) 2583 { 2584 struct elf_link_hash_table *htab; 2585 struct eh_frame_hdr_info *hdr_info; 2586 asection *sec; 2587 2588 htab = elf_hash_table (info); 2589 hdr_info = &htab->eh_info; 2590 sec = hdr_info->hdr_sec; 2591 2592 if (info->eh_frame_hdr_type == 0 || sec == NULL) 2593 return true; 2594 2595 if (info->eh_frame_hdr_type == COMPACT_EH_HDR) 2596 return write_compact_eh_frame_hdr (abfd, info); 2597 else 2598 return write_dwarf_eh_frame_hdr (abfd, info); 2599 } 2600 2601 /* Return the width of FDE addresses. This is the default implementation. */ 2602 2603 unsigned int 2604 _bfd_elf_eh_frame_address_size (bfd *abfd, const asection *sec ATTRIBUTE_UNUSED) 2605 { 2606 return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4; 2607 } 2608 2609 /* Decide whether we can use a PC-relative encoding within the given 2610 EH frame section. This is the default implementation. */ 2611 2612 bool 2613 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED, 2614 struct bfd_link_info *info ATTRIBUTE_UNUSED, 2615 asection *eh_frame_section ATTRIBUTE_UNUSED) 2616 { 2617 return true; 2618 } 2619 2620 /* Select an encoding for the given address. Preference is given to 2621 PC-relative addressing modes. */ 2622 2623 bfd_byte 2624 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED, 2625 struct bfd_link_info *info ATTRIBUTE_UNUSED, 2626 asection *osec, bfd_vma offset, 2627 asection *loc_sec, bfd_vma loc_offset, 2628 bfd_vma *encoded) 2629 { 2630 *encoded = osec->vma + offset - 2631 (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset); 2632 return DW_EH_PE_pcrel | DW_EH_PE_sdata4; 2633 } 2634
Indexes created Sun Sep 13 00:25:22 UTC 2026