gas/dw2gencfi.c

   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 \f
 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 \f
 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 \f
 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 (&notes, name, len);
 584   insn->u.sym_name = (char *) obstack_finish (&notes);
 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 \f
 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 \f
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 */