gas/dw2gencfi.c

   1 /* dw2gencfi.c - Support for generating Dwarf2 CFI information.
   2    Copyright (C) 2003-2015 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 #ifndef DWARF2_FORMAT
  79 #define DWARF2_FORMAT(SEC) dwarf2_format_32bit
  80 #endif
  81
  82 #ifndef DWARF2_ADDR_SIZE
  83 #define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
  84 #endif
  85
  86 #if SUPPORT_FRAME_LINKONCE
  87 #define CUR_SEG(structp) structp->cur_seg
  88 #define SET_CUR_SEG(structp, seg) structp->cur_seg = seg
  89 #define HANDLED(structp) structp->handled
  90 #define SET_HANDLED(structp, val) structp->handled = val
  91 #else
  92 #define CUR_SEG(structp) NULL
  93 #define SET_CUR_SEG(structp, seg) (void) (0 && seg)
  94 #define HANDLED(structp) 0
  95 #define SET_HANDLED(structp, val) (void) (0 && val)
  96 #endif
  97
  98 /* Private segment collection list.  */
  99 struct dwcfi_seg_list
 100 {
 101   segT   seg;
 102   int    subseg;
 103   char * seg_name;
 104 };
 105
 106 #define FRAME_NAME ".eh_frame"
 107
 108 static struct hash_control *dwcfi_hash;
 109
 110 /* Build based on segment the derived .debug_...
 111    segment name containing origin segment's postfix name part.  */
 112
 113 static char *
 114 get_debugseg_name (segT seg, const char *base_name)
 115 {
 116   const char *name;
 117
 118   if (!seg)
 119     name = "";
 120   else
 121     {
 122       const char * dollar;
 123       const char * dot;
 124
 125       name = bfd_get_section_name (stdoutput, seg);
 126
 127       dollar = strchr (name, '$');
 128       dot = strchr (name + 1, '.');
 129
 130       if (!dollar && !dot)
 131         name = "";
 132       else if (!dollar)
 133         name = dot;
 134       else if (!dot)
 135         name = dollar;
 136       else if (dot < dollar)
 137         name = dot;
 138       else
 139         name = dollar;
 140     }
 141
 142   return concat (base_name, name, NULL);
 143 }
 144
 145 /* Allocate a dwcfi_seg_list structure.  */
 146
 147 static struct dwcfi_seg_list *
 148 alloc_debugseg_item (segT seg, int subseg, char *name)
 149 {
 150   struct dwcfi_seg_list *r;
 151
 152   r = (struct dwcfi_seg_list *)
 153     xmalloc (sizeof (struct dwcfi_seg_list) + strlen (name));
 154   r->seg = seg;
 155   r->subseg = subseg;
 156   r->seg_name = name;
 157   return r;
 158 }
 159
 160 static segT
 161 is_now_linkonce_segment (void)
 162 {
 163   if ((bfd_get_section_flags (stdoutput, now_seg)
 164        & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD
 165           | SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE
 166           | SEC_LINK_DUPLICATES_SAME_CONTENTS)) != 0)
 167     return now_seg;
 168   return NULL;
 169 }
 170
 171 /* Generate debug... segment with same linkonce properties
 172    of based segment.  */
 173
 174 static segT
 175 make_debug_seg (segT cseg, char *name, int sflags)
 176 {
 177   segT save_seg = now_seg;
 178   int save_subseg = now_subseg;
 179   segT r;
 180   flagword flags;
 181
 182   r = subseg_new (name, 0);
 183
 184   /* Check if code segment is marked as linked once.  */
 185   if (!cseg)
 186     flags = 0;
 187   else
 188     flags = bfd_get_section_flags (stdoutput, cseg)
 189       & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD
 190          | SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE
 191          | SEC_LINK_DUPLICATES_SAME_CONTENTS);
 192
 193   /* Add standard section flags.  */
 194   flags |= sflags;
 195
 196   /* Apply possibly linked once flags to new generated segment, too.  */
 197   if (!bfd_set_section_flags (stdoutput, r, flags))
 198     as_bad (_("bfd_set_section_flags: %s"),
 199             bfd_errmsg (bfd_get_error ()));
 200
 201   /* Restore to previous segment.  */
 202   if (save_seg != NULL)
 203     subseg_set (save_seg, save_subseg);
 204   return r;
 205 }
 206
 207 static void
 208 dwcfi_hash_insert (const char *name, struct dwcfi_seg_list *item)
 209 {
 210   const char *error_string;
 211
 212   if ((error_string = hash_jam (dwcfi_hash, name, (char *) item)))
 213     as_fatal (_("Inserting \"%s\" into structure table failed: %s"),
 214               name, error_string);
 215 }
 216
 217 static struct dwcfi_seg_list *
 218 dwcfi_hash_find (char *name)
 219 {
 220   return (struct dwcfi_seg_list *) hash_find (dwcfi_hash, name);
 221 }
 222
 223 static struct dwcfi_seg_list *
 224 dwcfi_hash_find_or_make (segT cseg, const char *base_name, int flags)
 225 {
 226   struct dwcfi_seg_list *item;
 227   char *name;
 228
 229   /* Initialize dwcfi_hash once.  */
 230   if (!dwcfi_hash)
 231     dwcfi_hash = hash_new ();
 232
 233   name = get_debugseg_name (cseg, base_name);
 234
 235   item = dwcfi_hash_find (name);
 236   if (!item)
 237     {
 238       item = alloc_debugseg_item (make_debug_seg (cseg, name, flags), 0, name);
 239
 240       dwcfi_hash_insert (item->seg_name, item);
 241     }
 242   else
 243     free (name);
 244
 245   return item;
 246 }
 247
 248 /* ??? Share this with dwarf2cfg.c.  */
 249 #ifndef TC_DWARF2_EMIT_OFFSET
 250 #define TC_DWARF2_EMIT_OFFSET  generic_dwarf2_emit_offset
 251
 252 /* Create an offset to .dwarf2_*.  */
 253
 254 static void
 255 generic_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
 256 {
 257   expressionS exp;
 258
 259   exp.X_op = O_symbol;
 260   exp.X_add_symbol = symbol;
 261   exp.X_add_number = 0;
 262   emit_expr (&exp, size);
 263 }
 264 #endif
 265
 266 struct cfi_escape_data
 267 {
 268   struct cfi_escape_data *next;
 269   expressionS exp;
 270 };
 271
 272 struct cie_entry
 273 {
 274   struct cie_entry *next;
 275 #if SUPPORT_FRAME_LINKONCE
 276   segT cur_seg;
 277 #endif
 278   symbolS *start_address;
 279   unsigned int return_column;
 280   unsigned int signal_frame;
 281   unsigned char per_encoding;
 282   unsigned char lsda_encoding;
 283   expressionS personality;
 284   struct cfi_insn_data *first, *last;
 285 };
 286
 287 /* List of FDE entries.  */
 288
 289 struct fde_entry *all_fde_data;
 290 static struct fde_entry **last_fde_data = &all_fde_data;
 291
 292 /* List of CIEs so that they could be reused.  */
 293 static struct cie_entry *cie_root;
 294
 295 /* Stack of old CFI data, for save/restore.  */
 296 struct cfa_save_data
 297 {
 298   struct cfa_save_data *next;
 299   offsetT cfa_offset;
 300 };
 301
 302 /* Current open FDE entry.  */
 303 struct frch_cfi_data
 304 {
 305   struct fde_entry *cur_fde_data;
 306   symbolS *last_address;
 307   offsetT cur_cfa_offset;
 308   struct cfa_save_data *cfa_save_stack;
 309 };
 310 \f
 311 /* Construct a new FDE structure and add it to the end of the fde list.  */
 312
 313 static struct fde_entry *
 314 alloc_fde_entry (void)
 315 {
 316   struct fde_entry *fde = (struct fde_entry *)
 317       xcalloc (1, sizeof (struct fde_entry));
 318
 319   frchain_now->frch_cfi_data = (struct frch_cfi_data *)
 320       xcalloc (1, sizeof (struct frch_cfi_data));
 321   frchain_now->frch_cfi_data->cur_fde_data = fde;
 322   *last_fde_data = fde;
 323   last_fde_data = &fde->next;
 324   SET_CUR_SEG (fde, is_now_linkonce_segment ());
 325   SET_HANDLED (fde, 0);
 326   fde->last = &fde->data;
 327   fde->return_column = DWARF2_DEFAULT_RETURN_COLUMN;
 328   fde->per_encoding = DW_EH_PE_omit;
 329   fde->lsda_encoding = DW_EH_PE_omit;
 330
 331   return fde;
 332 }
 333
 334 /* The following functions are available for a backend to construct its
 335    own unwind information, usually from legacy unwind directives.  */
 336
 337 /* Construct a new INSN structure and add it to the end of the insn list
 338    for the currently active FDE.  */
 339
 340 static struct cfi_insn_data *
 341 alloc_cfi_insn_data (void)
 342 {
 343   struct cfi_insn_data *insn = (struct cfi_insn_data *)
 344       xcalloc (1, sizeof (struct cfi_insn_data));
 345   struct fde_entry *cur_fde_data = frchain_now->frch_cfi_data->cur_fde_data;
 346
 347   *cur_fde_data->last = insn;
 348   cur_fde_data->last = &insn->next;
 349   SET_CUR_SEG (insn, is_now_linkonce_segment ());
 350   return insn;
 351 }
 352
 353 /* Construct a new FDE structure that begins at LABEL.  */
 354
 355 void
 356 cfi_new_fde (symbolS *label)
 357 {
 358   struct fde_entry *fde = alloc_fde_entry ();
 359   fde->start_address = label;
 360   frchain_now->frch_cfi_data->last_address = label;
 361 }
 362
 363 /* End the currently open FDE.  */
 364
 365 void
 366 cfi_end_fde (symbolS *label)
 367 {
 368   frchain_now->frch_cfi_data->cur_fde_data->end_address = label;
 369   free (frchain_now->frch_cfi_data);
 370   frchain_now->frch_cfi_data = NULL;
 371 }
 372
 373 /* Set the return column for the current FDE.  */
 374
 375 void
 376 cfi_set_return_column (unsigned regno)
 377 {
 378   frchain_now->frch_cfi_data->cur_fde_data->return_column = regno;
 379 }
 380
 381 /* Universal functions to store new instructions.  */
 382
 383 static void
 384 cfi_add_CFA_insn (int insn)
 385 {
 386   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
 387
 388   insn_ptr->insn = insn;
 389 }
 390
 391 static void
 392 cfi_add_CFA_insn_reg (int insn, unsigned regno)
 393 {
 394   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
 395
 396   insn_ptr->insn = insn;
 397   insn_ptr->u.r = regno;
 398 }
 399
 400 static void
 401 cfi_add_CFA_insn_offset (int insn, offsetT offset)
 402 {
 403   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
 404
 405   insn_ptr->insn = insn;
 406   insn_ptr->u.i = offset;
 407 }
 408
 409 static void
 410 cfi_add_CFA_insn_reg_reg (int insn, unsigned reg1, unsigned reg2)
 411 {
 412   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
 413
 414   insn_ptr->insn = insn;
 415   insn_ptr->u.rr.reg1 = reg1;
 416   insn_ptr->u.rr.reg2 = reg2;
 417 }
 418
 419 static void
 420 cfi_add_CFA_insn_reg_offset (int insn, unsigned regno, offsetT offset)
 421 {
 422   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
 423
 424   insn_ptr->insn = insn;
 425   insn_ptr->u.ri.reg = regno;
 426   insn_ptr->u.ri.offset = offset;
 427 }
 428
 429 /* Add a CFI insn to advance the PC from the last address to LABEL.  */
 430
 431 void
 432 cfi_add_advance_loc (symbolS *label)
 433 {
 434   struct cfi_insn_data *insn = alloc_cfi_insn_data ();
 435
 436   insn->insn = DW_CFA_advance_loc;
 437   insn->u.ll.lab1 = frchain_now->frch_cfi_data->last_address;
 438   insn->u.ll.lab2 = label;
 439
 440   frchain_now->frch_cfi_data->last_address = label;
 441 }
 442
 443 /* Add a DW_CFA_offset record to the CFI data.  */
 444
 445 void
 446 cfi_add_CFA_offset (unsigned regno, offsetT offset)
 447 {
 448   unsigned int abs_data_align;
 449
 450   gas_assert (DWARF2_CIE_DATA_ALIGNMENT != 0);
 451   cfi_add_CFA_insn_reg_offset (DW_CFA_offset, regno, offset);
 452
 453   abs_data_align = (DWARF2_CIE_DATA_ALIGNMENT < 0
 454                     ? -DWARF2_CIE_DATA_ALIGNMENT : DWARF2_CIE_DATA_ALIGNMENT);
 455   if (offset % abs_data_align)
 456     as_bad (_("register save offset not a multiple of %u"), abs_data_align);
 457 }
 458
 459 /* Add a DW_CFA_def_cfa record to the CFI data.  */
 460
 461 void
 462 cfi_add_CFA_def_cfa (unsigned regno, offsetT offset)
 463 {
 464   cfi_add_CFA_insn_reg_offset (DW_CFA_def_cfa, regno, offset);
 465   frchain_now->frch_cfi_data->cur_cfa_offset = offset;
 466 }
 467
 468 /* Add a DW_CFA_register record to the CFI data.  */
 469
 470 void
 471 cfi_add_CFA_register (unsigned reg1, unsigned reg2)
 472 {
 473   cfi_add_CFA_insn_reg_reg (DW_CFA_register, reg1, reg2);
 474 }
 475
 476 /* Add a DW_CFA_def_cfa_register record to the CFI data.  */
 477
 478 void
 479 cfi_add_CFA_def_cfa_register (unsigned regno)
 480 {
 481   cfi_add_CFA_insn_reg (DW_CFA_def_cfa_register, regno);
 482 }
 483
 484 /* Add a DW_CFA_def_cfa_offset record to the CFI data.  */
 485
 486 void
 487 cfi_add_CFA_def_cfa_offset (offsetT offset)
 488 {
 489   cfi_add_CFA_insn_offset (DW_CFA_def_cfa_offset, offset);
 490   frchain_now->frch_cfi_data->cur_cfa_offset = offset;
 491 }
 492
 493 void
 494 cfi_add_CFA_restore (unsigned regno)
 495 {
 496   cfi_add_CFA_insn_reg (DW_CFA_restore, regno);
 497 }
 498
 499 void
 500 cfi_add_CFA_undefined (unsigned regno)
 501 {
 502   cfi_add_CFA_insn_reg (DW_CFA_undefined, regno);
 503 }
 504
 505 void
 506 cfi_add_CFA_same_value (unsigned regno)
 507 {
 508   cfi_add_CFA_insn_reg (DW_CFA_same_value, regno);
 509 }
 510
 511 void
 512 cfi_add_CFA_remember_state (void)
 513 {
 514   struct cfa_save_data *p;
 515
 516   cfi_add_CFA_insn (DW_CFA_remember_state);
 517
 518   p = (struct cfa_save_data *) xmalloc (sizeof (*p));
 519   p->cfa_offset = frchain_now->frch_cfi_data->cur_cfa_offset;
 520   p->next = frchain_now->frch_cfi_data->cfa_save_stack;
 521   frchain_now->frch_cfi_data->cfa_save_stack = p;
 522 }
 523
 524 void
 525 cfi_add_CFA_restore_state (void)
 526 {
 527   struct cfa_save_data *p;
 528
 529   cfi_add_CFA_insn (DW_CFA_restore_state);
 530
 531   p = frchain_now->frch_cfi_data->cfa_save_stack;
 532   if (p)
 533     {
 534       frchain_now->frch_cfi_data->cur_cfa_offset = p->cfa_offset;
 535       frchain_now->frch_cfi_data->cfa_save_stack = p->next;
 536       free (p);
 537     }
 538   else
 539     as_bad (_("CFI state restore without previous remember"));
 540 }
 541
 542 \f
 543 /* Parse CFI assembler directives.  */
 544
 545 static void dot_cfi (int);
 546 static void dot_cfi_escape (int);
 547 static void dot_cfi_sections (int);
 548 static void dot_cfi_startproc (int);
 549 static void dot_cfi_endproc (int);
 550 static void dot_cfi_personality (int);
 551 static void dot_cfi_lsda (int);
 552 static void dot_cfi_val_encoded_addr (int);
 553
 554 const pseudo_typeS cfi_pseudo_table[] =
 555   {
 556     { "cfi_sections", dot_cfi_sections, 0 },
 557     { "cfi_startproc", dot_cfi_startproc, 0 },
 558     { "cfi_endproc", dot_cfi_endproc, 0 },
 559     { "cfi_def_cfa", dot_cfi, DW_CFA_def_cfa },
 560     { "cfi_def_cfa_register", dot_cfi, DW_CFA_def_cfa_register },
 561     { "cfi_def_cfa_offset", dot_cfi, DW_CFA_def_cfa_offset },
 562     { "cfi_adjust_cfa_offset", dot_cfi, CFI_adjust_cfa_offset },
 563     { "cfi_offset", dot_cfi, DW_CFA_offset },
 564     { "cfi_rel_offset", dot_cfi, CFI_rel_offset },
 565     { "cfi_register", dot_cfi, DW_CFA_register },
 566     { "cfi_return_column", dot_cfi, CFI_return_column },
 567     { "cfi_restore", dot_cfi, DW_CFA_restore },
 568     { "cfi_undefined", dot_cfi, DW_CFA_undefined },
 569     { "cfi_same_value", dot_cfi, DW_CFA_same_value },
 570     { "cfi_remember_state", dot_cfi, DW_CFA_remember_state },
 571     { "cfi_restore_state", dot_cfi, DW_CFA_restore_state },
 572     { "cfi_window_save", dot_cfi, DW_CFA_GNU_window_save },
 573     { "cfi_escape", dot_cfi_escape, 0 },
 574     { "cfi_signal_frame", dot_cfi, CFI_signal_frame },
 575     { "cfi_personality", dot_cfi_personality, 0 },
 576     { "cfi_lsda", dot_cfi_lsda, 0 },
 577     { "cfi_val_encoded_addr", dot_cfi_val_encoded_addr, 0 },
 578     { NULL, NULL, 0 }
 579   };
 580
 581 static void
 582 cfi_parse_separator (void)
 583 {
 584   SKIP_WHITESPACE ();
 585   if (*input_line_pointer == ',')
 586     input_line_pointer++;
 587   else
 588     as_bad (_("missing separator"));
 589 }
 590
 591 #ifndef tc_parse_to_dw2regnum
 592 static void
 593 tc_parse_to_dw2regnum (expressionS *exp)
 594 {
 595 # ifdef tc_regname_to_dw2regnum
 596   SKIP_WHITESPACE ();
 597   if (is_name_beginner (*input_line_pointer)
 598       || (*input_line_pointer == '%'
 599           && is_name_beginner (*++input_line_pointer)))
 600     {
 601       char *name, c;
 602
 603       name = input_line_pointer;
 604       c = get_symbol_end ();
 605
 606       exp->X_op = O_constant;
 607       exp->X_add_number = tc_regname_to_dw2regnum (name);
 608
 609       *input_line_pointer = c;
 610     }
 611   else
 612 # endif
 613     expression_and_evaluate (exp);
 614 }
 615 #endif
 616
 617 static unsigned
 618 cfi_parse_reg (void)
 619 {
 620   int regno;
 621   expressionS exp;
 622
 623   tc_parse_to_dw2regnum (&exp);
 624   switch (exp.X_op)
 625     {
 626     case O_register:
 627     case O_constant:
 628       regno = exp.X_add_number;
 629       break;
 630
 631     default:
 632       regno = -1;
 633       break;
 634     }
 635
 636   if (regno < 0)
 637     {
 638       as_bad (_("bad register expression"));
 639       regno = 0;
 640     }
 641
 642   return regno;
 643 }
 644
 645 static offsetT
 646 cfi_parse_const (void)
 647 {
 648   return get_absolute_expression ();
 649 }
 650
 651 static void
 652 dot_cfi (int arg)
 653 {
 654   offsetT offset;
 655   unsigned reg1, reg2;
 656
 657   if (frchain_now->frch_cfi_data == NULL)
 658     {
 659       as_bad (_("CFI instruction used without previous .cfi_startproc"));
 660       ignore_rest_of_line ();
 661       return;
 662     }
 663
 664   /* If the last address was not at the current PC, advance to current.  */
 665   if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now
 666       || S_GET_VALUE (frchain_now->frch_cfi_data->last_address)
 667          != frag_now_fix ())
 668     cfi_add_advance_loc (symbol_temp_new_now ());
 669
 670   switch (arg)
 671     {
 672     case DW_CFA_offset:
 673       reg1 = cfi_parse_reg ();
 674       cfi_parse_separator ();
 675       offset = cfi_parse_const ();
 676       cfi_add_CFA_offset (reg1, offset);
 677       break;
 678
 679     case CFI_rel_offset:
 680       reg1 = cfi_parse_reg ();
 681       cfi_parse_separator ();
 682       offset = cfi_parse_const ();
 683       cfi_add_CFA_offset (reg1,
 684                           offset - frchain_now->frch_cfi_data->cur_cfa_offset);
 685       break;
 686
 687     case DW_CFA_def_cfa:
 688       reg1 = cfi_parse_reg ();
 689       cfi_parse_separator ();
 690       offset = cfi_parse_const ();
 691       cfi_add_CFA_def_cfa (reg1, offset);
 692       break;
 693
 694     case DW_CFA_register:
 695       reg1 = cfi_parse_reg ();
 696       cfi_parse_separator ();
 697       reg2 = cfi_parse_reg ();
 698       cfi_add_CFA_register (reg1, reg2);
 699       break;
 700
 701     case DW_CFA_def_cfa_register:
 702       reg1 = cfi_parse_reg ();
 703       cfi_add_CFA_def_cfa_register (reg1);
 704       break;
 705
 706     case DW_CFA_def_cfa_offset:
 707       offset = cfi_parse_const ();
 708       cfi_add_CFA_def_cfa_offset (offset);
 709       break;
 710
 711     case CFI_adjust_cfa_offset:
 712       offset = cfi_parse_const ();
 713       cfi_add_CFA_def_cfa_offset (frchain_now->frch_cfi_data->cur_cfa_offset
 714                                   + offset);
 715       break;
 716
 717     case DW_CFA_restore:
 718       for (;;)
 719         {
 720           reg1 = cfi_parse_reg ();
 721           cfi_add_CFA_restore (reg1);
 722           SKIP_WHITESPACE ();
 723           if (*input_line_pointer != ',')
 724             break;
 725           ++input_line_pointer;
 726         }
 727       break;
 728
 729     case DW_CFA_undefined:
 730       for (;;)
 731         {
 732           reg1 = cfi_parse_reg ();
 733           cfi_add_CFA_undefined (reg1);
 734           SKIP_WHITESPACE ();
 735           if (*input_line_pointer != ',')
 736             break;
 737           ++input_line_pointer;
 738         }
 739       break;
 740
 741     case DW_CFA_same_value:
 742       reg1 = cfi_parse_reg ();
 743       cfi_add_CFA_same_value (reg1);
 744       break;
 745
 746     case CFI_return_column:
 747       reg1 = cfi_parse_reg ();
 748       cfi_set_return_column (reg1);
 749       break;
 750
 751     case DW_CFA_remember_state:
 752       cfi_add_CFA_remember_state ();
 753       break;
 754
 755     case DW_CFA_restore_state:
 756       cfi_add_CFA_restore_state ();
 757       break;
 758
 759     case DW_CFA_GNU_window_save:
 760       cfi_add_CFA_insn (DW_CFA_GNU_window_save);
 761       break;
 762
 763     case CFI_signal_frame:
 764       frchain_now->frch_cfi_data->cur_fde_data->signal_frame = 1;
 765       break;
 766
 767     default:
 768       abort ();
 769     }
 770
 771   demand_empty_rest_of_line ();
 772 }
 773
 774 static void
 775 dot_cfi_escape (int ignored ATTRIBUTE_UNUSED)
 776 {
 777   struct cfi_escape_data *head, **tail, *e;
 778   struct cfi_insn_data *insn;
 779
 780   if (frchain_now->frch_cfi_data == NULL)
 781     {
 782       as_bad (_("CFI instruction used without previous .cfi_startproc"));
 783       ignore_rest_of_line ();
 784       return;
 785     }
 786
 787   /* If the last address was not at the current PC, advance to current.  */
 788   if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now
 789       || S_GET_VALUE (frchain_now->frch_cfi_data->last_address)
 790          != frag_now_fix ())
 791     cfi_add_advance_loc (symbol_temp_new_now ());
 792
 793   tail = &head;
 794   do
 795     {
 796       e = (struct cfi_escape_data *) xmalloc (sizeof (*e));
 797       do_parse_cons_expression (&e->exp, 1);
 798       *tail = e;
 799       tail = &e->next;
 800     }
 801   while (*input_line_pointer++ == ',');
 802   *tail = NULL;
 803
 804   insn = alloc_cfi_insn_data ();
 805   insn->insn = CFI_escape;
 806   insn->u.esc = head;
 807
 808   --input_line_pointer;
 809   demand_empty_rest_of_line ();
 810 }
 811
 812 static void
 813 dot_cfi_personality (int ignored ATTRIBUTE_UNUSED)
 814 {
 815   struct fde_entry *fde;
 816   offsetT encoding;
 817
 818   if (frchain_now->frch_cfi_data == NULL)
 819     {
 820       as_bad (_("CFI instruction used without previous .cfi_startproc"));
 821       ignore_rest_of_line ();
 822       return;
 823     }
 824
 825   fde = frchain_now->frch_cfi_data->cur_fde_data;
 826   encoding = cfi_parse_const ();
 827   if (encoding == DW_EH_PE_omit)
 828     {
 829       demand_empty_rest_of_line ();
 830       fde->per_encoding = encoding;
 831       return;
 832     }
 833
 834   if ((encoding & 0xff) != encoding
 835       || ((encoding & 0x70) != 0
 836 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
 837           && (encoding & 0x70) != DW_EH_PE_pcrel
 838 #endif
 839           )
 840          /* leb128 can be handled, but does something actually need it?  */
 841       || (encoding & 7) == DW_EH_PE_uleb128
 842       || (encoding & 7) > DW_EH_PE_udata8)
 843     {
 844       as_bad (_("invalid or unsupported encoding in .cfi_personality"));
 845       ignore_rest_of_line ();
 846       return;
 847     }
 848
 849   if (*input_line_pointer++ != ',')
 850     {
 851       as_bad (_(".cfi_personality requires encoding and symbol arguments"));
 852       ignore_rest_of_line ();
 853       return;
 854     }
 855
 856   expression_and_evaluate (&fde->personality);
 857   switch (fde->personality.X_op)
 858     {
 859     case O_symbol:
 860       break;
 861     case O_constant:
 862       if ((encoding & 0x70) == DW_EH_PE_pcrel)
 863         encoding = DW_EH_PE_omit;
 864       break;
 865     default:
 866       encoding = DW_EH_PE_omit;
 867       break;
 868     }
 869
 870   fde->per_encoding = encoding;
 871
 872   if (encoding == DW_EH_PE_omit)
 873     {
 874       as_bad (_("wrong second argument to .cfi_personality"));
 875       ignore_rest_of_line ();
 876       return;
 877     }
 878
 879   demand_empty_rest_of_line ();
 880 }
 881
 882 static void
 883 dot_cfi_lsda (int ignored ATTRIBUTE_UNUSED)
 884 {
 885   struct fde_entry *fde;
 886   offsetT encoding;
 887
 888   if (frchain_now->frch_cfi_data == NULL)
 889     {
 890       as_bad (_("CFI instruction used without previous .cfi_startproc"));
 891       ignore_rest_of_line ();
 892       return;
 893     }
 894
 895   fde = frchain_now->frch_cfi_data->cur_fde_data;
 896   encoding = cfi_parse_const ();
 897   if (encoding == DW_EH_PE_omit)
 898     {
 899       demand_empty_rest_of_line ();
 900       fde->lsda_encoding = encoding;
 901       return;
 902     }
 903
 904   if ((encoding & 0xff) != encoding
 905       || ((encoding & 0x70) != 0
 906 #if CFI_DIFF_LSDA_OK || defined tc_cfi_emit_pcrel_expr
 907           && (encoding & 0x70) != DW_EH_PE_pcrel
 908 #endif
 909           )
 910          /* leb128 can be handled, but does something actually need it?  */
 911       || (encoding & 7) == DW_EH_PE_uleb128
 912       || (encoding & 7) > DW_EH_PE_udata8)
 913     {
 914       as_bad (_("invalid or unsupported encoding in .cfi_lsda"));
 915       ignore_rest_of_line ();
 916       return;
 917     }
 918
 919   if (*input_line_pointer++ != ',')
 920     {
 921       as_bad (_(".cfi_lsda requires encoding and symbol arguments"));
 922       ignore_rest_of_line ();
 923       return;
 924     }
 925
 926   fde->lsda_encoding = encoding;
 927
 928   expression_and_evaluate (&fde->lsda);
 929   switch (fde->lsda.X_op)
 930     {
 931     case O_symbol:
 932       break;
 933     case O_constant:
 934       if ((encoding & 0x70) == DW_EH_PE_pcrel)
 935         encoding = DW_EH_PE_omit;
 936       break;
 937     default:
 938       encoding = DW_EH_PE_omit;
 939       break;
 940     }
 941
 942   fde->lsda_encoding = encoding;
 943
 944   if (encoding == DW_EH_PE_omit)
 945     {
 946       as_bad (_("wrong second argument to .cfi_lsda"));
 947       ignore_rest_of_line ();
 948       return;
 949     }
 950
 951   demand_empty_rest_of_line ();
 952 }
 953
 954 static void
 955 dot_cfi_val_encoded_addr (int ignored ATTRIBUTE_UNUSED)
 956 {
 957   struct cfi_insn_data *insn_ptr;
 958   offsetT encoding;
 959
 960   if (frchain_now->frch_cfi_data == NULL)
 961     {
 962       as_bad (_("CFI instruction used without previous .cfi_startproc"));
 963       ignore_rest_of_line ();
 964       return;
 965     }
 966
 967   /* If the last address was not at the current PC, advance to current.  */
 968   if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now
 969       || S_GET_VALUE (frchain_now->frch_cfi_data->last_address)
 970          != frag_now_fix ())
 971     cfi_add_advance_loc (symbol_temp_new_now ());
 972
 973   insn_ptr = alloc_cfi_insn_data ();
 974   insn_ptr->insn = CFI_val_encoded_addr;
 975
 976   insn_ptr->u.ea.reg = cfi_parse_reg ();
 977
 978   cfi_parse_separator ();
 979   encoding = cfi_parse_const ();
 980   if ((encoding & 0xff) != encoding
 981       || ((encoding & 0x70) != 0
 982 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
 983           && (encoding & 0x70) != DW_EH_PE_pcrel
 984 #endif
 985           )
 986          /* leb128 can be handled, but does something actually need it?  */
 987       || (encoding & 7) == DW_EH_PE_uleb128
 988       || (encoding & 7) > DW_EH_PE_udata8)
 989     {
 990       as_bad (_("invalid or unsupported encoding in .cfi_lsda"));
 991       encoding = DW_EH_PE_omit;
 992     }
 993
 994   cfi_parse_separator ();
 995   expression_and_evaluate (&insn_ptr->u.ea.exp);
 996   switch (insn_ptr->u.ea.exp.X_op)
 997     {
 998     case O_symbol:
 999       break;
1000     case O_constant:
1001       if ((encoding & 0x70) != DW_EH_PE_pcrel)
1002         break;
1003     default:
1004       encoding = DW_EH_PE_omit;
1005       break;
1006     }
1007
1008   insn_ptr->u.ea.encoding = encoding;
1009   if (encoding == DW_EH_PE_omit)
1010     {
1011       as_bad (_("wrong third argument to .cfi_val_encoded_addr"));
1012       ignore_rest_of_line ();
1013       return;
1014     }
1015
1016   demand_empty_rest_of_line ();
1017 }
1018
1019 /* By default emit .eh_frame only, not .debug_frame.  */
1020 #define CFI_EMIT_eh_frame       (1 << 0)
1021 #define CFI_EMIT_debug_frame    (1 << 1)
1022 #define CFI_EMIT_target         (1 << 2)
1023 static int cfi_sections = CFI_EMIT_eh_frame;
1024
1025 static void
1026 dot_cfi_sections (int ignored ATTRIBUTE_UNUSED)
1027 {
1028   int sections = 0;
1029
1030   SKIP_WHITESPACE ();
1031   if (is_name_beginner (*input_line_pointer))
1032     while (1)
1033       {
1034         char *name, c;
1035
1036         name = input_line_pointer;
1037         c = get_symbol_end ();
1038
1039         if (strncmp (name, ".eh_frame", sizeof ".eh_frame") == 0
1040             && name[9] != '_')
1041           sections |= CFI_EMIT_eh_frame;
1042         else if (strncmp (name, ".debug_frame", sizeof ".debug_frame") == 0)
1043           sections |= CFI_EMIT_debug_frame;
1044 #ifdef tc_cfi_section_name
1045         else if (strcmp (name, tc_cfi_section_name) == 0)
1046           sections |= CFI_EMIT_target;
1047 #endif
1048         else
1049           {
1050             *input_line_pointer = c;
1051             input_line_pointer = name;
1052             break;
1053           }
1054
1055         *input_line_pointer = c;
1056         SKIP_WHITESPACE ();
1057         if (*input_line_pointer == ',')
1058           {
1059             name = input_line_pointer++;
1060             SKIP_WHITESPACE ();
1061             if (!is_name_beginner (*input_line_pointer))
1062               {
1063                 input_line_pointer = name;
1064                 break;
1065               }
1066           }
1067         else if (is_name_beginner (*input_line_pointer))
1068           break;
1069       }
1070
1071   demand_empty_rest_of_line ();
1072   cfi_sections = sections;
1073 }
1074
1075 static void
1076 dot_cfi_startproc (int ignored ATTRIBUTE_UNUSED)
1077 {
1078   int simple = 0;
1079
1080   if (frchain_now->frch_cfi_data != NULL)
1081     {
1082       as_bad (_("previous CFI entry not closed (missing .cfi_endproc)"));
1083       ignore_rest_of_line ();
1084       return;
1085     }
1086
1087   cfi_new_fde (symbol_temp_new_now ());
1088
1089   SKIP_WHITESPACE ();
1090   if (is_name_beginner (*input_line_pointer))
1091     {
1092       char *name, c;
1093
1094       name = input_line_pointer;
1095       c = get_symbol_end ();
1096
1097       if (strcmp (name, "simple") == 0)
1098         {
1099           simple = 1;
1100           *input_line_pointer = c;
1101         }
1102       else
1103         input_line_pointer = name;
1104     }
1105   demand_empty_rest_of_line ();
1106
1107   frchain_now->frch_cfi_data->cur_cfa_offset = 0;
1108   if (!simple)
1109     tc_cfi_frame_initial_instructions ();
1110
1111   if ((cfi_sections & CFI_EMIT_target) != 0)
1112     tc_cfi_startproc ();
1113 }
1114
1115 static void
1116 dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED)
1117 {
1118   struct fde_entry *fde;
1119
1120   if (frchain_now->frch_cfi_data == NULL)
1121     {
1122       as_bad (_(".cfi_endproc without corresponding .cfi_startproc"));
1123       ignore_rest_of_line ();
1124       return;
1125     }
1126
1127   fde = frchain_now->frch_cfi_data->cur_fde_data;
1128
1129   cfi_end_fde (symbol_temp_new_now ());
1130
1131   demand_empty_rest_of_line ();
1132
1133   if ((cfi_sections & CFI_EMIT_target) != 0)
1134     tc_cfi_endproc (fde);
1135 }
1136
1137 \f
1138 /* Emit a single byte into the current segment.  */
1139
1140 static inline void
1141 out_one (int byte)
1142 {
1143   FRAG_APPEND_1_CHAR (byte);
1144 }
1145
1146 /* Emit a two-byte word into the current segment.  */
1147
1148 static inline void
1149 out_two (int data)
1150 {
1151   md_number_to_chars (frag_more (2), data, 2);
1152 }
1153
1154 /* Emit a four byte word into the current segment.  */
1155
1156 static inline void
1157 out_four (int data)
1158 {
1159   md_number_to_chars (frag_more (4), data, 4);
1160 }
1161
1162 /* Emit an unsigned "little-endian base 128" number.  */
1163
1164 static void
1165 out_uleb128 (addressT value)
1166 {
1167   output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
1168 }
1169
1170 /* Emit an unsigned "little-endian base 128" number.  */
1171
1172 static void
1173 out_sleb128 (offsetT value)
1174 {
1175   output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1);
1176 }
1177
1178 static void
1179 output_cfi_insn (struct cfi_insn_data *insn)
1180 {
1181   offsetT offset;
1182   unsigned int regno;
1183
1184   switch (insn->insn)
1185     {
1186     case DW_CFA_advance_loc:
1187       {
1188         symbolS *from = insn->u.ll.lab1;
1189         symbolS *to = insn->u.ll.lab2;
1190
1191         if (symbol_get_frag (to) == symbol_get_frag (from))
1192           {
1193             addressT delta = S_GET_VALUE (to) - S_GET_VALUE (from);
1194             addressT scaled = delta / DWARF2_LINE_MIN_INSN_LENGTH;
1195
1196             if (scaled <= 0x3F)
1197               out_one (DW_CFA_advance_loc + scaled);
1198             else if (scaled <= 0xFF)
1199               {
1200                 out_one (DW_CFA_advance_loc1);
1201                 out_one (scaled);
1202               }
1203             else if (scaled <= 0xFFFF)
1204               {
1205                 out_one (DW_CFA_advance_loc2);
1206                 out_two (scaled);
1207               }
1208             else
1209               {
1210                 out_one (DW_CFA_advance_loc4);
1211                 out_four (scaled);
1212               }
1213           }
1214         else
1215           {
1216             expressionS exp;
1217
1218             exp.X_op = O_subtract;
1219             exp.X_add_symbol = to;
1220             exp.X_op_symbol = from;
1221             exp.X_add_number = 0;
1222
1223             /* The code in ehopt.c expects that one byte of the encoding
1224                is already allocated to the frag.  This comes from the way
1225                that it scans the .eh_frame section looking first for the
1226                .byte DW_CFA_advance_loc4.  */
1227             *frag_more (1) = DW_CFA_advance_loc4;
1228
1229             frag_var (rs_cfa, 4, 0, DWARF2_LINE_MIN_INSN_LENGTH << 3,
1230                       make_expr_symbol (&exp), frag_now_fix () - 1,
1231                       (char *) frag_now);
1232           }
1233       }
1234       break;
1235
1236     case DW_CFA_def_cfa:
1237       offset = insn->u.ri.offset;
1238       if (offset < 0)
1239         {
1240           out_one (DW_CFA_def_cfa_sf);
1241           out_uleb128 (insn->u.ri.reg);
1242           out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
1243         }
1244       else
1245         {
1246           out_one (DW_CFA_def_cfa);
1247           out_uleb128 (insn->u.ri.reg);
1248           out_uleb128 (offset);
1249         }
1250       break;
1251
1252     case DW_CFA_def_cfa_register:
1253     case DW_CFA_undefined:
1254     case DW_CFA_same_value:
1255       out_one (insn->insn);
1256       out_uleb128 (insn->u.r);
1257       break;
1258
1259     case DW_CFA_def_cfa_offset:
1260       offset = insn->u.i;
1261       if (offset < 0)
1262         {
1263           out_one (DW_CFA_def_cfa_offset_sf);
1264           out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
1265         }
1266       else
1267         {
1268           out_one (DW_CFA_def_cfa_offset);
1269           out_uleb128 (offset);
1270         }
1271       break;
1272
1273     case DW_CFA_restore:
1274       regno = insn->u.r;
1275       if (regno <= 0x3F)
1276         {
1277           out_one (DW_CFA_restore + regno);
1278         }
1279       else
1280         {
1281           out_one (DW_CFA_restore_extended);
1282           out_uleb128 (regno);
1283         }
1284       break;
1285
1286     case DW_CFA_offset:
1287       regno = insn->u.ri.reg;
1288       offset = insn->u.ri.offset / DWARF2_CIE_DATA_ALIGNMENT;
1289       if (offset < 0)
1290         {
1291           out_one (DW_CFA_offset_extended_sf);
1292           out_uleb128 (regno);
1293           out_sleb128 (offset);
1294         }
1295       else if (regno <= 0x3F)
1296         {
1297           out_one (DW_CFA_offset + regno);
1298           out_uleb128 (offset);
1299         }
1300       else
1301         {
1302           out_one (DW_CFA_offset_extended);
1303           out_uleb128 (regno);
1304           out_uleb128 (offset);
1305         }
1306       break;
1307
1308     case DW_CFA_register:
1309       out_one (DW_CFA_register);
1310       out_uleb128 (insn->u.rr.reg1);
1311       out_uleb128 (insn->u.rr.reg2);
1312       break;
1313
1314     case DW_CFA_remember_state:
1315     case DW_CFA_restore_state:
1316       out_one (insn->insn);
1317       break;
1318
1319     case DW_CFA_GNU_window_save:
1320       out_one (DW_CFA_GNU_window_save);
1321       break;
1322
1323     case CFI_escape:
1324       {
1325         struct cfi_escape_data *e;
1326         for (e = insn->u.esc; e ; e = e->next)
1327           emit_expr (&e->exp, 1);
1328         break;
1329       }
1330
1331     case CFI_val_encoded_addr:
1332       {
1333         unsigned encoding = insn->u.ea.encoding;
1334         offsetT encoding_size;
1335
1336         if (encoding == DW_EH_PE_omit)
1337           break;
1338         out_one (DW_CFA_val_expression);
1339         out_uleb128 (insn->u.ea.reg);
1340
1341         switch (encoding & 0x7)
1342           {
1343           case DW_EH_PE_absptr:
1344             encoding_size = DWARF2_ADDR_SIZE (stdoutput);
1345             break;
1346           case DW_EH_PE_udata2:
1347             encoding_size = 2;
1348             break;
1349           case DW_EH_PE_udata4:
1350             encoding_size = 4;
1351             break;
1352           case DW_EH_PE_udata8:
1353             encoding_size = 8;
1354             break;
1355           default:
1356             abort ();
1357           }
1358
1359         /* If the user has requested absolute encoding,
1360            then use the smaller DW_OP_addr encoding.  */
1361         if (insn->u.ea.encoding == DW_EH_PE_absptr)
1362           {
1363             out_uleb128 (1 + encoding_size);
1364             out_one (DW_OP_addr);
1365           }
1366         else
1367           {
1368             out_uleb128 (1 + 1 + encoding_size);
1369             out_one (DW_OP_GNU_encoded_addr);
1370             out_one (encoding);
1371
1372             if ((encoding & 0x70) == DW_EH_PE_pcrel)
1373               {
1374 #if CFI_DIFF_EXPR_OK
1375                 insn->u.ea.exp.X_op = O_subtract;
1376                 insn->u.ea.exp.X_op_symbol = symbol_temp_new_now ();
1377 #elif defined (tc_cfi_emit_pcrel_expr)
1378                 tc_cfi_emit_pcrel_expr (&insn->u.ea.exp, encoding_size);
1379                 break;
1380 #else
1381                 abort ();
1382 #endif
1383               }
1384           }
1385         emit_expr (&insn->u.ea.exp, encoding_size);
1386       }
1387       break;
1388
1389     default:
1390       abort ();
1391     }
1392 }
1393
1394 static offsetT
1395 encoding_size (unsigned char encoding)
1396 {
1397   if (encoding == DW_EH_PE_omit)
1398     return 0;
1399   switch (encoding & 0x7)
1400     {
1401     case 0:
1402       return bfd_get_arch_size (stdoutput) == 64 ? 8 : 4;
1403     case DW_EH_PE_udata2:
1404       return 2;
1405     case DW_EH_PE_udata4:
1406       return 4;
1407     case DW_EH_PE_udata8:
1408       return 8;
1409     default:
1410       abort ();
1411     }
1412 }
1413
1414 static void
1415 output_cie (struct cie_entry *cie, bfd_boolean eh_frame, int align)
1416 {
1417   symbolS *after_size_address, *end_address;
1418   expressionS exp;
1419   struct cfi_insn_data *i;
1420   offsetT augmentation_size;
1421   int enc;
1422   enum dwarf2_format fmt = DWARF2_FORMAT (now_seg);
1423
1424   cie->start_address = symbol_temp_new_now ();
1425   after_size_address = symbol_temp_make ();
1426   end_address = symbol_temp_make ();
1427
1428   exp.X_op = O_subtract;
1429   exp.X_add_symbol = end_address;
1430   exp.X_op_symbol = after_size_address;
1431   exp.X_add_number = 0;
1432
1433   if (eh_frame || fmt == dwarf2_format_32bit)
1434     emit_expr (&exp, 4);                        /* Length.  */
1435   else
1436     {
1437       if (fmt == dwarf2_format_64bit)
1438         out_four (-1);
1439       emit_expr (&exp, 8);                      /* Length.  */
1440     }
1441   symbol_set_value_now (after_size_address);
1442   if (eh_frame)
1443     out_four (0);                               /* CIE id.  */
1444   else
1445     {
1446       out_four (-1);                            /* CIE id.  */
1447       if (fmt != dwarf2_format_32bit)
1448         out_four (-1);
1449     }
1450   out_one (DW_CIE_VERSION);                     /* Version.  */
1451   if (eh_frame)
1452     {
1453       out_one ('z');                            /* Augmentation.  */
1454       if (cie->per_encoding != DW_EH_PE_omit)
1455         out_one ('P');
1456       if (cie->lsda_encoding != DW_EH_PE_omit)
1457         out_one ('L');
1458       out_one ('R');
1459     }
1460   if (cie->signal_frame)
1461     out_one ('S');
1462   out_one (0);
1463   out_uleb128 (DWARF2_LINE_MIN_INSN_LENGTH);    /* Code alignment.  */
1464   out_sleb128 (DWARF2_CIE_DATA_ALIGNMENT);      /* Data alignment.  */
1465   if (DW_CIE_VERSION == 1)                      /* Return column.  */
1466     out_one (cie->return_column);
1467   else
1468     out_uleb128 (cie->return_column);
1469   if (eh_frame)
1470     {
1471       augmentation_size = 1 + (cie->lsda_encoding != DW_EH_PE_omit);
1472       if (cie->per_encoding != DW_EH_PE_omit)
1473         augmentation_size += 1 + encoding_size (cie->per_encoding);
1474       out_uleb128 (augmentation_size);          /* Augmentation size.  */
1475
1476       if (cie->per_encoding != DW_EH_PE_omit)
1477         {
1478           offsetT size = encoding_size (cie->per_encoding);
1479           out_one (cie->per_encoding);
1480           exp = cie->personality;
1481           if ((cie->per_encoding & 0x70) == DW_EH_PE_pcrel)
1482             {
1483 #if CFI_DIFF_EXPR_OK
1484               exp.X_op = O_subtract;
1485               exp.X_op_symbol = symbol_temp_new_now ();
1486               emit_expr (&exp, size);
1487 #elif defined (tc_cfi_emit_pcrel_expr)
1488               tc_cfi_emit_pcrel_expr (&exp, size);
1489 #else
1490               abort ();
1491 #endif
1492             }
1493           else
1494             emit_expr (&exp, size);
1495         }
1496
1497       if (cie->lsda_encoding != DW_EH_PE_omit)
1498         out_one (cie->lsda_encoding);
1499     }
1500
1501   switch (DWARF2_FDE_RELOC_SIZE)
1502     {
1503     case 2:
1504       enc = DW_EH_PE_sdata2;
1505       break;
1506     case 4:
1507       enc = DW_EH_PE_sdata4;
1508       break;
1509     case 8:
1510       enc = DW_EH_PE_sdata8;
1511       break;
1512     default:
1513       abort ();
1514     }
1515 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
1516   enc |= DW_EH_PE_pcrel;
1517 #endif
1518   if (eh_frame)
1519     out_one (enc);
1520
1521   if (cie->first)
1522     {
1523       for (i = cie->first; i != cie->last; i = i->next)
1524         {
1525           if (CUR_SEG (i) != CUR_SEG (cie))
1526             continue;
1527           output_cfi_insn (i);
1528         }
1529     }
1530
1531   frag_align (align, DW_CFA_nop, 0);
1532   symbol_set_value_now (end_address);
1533 }
1534
1535 static void
1536 output_fde (struct fde_entry *fde, struct cie_entry *cie,
1537             bfd_boolean eh_frame, struct cfi_insn_data *first,
1538             int align)
1539 {
1540   symbolS *after_size_address, *end_address;
1541   expressionS exp;
1542   offsetT augmentation_size;
1543   enum dwarf2_format fmt = DWARF2_FORMAT (now_seg);
1544   int offset_size;
1545   int addr_size;
1546
1547   after_size_address = symbol_temp_make ();
1548   end_address = symbol_temp_make ();
1549
1550   exp.X_op = O_subtract;
1551   exp.X_add_symbol = end_address;
1552   exp.X_op_symbol = after_size_address;
1553   exp.X_add_number = 0;
1554   if (eh_frame || fmt == dwarf2_format_32bit)
1555     offset_size = 4;
1556   else
1557     {
1558       if (fmt == dwarf2_format_64bit)
1559         out_four (-1);
1560       offset_size = 8;
1561     }
1562   emit_expr (&exp, offset_size);                /* Length.  */
1563   symbol_set_value_now (after_size_address);
1564
1565   if (eh_frame)
1566     {
1567       exp.X_op = O_subtract;
1568       exp.X_add_symbol = after_size_address;
1569       exp.X_op_symbol = cie->start_address;
1570       exp.X_add_number = 0;
1571       emit_expr (&exp, offset_size);            /* CIE offset.  */
1572     }
1573   else
1574     {
1575       TC_DWARF2_EMIT_OFFSET (cie->start_address, offset_size);
1576     }
1577
1578   if (eh_frame)
1579     {
1580       exp.X_op = O_subtract;
1581       exp.X_add_number = 0;
1582 #if CFI_DIFF_EXPR_OK
1583       exp.X_add_symbol = fde->start_address;
1584       exp.X_op_symbol = symbol_temp_new_now ();
1585       emit_expr (&exp, DWARF2_FDE_RELOC_SIZE);  /* Code offset.  */
1586 #else
1587       exp.X_op = O_symbol;
1588       exp.X_add_symbol = fde->start_address;
1589 #ifdef tc_cfi_emit_pcrel_expr
1590       tc_cfi_emit_pcrel_expr (&exp, DWARF2_FDE_RELOC_SIZE);      /* Code offset.  */
1591 #else
1592       emit_expr (&exp, DWARF2_FDE_RELOC_SIZE);  /* Code offset.  */
1593 #endif
1594 #endif
1595       addr_size = DWARF2_FDE_RELOC_SIZE;
1596     }
1597   else
1598     {
1599       exp.X_op = O_symbol;
1600       exp.X_add_symbol = fde->start_address;
1601       exp.X_add_number = 0;
1602       addr_size = DWARF2_ADDR_SIZE (stdoutput);
1603       emit_expr (&exp, addr_size);
1604     }
1605
1606   exp.X_op = O_subtract;
1607   exp.X_add_symbol = fde->end_address;
1608   exp.X_op_symbol = fde->start_address;         /* Code length.  */
1609   exp.X_add_number = 0;
1610   emit_expr (&exp, addr_size);
1611
1612   augmentation_size = encoding_size (fde->lsda_encoding);
1613   if (eh_frame)
1614     out_uleb128 (augmentation_size);            /* Augmentation size.  */
1615
1616   if (fde->lsda_encoding != DW_EH_PE_omit)
1617     {
1618       exp = fde->lsda;
1619       if ((fde->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
1620         {
1621 #if CFI_DIFF_LSDA_OK
1622           exp.X_op = O_subtract;
1623           exp.X_op_symbol = symbol_temp_new_now ();
1624           emit_expr (&exp, augmentation_size);
1625 #elif defined (tc_cfi_emit_pcrel_expr)
1626           tc_cfi_emit_pcrel_expr (&exp, augmentation_size);
1627 #else
1628           abort ();
1629 #endif
1630         }
1631       else
1632         emit_expr (&exp, augmentation_size);
1633     }
1634
1635   for (; first; first = first->next)
1636     if (CUR_SEG (first) == CUR_SEG (fde))
1637       output_cfi_insn (first);
1638
1639   frag_align (align, DW_CFA_nop, 0);
1640   symbol_set_value_now (end_address);
1641 }
1642
1643 static struct cie_entry *
1644 select_cie_for_fde (struct fde_entry *fde, bfd_boolean eh_frame,
1645                     struct cfi_insn_data **pfirst, int align)
1646 {
1647   struct cfi_insn_data *i, *j;
1648   struct cie_entry *cie;
1649
1650   for (cie = cie_root; cie; cie = cie->next)
1651     {
1652       if (CUR_SEG (cie) != CUR_SEG (fde))
1653         continue;
1654       if (cie->return_column != fde->return_column
1655           || cie->signal_frame != fde->signal_frame
1656           || cie->per_encoding != fde->per_encoding
1657           || cie->lsda_encoding != fde->lsda_encoding)
1658         continue;
1659       if (cie->per_encoding != DW_EH_PE_omit)
1660         {
1661           if (cie->personality.X_op != fde->personality.X_op
1662               || cie->personality.X_add_number
1663                  != fde->personality.X_add_number)
1664             continue;
1665           switch (cie->personality.X_op)
1666             {
1667             case O_constant:
1668               if (cie->personality.X_unsigned != fde->personality.X_unsigned)
1669                 continue;
1670               break;
1671             case O_symbol:
1672               if (cie->personality.X_add_symbol
1673                   != fde->personality.X_add_symbol)
1674                 continue;
1675               break;
1676             default:
1677               abort ();
1678             }
1679         }
1680       for (i = cie->first, j = fde->data;
1681            i != cie->last && j != NULL;
1682            i = i->next, j = j->next)
1683         {
1684           if (i->insn != j->insn)
1685             goto fail;
1686           switch (i->insn)
1687             {
1688             case DW_CFA_advance_loc:
1689             case DW_CFA_remember_state:
1690               /* We reached the first advance/remember in the FDE,
1691                  but did not reach the end of the CIE list.  */
1692               goto fail;
1693
1694             case DW_CFA_offset:
1695             case DW_CFA_def_cfa:
1696               if (i->u.ri.reg != j->u.ri.reg)
1697                 goto fail;
1698               if (i->u.ri.offset != j->u.ri.offset)
1699                 goto fail;
1700               break;
1701
1702             case DW_CFA_register:
1703               if (i->u.rr.reg1 != j->u.rr.reg1)
1704                 goto fail;
1705               if (i->u.rr.reg2 != j->u.rr.reg2)
1706                 goto fail;
1707               break;
1708
1709             case DW_CFA_def_cfa_register:
1710             case DW_CFA_restore:
1711             case DW_CFA_undefined:
1712             case DW_CFA_same_value:
1713               if (i->u.r != j->u.r)
1714                 goto fail;
1715               break;
1716
1717             case DW_CFA_def_cfa_offset:
1718               if (i->u.i != j->u.i)
1719                 goto fail;
1720               break;
1721
1722             case CFI_escape:
1723             case CFI_val_encoded_addr:
1724               /* Don't bother matching these for now.  */
1725               goto fail;
1726
1727             default:
1728               abort ();
1729             }
1730         }
1731
1732       /* Success if we reached the end of the CIE list, and we've either
1733          run out of FDE entries or we've encountered an advance,
1734          remember, or escape.  */
1735       if (i == cie->last
1736           && (!j
1737               || j->insn == DW_CFA_advance_loc
1738               || j->insn == DW_CFA_remember_state
1739               || j->insn == CFI_escape
1740               || j->insn == CFI_val_encoded_addr))
1741         {
1742           *pfirst = j;
1743           return cie;
1744         }
1745
1746     fail:;
1747     }
1748
1749   cie = (struct cie_entry *) xmalloc (sizeof (struct cie_entry));
1750   cie->next = cie_root;
1751   cie_root = cie;
1752   SET_CUR_SEG (cie, CUR_SEG (fde));
1753   cie->return_column = fde->return_column;
1754   cie->signal_frame = fde->signal_frame;
1755   cie->per_encoding = fde->per_encoding;
1756   cie->lsda_encoding = fde->lsda_encoding;
1757   cie->personality = fde->personality;
1758   cie->first = fde->data;
1759
1760   for (i = cie->first; i ; i = i->next)
1761     if (i->insn == DW_CFA_advance_loc
1762         || i->insn == DW_CFA_remember_state
1763         || i->insn == CFI_escape
1764         || i->insn == CFI_val_encoded_addr)
1765       break;
1766
1767   cie->last = i;
1768   *pfirst = i;
1769
1770   output_cie (cie, eh_frame, align);
1771
1772   return cie;
1773 }
1774
1775 #ifdef md_reg_eh_frame_to_debug_frame
1776 static void
1777 cfi_change_reg_numbers (struct cfi_insn_data *insn, segT ccseg)
1778 {
1779   for (; insn; insn = insn->next)
1780     {
1781       if (CUR_SEG (insn) != ccseg)
1782         continue;
1783       switch (insn->insn)
1784         {
1785         case DW_CFA_advance_loc:
1786         case DW_CFA_def_cfa_offset:
1787         case DW_CFA_remember_state:
1788         case DW_CFA_restore_state:
1789         case DW_CFA_GNU_window_save:
1790         case CFI_escape:
1791           break;
1792
1793         case DW_CFA_def_cfa:
1794         case DW_CFA_offset:
1795           insn->u.ri.reg = md_reg_eh_frame_to_debug_frame (insn->u.ri.reg);
1796           break;
1797
1798         case DW_CFA_def_cfa_register:
1799         case DW_CFA_undefined:
1800         case DW_CFA_same_value:
1801         case DW_CFA_restore:
1802           insn->u.r = md_reg_eh_frame_to_debug_frame (insn->u.r);
1803           break;
1804
1805         case DW_CFA_register:
1806           insn->u.rr.reg1 = md_reg_eh_frame_to_debug_frame (insn->u.rr.reg1);
1807           insn->u.rr.reg2 = md_reg_eh_frame_to_debug_frame (insn->u.rr.reg2);
1808           break;
1809
1810         case CFI_val_encoded_addr:
1811           insn->u.ea.reg = md_reg_eh_frame_to_debug_frame (insn->u.ea.reg);
1812           break;
1813
1814         default:
1815           abort ();
1816         }
1817     }
1818 }
1819 #else
1820 #define cfi_change_reg_numbers(insn, cseg) do { } while (0)
1821 #endif
1822
1823 static segT
1824 get_cfi_seg (segT cseg, const char *base, flagword flags, int align)
1825 {
1826   if (SUPPORT_FRAME_LINKONCE)
1827     {
1828       struct dwcfi_seg_list *l;
1829
1830       l = dwcfi_hash_find_or_make (cseg, base, flags);
1831
1832       cseg = l->seg;
1833       subseg_set (cseg, l->subseg);
1834     }
1835   else
1836     {
1837       cseg = subseg_new (base, 0);
1838       bfd_set_section_flags (stdoutput, cseg, flags);
1839     }
1840   record_alignment (cseg, align);
1841   return cseg;
1842 }
1843
1844 void
1845 cfi_finish (void)
1846 {
1847   struct cie_entry *cie, *cie_next;
1848   segT cfi_seg, ccseg;
1849   struct fde_entry *fde;
1850   struct cfi_insn_data *first;
1851   int save_flag_traditional_format, seek_next_seg;
1852
1853   if (all_fde_data == 0)
1854     return;
1855
1856   if ((cfi_sections & CFI_EMIT_eh_frame) != 0)
1857     {
1858       /* Make sure check_eh_frame doesn't do anything with our output.  */
1859       save_flag_traditional_format = flag_traditional_format;
1860       flag_traditional_format = 1;
1861
1862       if (!SUPPORT_FRAME_LINKONCE)
1863         {
1864           /* Open .eh_frame section.  */
1865           cfi_seg = get_cfi_seg (NULL, ".eh_frame",
1866                                  (SEC_ALLOC | SEC_LOAD | SEC_DATA
1867                                   | DWARF2_EH_FRAME_READ_ONLY),
1868                                  EH_FRAME_ALIGNMENT);
1869 #ifdef md_fix_up_eh_frame
1870           md_fix_up_eh_frame (cfi_seg);
1871 #else
1872           (void) cfi_seg;
1873 #endif
1874         }
1875
1876       do
1877         {
1878           ccseg = NULL;
1879           seek_next_seg = 0;
1880
1881           for (cie = cie_root; cie; cie = cie_next)
1882             {
1883               cie_next = cie->next;
1884               free ((void *) cie);
1885             }
1886           cie_root = NULL;
1887
1888           for (fde = all_fde_data; fde ; fde = fde->next)
1889             {
1890               if (SUPPORT_FRAME_LINKONCE)
1891                 {
1892                   if (HANDLED (fde))
1893                     continue;
1894                   if (seek_next_seg && CUR_SEG (fde) != ccseg)
1895                     {
1896                       seek_next_seg = 2;
1897                       continue;
1898                     }
1899                   if (!seek_next_seg)
1900                     {
1901                       ccseg = CUR_SEG (fde);
1902                       /* Open .eh_frame section.  */
1903                       cfi_seg = get_cfi_seg (ccseg, ".eh_frame",
1904                                              (SEC_ALLOC | SEC_LOAD | SEC_DATA
1905                                               | DWARF2_EH_FRAME_READ_ONLY),
1906                                              EH_FRAME_ALIGNMENT);
1907 #ifdef md_fix_up_eh_frame
1908                       md_fix_up_eh_frame (cfi_seg);
1909 #else
1910                       (void) cfi_seg;
1911 #endif
1912                       seek_next_seg = 1;
1913                     }
1914                   SET_HANDLED (fde, 1);
1915                 }
1916
1917               if (fde->end_address == NULL)
1918                 {
1919                   as_bad (_("open CFI at the end of file; missing .cfi_endproc directive"));
1920                   fde->end_address = fde->start_address;
1921                 }
1922
1923               cie = select_cie_for_fde (fde, TRUE, &first, 2);
1924               output_fde (fde, cie, TRUE, first,
1925                           fde->next == NULL ? EH_FRAME_ALIGNMENT : 2);
1926             }
1927         }
1928       while (SUPPORT_FRAME_LINKONCE && seek_next_seg == 2);
1929
1930       if (SUPPORT_FRAME_LINKONCE)
1931         for (fde = all_fde_data; fde ; fde = fde->next)
1932           SET_HANDLED (fde, 0);
1933
1934       flag_traditional_format = save_flag_traditional_format;
1935     }
1936
1937   if ((cfi_sections & CFI_EMIT_debug_frame) != 0)
1938     {
1939       int alignment = ffs (DWARF2_ADDR_SIZE (stdoutput)) - 1;
1940
1941       if (!SUPPORT_FRAME_LINKONCE)
1942         get_cfi_seg (NULL, ".debug_frame",
1943                      SEC_READONLY | SEC_DEBUGGING,
1944                      alignment);
1945
1946       do
1947         {
1948           ccseg = NULL;
1949           seek_next_seg = 0;
1950
1951           for (cie = cie_root; cie; cie = cie_next)
1952             {
1953               cie_next = cie->next;
1954               free ((void *) cie);
1955             }
1956           cie_root = NULL;
1957
1958           for (fde = all_fde_data; fde ; fde = fde->next)
1959             {
1960               if (SUPPORT_FRAME_LINKONCE)
1961                 {
1962                   if (HANDLED (fde))
1963                     continue;
1964                   if (seek_next_seg && CUR_SEG (fde) != ccseg)
1965                     {
1966                       seek_next_seg = 2;
1967                       continue;
1968                     }
1969                   if (!seek_next_seg)
1970                     {
1971                       ccseg = CUR_SEG (fde);
1972                       /* Open .debug_frame section.  */
1973                       get_cfi_seg (ccseg, ".debug_frame",
1974                                    SEC_READONLY | SEC_DEBUGGING,
1975                                    alignment);
1976                       seek_next_seg = 1;
1977                     }
1978                   SET_HANDLED (fde, 1);
1979                 }
1980               if (fde->end_address == NULL)
1981                 {
1982                   as_bad (_("open CFI at the end of file; missing .cfi_endproc directive"));
1983                   fde->end_address = fde->start_address;
1984                 }
1985
1986               fde->per_encoding = DW_EH_PE_omit;
1987               fde->lsda_encoding = DW_EH_PE_omit;
1988               cfi_change_reg_numbers (fde->data, ccseg);
1989               cie = select_cie_for_fde (fde, FALSE, &first, alignment);
1990               output_fde (fde, cie, FALSE, first, alignment);
1991             }
1992         }
1993       while (SUPPORT_FRAME_LINKONCE && seek_next_seg == 2);
1994
1995       if (SUPPORT_FRAME_LINKONCE)
1996         for (fde = all_fde_data; fde ; fde = fde->next)
1997           SET_HANDLED (fde, 0);
1998     }
1999 }
2000
2001 #else /* TARGET_USE_CFIPOP */
2002
2003 /* Emit an intelligible error message for missing support.  */
2004
2005 static void
2006 dot_cfi_dummy (int ignored ATTRIBUTE_UNUSED)
2007 {
2008   as_bad (_("CFI is not supported for this target"));
2009   ignore_rest_of_line ();
2010 }
2011
2012 const pseudo_typeS cfi_pseudo_table[] =
2013   {
2014     { "cfi_sections", dot_cfi_dummy, 0 },
2015     { "cfi_startproc", dot_cfi_dummy, 0 },
2016     { "cfi_endproc", dot_cfi_dummy, 0 },
2017     { "cfi_def_cfa", dot_cfi_dummy, 0 },
2018     { "cfi_def_cfa_register", dot_cfi_dummy, 0 },
2019     { "cfi_def_cfa_offset", dot_cfi_dummy, 0 },
2020     { "cfi_adjust_cfa_offset", dot_cfi_dummy, 0 },
2021     { "cfi_offset", dot_cfi_dummy, 0 },
2022     { "cfi_rel_offset", dot_cfi_dummy, 0 },
2023     { "cfi_register", dot_cfi_dummy, 0 },
2024     { "cfi_return_column", dot_cfi_dummy, 0 },
2025     { "cfi_restore", dot_cfi_dummy, 0 },
2026     { "cfi_undefined", dot_cfi_dummy, 0 },
2027     { "cfi_same_value", dot_cfi_dummy, 0 },
2028     { "cfi_remember_state", dot_cfi_dummy, 0 },
2029     { "cfi_restore_state", dot_cfi_dummy, 0 },
2030     { "cfi_window_save", dot_cfi_dummy, 0 },
2031     { "cfi_escape", dot_cfi_dummy, 0 },
2032     { "cfi_signal_frame", dot_cfi_dummy, 0 },
2033     { "cfi_personality", dot_cfi_dummy, 0 },
2034     { "cfi_lsda", dot_cfi_dummy, 0 },
2035     { "cfi_val_encoded_addr", dot_cfi_dummy, 0 },
2036     { NULL, NULL, 0 }
2037   };
2038
2039 void
2040 cfi_finish (void)
2041 {
2042 }
2043 #endif /* TARGET_USE_CFIPOP */