1 /* dw2gencfi.c - Support for generating Dwarf2 CFI information. 2 Copyright (C) 2003-2016 Free Software Foundation, Inc. 3 Contributed by Michal Ludvig <mludvig@suse.cz> 4 5 This file is part of GAS, the GNU Assembler. 6 7 GAS 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, or (at your option) 10 any later version. 11 12 GAS 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 GAS; see the file COPYING. If not, write to the Free 19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 20 02110-1301, USA. */ 21 22 #include "as.h" 23 #include "dw2gencfi.h" 24 #include "subsegs.h" 25 #include "dwarf2dbg.h" 26 27 #ifdef TARGET_USE_CFIPOP 28 29 /* By default, use difference expressions if DIFF_EXPR_OK is defined. */ 30 #ifndef CFI_DIFF_EXPR_OK 31 # ifdef DIFF_EXPR_OK 32 # define CFI_DIFF_EXPR_OK 1 33 # else 34 # define CFI_DIFF_EXPR_OK 0 35 # endif 36 #endif 37 38 #ifndef CFI_DIFF_LSDA_OK 39 #define CFI_DIFF_LSDA_OK CFI_DIFF_EXPR_OK 40 #endif 41 42 #if CFI_DIFF_EXPR_OK == 1 && CFI_DIFF_LSDA_OK == 0 43 # error "CFI_DIFF_EXPR_OK should imply CFI_DIFF_LSDA_OK" 44 #endif 45 46 /* We re-use DWARF2_LINE_MIN_INSN_LENGTH for the code alignment field 47 of the CIE. Default to 1 if not otherwise specified. */ 48 #ifndef DWARF2_LINE_MIN_INSN_LENGTH 49 #define DWARF2_LINE_MIN_INSN_LENGTH 1 50 #endif 51 52 /* By default, use 32-bit relocations from .eh_frame into .text. */ 53 #ifndef DWARF2_FDE_RELOC_SIZE 54 #define DWARF2_FDE_RELOC_SIZE 4 55 #endif 56 57 /* By default, use a read-only .eh_frame section. */ 58 #ifndef DWARF2_EH_FRAME_READ_ONLY 59 #define DWARF2_EH_FRAME_READ_ONLY SEC_READONLY 60 #endif 61 62 #ifndef EH_FRAME_ALIGNMENT 63 #define EH_FRAME_ALIGNMENT (bfd_get_arch_size (stdoutput) == 64 ? 3 : 2) 64 #endif 65 66 #ifndef tc_cfi_frame_initial_instructions 67 #define tc_cfi_frame_initial_instructions() ((void)0) 68 #endif 69 70 #ifndef tc_cfi_startproc 71 # define tc_cfi_startproc() ((void)0) 72 #endif 73 74 #ifndef tc_cfi_endproc 75 # define tc_cfi_endproc(fde) ((void) (fde)) 76 #endif 77 78 #define EH_FRAME_LINKONCE (SUPPORT_FRAME_LINKONCE || compact_eh) 79 80 #ifndef DWARF2_FORMAT 81 #define DWARF2_FORMAT(SEC) dwarf2_format_32bit 82 #endif 83 84 #ifndef DWARF2_ADDR_SIZE 85 #define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8) 86 #endif 87 88 #if MULTIPLE_FRAME_SECTIONS 89 #define CUR_SEG(structp) structp->cur_seg 90 #define SET_CUR_SEG(structp, seg) structp->cur_seg = seg 91 #define HANDLED(structp) structp->handled 92 #define SET_HANDLED(structp, val) structp->handled = val 93 #else 94 #define CUR_SEG(structp) NULL 95 #define SET_CUR_SEG(structp, seg) (void) (0 && seg) 96 #define HANDLED(structp) 0 97 #define SET_HANDLED(structp, val) (void) (0 && val) 98 #endif 99 100 #ifndef tc_cfi_reloc_for_encoding 101 #define tc_cfi_reloc_for_encoding(e) BFD_RELOC_NONE 102 #endif 103 104 /* Private segment collection list. */ 105 struct dwcfi_seg_list 106 { 107 segT seg; 108 int subseg; 109 char * seg_name; 110 }; 111 112 #ifdef SUPPORT_COMPACT_EH 113 static bfd_boolean compact_eh; 114 #else 115 #define compact_eh 0 116 #endif 117 118 static struct hash_control *dwcfi_hash; 119 120 /* Emit a single byte into the current segment. */ 121 122 static inline void 123 out_one (int byte) 124 { 125 FRAG_APPEND_1_CHAR (byte); 126 } 127 128 /* Emit a two-byte word into the current segment. */ 129 130 static inline void 131 out_two (int data) 132 { 133 md_number_to_chars (frag_more (2), data, 2); 134 } 135 136 /* Emit a four byte word into the current segment. */ 137 138 static inline void 139 out_four (int data) 140 { 141 md_number_to_chars (frag_more (4), data, 4); 142 } 143 144 /* Emit an unsigned "little-endian base 128" number. */ 145 146 static void 147 out_uleb128 (addressT value) 148 { 149 output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0); 150 } 151 152 /* Emit an unsigned "little-endian base 128" number. */ 153 154 static void 155 out_sleb128 (offsetT value) 156 { 157 output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1); 158 } 159 160 static offsetT 161 encoding_size (unsigned char encoding) 162 { 163 if (encoding == DW_EH_PE_omit) 164 return 0; 165 switch (encoding & 0x7) 166 { 167 case 0: 168 return bfd_get_arch_size (stdoutput) == 64 ? 8 : 4; 169 case DW_EH_PE_udata2: 170 return 2; 171 case DW_EH_PE_udata4: 172 return 4; 173 case DW_EH_PE_udata8: 174 return 8; 175 default: 176 abort (); 177 } 178 } 179 180 /* Emit expression EXP in ENCODING. If EMIT_ENCODING is true, first 181 emit a byte containing ENCODING. */ 182 183 static void 184 emit_expr_encoded (expressionS *exp, int encoding, bfd_boolean emit_encoding) 185 { 186 offsetT size = encoding_size (encoding); 187 bfd_reloc_code_real_type code; 188 189 if (encoding == DW_EH_PE_omit) 190 return; 191 192 if (emit_encoding) 193 out_one (encoding); 194 195 code = tc_cfi_reloc_for_encoding (encoding); 196 if (code != BFD_RELOC_NONE) 197 { 198 reloc_howto_type *howto = bfd_reloc_type_lookup (stdoutput, code); 199 char *p = frag_more (size); 200 md_number_to_chars (p, 0, size); 201 fix_new (frag_now, p - frag_now->fr_literal, size, exp->X_add_symbol, 202 exp->X_add_number, howto->pc_relative, code); 203 } 204 else if ((encoding & 0x70) == DW_EH_PE_pcrel) 205 { 206 #if CFI_DIFF_EXPR_OK 207 expressionS tmp = *exp; 208 tmp.X_op = O_subtract; 209 tmp.X_op_symbol = symbol_temp_new_now (); 210 emit_expr (&tmp, size); 211 #elif defined (tc_cfi_emit_pcrel_expr) 212 tc_cfi_emit_pcrel_expr (exp, size); 213 #else 214 abort (); 215 #endif 216 } 217 else 218 emit_expr (exp, size); 219 } 220 221 /* Build based on segment the derived .debug_... 222 segment name containing origin segment's postfix name part. */ 223 224 static char * 225 get_debugseg_name (segT seg, const char *base_name) 226 { 227 const char *name; 228 229 if (!seg) 230 name = ""; 231 else 232 { 233 const char * dollar; 234 const char * dot; 235 236 name = bfd_get_section_name (stdoutput, seg); 237 238 dollar = strchr (name, '$'); 239 dot = strchr (name + 1, '.'); 240 241 if (!dollar && !dot) 242 { 243 if (!strcmp (base_name, ".eh_frame_entry") 244 && strcmp (name, ".text") != 0) 245 return concat (base_name, ".", name, NULL); 246 247 name = ""; 248 } 249 else if (!dollar) 250 name = dot; 251 else if (!dot) 252 name = dollar; 253 else if (dot < dollar) 254 name = dot; 255 else 256 name = dollar; 257 } 258 259 return concat (base_name, name, NULL); 260 } 261 262 /* Allocate a dwcfi_seg_list structure. */ 263 264 static struct dwcfi_seg_list * 265 alloc_debugseg_item (segT seg, int subseg, char *name) 266 { 267 struct dwcfi_seg_list *r; 268 269 r = (struct dwcfi_seg_list *) 270 xmalloc (sizeof (struct dwcfi_seg_list) + strlen (name)); 271 r->seg = seg; 272 r->subseg = subseg; 273 r->seg_name = name; 274 return r; 275 } 276 277 static segT 278 is_now_linkonce_segment (void) 279 { 280 if (compact_eh) 281 return now_seg; 282 283 if ((bfd_get_section_flags (stdoutput, now_seg) 284 & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD 285 | SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE 286 | SEC_LINK_DUPLICATES_SAME_CONTENTS)) != 0) 287 return now_seg; 288 return NULL; 289 } 290 291 /* Generate debug... segment with same linkonce properties 292 of based segment. */ 293 294 static segT 295 make_debug_seg (segT cseg, char *name, int sflags) 296 { 297 segT save_seg = now_seg; 298 int save_subseg = now_subseg; 299 segT r; 300 flagword flags; 301 302 r = subseg_new (name, 0); 303 304 /* Check if code segment is marked as linked once. */ 305 if (!cseg) 306 flags = 0; 307 else 308 flags = bfd_get_section_flags (stdoutput, cseg) 309 & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD 310 | SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE 311 | SEC_LINK_DUPLICATES_SAME_CONTENTS); 312 313 /* Add standard section flags. */ 314 flags |= sflags; 315 316 /* Apply possibly linked once flags to new generated segment, too. */ 317 if (!bfd_set_section_flags (stdoutput, r, flags)) 318 as_bad (_("bfd_set_section_flags: %s"), 319 bfd_errmsg (bfd_get_error ())); 320 321 /* Restore to previous segment. */ 322 if (save_seg != NULL) 323 subseg_set (save_seg, save_subseg); 324 return r; 325 } 326 327 static void 328 dwcfi_hash_insert (const char *name, struct dwcfi_seg_list *item) 329 { 330 const char *error_string; 331 332 if ((error_string = hash_jam (dwcfi_hash, name, (char *) item))) 333 as_fatal (_("Inserting \"%s\" into structure table failed: %s"), 334 name, error_string); 335 } 336 337 static struct dwcfi_seg_list * 338 dwcfi_hash_find (char *name) 339 { 340 return (struct dwcfi_seg_list *) hash_find (dwcfi_hash, name); 341 } 342 343 static struct dwcfi_seg_list * 344 dwcfi_hash_find_or_make (segT cseg, const char *base_name, int flags) 345 { 346 struct dwcfi_seg_list *item; 347 char *name; 348 349 /* Initialize dwcfi_hash once. */ 350 if (!dwcfi_hash) 351 dwcfi_hash = hash_new (); 352 353 name = get_debugseg_name (cseg, base_name); 354 355 item = dwcfi_hash_find (name); 356 if (!item) 357 { 358 item = alloc_debugseg_item (make_debug_seg (cseg, name, flags), 0, name); 359 360 dwcfi_hash_insert (item->seg_name, item); 361 } 362 else 363 free (name); 364 365 return item; 366 } 367 368 /* ??? Share this with dwarf2cfg.c. */ 369 #ifndef TC_DWARF2_EMIT_OFFSET 370 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset 371 372 /* Create an offset to .dwarf2_*. */ 373 374 static void 375 generic_dwarf2_emit_offset (symbolS *symbol, unsigned int size) 376 { 377 expressionS exp; 378 379 exp.X_op = O_symbol; 380 exp.X_add_symbol = symbol; 381 exp.X_add_number = 0; 382 emit_expr (&exp, size); 383 } 384 #endif 385 386 struct cfi_escape_data 387 { 388 struct cfi_escape_data *next; 389 expressionS exp; 390 }; 391 392 struct cie_entry 393 { 394 struct cie_entry *next; 395 #if MULTIPLE_FRAME_SECTIONS 396 segT cur_seg; 397 #endif 398 symbolS *start_address; 399 unsigned int return_column; 400 unsigned int signal_frame; 401 unsigned char fde_encoding; 402 unsigned char per_encoding; 403 unsigned char lsda_encoding; 404 expressionS personality; 405 struct cfi_insn_data *first, *last; 406 }; 407 408 /* List of FDE entries. */ 409 410 struct fde_entry *all_fde_data; 411 static struct fde_entry **last_fde_data = &all_fde_data; 412 413 /* List of CIEs so that they could be reused. */ 414 static struct cie_entry *cie_root; 415 416 /* Stack of old CFI data, for save/restore. */ 417 struct cfa_save_data 418 { 419 struct cfa_save_data *next; 420 offsetT cfa_offset; 421 }; 422 423 /* Current open FDE entry. */ 424 struct frch_cfi_data 425 { 426 struct fde_entry *cur_fde_data; 427 symbolS *last_address; 428 offsetT cur_cfa_offset; 429 struct cfa_save_data *cfa_save_stack; 430 }; 431 432 /* Construct a new FDE structure and add it to the end of the fde list. */ 433 434 static struct fde_entry * 435 alloc_fde_entry (void) 436 { 437 struct fde_entry *fde = XCNEW (struct fde_entry); 438 439 frchain_now->frch_cfi_data = XCNEW (struct frch_cfi_data); 440 frchain_now->frch_cfi_data->cur_fde_data = fde; 441 *last_fde_data = fde; 442 last_fde_data = &fde->next; 443 SET_CUR_SEG (fde, is_now_linkonce_segment ()); 444 SET_HANDLED (fde, 0); 445 fde->last = &fde->data; 446 fde->return_column = DWARF2_DEFAULT_RETURN_COLUMN; 447 fde->per_encoding = DW_EH_PE_omit; 448 fde->lsda_encoding = DW_EH_PE_omit; 449 fde->eh_header_type = EH_COMPACT_UNKNOWN; 450 451 return fde; 452 } 453 454 /* The following functions are available for a backend to construct its 455 own unwind information, usually from legacy unwind directives. */ 456 457 /* Construct a new INSN structure and add it to the end of the insn list 458 for the currently active FDE. */ 459 460 static bfd_boolean cfi_sections_set = FALSE; 461 static int cfi_sections = CFI_EMIT_eh_frame; 462 int all_cfi_sections = 0; 463 static struct fde_entry *last_fde; 464 465 static struct cfi_insn_data * 466 alloc_cfi_insn_data (void) 467 { 468 struct cfi_insn_data *insn = XCNEW (struct cfi_insn_data); 469 struct fde_entry *cur_fde_data = frchain_now->frch_cfi_data->cur_fde_data; 470 471 *cur_fde_data->last = insn; 472 cur_fde_data->last = &insn->next; 473 SET_CUR_SEG (insn, is_now_linkonce_segment ()); 474 return insn; 475 } 476 477 /* Construct a new FDE structure that begins at LABEL. */ 478 479 void 480 cfi_new_fde (symbolS *label) 481 { 482 struct fde_entry *fde = alloc_fde_entry (); 483 fde->start_address = label; 484 frchain_now->frch_cfi_data->last_address = label; 485 } 486 487 /* End the currently open FDE. */ 488 489 void 490 cfi_end_fde (symbolS *label) 491 { 492 frchain_now->frch_cfi_data->cur_fde_data->end_address = label; 493 free (frchain_now->frch_cfi_data); 494 frchain_now->frch_cfi_data = NULL; 495 } 496 497 /* Set the return column for the current FDE. */ 498 499 void 500 cfi_set_return_column (unsigned regno) 501 { 502 frchain_now->frch_cfi_data->cur_fde_data->return_column = regno; 503 } 504 505 void 506 cfi_set_sections (void) 507 { 508 frchain_now->frch_cfi_data->cur_fde_data->sections = all_cfi_sections; 509 cfi_sections_set = TRUE; 510 } 511 512 /* Universal functions to store new instructions. */ 513 514 static void 515 cfi_add_CFA_insn (int insn) 516 { 517 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data (); 518 519 insn_ptr->insn = insn; 520 } 521 522 static void 523 cfi_add_CFA_insn_reg (int insn, unsigned regno) 524 { 525 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data (); 526 527 insn_ptr->insn = insn; 528 insn_ptr->u.r = regno; 529 } 530 531 static void 532 cfi_add_CFA_insn_offset (int insn, offsetT offset) 533 { 534 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data (); 535 536 insn_ptr->insn = insn; 537 insn_ptr->u.i = offset; 538 } 539 540 static void 541 cfi_add_CFA_insn_reg_reg (int insn, unsigned reg1, unsigned reg2) 542 { 543 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data (); 544 545 insn_ptr->insn = insn; 546 insn_ptr->u.rr.reg1 = reg1; 547 insn_ptr->u.rr.reg2 = reg2; 548 } 549 550 static void 551 cfi_add_CFA_insn_reg_offset (int insn, unsigned regno, offsetT offset) 552 { 553 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data (); 554 555 insn_ptr->insn = insn; 556 insn_ptr->u.ri.reg = regno; 557 insn_ptr->u.ri.offset = offset; 558 } 559 560 /* Add a CFI insn to advance the PC from the last address to LABEL. */ 561 562 void 563 cfi_add_advance_loc (symbolS *label) 564 { 565 struct cfi_insn_data *insn = alloc_cfi_insn_data (); 566 567 insn->insn = DW_CFA_advance_loc; 568 insn->u.ll.lab1 = frchain_now->frch_cfi_data->last_address; 569 insn->u.ll.lab2 = label; 570 571 frchain_now->frch_cfi_data->last_address = label; 572 } 573 574 /* Add a CFI insn to label the current position in the CFI segment. */ 575 576 void 577 cfi_add_label (const char *name) 578 { 579 unsigned int len = strlen (name) + 1; 580 struct cfi_insn_data *insn = alloc_cfi_insn_data (); 581 582 insn->insn = CFI_label; 583 obstack_grow (¬es, name, len); 584 insn->u.sym_name = (char *) obstack_finish (¬es); 585 } 586 587 /* Add a DW_CFA_offset record to the CFI data. */ 588 589 void 590 cfi_add_CFA_offset (unsigned regno, offsetT offset) 591 { 592 unsigned int abs_data_align; 593 594 gas_assert (DWARF2_CIE_DATA_ALIGNMENT != 0); 595 cfi_add_CFA_insn_reg_offset (DW_CFA_offset, regno, offset); 596 597 abs_data_align = (DWARF2_CIE_DATA_ALIGNMENT < 0 598 ? -DWARF2_CIE_DATA_ALIGNMENT : DWARF2_CIE_DATA_ALIGNMENT); 599 if (offset % abs_data_align) 600 as_bad (_("register save offset not a multiple of %u"), abs_data_align); 601 } 602 603 /* Add a DW_CFA_def_cfa record to the CFI data. */ 604 605 void 606 cfi_add_CFA_def_cfa (unsigned regno, offsetT offset) 607 { 608 cfi_add_CFA_insn_reg_offset (DW_CFA_def_cfa, regno, offset); 609 frchain_now->frch_cfi_data->cur_cfa_offset = offset; 610 } 611 612 /* Add a DW_CFA_register record to the CFI data. */ 613 614 void 615 cfi_add_CFA_register (unsigned reg1, unsigned reg2) 616 { 617 cfi_add_CFA_insn_reg_reg (DW_CFA_register, reg1, reg2); 618 } 619 620 /* Add a DW_CFA_def_cfa_register record to the CFI data. */ 621 622 void 623 cfi_add_CFA_def_cfa_register (unsigned regno) 624 { 625 cfi_add_CFA_insn_reg (DW_CFA_def_cfa_register, regno); 626 } 627 628 /* Add a DW_CFA_def_cfa_offset record to the CFI data. */ 629 630 void 631 cfi_add_CFA_def_cfa_offset (offsetT offset) 632 { 633 cfi_add_CFA_insn_offset (DW_CFA_def_cfa_offset, offset); 634 frchain_now->frch_cfi_data->cur_cfa_offset = offset; 635 } 636 637 void 638 cfi_add_CFA_restore (unsigned regno) 639 { 640 cfi_add_CFA_insn_reg (DW_CFA_restore, regno); 641 } 642 643 void 644 cfi_add_CFA_undefined (unsigned regno) 645 { 646 cfi_add_CFA_insn_reg (DW_CFA_undefined, regno); 647 } 648 649 void 650 cfi_add_CFA_same_value (unsigned regno) 651 { 652 cfi_add_CFA_insn_reg (DW_CFA_same_value, regno); 653 } 654 655 void 656 cfi_add_CFA_remember_state (void) 657 { 658 struct cfa_save_data *p; 659 660 cfi_add_CFA_insn (DW_CFA_remember_state); 661 662 p = XNEW (struct cfa_save_data); 663 p->cfa_offset = frchain_now->frch_cfi_data->cur_cfa_offset; 664 p->next = frchain_now->frch_cfi_data->cfa_save_stack; 665 frchain_now->frch_cfi_data->cfa_save_stack = p; 666 } 667 668 void 669 cfi_add_CFA_restore_state (void) 670 { 671 struct cfa_save_data *p; 672 673 cfi_add_CFA_insn (DW_CFA_restore_state); 674 675 p = frchain_now->frch_cfi_data->cfa_save_stack; 676 if (p) 677 { 678 frchain_now->frch_cfi_data->cur_cfa_offset = p->cfa_offset; 679 frchain_now->frch_cfi_data->cfa_save_stack = p->next; 680 free (p); 681 } 682 else 683 as_bad (_("CFI state restore without previous remember")); 684 } 685 686 687 /* Parse CFI assembler directives. */ 688 689 static void dot_cfi (int); 690 static void dot_cfi_escape (int); 691 static void dot_cfi_sections (int); 692 static void dot_cfi_startproc (int); 693 static void dot_cfi_endproc (int); 694 static void dot_cfi_fde_data (int); 695 static void dot_cfi_personality (int); 696 static void dot_cfi_personality_id (int); 697 static void dot_cfi_lsda (int); 698 static void dot_cfi_val_encoded_addr (int); 699 static void dot_cfi_inline_lsda (int); 700 static void dot_cfi_label (int); 701 702 const pseudo_typeS cfi_pseudo_table[] = 703 { 704 { "cfi_sections", dot_cfi_sections, 0 }, 705 { "cfi_startproc", dot_cfi_startproc, 0 }, 706 { "cfi_endproc", dot_cfi_endproc, 0 }, 707 { "cfi_fde_data", dot_cfi_fde_data, 0 }, 708 { "cfi_def_cfa", dot_cfi, DW_CFA_def_cfa }, 709 { "cfi_def_cfa_register", dot_cfi, DW_CFA_def_cfa_register }, 710 { "cfi_def_cfa_offset", dot_cfi, DW_CFA_def_cfa_offset }, 711 { "cfi_adjust_cfa_offset", dot_cfi, CFI_adjust_cfa_offset }, 712 { "cfi_offset", dot_cfi, DW_CFA_offset }, 713 { "cfi_rel_offset", dot_cfi, CFI_rel_offset }, 714 { "cfi_register", dot_cfi, DW_CFA_register }, 715 { "cfi_return_column", dot_cfi, CFI_return_column }, 716 { "cfi_restore", dot_cfi, DW_CFA_restore }, 717 { "cfi_undefined", dot_cfi, DW_CFA_undefined }, 718 { "cfi_same_value", dot_cfi, DW_CFA_same_value }, 719 { "cfi_remember_state", dot_cfi, DW_CFA_remember_state }, 720 { "cfi_restore_state", dot_cfi, DW_CFA_restore_state }, 721 { "cfi_window_save", dot_cfi, DW_CFA_GNU_window_save }, 722 { "cfi_escape", dot_cfi_escape, 0 }, 723 { "cfi_signal_frame", dot_cfi, CFI_signal_frame }, 724 { "cfi_personality", dot_cfi_personality, 0 }, 725 { "cfi_personality_id", dot_cfi_personality_id, 0 }, 726 { "cfi_lsda", dot_cfi_lsda, 0 }, 727 { "cfi_val_encoded_addr", dot_cfi_val_encoded_addr, 0 }, 728 { "cfi_inline_lsda", dot_cfi_inline_lsda, 0 }, 729 { "cfi_label", dot_cfi_label, 0 }, 730 { NULL, NULL, 0 } 731 }; 732 733 static void 734 cfi_parse_separator (void) 735 { 736 SKIP_WHITESPACE (); 737 if (*input_line_pointer == ',') 738 input_line_pointer++; 739 else 740 as_bad (_("missing separator")); 741 } 742 743 #ifndef tc_parse_to_dw2regnum 744 static void 745 tc_parse_to_dw2regnum (expressionS *exp) 746 { 747 # ifdef tc_regname_to_dw2regnum 748 SKIP_WHITESPACE (); 749 if (is_name_beginner (*input_line_pointer) 750 || (*input_line_pointer == '%' 751 && is_name_beginner (*++input_line_pointer))) 752 { 753 char *name, c; 754 755 c = get_symbol_name (& name); 756 757 exp->X_op = O_constant; 758 exp->X_add_number = tc_regname_to_dw2regnum (name); 759 760 restore_line_pointer (c); 761 } 762 else 763 # endif 764 expression_and_evaluate (exp); 765 } 766 #endif 767 768 static unsigned 769 cfi_parse_reg (void) 770 { 771 int regno; 772 expressionS exp; 773 774 tc_parse_to_dw2regnum (&exp); 775 switch (exp.X_op) 776 { 777 case O_register: 778 case O_constant: 779 regno = exp.X_add_number; 780 break; 781 782 default: 783 regno = -1; 784 break; 785 } 786 787 if (regno < 0) 788 { 789 as_bad (_("bad register expression")); 790 regno = 0; 791 } 792 793 return regno; 794 } 795 796 static offsetT 797 cfi_parse_const (void) 798 { 799 return get_absolute_expression (); 800 } 801 802 static void 803 dot_cfi (int arg) 804 { 805 offsetT offset; 806 unsigned reg1, reg2; 807 808 if (frchain_now->frch_cfi_data == NULL) 809 { 810 as_bad (_("CFI instruction used without previous .cfi_startproc")); 811 ignore_rest_of_line (); 812 return; 813 } 814 815 /* If the last address was not at the current PC, advance to current. */ 816 if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now 817 || S_GET_VALUE (frchain_now->frch_cfi_data->last_address) 818 != frag_now_fix ()) 819 cfi_add_advance_loc (symbol_temp_new_now ()); 820 821 switch (arg) 822 { 823 case DW_CFA_offset: 824 reg1 = cfi_parse_reg (); 825 cfi_parse_separator (); 826 offset = cfi_parse_const (); 827 cfi_add_CFA_offset (reg1, offset); 828 break; 829 830 case CFI_rel_offset: 831 reg1 = cfi_parse_reg (); 832 cfi_parse_separator (); 833 offset = cfi_parse_const (); 834 cfi_add_CFA_offset (reg1, 835 offset - frchain_now->frch_cfi_data->cur_cfa_offset); 836 break; 837 838 case DW_CFA_def_cfa: 839 reg1 = cfi_parse_reg (); 840 cfi_parse_separator (); 841 offset = cfi_parse_const (); 842 cfi_add_CFA_def_cfa (reg1, offset); 843 break; 844 845 case DW_CFA_register: 846 reg1 = cfi_parse_reg (); 847 cfi_parse_separator (); 848 reg2 = cfi_parse_reg (); 849 cfi_add_CFA_register (reg1, reg2); 850 break; 851 852 case DW_CFA_def_cfa_register: 853 reg1 = cfi_parse_reg (); 854 cfi_add_CFA_def_cfa_register (reg1); 855 break; 856 857 case DW_CFA_def_cfa_offset: 858 offset = cfi_parse_const (); 859 cfi_add_CFA_def_cfa_offset (offset); 860 break; 861 862 case CFI_adjust_cfa_offset: 863 offset = cfi_parse_const (); 864 cfi_add_CFA_def_cfa_offset (frchain_now->frch_cfi_data->cur_cfa_offset 865 + offset); 866 break; 867 868 case DW_CFA_restore: 869 for (;;) 870 { 871 reg1 = cfi_parse_reg (); 872 cfi_add_CFA_restore (reg1); 873 SKIP_WHITESPACE (); 874 if (*input_line_pointer != ',') 875 break; 876 ++input_line_pointer; 877 } 878 break; 879 880 case DW_CFA_undefined: 881 for (;;) 882 { 883 reg1 = cfi_parse_reg (); 884 cfi_add_CFA_undefined (reg1); 885 SKIP_WHITESPACE (); 886 if (*input_line_pointer != ',') 887 break; 888 ++input_line_pointer; 889 } 890 break; 891 892 case DW_CFA_same_value: 893 reg1 = cfi_parse_reg (); 894 cfi_add_CFA_same_value (reg1); 895 break; 896 897 case CFI_return_column: 898 reg1 = cfi_parse_reg (); 899 cfi_set_return_column (reg1); 900 break; 901 902 case DW_CFA_remember_state: 903 cfi_add_CFA_remember_state (); 904 break; 905 906 case DW_CFA_restore_state: 907 cfi_add_CFA_restore_state (); 908 break; 909 910 case DW_CFA_GNU_window_save: 911 cfi_add_CFA_insn (DW_CFA_GNU_window_save); 912 break; 913 914 case CFI_signal_frame: 915 frchain_now->frch_cfi_data->cur_fde_data->signal_frame = 1; 916 break; 917 918 default: 919 abort (); 920 } 921 922 demand_empty_rest_of_line (); 923 } 924 925 static void 926 dot_cfi_escape (int ignored ATTRIBUTE_UNUSED) 927 { 928 struct cfi_escape_data *head, **tail, *e; 929 struct cfi_insn_data *insn; 930 931 if (frchain_now->frch_cfi_data == NULL) 932 { 933 as_bad (_("CFI instruction used without previous .cfi_startproc")); 934 ignore_rest_of_line (); 935 return; 936 } 937 938 /* If the last address was not at the current PC, advance to current. */ 939 if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now 940 || S_GET_VALUE (frchain_now->frch_cfi_data->last_address) 941 != frag_now_fix ()) 942 cfi_add_advance_loc (symbol_temp_new_now ()); 943 944 tail = &head; 945 do 946 { 947 e = XNEW (struct cfi_escape_data); 948 do_parse_cons_expression (&e->exp, 1); 949 *tail = e; 950 tail = &e->next; 951 } 952 while (*input_line_pointer++ == ','); 953 *tail = NULL; 954 955 insn = alloc_cfi_insn_data (); 956 insn->insn = CFI_escape; 957 insn->u.esc = head; 958 959 --input_line_pointer; 960 demand_empty_rest_of_line (); 961 } 962 963 static void 964 dot_cfi_personality (int ignored ATTRIBUTE_UNUSED) 965 { 966 struct fde_entry *fde; 967 offsetT encoding; 968 969 if (frchain_now->frch_cfi_data == NULL) 970 { 971 as_bad (_("CFI instruction used without previous .cfi_startproc")); 972 ignore_rest_of_line (); 973 return; 974 } 975 976 fde = frchain_now->frch_cfi_data->cur_fde_data; 977 encoding = cfi_parse_const (); 978 if (encoding == DW_EH_PE_omit) 979 { 980 demand_empty_rest_of_line (); 981 fde->per_encoding = encoding; 982 return; 983 } 984 985 if ((encoding & 0xff) != encoding 986 || ((((encoding & 0x70) != 0 987 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr 988 && (encoding & 0x70) != DW_EH_PE_pcrel 989 #endif 990 ) 991 /* leb128 can be handled, but does something actually need it? */ 992 || (encoding & 7) == DW_EH_PE_uleb128 993 || (encoding & 7) > DW_EH_PE_udata8) 994 && tc_cfi_reloc_for_encoding (encoding) == BFD_RELOC_NONE)) 995 { 996 as_bad (_("invalid or unsupported encoding in .cfi_personality")); 997 ignore_rest_of_line (); 998 return; 999 } 1000 1001 if (*input_line_pointer++ != ',') 1002 { 1003 as_bad (_(".cfi_personality requires encoding and symbol arguments")); 1004 ignore_rest_of_line (); 1005 return; 1006 } 1007 1008 expression_and_evaluate (&fde->personality); 1009 switch (fde->personality.X_op) 1010 { 1011 case O_symbol: 1012 break; 1013 case O_constant: 1014 if ((encoding & 0x70) == DW_EH_PE_pcrel) 1015 encoding = DW_EH_PE_omit; 1016 break; 1017 default: 1018 encoding = DW_EH_PE_omit; 1019 break; 1020 } 1021 1022 fde->per_encoding = encoding; 1023 1024 if (encoding == DW_EH_PE_omit) 1025 { 1026 as_bad (_("wrong second argument to .cfi_personality")); 1027 ignore_rest_of_line (); 1028 return; 1029 } 1030 1031 demand_empty_rest_of_line (); 1032 } 1033 1034 static void 1035 dot_cfi_lsda (int ignored ATTRIBUTE_UNUSED) 1036 { 1037 struct fde_entry *fde; 1038 offsetT encoding; 1039 1040 if (frchain_now->frch_cfi_data == NULL) 1041 { 1042 as_bad (_("CFI instruction used without previous .cfi_startproc")); 1043 ignore_rest_of_line (); 1044 return; 1045 } 1046 1047 fde = frchain_now->frch_cfi_data->cur_fde_data; 1048 encoding = cfi_parse_const (); 1049 if (encoding == DW_EH_PE_omit) 1050 { 1051 demand_empty_rest_of_line (); 1052 fde->lsda_encoding = encoding; 1053 return; 1054 } 1055 1056 if ((encoding & 0xff) != encoding 1057 || ((((encoding & 0x70) != 0 1058 #if CFI_DIFF_LSDA_OK || defined tc_cfi_emit_pcrel_expr 1059 && (encoding & 0x70) != DW_EH_PE_pcrel 1060 #endif 1061 ) 1062 /* leb128 can be handled, but does something actually need it? */ 1063 || (encoding & 7) == DW_EH_PE_uleb128 1064 || (encoding & 7) > DW_EH_PE_udata8) 1065 && tc_cfi_reloc_for_encoding (encoding) == BFD_RELOC_NONE)) 1066 { 1067 as_bad (_("invalid or unsupported encoding in .cfi_lsda")); 1068 ignore_rest_of_line (); 1069 return; 1070 } 1071 1072 if (*input_line_pointer++ != ',') 1073 { 1074 as_bad (_(".cfi_lsda requires encoding and symbol arguments")); 1075 ignore_rest_of_line (); 1076 return; 1077 } 1078 1079 fde->lsda_encoding = encoding; 1080 1081 expression_and_evaluate (&fde->lsda); 1082 switch (fde->lsda.X_op) 1083 { 1084 case O_symbol: 1085 break; 1086 case O_constant: 1087 if ((encoding & 0x70) == DW_EH_PE_pcrel) 1088 encoding = DW_EH_PE_omit; 1089 break; 1090 default: 1091 encoding = DW_EH_PE_omit; 1092 break; 1093 } 1094 1095 fde->lsda_encoding = encoding; 1096 1097 if (encoding == DW_EH_PE_omit) 1098 { 1099 as_bad (_("wrong second argument to .cfi_lsda")); 1100 ignore_rest_of_line (); 1101 return; 1102 } 1103 1104 demand_empty_rest_of_line (); 1105 } 1106 1107 static void 1108 dot_cfi_val_encoded_addr (int ignored ATTRIBUTE_UNUSED) 1109 { 1110 struct cfi_insn_data *insn_ptr; 1111 offsetT encoding; 1112 1113 if (frchain_now->frch_cfi_data == NULL) 1114 { 1115 as_bad (_("CFI instruction used without previous .cfi_startproc")); 1116 ignore_rest_of_line (); 1117 return; 1118 } 1119 1120 /* If the last address was not at the current PC, advance to current. */ 1121 if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now 1122 || S_GET_VALUE (frchain_now->frch_cfi_data->last_address) 1123 != frag_now_fix ()) 1124 cfi_add_advance_loc (symbol_temp_new_now ()); 1125 1126 insn_ptr = alloc_cfi_insn_data (); 1127 insn_ptr->insn = CFI_val_encoded_addr; 1128 1129 insn_ptr->u.ea.reg = cfi_parse_reg (); 1130 1131 cfi_parse_separator (); 1132 encoding = cfi_parse_const (); 1133 if ((encoding & 0xff) != encoding 1134 || ((encoding & 0x70) != 0 1135 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr 1136 && (encoding & 0x70) != DW_EH_PE_pcrel 1137 #endif 1138 ) 1139 /* leb128 can be handled, but does something actually need it? */ 1140 || (encoding & 7) == DW_EH_PE_uleb128 1141 || (encoding & 7) > DW_EH_PE_udata8) 1142 { 1143 as_bad (_("invalid or unsupported encoding in .cfi_lsda")); 1144 encoding = DW_EH_PE_omit; 1145 } 1146 1147 cfi_parse_separator (); 1148 expression_and_evaluate (&insn_ptr->u.ea.exp); 1149 switch (insn_ptr->u.ea.exp.X_op) 1150 { 1151 case O_symbol: 1152 break; 1153 case O_constant: 1154 if ((encoding & 0x70) != DW_EH_PE_pcrel) 1155 break; 1156 default: 1157 encoding = DW_EH_PE_omit; 1158 break; 1159 } 1160 1161 insn_ptr->u.ea.encoding = encoding; 1162 if (encoding == DW_EH_PE_omit) 1163 { 1164 as_bad (_("wrong third argument to .cfi_val_encoded_addr")); 1165 ignore_rest_of_line (); 1166 return; 1167 } 1168 1169 demand_empty_rest_of_line (); 1170 } 1171 1172 static void 1173 dot_cfi_label (int ignored ATTRIBUTE_UNUSED) 1174 { 1175 char *name = read_symbol_name (); 1176 1177 if (name == NULL) 1178 return; 1179 1180 /* If the last address was not at the current PC, advance to current. */ 1181 if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now 1182 || S_GET_VALUE (frchain_now->frch_cfi_data->last_address) 1183 != frag_now_fix ()) 1184 cfi_add_advance_loc (symbol_temp_new_now ()); 1185 1186 cfi_add_label (name); 1187 free (name); 1188 1189 demand_empty_rest_of_line (); 1190 } 1191 1192 static void 1193 dot_cfi_sections (int ignored ATTRIBUTE_UNUSED) 1194 { 1195 int sections = 0; 1196 1197 SKIP_WHITESPACE (); 1198 if (is_name_beginner (*input_line_pointer) || *input_line_pointer == '"') 1199 while (1) 1200 { 1201 char * saved_ilp; 1202 char *name, c; 1203 1204 saved_ilp = input_line_pointer; 1205 c = get_symbol_name (& name); 1206 1207 if (strncmp (name, ".eh_frame", sizeof ".eh_frame") == 0 1208 && name[9] != '_') 1209 sections |= CFI_EMIT_eh_frame; 1210 else if (strncmp (name, ".debug_frame", sizeof ".debug_frame") == 0) 1211 sections |= CFI_EMIT_debug_frame; 1212 #if SUPPORT_COMPACT_EH 1213 else if (strncmp (name, ".eh_frame_entry", sizeof ".eh_frame_entry") == 0) 1214 { 1215 compact_eh = TRUE; 1216 sections |= CFI_EMIT_eh_frame_compact; 1217 } 1218 #endif 1219 #ifdef tc_cfi_section_name 1220 else if (strcmp (name, tc_cfi_section_name) == 0) 1221 sections |= CFI_EMIT_target; 1222 #endif 1223 else 1224 { 1225 *input_line_pointer = c; 1226 input_line_pointer = saved_ilp; 1227 break; 1228 } 1229 1230 *input_line_pointer = c; 1231 SKIP_WHITESPACE_AFTER_NAME (); 1232 if (*input_line_pointer == ',') 1233 { 1234 name = input_line_pointer++; 1235 SKIP_WHITESPACE (); 1236 if (!is_name_beginner (*input_line_pointer) && *input_line_pointer != '"') 1237 { 1238 input_line_pointer = name; 1239 break; 1240 } 1241 } 1242 else if (is_name_beginner (*input_line_pointer) || *input_line_pointer == '"') 1243 break; 1244 } 1245 1246 demand_empty_rest_of_line (); 1247 if (cfi_sections_set && cfi_sections != sections) 1248 as_bad (_("inconsistent uses of .cfi_sections")); 1249 cfi_sections = sections; 1250 } 1251 1252 static void 1253 dot_cfi_startproc (int ignored ATTRIBUTE_UNUSED) 1254 { 1255 int simple = 0; 1256 1257 if (frchain_now->frch_cfi_data != NULL) 1258 { 1259 as_bad (_("previous CFI entry not closed (missing .cfi_endproc)")); 1260 ignore_rest_of_line (); 1261 return; 1262 } 1263 1264 cfi_new_fde (symbol_temp_new_now ()); 1265 1266 SKIP_WHITESPACE (); 1267 if (is_name_beginner (*input_line_pointer) || *input_line_pointer == '"') 1268 { 1269 char * saved_ilp = input_line_pointer; 1270 char *name, c; 1271 1272 c = get_symbol_name (& name); 1273 1274 if (strcmp (name, "simple") == 0) 1275 { 1276 simple = 1; 1277 restore_line_pointer (c); 1278 } 1279 else 1280 input_line_pointer = saved_ilp; 1281 } 1282 demand_empty_rest_of_line (); 1283 1284 cfi_sections_set = TRUE; 1285 all_cfi_sections |= cfi_sections; 1286 cfi_set_sections (); 1287 frchain_now->frch_cfi_data->cur_cfa_offset = 0; 1288 if (!simple) 1289 tc_cfi_frame_initial_instructions (); 1290 1291 if ((cfi_sections & CFI_EMIT_target) != 0) 1292 tc_cfi_startproc (); 1293 } 1294 1295 static void 1296 dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED) 1297 { 1298 if (frchain_now->frch_cfi_data == NULL) 1299 { 1300 as_bad (_(".cfi_endproc without corresponding .cfi_startproc")); 1301 ignore_rest_of_line (); 1302 return; 1303 } 1304 1305 last_fde = frchain_now->frch_cfi_data->cur_fde_data; 1306 1307 cfi_end_fde (symbol_temp_new_now ()); 1308 1309 demand_empty_rest_of_line (); 1310 1311 cfi_sections_set = TRUE; 1312 if ((cfi_sections & CFI_EMIT_target) != 0) 1313 tc_cfi_endproc (last_fde); 1314 } 1315 1316 static segT 1317 get_cfi_seg (segT cseg, const char *base, flagword flags, int align) 1318 { 1319 /* Exclude .debug_frame sections for Compact EH. */ 1320 if (SUPPORT_FRAME_LINKONCE || ((flags & SEC_DEBUGGING) == 0 && compact_eh)) 1321 { 1322 struct dwcfi_seg_list *l; 1323 1324 l = dwcfi_hash_find_or_make (cseg, base, flags); 1325 1326 cseg = l->seg; 1327 subseg_set (cseg, l->subseg); 1328 } 1329 else 1330 { 1331 cseg = subseg_new (base, 0); 1332 bfd_set_section_flags (stdoutput, cseg, flags); 1333 } 1334 record_alignment (cseg, align); 1335 return cseg; 1336 } 1337 1338 #if SUPPORT_COMPACT_EH 1339 static void 1340 dot_cfi_personality_id (int ignored ATTRIBUTE_UNUSED) 1341 { 1342 struct fde_entry *fde; 1343 1344 if (frchain_now->frch_cfi_data == NULL) 1345 { 1346 as_bad (_("CFI instruction used without previous .cfi_startproc")); 1347 ignore_rest_of_line (); 1348 return; 1349 } 1350 1351 fde = frchain_now->frch_cfi_data->cur_fde_data; 1352 fde->personality_id = cfi_parse_const (); 1353 demand_empty_rest_of_line (); 1354 1355 if (fde->personality_id == 0 || fde->personality_id > 3) 1356 { 1357 as_bad (_("wrong argument to .cfi_personality_id")); 1358 return; 1359 } 1360 } 1361 1362 static void 1363 dot_cfi_fde_data (int ignored ATTRIBUTE_UNUSED) 1364 { 1365 if (frchain_now->frch_cfi_data == NULL) 1366 { 1367 as_bad (_(".cfi_fde_data without corresponding .cfi_startproc")); 1368 ignore_rest_of_line (); 1369 return; 1370 } 1371 1372 last_fde = frchain_now->frch_cfi_data->cur_fde_data; 1373 1374 cfi_sections_set = TRUE; 1375 if ((cfi_sections & CFI_EMIT_target) != 0 1376 || (cfi_sections & CFI_EMIT_eh_frame_compact) != 0) 1377 { 1378 struct cfi_escape_data *head, **tail, *e; 1379 int num_ops = 0; 1380 1381 tail = &head; 1382 if (!is_it_end_of_statement ()) 1383 { 1384 num_ops = 0; 1385 do 1386 { 1387 e = XNEW (struct cfi_escape_data); 1388 do_parse_cons_expression (&e->exp, 1); 1389 *tail = e; 1390 tail = &e->next; 1391 num_ops++; 1392 } 1393 while (*input_line_pointer++ == ','); 1394 --input_line_pointer; 1395 } 1396 *tail = NULL; 1397 1398 if (last_fde->lsda_encoding != DW_EH_PE_omit) 1399 last_fde->eh_header_type = EH_COMPACT_HAS_LSDA; 1400 else if (num_ops <= 3 && last_fde->per_encoding == DW_EH_PE_omit) 1401 last_fde->eh_header_type = EH_COMPACT_INLINE; 1402 else 1403 last_fde->eh_header_type = EH_COMPACT_OUTLINE; 1404 1405 if (last_fde->eh_header_type == EH_COMPACT_INLINE) 1406 num_ops = 3; 1407 1408 last_fde->eh_data_size = num_ops; 1409 last_fde->eh_data = XNEWVEC (bfd_byte, num_ops); 1410 num_ops = 0; 1411 while (head) 1412 { 1413 e = head; 1414 head = e->next; 1415 last_fde->eh_data[num_ops++] = e->exp.X_add_number; 1416 free (e); 1417 } 1418 if (last_fde->eh_header_type == EH_COMPACT_INLINE) 1419 while (num_ops < 3) 1420 last_fde->eh_data[num_ops++] = tc_compact_eh_opcode_stop; 1421 } 1422 1423 demand_empty_rest_of_line (); 1424 } 1425 1426 /* Function to emit the compact unwinding opcodes stored in the 1427 fde's eh_data field. The end of the opcode data will be 1428 padded to the value in align. */ 1429 1430 static void 1431 output_compact_unwind_data (struct fde_entry *fde, int align) 1432 { 1433 int data_size = fde->eh_data_size + 2; 1434 int align_padding; 1435 int amask; 1436 char *p; 1437 1438 fde->eh_loc = symbol_temp_new_now (); 1439 1440 p = frag_more (1); 1441 if (fde->personality_id != 0) 1442 *p = fde->personality_id; 1443 else if (fde->per_encoding != DW_EH_PE_omit) 1444 { 1445 *p = 0; 1446 emit_expr_encoded (&fde->personality, fde->per_encoding, FALSE); 1447 data_size += encoding_size (fde->per_encoding); 1448 } 1449 else 1450 *p = 1; 1451 1452 amask = (1 << align) - 1; 1453 align_padding = ((data_size + amask) & ~amask) - data_size; 1454 1455 p = frag_more (fde->eh_data_size + 1 + align_padding); 1456 memcpy (p, fde->eh_data, fde->eh_data_size); 1457 p += fde->eh_data_size; 1458 1459 while (align_padding-- > 0) 1460 *(p++) = tc_compact_eh_opcode_pad; 1461 1462 *(p++) = tc_compact_eh_opcode_stop; 1463 fde->eh_header_type = EH_COMPACT_OUTLINE_DONE; 1464 } 1465 1466 /* Handle the .cfi_inline_lsda directive. */ 1467 static void 1468 dot_cfi_inline_lsda (int ignored ATTRIBUTE_UNUSED) 1469 { 1470 segT ccseg; 1471 int align; 1472 long max_alignment = 28; 1473 1474 if (!last_fde) 1475 { 1476 as_bad (_("unexpected .cfi_inline_lsda")); 1477 ignore_rest_of_line (); 1478 return; 1479 } 1480 1481 if ((last_fde->sections & CFI_EMIT_eh_frame_compact) == 0) 1482 { 1483 as_bad (_(".cfi_inline_lsda not valid for this frame")); 1484 ignore_rest_of_line (); 1485 return; 1486 } 1487 1488 if (last_fde->eh_header_type != EH_COMPACT_UNKNOWN 1489 && last_fde->eh_header_type != EH_COMPACT_HAS_LSDA) 1490 { 1491 as_bad (_(".cfi_inline_lsda seen for frame without .cfi_lsda")); 1492 ignore_rest_of_line (); 1493 return; 1494 } 1495 1496 #ifdef md_flush_pending_output 1497 md_flush_pending_output (); 1498 #endif 1499 1500 align = get_absolute_expression (); 1501 if (align > max_alignment) 1502 { 1503 align = max_alignment; 1504 as_bad (_("Alignment too large: %d. assumed."), align); 1505 } 1506 else if (align < 0) 1507 { 1508 as_warn (_("Alignment negative: 0 assumed.")); 1509 align = 0; 1510 } 1511 1512 demand_empty_rest_of_line (); 1513 ccseg = CUR_SEG (last_fde); 1514 1515 /* Open .gnu_extab section. */ 1516 get_cfi_seg (ccseg, ".gnu_extab", 1517 (SEC_ALLOC | SEC_LOAD | SEC_DATA 1518 | DWARF2_EH_FRAME_READ_ONLY), 1519 1); 1520 1521 frag_align (align, 0, 0); 1522 record_alignment (now_seg, align); 1523 if (last_fde->eh_header_type == EH_COMPACT_HAS_LSDA) 1524 output_compact_unwind_data (last_fde, align); 1525 1526 last_fde = NULL; 1527 1528 return; 1529 } 1530 #else /* !SUPPORT_COMPACT_EH */ 1531 static void 1532 dot_cfi_inline_lsda (int ignored ATTRIBUTE_UNUSED) 1533 { 1534 as_bad (_(".cfi_inline_lsda is not supported for this target")); 1535 ignore_rest_of_line (); 1536 } 1537 1538 static void 1539 dot_cfi_fde_data (int ignored ATTRIBUTE_UNUSED) 1540 { 1541 as_bad (_(".cfi_fde_data is not supported for this target")); 1542 ignore_rest_of_line (); 1543 } 1544 1545 static void 1546 dot_cfi_personality_id (int ignored ATTRIBUTE_UNUSED) 1547 { 1548 as_bad (_(".cfi_personality_id is not supported for this target")); 1549 ignore_rest_of_line (); 1550 } 1551 #endif 1552 1553 static void 1554 output_cfi_insn (struct cfi_insn_data *insn) 1555 { 1556 offsetT offset; 1557 unsigned int regno; 1558 1559 switch (insn->insn) 1560 { 1561 case DW_CFA_advance_loc: 1562 { 1563 symbolS *from = insn->u.ll.lab1; 1564 symbolS *to = insn->u.ll.lab2; 1565 1566 if (symbol_get_frag (to) == symbol_get_frag (from)) 1567 { 1568 addressT delta = S_GET_VALUE (to) - S_GET_VALUE (from); 1569 addressT scaled = delta / DWARF2_LINE_MIN_INSN_LENGTH; 1570 1571 if (scaled <= 0x3F) 1572 out_one (DW_CFA_advance_loc + scaled); 1573 else if (scaled <= 0xFF) 1574 { 1575 out_one (DW_CFA_advance_loc1); 1576 out_one (scaled); 1577 } 1578 else if (scaled <= 0xFFFF) 1579 { 1580 out_one (DW_CFA_advance_loc2); 1581 out_two (scaled); 1582 } 1583 else 1584 { 1585 out_one (DW_CFA_advance_loc4); 1586 out_four (scaled); 1587 } 1588 } 1589 else 1590 { 1591 expressionS exp; 1592 1593 exp.X_op = O_subtract; 1594 exp.X_add_symbol = to; 1595 exp.X_op_symbol = from; 1596 exp.X_add_number = 0; 1597 1598 /* The code in ehopt.c expects that one byte of the encoding 1599 is already allocated to the frag. This comes from the way 1600 that it scans the .eh_frame section looking first for the 1601 .byte DW_CFA_advance_loc4. */ 1602 *frag_more (1) = DW_CFA_advance_loc4; 1603 1604 frag_var (rs_cfa, 4, 0, DWARF2_LINE_MIN_INSN_LENGTH << 3, 1605 make_expr_symbol (&exp), frag_now_fix () - 1, 1606 (char *) frag_now); 1607 } 1608 } 1609 break; 1610 1611 case DW_CFA_def_cfa: 1612 offset = insn->u.ri.offset; 1613 if (offset < 0) 1614 { 1615 out_one (DW_CFA_def_cfa_sf); 1616 out_uleb128 (insn->u.ri.reg); 1617 out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT); 1618 } 1619 else 1620 { 1621 out_one (DW_CFA_def_cfa); 1622 out_uleb128 (insn->u.ri.reg); 1623 out_uleb128 (offset); 1624 } 1625 break; 1626 1627 case DW_CFA_def_cfa_register: 1628 case DW_CFA_undefined: 1629 case DW_CFA_same_value: 1630 out_one (insn->insn); 1631 out_uleb128 (insn->u.r); 1632 break; 1633 1634 case DW_CFA_def_cfa_offset: 1635 offset = insn->u.i; 1636 if (offset < 0) 1637 { 1638 out_one (DW_CFA_def_cfa_offset_sf); 1639 out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT); 1640 } 1641 else 1642 { 1643 out_one (DW_CFA_def_cfa_offset); 1644 out_uleb128 (offset); 1645 } 1646 break; 1647 1648 case DW_CFA_restore: 1649 regno = insn->u.r; 1650 if (regno <= 0x3F) 1651 { 1652 out_one (DW_CFA_restore + regno); 1653 } 1654 else 1655 { 1656 out_one (DW_CFA_restore_extended); 1657 out_uleb128 (regno); 1658 } 1659 break; 1660 1661 case DW_CFA_offset: 1662 regno = insn->u.ri.reg; 1663 offset = insn->u.ri.offset / DWARF2_CIE_DATA_ALIGNMENT; 1664 if (offset < 0) 1665 { 1666 out_one (DW_CFA_offset_extended_sf); 1667 out_uleb128 (regno); 1668 out_sleb128 (offset); 1669 } 1670 else if (regno <= 0x3F) 1671 { 1672 out_one (DW_CFA_offset + regno); 1673 out_uleb128 (offset); 1674 } 1675 else 1676 { 1677 out_one (DW_CFA_offset_extended); 1678 out_uleb128 (regno); 1679 out_uleb128 (offset); 1680 } 1681 break; 1682 1683 case DW_CFA_register: 1684 out_one (DW_CFA_register); 1685 out_uleb128 (insn->u.rr.reg1); 1686 out_uleb128 (insn->u.rr.reg2); 1687 break; 1688 1689 case DW_CFA_remember_state: 1690 case DW_CFA_restore_state: 1691 out_one (insn->insn); 1692 break; 1693 1694 case DW_CFA_GNU_window_save: 1695 out_one (DW_CFA_GNU_window_save); 1696 break; 1697 1698 case CFI_escape: 1699 { 1700 struct cfi_escape_data *e; 1701 for (e = insn->u.esc; e ; e = e->next) 1702 emit_expr (&e->exp, 1); 1703 break; 1704 } 1705 1706 case CFI_val_encoded_addr: 1707 { 1708 unsigned encoding = insn->u.ea.encoding; 1709 offsetT enc_size; 1710 1711 if (encoding == DW_EH_PE_omit) 1712 break; 1713 out_one (DW_CFA_val_expression); 1714 out_uleb128 (insn->u.ea.reg); 1715 1716 switch (encoding & 0x7) 1717 { 1718 case DW_EH_PE_absptr: 1719 enc_size = DWARF2_ADDR_SIZE (stdoutput); 1720 break; 1721 case DW_EH_PE_udata2: 1722 enc_size = 2; 1723 break; 1724 case DW_EH_PE_udata4: 1725 enc_size = 4; 1726 break; 1727 case DW_EH_PE_udata8: 1728 enc_size = 8; 1729 break; 1730 default: 1731 abort (); 1732 } 1733 1734 /* If the user has requested absolute encoding, 1735 then use the smaller DW_OP_addr encoding. */ 1736 if (insn->u.ea.encoding == DW_EH_PE_absptr) 1737 { 1738 out_uleb128 (1 + enc_size); 1739 out_one (DW_OP_addr); 1740 } 1741 else 1742 { 1743 out_uleb128 (1 + 1 + enc_size); 1744 out_one (DW_OP_GNU_encoded_addr); 1745 out_one (encoding); 1746 1747 if ((encoding & 0x70) == DW_EH_PE_pcrel) 1748 { 1749 #if CFI_DIFF_EXPR_OK 1750 insn->u.ea.exp.X_op = O_subtract; 1751 insn->u.ea.exp.X_op_symbol = symbol_temp_new_now (); 1752 #elif defined (tc_cfi_emit_pcrel_expr) 1753 tc_cfi_emit_pcrel_expr (&insn->u.ea.exp, enc_size); 1754 break; 1755 #else 1756 abort (); 1757 #endif 1758 } 1759 } 1760 emit_expr (&insn->u.ea.exp, enc_size); 1761 } 1762 break; 1763 1764 case CFI_label: 1765 colon (insn->u.sym_name); 1766 break; 1767 1768 default: 1769 abort (); 1770 } 1771 } 1772 1773 static void 1774 output_cie (struct cie_entry *cie, bfd_boolean eh_frame, int align) 1775 { 1776 symbolS *after_size_address, *end_address; 1777 expressionS exp; 1778 struct cfi_insn_data *i; 1779 offsetT augmentation_size; 1780 int enc; 1781 enum dwarf2_format fmt = DWARF2_FORMAT (now_seg); 1782 1783 cie->start_address = symbol_temp_new_now (); 1784 after_size_address = symbol_temp_make (); 1785 end_address = symbol_temp_make (); 1786 1787 exp.X_op = O_subtract; 1788 exp.X_add_symbol = end_address; 1789 exp.X_op_symbol = after_size_address; 1790 exp.X_add_number = 0; 1791 1792 if (eh_frame || fmt == dwarf2_format_32bit) 1793 emit_expr (&exp, 4); /* Length. */ 1794 else 1795 { 1796 if (fmt == dwarf2_format_64bit) 1797 out_four (-1); 1798 emit_expr (&exp, 8); /* Length. */ 1799 } 1800 symbol_set_value_now (after_size_address); 1801 if (eh_frame) 1802 out_four (0); /* CIE id. */ 1803 else 1804 { 1805 out_four (-1); /* CIE id. */ 1806 if (fmt != dwarf2_format_32bit) 1807 out_four (-1); 1808 } 1809 out_one (DW_CIE_VERSION); /* Version. */ 1810 if (eh_frame) 1811 { 1812 out_one ('z'); /* Augmentation. */ 1813 if (cie->per_encoding != DW_EH_PE_omit) 1814 out_one ('P'); 1815 if (cie->lsda_encoding != DW_EH_PE_omit) 1816 out_one ('L'); 1817 out_one ('R'); 1818 } 1819 if (cie->signal_frame) 1820 out_one ('S'); 1821 out_one (0); 1822 out_uleb128 (DWARF2_LINE_MIN_INSN_LENGTH); /* Code alignment. */ 1823 out_sleb128 (DWARF2_CIE_DATA_ALIGNMENT); /* Data alignment. */ 1824 if (DW_CIE_VERSION == 1) /* Return column. */ 1825 out_one (cie->return_column); 1826 else 1827 out_uleb128 (cie->return_column); 1828 if (eh_frame) 1829 { 1830 augmentation_size = 1 + (cie->lsda_encoding != DW_EH_PE_omit); 1831 if (cie->per_encoding != DW_EH_PE_omit) 1832 augmentation_size += 1 + encoding_size (cie->per_encoding); 1833 out_uleb128 (augmentation_size); /* Augmentation size. */ 1834 1835 emit_expr_encoded (&cie->personality, cie->per_encoding, TRUE); 1836 1837 if (cie->lsda_encoding != DW_EH_PE_omit) 1838 out_one (cie->lsda_encoding); 1839 } 1840 1841 switch (DWARF2_FDE_RELOC_SIZE) 1842 { 1843 case 2: 1844 enc = DW_EH_PE_sdata2; 1845 break; 1846 case 4: 1847 enc = DW_EH_PE_sdata4; 1848 break; 1849 case 8: 1850 enc = DW_EH_PE_sdata8; 1851 break; 1852 default: 1853 abort (); 1854 } 1855 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr 1856 enc |= DW_EH_PE_pcrel; 1857 #endif 1858 #ifdef DWARF2_FDE_RELOC_ENCODING 1859 /* Allow target to override encoding. */ 1860 enc = DWARF2_FDE_RELOC_ENCODING (enc); 1861 #endif 1862 cie->fde_encoding = enc; 1863 if (eh_frame) 1864 out_one (enc); 1865 1866 if (cie->first) 1867 { 1868 for (i = cie->first; i != cie->last; i = i->next) 1869 { 1870 if (CUR_SEG (i) != CUR_SEG (cie)) 1871 continue; 1872 output_cfi_insn (i); 1873 } 1874 } 1875 1876 frag_align (align, DW_CFA_nop, 0); 1877 symbol_set_value_now (end_address); 1878 } 1879 1880 static void 1881 output_fde (struct fde_entry *fde, struct cie_entry *cie, 1882 bfd_boolean eh_frame, struct cfi_insn_data *first, 1883 int align) 1884 { 1885 symbolS *after_size_address, *end_address; 1886 expressionS exp; 1887 offsetT augmentation_size; 1888 enum dwarf2_format fmt = DWARF2_FORMAT (now_seg); 1889 int offset_size; 1890 int addr_size; 1891 1892 after_size_address = symbol_temp_make (); 1893 end_address = symbol_temp_make (); 1894 1895 exp.X_op = O_subtract; 1896 exp.X_add_symbol = end_address; 1897 exp.X_op_symbol = after_size_address; 1898 exp.X_add_number = 0; 1899 if (eh_frame || fmt == dwarf2_format_32bit) 1900 offset_size = 4; 1901 else 1902 { 1903 if (fmt == dwarf2_format_64bit) 1904 out_four (-1); 1905 offset_size = 8; 1906 } 1907 emit_expr (&exp, offset_size); /* Length. */ 1908 symbol_set_value_now (after_size_address); 1909 1910 if (eh_frame) 1911 { 1912 exp.X_op = O_subtract; 1913 exp.X_add_symbol = after_size_address; 1914 exp.X_op_symbol = cie->start_address; 1915 exp.X_add_number = 0; 1916 emit_expr (&exp, offset_size); /* CIE offset. */ 1917 } 1918 else 1919 { 1920 TC_DWARF2_EMIT_OFFSET (cie->start_address, offset_size); 1921 } 1922 1923 exp.X_op = O_symbol; 1924 if (eh_frame) 1925 { 1926 bfd_reloc_code_real_type code 1927 = tc_cfi_reloc_for_encoding (cie->fde_encoding); 1928 if (code != BFD_RELOC_NONE) 1929 { 1930 reloc_howto_type *howto = bfd_reloc_type_lookup (stdoutput, code); 1931 char *p = frag_more (4); 1932 md_number_to_chars (p, 0, 4); 1933 fix_new (frag_now, p - frag_now->fr_literal, 4, fde->start_address, 1934 0, howto->pc_relative, code); 1935 } 1936 else 1937 { 1938 exp.X_op = O_subtract; 1939 exp.X_add_number = 0; 1940 #if CFI_DIFF_EXPR_OK 1941 exp.X_add_symbol = fde->start_address; 1942 exp.X_op_symbol = symbol_temp_new_now (); 1943 emit_expr (&exp, DWARF2_FDE_RELOC_SIZE); /* Code offset. */ 1944 #else 1945 exp.X_op = O_symbol; 1946 exp.X_add_symbol = fde->start_address; 1947 1948 #if defined(tc_cfi_emit_pcrel_expr) 1949 tc_cfi_emit_pcrel_expr (&exp, DWARF2_FDE_RELOC_SIZE); /* Code offset. */ 1950 #else 1951 emit_expr (&exp, DWARF2_FDE_RELOC_SIZE); /* Code offset. */ 1952 #endif 1953 #endif 1954 } 1955 addr_size = DWARF2_FDE_RELOC_SIZE; 1956 } 1957 else 1958 { 1959 exp.X_add_number = 0; 1960 exp.X_add_symbol = fde->start_address; 1961 addr_size = DWARF2_ADDR_SIZE (stdoutput); 1962 emit_expr (&exp, addr_size); 1963 } 1964 1965 exp.X_op = O_subtract; 1966 exp.X_add_symbol = fde->end_address; 1967 exp.X_op_symbol = fde->start_address; /* Code length. */ 1968 exp.X_add_number = 0; 1969 emit_expr (&exp, addr_size); 1970 1971 augmentation_size = encoding_size (fde->lsda_encoding); 1972 if (eh_frame) 1973 out_uleb128 (augmentation_size); /* Augmentation size. */ 1974 1975 emit_expr_encoded (&fde->lsda, cie->lsda_encoding, FALSE); 1976 1977 for (; first; first = first->next) 1978 if (CUR_SEG (first) == CUR_SEG (fde)) 1979 output_cfi_insn (first); 1980 1981 frag_align (align, DW_CFA_nop, 0); 1982 symbol_set_value_now (end_address); 1983 } 1984 1985 static struct cie_entry * 1986 select_cie_for_fde (struct fde_entry *fde, bfd_boolean eh_frame, 1987 struct cfi_insn_data **pfirst, int align) 1988 { 1989 struct cfi_insn_data *i, *j; 1990 struct cie_entry *cie; 1991 1992 for (cie = cie_root; cie; cie = cie->next) 1993 { 1994 if (CUR_SEG (cie) != CUR_SEG (fde)) 1995 continue; 1996 if (cie->return_column != fde->return_column 1997 || cie->signal_frame != fde->signal_frame 1998 || cie->per_encoding != fde->per_encoding 1999 || cie->lsda_encoding != fde->lsda_encoding) 2000 continue; 2001 if (cie->per_encoding != DW_EH_PE_omit) 2002 { 2003 if (cie->personality.X_op != fde->personality.X_op 2004 || cie->personality.X_add_number 2005 != fde->personality.X_add_number) 2006 continue; 2007 switch (cie->personality.X_op) 2008 { 2009 case O_constant: 2010 if (cie->personality.X_unsigned != fde->personality.X_unsigned) 2011 continue; 2012 break; 2013 case O_symbol: 2014 if (cie->personality.X_add_symbol 2015 != fde->personality.X_add_symbol) 2016 continue; 2017 break; 2018 default: 2019 abort (); 2020 } 2021 } 2022 for (i = cie->first, j = fde->data; 2023 i != cie->last && j != NULL; 2024 i = i->next, j = j->next) 2025 { 2026 if (i->insn != j->insn) 2027 goto fail; 2028 switch (i->insn) 2029 { 2030 case DW_CFA_advance_loc: 2031 case DW_CFA_remember_state: 2032 /* We reached the first advance/remember in the FDE, 2033 but did not reach the end of the CIE list. */ 2034 goto fail; 2035 2036 case DW_CFA_offset: 2037 case DW_CFA_def_cfa: 2038 if (i->u.ri.reg != j->u.ri.reg) 2039 goto fail; 2040 if (i->u.ri.offset != j->u.ri.offset) 2041 goto fail; 2042 break; 2043 2044 case DW_CFA_register: 2045 if (i->u.rr.reg1 != j->u.rr.reg1) 2046 goto fail; 2047 if (i->u.rr.reg2 != j->u.rr.reg2) 2048 goto fail; 2049 break; 2050 2051 case DW_CFA_def_cfa_register: 2052 case DW_CFA_restore: 2053 case DW_CFA_undefined: 2054 case DW_CFA_same_value: 2055 if (i->u.r != j->u.r) 2056 goto fail; 2057 break; 2058 2059 case DW_CFA_def_cfa_offset: 2060 if (i->u.i != j->u.i) 2061 goto fail; 2062 break; 2063 2064 case CFI_escape: 2065 case CFI_val_encoded_addr: 2066 case CFI_label: 2067 /* Don't bother matching these for now. */ 2068 goto fail; 2069 2070 default: 2071 abort (); 2072 } 2073 } 2074 2075 /* Success if we reached the end of the CIE list, and we've either 2076 run out of FDE entries or we've encountered an advance, 2077 remember, or escape. */ 2078 if (i == cie->last 2079 && (!j 2080 || j->insn == DW_CFA_advance_loc 2081 || j->insn == DW_CFA_remember_state 2082 || j->insn == CFI_escape 2083 || j->insn == CFI_val_encoded_addr 2084 || j->insn == CFI_label)) 2085 { 2086 *pfirst = j; 2087 return cie; 2088 } 2089 2090 fail:; 2091 } 2092 2093 cie = XNEW (struct cie_entry); 2094 cie->next = cie_root; 2095 cie_root = cie; 2096 SET_CUR_SEG (cie, CUR_SEG (fde)); 2097 cie->return_column = fde->return_column; 2098 cie->signal_frame = fde->signal_frame; 2099 cie->per_encoding = fde->per_encoding; 2100 cie->lsda_encoding = fde->lsda_encoding; 2101 cie->personality = fde->personality; 2102 cie->first = fde->data; 2103 2104 for (i = cie->first; i ; i = i->next) 2105 if (i->insn == DW_CFA_advance_loc 2106 || i->insn == DW_CFA_remember_state 2107 || i->insn == CFI_escape 2108 || i->insn == CFI_val_encoded_addr 2109 || i->insn == CFI_label) 2110 break; 2111 2112 cie->last = i; 2113 *pfirst = i; 2114 2115 output_cie (cie, eh_frame, align); 2116 2117 return cie; 2118 } 2119 2120 #ifdef md_reg_eh_frame_to_debug_frame 2121 static void 2122 cfi_change_reg_numbers (struct cfi_insn_data *insn, segT ccseg) 2123 { 2124 for (; insn; insn = insn->next) 2125 { 2126 if (CUR_SEG (insn) != ccseg) 2127 continue; 2128 switch (insn->insn) 2129 { 2130 case DW_CFA_advance_loc: 2131 case DW_CFA_def_cfa_offset: 2132 case DW_CFA_remember_state: 2133 case DW_CFA_restore_state: 2134 case DW_CFA_GNU_window_save: 2135 case CFI_escape: 2136 case CFI_label: 2137 break; 2138 2139 case DW_CFA_def_cfa: 2140 case DW_CFA_offset: 2141 insn->u.ri.reg = md_reg_eh_frame_to_debug_frame (insn->u.ri.reg); 2142 break; 2143 2144 case DW_CFA_def_cfa_register: 2145 case DW_CFA_undefined: 2146 case DW_CFA_same_value: 2147 case DW_CFA_restore: 2148 insn->u.r = md_reg_eh_frame_to_debug_frame (insn->u.r); 2149 break; 2150 2151 case DW_CFA_register: 2152 insn->u.rr.reg1 = md_reg_eh_frame_to_debug_frame (insn->u.rr.reg1); 2153 insn->u.rr.reg2 = md_reg_eh_frame_to_debug_frame (insn->u.rr.reg2); 2154 break; 2155 2156 case CFI_val_encoded_addr: 2157 insn->u.ea.reg = md_reg_eh_frame_to_debug_frame (insn->u.ea.reg); 2158 break; 2159 2160 default: 2161 abort (); 2162 } 2163 } 2164 } 2165 #else 2166 #define cfi_change_reg_numbers(insn, cseg) do { } while (0) 2167 #endif 2168 2169 #if SUPPORT_COMPACT_EH 2170 static void 2171 cfi_emit_eh_header (symbolS *sym, bfd_vma addend) 2172 { 2173 expressionS exp; 2174 2175 exp.X_add_number = addend; 2176 exp.X_add_symbol = sym; 2177 emit_expr_encoded (&exp, DW_EH_PE_sdata4 | DW_EH_PE_pcrel, FALSE); 2178 } 2179 2180 static void 2181 output_eh_header (struct fde_entry *fde) 2182 { 2183 char *p; 2184 bfd_vma addend; 2185 2186 if (fde->eh_header_type == EH_COMPACT_INLINE) 2187 addend = 0; 2188 else 2189 addend = 1; 2190 2191 cfi_emit_eh_header (fde->start_address, addend); 2192 2193 if (fde->eh_header_type == EH_COMPACT_INLINE) 2194 { 2195 p = frag_more (4); 2196 /* Inline entries always use PR1. */ 2197 *(p++) = 1; 2198 memcpy(p, fde->eh_data, 3); 2199 } 2200 else 2201 { 2202 if (fde->eh_header_type == EH_COMPACT_LEGACY) 2203 addend = 1; 2204 else if (fde->eh_header_type == EH_COMPACT_OUTLINE 2205 || fde->eh_header_type == EH_COMPACT_OUTLINE_DONE) 2206 addend = 0; 2207 else 2208 abort (); 2209 cfi_emit_eh_header (fde->eh_loc, addend); 2210 } 2211 } 2212 #endif 2213 2214 void 2215 cfi_finish (void) 2216 { 2217 struct cie_entry *cie, *cie_next; 2218 segT cfi_seg, ccseg; 2219 struct fde_entry *fde; 2220 struct cfi_insn_data *first; 2221 int save_flag_traditional_format, seek_next_seg; 2222 2223 if (all_fde_data == 0) 2224 return; 2225 2226 cfi_sections_set = TRUE; 2227 if ((all_cfi_sections & CFI_EMIT_eh_frame) != 0 2228 || (all_cfi_sections & CFI_EMIT_eh_frame_compact) != 0) 2229 { 2230 /* Make sure check_eh_frame doesn't do anything with our output. */ 2231 save_flag_traditional_format = flag_traditional_format; 2232 flag_traditional_format = 1; 2233 2234 if (!EH_FRAME_LINKONCE) 2235 { 2236 /* Open .eh_frame section. */ 2237 cfi_seg = get_cfi_seg (NULL, ".eh_frame", 2238 (SEC_ALLOC | SEC_LOAD | SEC_DATA 2239 | DWARF2_EH_FRAME_READ_ONLY), 2240 EH_FRAME_ALIGNMENT); 2241 #ifdef md_fix_up_eh_frame 2242 md_fix_up_eh_frame (cfi_seg); 2243 #else 2244 (void) cfi_seg; 2245 #endif 2246 } 2247 2248 do 2249 { 2250 ccseg = NULL; 2251 seek_next_seg = 0; 2252 2253 for (cie = cie_root; cie; cie = cie_next) 2254 { 2255 cie_next = cie->next; 2256 free ((void *) cie); 2257 } 2258 cie_root = NULL; 2259 2260 for (fde = all_fde_data; fde ; fde = fde->next) 2261 { 2262 if ((fde->sections & CFI_EMIT_eh_frame) == 0 2263 && (fde->sections & CFI_EMIT_eh_frame_compact) == 0) 2264 continue; 2265 2266 #if SUPPORT_COMPACT_EH 2267 /* Emit a LEGACY format header if we have processed all 2268 of the .cfi directives without encountering either inline or 2269 out-of-line compact unwinding opcodes. */ 2270 if (fde->eh_header_type == EH_COMPACT_HAS_LSDA 2271 || fde->eh_header_type == EH_COMPACT_UNKNOWN) 2272 fde->eh_header_type = EH_COMPACT_LEGACY; 2273 2274 if (fde->eh_header_type != EH_COMPACT_LEGACY) 2275 continue; 2276 #endif 2277 if (EH_FRAME_LINKONCE) 2278 { 2279 if (HANDLED (fde)) 2280 continue; 2281 if (seek_next_seg && CUR_SEG (fde) != ccseg) 2282 { 2283 seek_next_seg = 2; 2284 continue; 2285 } 2286 if (!seek_next_seg) 2287 { 2288 ccseg = CUR_SEG (fde); 2289 /* Open .eh_frame section. */ 2290 cfi_seg = get_cfi_seg (ccseg, ".eh_frame", 2291 (SEC_ALLOC | SEC_LOAD | SEC_DATA 2292 | DWARF2_EH_FRAME_READ_ONLY), 2293 EH_FRAME_ALIGNMENT); 2294 #ifdef md_fix_up_eh_frame 2295 md_fix_up_eh_frame (cfi_seg); 2296 #else 2297 (void) cfi_seg; 2298 #endif 2299 seek_next_seg = 1; 2300 } 2301 SET_HANDLED (fde, 1); 2302 } 2303 2304 if (fde->end_address == NULL) 2305 { 2306 as_bad (_("open CFI at the end of file; missing .cfi_endproc directive")); 2307 fde->end_address = fde->start_address; 2308 } 2309 2310 cie = select_cie_for_fde (fde, TRUE, &first, 2); 2311 fde->eh_loc = symbol_temp_new_now (); 2312 output_fde (fde, cie, TRUE, first, 2313 fde->next == NULL ? EH_FRAME_ALIGNMENT : 2); 2314 } 2315 } 2316 while (EH_FRAME_LINKONCE && seek_next_seg == 2); 2317 2318 if (EH_FRAME_LINKONCE) 2319 for (fde = all_fde_data; fde ; fde = fde->next) 2320 SET_HANDLED (fde, 0); 2321 2322 #if SUPPORT_COMPACT_EH 2323 if (compact_eh) 2324 { 2325 /* Create remaining out of line table entries. */ 2326 do 2327 { 2328 ccseg = NULL; 2329 seek_next_seg = 0; 2330 2331 for (fde = all_fde_data; fde ; fde = fde->next) 2332 { 2333 if ((fde->sections & CFI_EMIT_eh_frame) == 0 2334 && (fde->sections & CFI_EMIT_eh_frame_compact) == 0) 2335 continue; 2336 2337 if (fde->eh_header_type != EH_COMPACT_OUTLINE) 2338 continue; 2339 if (HANDLED (fde)) 2340 continue; 2341 if (seek_next_seg && CUR_SEG (fde) != ccseg) 2342 { 2343 seek_next_seg = 2; 2344 continue; 2345 } 2346 if (!seek_next_seg) 2347 { 2348 ccseg = CUR_SEG (fde); 2349 /* Open .gnu_extab section. */ 2350 get_cfi_seg (ccseg, ".gnu_extab", 2351 (SEC_ALLOC | SEC_LOAD | SEC_DATA 2352 | DWARF2_EH_FRAME_READ_ONLY), 2353 1); 2354 seek_next_seg = 1; 2355 } 2356 SET_HANDLED (fde, 1); 2357 2358 frag_align (1, 0, 0); 2359 record_alignment (now_seg, 1); 2360 output_compact_unwind_data (fde, 1); 2361 } 2362 } 2363 while (EH_FRAME_LINKONCE && seek_next_seg == 2); 2364 2365 for (fde = all_fde_data; fde ; fde = fde->next) 2366 SET_HANDLED (fde, 0); 2367 2368 /* Create index table fragments. */ 2369 do 2370 { 2371 ccseg = NULL; 2372 seek_next_seg = 0; 2373 2374 for (fde = all_fde_data; fde ; fde = fde->next) 2375 { 2376 if ((fde->sections & CFI_EMIT_eh_frame) == 0 2377 && (fde->sections & CFI_EMIT_eh_frame_compact) == 0) 2378 continue; 2379 2380 if (HANDLED (fde)) 2381 continue; 2382 if (seek_next_seg && CUR_SEG (fde) != ccseg) 2383 { 2384 seek_next_seg = 2; 2385 continue; 2386 } 2387 if (!seek_next_seg) 2388 { 2389 ccseg = CUR_SEG (fde); 2390 /* Open .eh_frame_entry section. */ 2391 cfi_seg = get_cfi_seg (ccseg, ".eh_frame_entry", 2392 (SEC_ALLOC | SEC_LOAD | SEC_DATA 2393 | DWARF2_EH_FRAME_READ_ONLY), 2394 2); 2395 seek_next_seg = 1; 2396 } 2397 SET_HANDLED (fde, 1); 2398 2399 output_eh_header (fde); 2400 } 2401 } 2402 while (seek_next_seg == 2); 2403 2404 for (fde = all_fde_data; fde ; fde = fde->next) 2405 SET_HANDLED (fde, 0); 2406 } 2407 #endif /* SUPPORT_COMPACT_EH */ 2408 2409 flag_traditional_format = save_flag_traditional_format; 2410 } 2411 2412 cfi_sections_set = TRUE; 2413 if ((all_cfi_sections & CFI_EMIT_debug_frame) != 0) 2414 { 2415 int alignment = ffs (DWARF2_ADDR_SIZE (stdoutput)) - 1; 2416 2417 if (!SUPPORT_FRAME_LINKONCE) 2418 get_cfi_seg (NULL, ".debug_frame", 2419 SEC_READONLY | SEC_DEBUGGING, 2420 alignment); 2421 2422 do 2423 { 2424 ccseg = NULL; 2425 seek_next_seg = 0; 2426 2427 for (cie = cie_root; cie; cie = cie_next) 2428 { 2429 cie_next = cie->next; 2430 free ((void *) cie); 2431 } 2432 cie_root = NULL; 2433 2434 for (fde = all_fde_data; fde ; fde = fde->next) 2435 { 2436 if ((fde->sections & CFI_EMIT_debug_frame) == 0) 2437 continue; 2438 2439 if (SUPPORT_FRAME_LINKONCE) 2440 { 2441 if (HANDLED (fde)) 2442 continue; 2443 if (seek_next_seg && CUR_SEG (fde) != ccseg) 2444 { 2445 seek_next_seg = 2; 2446 continue; 2447 } 2448 if (!seek_next_seg) 2449 { 2450 ccseg = CUR_SEG (fde); 2451 /* Open .debug_frame section. */ 2452 get_cfi_seg (ccseg, ".debug_frame", 2453 SEC_READONLY | SEC_DEBUGGING, 2454 alignment); 2455 seek_next_seg = 1; 2456 } 2457 SET_HANDLED (fde, 1); 2458 } 2459 if (fde->end_address == NULL) 2460 { 2461 as_bad (_("open CFI at the end of file; missing .cfi_endproc directive")); 2462 fde->end_address = fde->start_address; 2463 } 2464 2465 fde->per_encoding = DW_EH_PE_omit; 2466 fde->lsda_encoding = DW_EH_PE_omit; 2467 cfi_change_reg_numbers (fde->data, ccseg); 2468 cie = select_cie_for_fde (fde, FALSE, &first, alignment); 2469 output_fde (fde, cie, FALSE, first, alignment); 2470 } 2471 } 2472 while (SUPPORT_FRAME_LINKONCE && seek_next_seg == 2); 2473 2474 if (SUPPORT_FRAME_LINKONCE) 2475 for (fde = all_fde_data; fde ; fde = fde->next) 2476 SET_HANDLED (fde, 0); 2477 } 2478 } 2479 2480 #else /* TARGET_USE_CFIPOP */ 2481 2482 /* Emit an intelligible error message for missing support. */ 2483 2484 static void 2485 dot_cfi_dummy (int ignored ATTRIBUTE_UNUSED) 2486 { 2487 as_bad (_("CFI is not supported for this target")); 2488 ignore_rest_of_line (); 2489 } 2490 2491 const pseudo_typeS cfi_pseudo_table[] = 2492 { 2493 { "cfi_sections", dot_cfi_dummy, 0 }, 2494 { "cfi_startproc", dot_cfi_dummy, 0 }, 2495 { "cfi_endproc", dot_cfi_dummy, 0 }, 2496 { "cfi_fde_data", dot_cfi_dummy, 0 }, 2497 { "cfi_def_cfa", dot_cfi_dummy, 0 }, 2498 { "cfi_def_cfa_register", dot_cfi_dummy, 0 }, 2499 { "cfi_def_cfa_offset", dot_cfi_dummy, 0 }, 2500 { "cfi_adjust_cfa_offset", dot_cfi_dummy, 0 }, 2501 { "cfi_offset", dot_cfi_dummy, 0 }, 2502 { "cfi_rel_offset", dot_cfi_dummy, 0 }, 2503 { "cfi_register", dot_cfi_dummy, 0 }, 2504 { "cfi_return_column", dot_cfi_dummy, 0 }, 2505 { "cfi_restore", dot_cfi_dummy, 0 }, 2506 { "cfi_undefined", dot_cfi_dummy, 0 }, 2507 { "cfi_same_value", dot_cfi_dummy, 0 }, 2508 { "cfi_remember_state", dot_cfi_dummy, 0 }, 2509 { "cfi_restore_state", dot_cfi_dummy, 0 }, 2510 { "cfi_window_save", dot_cfi_dummy, 0 }, 2511 { "cfi_escape", dot_cfi_dummy, 0 }, 2512 { "cfi_signal_frame", dot_cfi_dummy, 0 }, 2513 { "cfi_personality", dot_cfi_dummy, 0 }, 2514 { "cfi_personality_id", dot_cfi_dummy, 0 }, 2515 { "cfi_lsda", dot_cfi_dummy, 0 }, 2516 { "cfi_val_encoded_addr", dot_cfi_dummy, 0 }, 2517 { "cfi_label", dot_cfi_dummy, 0 }, 2518 { "cfi_inline_lsda", dot_cfi_dummy, 0 }, 2519 { NULL, NULL, 0 } 2520 }; 2521 2522 void 2523 cfi_finish (void) 2524 { 2525 } 2526 #endif /* TARGET_USE_CFIPOP */ 2527