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 CFI insn to label the current position in the CFI segment.  */
 444
 445 void
 446 cfi_add_label (const char *name)
 447 {
 448   unsigned int len = strlen (name) + 1;
 449   struct cfi_insn_data *insn = alloc_cfi_insn_data ();
 450
 451   insn->insn = CFI_label;
 452   obstack_grow (&notes, name, len);
 453   insn->u.sym_name = (char *) obstack_finish (&notes);
 454 }
 455
 456 /* Add a DW_CFA_offset record to the CFI data.  */
 457
 458 void
 459 cfi_add_CFA_offset (unsigned regno, offsetT offset)
 460 {
 461   unsigned int abs_data_align;
 462
 463   gas_assert (DWARF2_CIE_DATA_ALIGNMENT != 0);
 464   cfi_add_CFA_insn_reg_offset (DW_CFA_offset, regno, offset);
 465
 466   abs_data_align = (DWARF2_CIE_DATA_ALIGNMENT < 0
 467                     ? -DWARF2_CIE_DATA_ALIGNMENT : DWARF2_CIE_DATA_ALIGNMENT);
 468   if (offset % abs_data_align)
 469     as_bad (_("register save offset not a multiple of %u"), abs_data_align);
 470 }
 471
 472 /* Add a DW_CFA_def_cfa record to the CFI data.  */
 473
 474 void
 475 cfi_add_CFA_def_cfa (unsigned regno, offsetT offset)
 476 {
 477   cfi_add_CFA_insn_reg_offset (DW_CFA_def_cfa, regno, offset);
 478   frchain_now->frch_cfi_data->cur_cfa_offset = offset;
 479 }
 480
 481 /* Add a DW_CFA_register record to the CFI data.  */
 482
 483 void
 484 cfi_add_CFA_register (unsigned reg1, unsigned reg2)
 485 {
 486   cfi_add_CFA_insn_reg_reg (DW_CFA_register, reg1, reg2);
 487 }
 488
 489 /* Add a DW_CFA_def_cfa_register record to the CFI data.  */
 490
 491 void
 492 cfi_add_CFA_def_cfa_register (unsigned regno)
 493 {
 494   cfi_add_CFA_insn_reg (DW_CFA_def_cfa_register, regno);
 495 }
 496
 497 /* Add a DW_CFA_def_cfa_offset record to the CFI data.  */
 498
 499 void
 500 cfi_add_CFA_def_cfa_offset (offsetT offset)
 501 {
 502   cfi_add_CFA_insn_offset (DW_CFA_def_cfa_offset, offset);
 503   frchain_now->frch_cfi_data->cur_cfa_offset = offset;
 504 }
 505
 506 void
 507 cfi_add_CFA_restore (unsigned regno)
 508 {
 509   cfi_add_CFA_insn_reg (DW_CFA_restore, regno);
 510 }
 511
 512 void
 513 cfi_add_CFA_undefined (unsigned regno)
 514 {
 515   cfi_add_CFA_insn_reg (DW_CFA_undefined, regno);
 516 }
 517
 518 void
 519 cfi_add_CFA_same_value (unsigned regno)
 520 {
 521   cfi_add_CFA_insn_reg (DW_CFA_same_value, regno);
 522 }
 523
 524 void
 525 cfi_add_CFA_remember_state (void)
 526 {
 527   struct cfa_save_data *p;
 528
 529   cfi_add_CFA_insn (DW_CFA_remember_state);
 530
 531   p = (struct cfa_save_data *) xmalloc (sizeof (*p));
 532   p->cfa_offset = frchain_now->frch_cfi_data->cur_cfa_offset;
 533   p->next = frchain_now->frch_cfi_data->cfa_save_stack;
 534   frchain_now->frch_cfi_data->cfa_save_stack = p;
 535 }
 536
 537 void
 538 cfi_add_CFA_restore_state (void)
 539 {
 540   struct cfa_save_data *p;
 541
 542   cfi_add_CFA_insn (DW_CFA_restore_state);
 543
 544   p = frchain_now->frch_cfi_data->cfa_save_stack;
 545   if (p)
 546     {
 547       frchain_now->frch_cfi_data->cur_cfa_offset = p->cfa_offset;
 548       frchain_now->frch_cfi_data->cfa_save_stack = p->next;
 549       free (p);
 550     }
 551   else
 552     as_bad (_("CFI state restore without previous remember"));
 553 }
 554
 555 \f
 556 /* Parse CFI assembler directives.  */
 557
 558 static void dot_cfi (int);
 559 static void dot_cfi_escape (int);
 560 static void dot_cfi_sections (int);
 561 static void dot_cfi_startproc (int);
 562 static void dot_cfi_endproc (int);
 563 static void dot_cfi_personality (int);
 564 static void dot_cfi_lsda (int);
 565 static void dot_cfi_val_encoded_addr (int);
 566 static void dot_cfi_label (int);
 567
 568 const pseudo_typeS cfi_pseudo_table[] =
 569   {
 570     { "cfi_sections", dot_cfi_sections, 0 },
 571     { "cfi_startproc", dot_cfi_startproc, 0 },
 572     { "cfi_endproc", dot_cfi_endproc, 0 },
 573     { "cfi_def_cfa", dot_cfi, DW_CFA_def_cfa },
 574     { "cfi_def_cfa_register", dot_cfi, DW_CFA_def_cfa_register },
 575     { "cfi_def_cfa_offset", dot_cfi, DW_CFA_def_cfa_offset },
 576     { "cfi_adjust_cfa_offset", dot_cfi, CFI_adjust_cfa_offset },
 577     { "cfi_offset", dot_cfi, DW_CFA_offset },
 578     { "cfi_rel_offset", dot_cfi, CFI_rel_offset },
 579     { "cfi_register", dot_cfi, DW_CFA_register },
 580     { "cfi_return_column", dot_cfi, CFI_return_column },
 581     { "cfi_restore", dot_cfi, DW_CFA_restore },
 582     { "cfi_undefined", dot_cfi, DW_CFA_undefined },
 583     { "cfi_same_value", dot_cfi, DW_CFA_same_value },
 584     { "cfi_remember_state", dot_cfi, DW_CFA_remember_state },
 585     { "cfi_restore_state", dot_cfi, DW_CFA_restore_state },
 586     { "cfi_window_save", dot_cfi, DW_CFA_GNU_window_save },
 587     { "cfi_escape", dot_cfi_escape, 0 },
 588     { "cfi_signal_frame", dot_cfi, CFI_signal_frame },
 589     { "cfi_personality", dot_cfi_personality, 0 },
 590     { "cfi_lsda", dot_cfi_lsda, 0 },
 591     { "cfi_val_encoded_addr", dot_cfi_val_encoded_addr, 0 },
 592     { "cfi_label", dot_cfi_label, 0 },
 593     { NULL, NULL, 0 }
 594   };
 595
 596 static void
 597 cfi_parse_separator (void)
 598 {
 599   SKIP_WHITESPACE ();
 600   if (*input_line_pointer == ',')
 601     input_line_pointer++;
 602   else
 603     as_bad (_("missing separator"));
 604 }
 605
 606 #ifndef tc_parse_to_dw2regnum
 607 static void
 608 tc_parse_to_dw2regnum (expressionS *exp)
 609 {
 610 # ifdef tc_regname_to_dw2regnum
 611   SKIP_WHITESPACE ();
 612   if (is_name_beginner (*input_line_pointer)
 613       || (*input_line_pointer == '%'
 614           && is_name_beginner (*++input_line_pointer)))
 615     {
 616       char *name, c;
 617
 618       name = input_line_pointer;
 619       c = get_symbol_end ();
 620
 621       exp->X_op = O_constant;
 622       exp->X_add_number = tc_regname_to_dw2regnum (name);
 623
 624       *input_line_pointer = c;
 625     }
 626   else
 627 # endif
 628     expression_and_evaluate (exp);
 629 }
 630 #endif
 631
 632 static unsigned
 633 cfi_parse_reg (void)
 634 {
 635   int regno;
 636   expressionS exp;
 637
 638   tc_parse_to_dw2regnum (&exp);
 639   switch (exp.X_op)
 640     {
 641     case O_register:
 642     case O_constant:
 643       regno = exp.X_add_number;
 644       break;
 645
 646     default:
 647       regno = -1;
 648       break;
 649     }
 650
 651   if (regno < 0)
 652     {
 653       as_bad (_("bad register expression"));
 654       regno = 0;
 655     }
 656
 657   return regno;
 658 }
 659
 660 static offsetT
 661 cfi_parse_const (void)
 662 {
 663   return get_absolute_expression ();
 664 }
 665
 666 static void
 667 dot_cfi (int arg)
 668 {
 669   offsetT offset;
 670   unsigned reg1, reg2;
 671
 672   if (frchain_now->frch_cfi_data == NULL)
 673     {
 674       as_bad (_("CFI instruction used without previous .cfi_startproc"));
 675       ignore_rest_of_line ();
 676       return;
 677     }
 678
 679   /* If the last address was not at the current PC, advance to current.  */
 680   if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now
 681       || S_GET_VALUE (frchain_now->frch_cfi_data->last_address)
 682          != frag_now_fix ())
 683     cfi_add_advance_loc (symbol_temp_new_now ());
 684
 685   switch (arg)
 686     {
 687     case DW_CFA_offset:
 688       reg1 = cfi_parse_reg ();
 689       cfi_parse_separator ();
 690       offset = cfi_parse_const ();
 691       cfi_add_CFA_offset (reg1, offset);
 692       break;
 693
 694     case CFI_rel_offset:
 695       reg1 = cfi_parse_reg ();
 696       cfi_parse_separator ();
 697       offset = cfi_parse_const ();
 698       cfi_add_CFA_offset (reg1,
 699                           offset - frchain_now->frch_cfi_data->cur_cfa_offset);
 700       break;
 701
 702     case DW_CFA_def_cfa:
 703       reg1 = cfi_parse_reg ();
 704       cfi_parse_separator ();
 705       offset = cfi_parse_const ();
 706       cfi_add_CFA_def_cfa (reg1, offset);
 707       break;
 708
 709     case DW_CFA_register:
 710       reg1 = cfi_parse_reg ();
 711       cfi_parse_separator ();
 712       reg2 = cfi_parse_reg ();
 713       cfi_add_CFA_register (reg1, reg2);
 714       break;
 715
 716     case DW_CFA_def_cfa_register:
 717       reg1 = cfi_parse_reg ();
 718       cfi_add_CFA_def_cfa_register (reg1);
 719       break;
 720
 721     case DW_CFA_def_cfa_offset:
 722       offset = cfi_parse_const ();
 723       cfi_add_CFA_def_cfa_offset (offset);
 724       break;
 725
 726     case CFI_adjust_cfa_offset:
 727       offset = cfi_parse_const ();
 728       cfi_add_CFA_def_cfa_offset (frchain_now->frch_cfi_data->cur_cfa_offset
 729                                   + offset);
 730       break;
 731
 732     case DW_CFA_restore:
 733       for (;;)
 734         {
 735           reg1 = cfi_parse_reg ();
 736           cfi_add_CFA_restore (reg1);
 737           SKIP_WHITESPACE ();
 738           if (*input_line_pointer != ',')
 739             break;
 740           ++input_line_pointer;
 741         }
 742       break;
 743
 744     case DW_CFA_undefined:
 745       for (;;)
 746         {
 747           reg1 = cfi_parse_reg ();
 748           cfi_add_CFA_undefined (reg1);
 749           SKIP_WHITESPACE ();
 750           if (*input_line_pointer != ',')
 751             break;
 752           ++input_line_pointer;
 753         }
 754       break;
 755
 756     case DW_CFA_same_value:
 757       reg1 = cfi_parse_reg ();
 758       cfi_add_CFA_same_value (reg1);
 759       break;
 760
 761     case CFI_return_column:
 762       reg1 = cfi_parse_reg ();
 763       cfi_set_return_column (reg1);
 764       break;
 765
 766     case DW_CFA_remember_state:
 767       cfi_add_CFA_remember_state ();
 768       break;
 769
 770     case DW_CFA_restore_state:
 771       cfi_add_CFA_restore_state ();
 772       break;
 773
 774     case DW_CFA_GNU_window_save:
 775       cfi_add_CFA_insn (DW_CFA_GNU_window_save);
 776       break;
 777
 778     case CFI_signal_frame:
 779       frchain_now->frch_cfi_data->cur_fde_data->signal_frame = 1;
 780       break;
 781
 782     default:
 783       abort ();
 784     }
 785
 786   demand_empty_rest_of_line ();
 787 }
 788
 789 static void
 790 dot_cfi_escape (int ignored ATTRIBUTE_UNUSED)
 791 {
 792   struct cfi_escape_data *head, **tail, *e;
 793   struct cfi_insn_data *insn;
 794
 795   if (frchain_now->frch_cfi_data == NULL)
 796     {
 797       as_bad (_("CFI instruction used without previous .cfi_startproc"));
 798       ignore_rest_of_line ();
 799       return;
 800     }
 801
 802   /* If the last address was not at the current PC, advance to current.  */
 803   if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now
 804       || S_GET_VALUE (frchain_now->frch_cfi_data->last_address)
 805          != frag_now_fix ())
 806     cfi_add_advance_loc (symbol_temp_new_now ());
 807
 808   tail = &head;
 809   do
 810     {
 811       e = (struct cfi_escape_data *) xmalloc (sizeof (*e));
 812       do_parse_cons_expression (&e->exp, 1);
 813       *tail = e;
 814       tail = &e->next;
 815     }
 816   while (*input_line_pointer++ == ',');
 817   *tail = NULL;
 818
 819   insn = alloc_cfi_insn_data ();
 820   insn->insn = CFI_escape;
 821   insn->u.esc = head;
 822
 823   --input_line_pointer;
 824   demand_empty_rest_of_line ();
 825 }
 826
 827 static void
 828 dot_cfi_personality (int ignored ATTRIBUTE_UNUSED)
 829 {
 830   struct fde_entry *fde;
 831   offsetT encoding;
 832
 833   if (frchain_now->frch_cfi_data == NULL)
 834     {
 835       as_bad (_("CFI instruction used without previous .cfi_startproc"));
 836       ignore_rest_of_line ();
 837       return;
 838     }
 839
 840   fde = frchain_now->frch_cfi_data->cur_fde_data;
 841   encoding = cfi_parse_const ();
 842   if (encoding == DW_EH_PE_omit)
 843     {
 844       demand_empty_rest_of_line ();
 845       fde->per_encoding = encoding;
 846       return;
 847     }
 848
 849   if ((encoding & 0xff) != encoding
 850       || ((encoding & 0x70) != 0
 851 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
 852           && (encoding & 0x70) != DW_EH_PE_pcrel
 853 #endif
 854           )
 855          /* leb128 can be handled, but does something actually need it?  */
 856       || (encoding & 7) == DW_EH_PE_uleb128
 857       || (encoding & 7) > DW_EH_PE_udata8)
 858     {
 859       as_bad (_("invalid or unsupported encoding in .cfi_personality"));
 860       ignore_rest_of_line ();
 861       return;
 862     }
 863
 864   if (*input_line_pointer++ != ',')
 865     {
 866       as_bad (_(".cfi_personality requires encoding and symbol arguments"));
 867       ignore_rest_of_line ();
 868       return;
 869     }
 870
 871   expression_and_evaluate (&fde->personality);
 872   switch (fde->personality.X_op)
 873     {
 874     case O_symbol:
 875       break;
 876     case O_constant:
 877       if ((encoding & 0x70) == DW_EH_PE_pcrel)
 878         encoding = DW_EH_PE_omit;
 879       break;
 880     default:
 881       encoding = DW_EH_PE_omit;
 882       break;
 883     }
 884
 885   fde->per_encoding = encoding;
 886
 887   if (encoding == DW_EH_PE_omit)
 888     {
 889       as_bad (_("wrong second argument to .cfi_personality"));
 890       ignore_rest_of_line ();
 891       return;
 892     }
 893
 894   demand_empty_rest_of_line ();
 895 }
 896
 897 static void
 898 dot_cfi_lsda (int ignored ATTRIBUTE_UNUSED)
 899 {
 900   struct fde_entry *fde;
 901   offsetT encoding;
 902
 903   if (frchain_now->frch_cfi_data == NULL)
 904     {
 905       as_bad (_("CFI instruction used without previous .cfi_startproc"));
 906       ignore_rest_of_line ();
 907       return;
 908     }
 909
 910   fde = frchain_now->frch_cfi_data->cur_fde_data;
 911   encoding = cfi_parse_const ();
 912   if (encoding == DW_EH_PE_omit)
 913     {
 914       demand_empty_rest_of_line ();
 915       fde->lsda_encoding = encoding;
 916       return;
 917     }
 918
 919   if ((encoding & 0xff) != encoding
 920       || ((encoding & 0x70) != 0
 921 #if CFI_DIFF_LSDA_OK || defined tc_cfi_emit_pcrel_expr
 922           && (encoding & 0x70) != DW_EH_PE_pcrel
 923 #endif
 924           )
 925          /* leb128 can be handled, but does something actually need it?  */
 926       || (encoding & 7) == DW_EH_PE_uleb128
 927       || (encoding & 7) > DW_EH_PE_udata8)
 928     {
 929       as_bad (_("invalid or unsupported encoding in .cfi_lsda"));
 930       ignore_rest_of_line ();
 931       return;
 932     }
 933
 934   if (*input_line_pointer++ != ',')
 935     {
 936       as_bad (_(".cfi_lsda requires encoding and symbol arguments"));
 937       ignore_rest_of_line ();
 938       return;
 939     }
 940
 941   fde->lsda_encoding = encoding;
 942
 943   expression_and_evaluate (&fde->lsda);
 944   switch (fde->lsda.X_op)
 945     {
 946     case O_symbol:
 947       break;
 948     case O_constant:
 949       if ((encoding & 0x70) == DW_EH_PE_pcrel)
 950         encoding = DW_EH_PE_omit;
 951       break;
 952     default:
 953       encoding = DW_EH_PE_omit;
 954       break;
 955     }
 956
 957   fde->lsda_encoding = encoding;
 958
 959   if (encoding == DW_EH_PE_omit)
 960     {
 961       as_bad (_("wrong second argument to .cfi_lsda"));
 962       ignore_rest_of_line ();
 963       return;
 964     }
 965
 966   demand_empty_rest_of_line ();
 967 }
 968
 969 static void
 970 dot_cfi_val_encoded_addr (int ignored ATTRIBUTE_UNUSED)
 971 {
 972   struct cfi_insn_data *insn_ptr;
 973   offsetT encoding;
 974
 975   if (frchain_now->frch_cfi_data == NULL)
 976     {
 977       as_bad (_("CFI instruction used without previous .cfi_startproc"));
 978       ignore_rest_of_line ();
 979       return;
 980     }
 981
 982   /* If the last address was not at the current PC, advance to current.  */
 983   if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now
 984       || S_GET_VALUE (frchain_now->frch_cfi_data->last_address)
 985          != frag_now_fix ())
 986     cfi_add_advance_loc (symbol_temp_new_now ());
 987
 988   insn_ptr = alloc_cfi_insn_data ();
 989   insn_ptr->insn = CFI_val_encoded_addr;
 990
 991   insn_ptr->u.ea.reg = cfi_parse_reg ();
 992
 993   cfi_parse_separator ();
 994   encoding = cfi_parse_const ();
 995   if ((encoding & 0xff) != encoding
 996       || ((encoding & 0x70) != 0
 997 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
 998           && (encoding & 0x70) != DW_EH_PE_pcrel
 999 #endif
1000           )
1001          /* leb128 can be handled, but does something actually need it?  */
1002       || (encoding & 7) == DW_EH_PE_uleb128
1003       || (encoding & 7) > DW_EH_PE_udata8)
1004     {
1005       as_bad (_("invalid or unsupported encoding in .cfi_lsda"));
1006       encoding = DW_EH_PE_omit;
1007     }
1008
1009   cfi_parse_separator ();
1010   expression_and_evaluate (&insn_ptr->u.ea.exp);
1011   switch (insn_ptr->u.ea.exp.X_op)
1012     {
1013     case O_symbol:
1014       break;
1015     case O_constant:
1016       if ((encoding & 0x70) != DW_EH_PE_pcrel)
1017         break;
1018     default:
1019       encoding = DW_EH_PE_omit;
1020       break;
1021     }
1022
1023   insn_ptr->u.ea.encoding = encoding;
1024   if (encoding == DW_EH_PE_omit)
1025     {
1026       as_bad (_("wrong third argument to .cfi_val_encoded_addr"));
1027       ignore_rest_of_line ();
1028       return;
1029     }
1030
1031   demand_empty_rest_of_line ();
1032 }
1033
1034 static void
1035 dot_cfi_label (int ignored ATTRIBUTE_UNUSED)
1036 {
1037   char *name = read_symbol_name ();
1038
1039   if (name == NULL)
1040     return;
1041
1042   /* If the last address was not at the current PC, advance to current.  */
1043   if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now
1044       || S_GET_VALUE (frchain_now->frch_cfi_data->last_address)
1045          != frag_now_fix ())
1046     cfi_add_advance_loc (symbol_temp_new_now ());
1047
1048   cfi_add_label (name);
1049
1050   demand_empty_rest_of_line ();
1051 }
1052
1053 /* By default emit .eh_frame only, not .debug_frame.  */
1054 #define CFI_EMIT_eh_frame       (1 << 0)
1055 #define CFI_EMIT_debug_frame    (1 << 1)
1056 #define CFI_EMIT_target         (1 << 2)
1057 static int cfi_sections = CFI_EMIT_eh_frame;
1058
1059 static void
1060 dot_cfi_sections (int ignored ATTRIBUTE_UNUSED)
1061 {
1062   int sections = 0;
1063
1064   SKIP_WHITESPACE ();
1065   if (is_name_beginner (*input_line_pointer))
1066     while (1)
1067       {
1068         char *name, c;
1069
1070         name = input_line_pointer;
1071         c = get_symbol_end ();
1072
1073         if (strncmp (name, ".eh_frame", sizeof ".eh_frame") == 0
1074             && name[9] != '_')
1075           sections |= CFI_EMIT_eh_frame;
1076         else if (strncmp (name, ".debug_frame", sizeof ".debug_frame") == 0)
1077           sections |= CFI_EMIT_debug_frame;
1078 #ifdef tc_cfi_section_name
1079         else if (strcmp (name, tc_cfi_section_name) == 0)
1080           sections |= CFI_EMIT_target;
1081 #endif
1082         else
1083           {
1084             *input_line_pointer = c;
1085             input_line_pointer = name;
1086             break;
1087           }
1088
1089         *input_line_pointer = c;
1090         SKIP_WHITESPACE ();
1091         if (*input_line_pointer == ',')
1092           {
1093             name = input_line_pointer++;
1094             SKIP_WHITESPACE ();
1095             if (!is_name_beginner (*input_line_pointer))
1096               {
1097                 input_line_pointer = name;
1098                 break;
1099               }
1100           }
1101         else if (is_name_beginner (*input_line_pointer))
1102           break;
1103       }
1104
1105   demand_empty_rest_of_line ();
1106   cfi_sections = sections;
1107 }
1108
1109 static void
1110 dot_cfi_startproc (int ignored ATTRIBUTE_UNUSED)
1111 {
1112   int simple = 0;
1113
1114   if (frchain_now->frch_cfi_data != NULL)
1115     {
1116       as_bad (_("previous CFI entry not closed (missing .cfi_endproc)"));
1117       ignore_rest_of_line ();
1118       return;
1119     }
1120
1121   cfi_new_fde (symbol_temp_new_now ());
1122
1123   SKIP_WHITESPACE ();
1124   if (is_name_beginner (*input_line_pointer))
1125     {
1126       char *name, c;
1127
1128       name = input_line_pointer;
1129       c = get_symbol_end ();
1130
1131       if (strcmp (name, "simple") == 0)
1132         {
1133           simple = 1;
1134           *input_line_pointer = c;
1135         }
1136       else
1137         input_line_pointer = name;
1138     }
1139   demand_empty_rest_of_line ();
1140
1141   frchain_now->frch_cfi_data->cur_cfa_offset = 0;
1142   if (!simple)
1143     tc_cfi_frame_initial_instructions ();
1144
1145   if ((cfi_sections & CFI_EMIT_target) != 0)
1146     tc_cfi_startproc ();
1147 }
1148
1149 static void
1150 dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED)
1151 {
1152   struct fde_entry *fde;
1153
1154   if (frchain_now->frch_cfi_data == NULL)
1155     {
1156       as_bad (_(".cfi_endproc without corresponding .cfi_startproc"));
1157       ignore_rest_of_line ();
1158       return;
1159     }
1160
1161   fde = frchain_now->frch_cfi_data->cur_fde_data;
1162
1163   cfi_end_fde (symbol_temp_new_now ());
1164
1165   demand_empty_rest_of_line ();
1166
1167   if ((cfi_sections & CFI_EMIT_target) != 0)
1168     tc_cfi_endproc (fde);
1169 }
1170
1171 \f
1172 /* Emit a single byte into the current segment.  */
1173
1174 static inline void
1175 out_one (int byte)
1176 {
1177   FRAG_APPEND_1_CHAR (byte);
1178 }
1179
1180 /* Emit a two-byte word into the current segment.  */
1181
1182 static inline void
1183 out_two (int data)
1184 {
1185   md_number_to_chars (frag_more (2), data, 2);
1186 }
1187
1188 /* Emit a four byte word into the current segment.  */
1189
1190 static inline void
1191 out_four (int data)
1192 {
1193   md_number_to_chars (frag_more (4), data, 4);
1194 }
1195
1196 /* Emit an unsigned "little-endian base 128" number.  */
1197
1198 static void
1199 out_uleb128 (addressT value)
1200 {
1201   output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
1202 }
1203
1204 /* Emit an unsigned "little-endian base 128" number.  */
1205
1206 static void
1207 out_sleb128 (offsetT value)
1208 {
1209   output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1);
1210 }
1211
1212 static void
1213 output_cfi_insn (struct cfi_insn_data *insn)
1214 {
1215   offsetT offset;
1216   unsigned int regno;
1217
1218   switch (insn->insn)
1219     {
1220     case DW_CFA_advance_loc:
1221       {
1222         symbolS *from = insn->u.ll.lab1;
1223         symbolS *to = insn->u.ll.lab2;
1224
1225         if (symbol_get_frag (to) == symbol_get_frag (from))
1226           {
1227             addressT delta = S_GET_VALUE (to) - S_GET_VALUE (from);
1228             addressT scaled = delta / DWARF2_LINE_MIN_INSN_LENGTH;
1229
1230             if (scaled <= 0x3F)
1231               out_one (DW_CFA_advance_loc + scaled);
1232             else if (scaled <= 0xFF)
1233               {
1234                 out_one (DW_CFA_advance_loc1);
1235                 out_one (scaled);
1236               }
1237             else if (scaled <= 0xFFFF)
1238               {
1239                 out_one (DW_CFA_advance_loc2);
1240                 out_two (scaled);
1241               }
1242             else
1243               {
1244                 out_one (DW_CFA_advance_loc4);
1245                 out_four (scaled);
1246               }
1247           }
1248         else
1249           {
1250             expressionS exp;
1251
1252             exp.X_op = O_subtract;
1253             exp.X_add_symbol = to;
1254             exp.X_op_symbol = from;
1255             exp.X_add_number = 0;
1256
1257             /* The code in ehopt.c expects that one byte of the encoding
1258                is already allocated to the frag.  This comes from the way
1259                that it scans the .eh_frame section looking first for the
1260                .byte DW_CFA_advance_loc4.  */
1261             *frag_more (1) = DW_CFA_advance_loc4;
1262
1263             frag_var (rs_cfa, 4, 0, DWARF2_LINE_MIN_INSN_LENGTH << 3,
1264                       make_expr_symbol (&exp), frag_now_fix () - 1,
1265                       (char *) frag_now);
1266           }
1267       }
1268       break;
1269
1270     case DW_CFA_def_cfa:
1271       offset = insn->u.ri.offset;
1272       if (offset < 0)
1273         {
1274           out_one (DW_CFA_def_cfa_sf);
1275           out_uleb128 (insn->u.ri.reg);
1276           out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
1277         }
1278       else
1279         {
1280           out_one (DW_CFA_def_cfa);
1281           out_uleb128 (insn->u.ri.reg);
1282           out_uleb128 (offset);
1283         }
1284       break;
1285
1286     case DW_CFA_def_cfa_register:
1287     case DW_CFA_undefined:
1288     case DW_CFA_same_value:
1289       out_one (insn->insn);
1290       out_uleb128 (insn->u.r);
1291       break;
1292
1293     case DW_CFA_def_cfa_offset:
1294       offset = insn->u.i;
1295       if (offset < 0)
1296         {
1297           out_one (DW_CFA_def_cfa_offset_sf);
1298           out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
1299         }
1300       else
1301         {
1302           out_one (DW_CFA_def_cfa_offset);
1303           out_uleb128 (offset);
1304         }
1305       break;
1306
1307     case DW_CFA_restore:
1308       regno = insn->u.r;
1309       if (regno <= 0x3F)
1310         {
1311           out_one (DW_CFA_restore + regno);
1312         }
1313       else
1314         {
1315           out_one (DW_CFA_restore_extended);
1316           out_uleb128 (regno);
1317         }
1318       break;
1319
1320     case DW_CFA_offset:
1321       regno = insn->u.ri.reg;
1322       offset = insn->u.ri.offset / DWARF2_CIE_DATA_ALIGNMENT;
1323       if (offset < 0)
1324         {
1325           out_one (DW_CFA_offset_extended_sf);
1326           out_uleb128 (regno);
1327           out_sleb128 (offset);
1328         }
1329       else if (regno <= 0x3F)
1330         {
1331           out_one (DW_CFA_offset + regno);
1332           out_uleb128 (offset);
1333         }
1334       else
1335         {
1336           out_one (DW_CFA_offset_extended);
1337           out_uleb128 (regno);
1338           out_uleb128 (offset);
1339         }
1340       break;
1341
1342     case DW_CFA_register:
1343       out_one (DW_CFA_register);
1344       out_uleb128 (insn->u.rr.reg1);
1345       out_uleb128 (insn->u.rr.reg2);
1346       break;
1347
1348     case DW_CFA_remember_state:
1349     case DW_CFA_restore_state:
1350       out_one (insn->insn);
1351       break;
1352
1353     case DW_CFA_GNU_window_save:
1354       out_one (DW_CFA_GNU_window_save);
1355       break;
1356
1357     case CFI_escape:
1358       {
1359         struct cfi_escape_data *e;
1360         for (e = insn->u.esc; e ; e = e->next)
1361           emit_expr (&e->exp, 1);
1362         break;
1363       }
1364
1365     case CFI_val_encoded_addr:
1366       {
1367         unsigned encoding = insn->u.ea.encoding;
1368         offsetT encoding_size;
1369
1370         if (encoding == DW_EH_PE_omit)
1371           break;
1372         out_one (DW_CFA_val_expression);
1373         out_uleb128 (insn->u.ea.reg);
1374
1375         switch (encoding & 0x7)
1376           {
1377           case DW_EH_PE_absptr:
1378             encoding_size = DWARF2_ADDR_SIZE (stdoutput);
1379             break;
1380           case DW_EH_PE_udata2:
1381             encoding_size = 2;
1382             break;
1383           case DW_EH_PE_udata4:
1384             encoding_size = 4;
1385             break;
1386           case DW_EH_PE_udata8:
1387             encoding_size = 8;
1388             break;
1389           default:
1390             abort ();
1391           }
1392
1393         /* If the user has requested absolute encoding,
1394            then use the smaller DW_OP_addr encoding.  */
1395         if (insn->u.ea.encoding == DW_EH_PE_absptr)
1396           {
1397             out_uleb128 (1 + encoding_size);
1398             out_one (DW_OP_addr);
1399           }
1400         else
1401           {
1402             out_uleb128 (1 + 1 + encoding_size);
1403             out_one (DW_OP_GNU_encoded_addr);
1404             out_one (encoding);
1405
1406             if ((encoding & 0x70) == DW_EH_PE_pcrel)
1407               {
1408 #if CFI_DIFF_EXPR_OK
1409                 insn->u.ea.exp.X_op = O_subtract;
1410                 insn->u.ea.exp.X_op_symbol = symbol_temp_new_now ();
1411 #elif defined (tc_cfi_emit_pcrel_expr)
1412                 tc_cfi_emit_pcrel_expr (&insn->u.ea.exp, encoding_size);
1413                 break;
1414 #else
1415                 abort ();
1416 #endif
1417               }
1418           }
1419         emit_expr (&insn->u.ea.exp, encoding_size);
1420       }
1421       break;
1422
1423     case CFI_label:
1424       colon (insn->u.sym_name);
1425       break;
1426
1427     default:
1428       abort ();
1429     }
1430 }
1431
1432 static offsetT
1433 encoding_size (unsigned char encoding)
1434 {
1435   if (encoding == DW_EH_PE_omit)
1436     return 0;
1437   switch (encoding & 0x7)
1438     {
1439     case 0:
1440       return bfd_get_arch_size (stdoutput) == 64 ? 8 : 4;
1441     case DW_EH_PE_udata2:
1442       return 2;
1443     case DW_EH_PE_udata4:
1444       return 4;
1445     case DW_EH_PE_udata8:
1446       return 8;
1447     default:
1448       abort ();
1449     }
1450 }
1451
1452 static void
1453 output_cie (struct cie_entry *cie, bfd_boolean eh_frame, int align)
1454 {
1455   symbolS *after_size_address, *end_address;
1456   expressionS exp;
1457   struct cfi_insn_data *i;
1458   offsetT augmentation_size;
1459   int enc;
1460   enum dwarf2_format fmt = DWARF2_FORMAT (now_seg);
1461
1462   cie->start_address = symbol_temp_new_now ();
1463   after_size_address = symbol_temp_make ();
1464   end_address = symbol_temp_make ();
1465
1466   exp.X_op = O_subtract;
1467   exp.X_add_symbol = end_address;
1468   exp.X_op_symbol = after_size_address;
1469   exp.X_add_number = 0;
1470
1471   if (eh_frame || fmt == dwarf2_format_32bit)
1472     emit_expr (&exp, 4);                        /* Length.  */
1473   else
1474     {
1475       if (fmt == dwarf2_format_64bit)
1476         out_four (-1);
1477       emit_expr (&exp, 8);                      /* Length.  */
1478     }
1479   symbol_set_value_now (after_size_address);
1480   if (eh_frame)
1481     out_four (0);                               /* CIE id.  */
1482   else
1483     {
1484       out_four (-1);                            /* CIE id.  */
1485       if (fmt != dwarf2_format_32bit)
1486         out_four (-1);
1487     }
1488   out_one (DW_CIE_VERSION);                     /* Version.  */
1489   if (eh_frame)
1490     {
1491       out_one ('z');                            /* Augmentation.  */
1492       if (cie->per_encoding != DW_EH_PE_omit)
1493         out_one ('P');
1494       if (cie->lsda_encoding != DW_EH_PE_omit)
1495         out_one ('L');
1496       out_one ('R');
1497     }
1498   if (cie->signal_frame)
1499     out_one ('S');
1500   out_one (0);
1501   out_uleb128 (DWARF2_LINE_MIN_INSN_LENGTH);    /* Code alignment.  */
1502   out_sleb128 (DWARF2_CIE_DATA_ALIGNMENT);      /* Data alignment.  */
1503   if (DW_CIE_VERSION == 1)                      /* Return column.  */
1504     out_one (cie->return_column);
1505   else
1506     out_uleb128 (cie->return_column);
1507   if (eh_frame)
1508     {
1509       augmentation_size = 1 + (cie->lsda_encoding != DW_EH_PE_omit);
1510       if (cie->per_encoding != DW_EH_PE_omit)
1511         augmentation_size += 1 + encoding_size (cie->per_encoding);
1512       out_uleb128 (augmentation_size);          /* Augmentation size.  */
1513
1514       if (cie->per_encoding != DW_EH_PE_omit)
1515         {
1516           offsetT size = encoding_size (cie->per_encoding);
1517           out_one (cie->per_encoding);
1518           exp = cie->personality;
1519           if ((cie->per_encoding & 0x70) == DW_EH_PE_pcrel)
1520             {
1521 #if CFI_DIFF_EXPR_OK
1522               exp.X_op = O_subtract;
1523               exp.X_op_symbol = symbol_temp_new_now ();
1524               emit_expr (&exp, size);
1525 #elif defined (tc_cfi_emit_pcrel_expr)
1526               tc_cfi_emit_pcrel_expr (&exp, size);
1527 #else
1528               abort ();
1529 #endif
1530             }
1531           else
1532             emit_expr (&exp, size);
1533         }
1534
1535       if (cie->lsda_encoding != DW_EH_PE_omit)
1536         out_one (cie->lsda_encoding);
1537     }
1538
1539   switch (DWARF2_FDE_RELOC_SIZE)
1540     {
1541     case 2:
1542       enc = DW_EH_PE_sdata2;
1543       break;
1544     case 4:
1545       enc = DW_EH_PE_sdata4;
1546       break;
1547     case 8:
1548       enc = DW_EH_PE_sdata8;
1549       break;
1550     default:
1551       abort ();
1552     }
1553 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
1554   enc |= DW_EH_PE_pcrel;
1555 #endif
1556   if (eh_frame)
1557     out_one (enc);
1558
1559   if (cie->first)
1560     {
1561       for (i = cie->first; i != cie->last; i = i->next)
1562         {
1563           if (CUR_SEG (i) != CUR_SEG (cie))
1564             continue;
1565           output_cfi_insn (i);
1566         }
1567     }
1568
1569   frag_align (align, DW_CFA_nop, 0);
1570   symbol_set_value_now (end_address);
1571 }
1572
1573 static void
1574 output_fde (struct fde_entry *fde, struct cie_entry *cie,
1575             bfd_boolean eh_frame, struct cfi_insn_data *first,
1576             int align)
1577 {
1578   symbolS *after_size_address, *end_address;
1579   expressionS exp;
1580   offsetT augmentation_size;
1581   enum dwarf2_format fmt = DWARF2_FORMAT (now_seg);
1582   int offset_size;
1583   int addr_size;
1584
1585   after_size_address = symbol_temp_make ();
1586   end_address = symbol_temp_make ();
1587
1588   exp.X_op = O_subtract;
1589   exp.X_add_symbol = end_address;
1590   exp.X_op_symbol = after_size_address;
1591   exp.X_add_number = 0;
1592   if (eh_frame || fmt == dwarf2_format_32bit)
1593     offset_size = 4;
1594   else
1595     {
1596       if (fmt == dwarf2_format_64bit)
1597         out_four (-1);
1598       offset_size = 8;
1599     }
1600   emit_expr (&exp, offset_size);                /* Length.  */
1601   symbol_set_value_now (after_size_address);
1602
1603   if (eh_frame)
1604     {
1605       exp.X_op = O_subtract;
1606       exp.X_add_symbol = after_size_address;
1607       exp.X_op_symbol = cie->start_address;
1608       exp.X_add_number = 0;
1609       emit_expr (&exp, offset_size);            /* CIE offset.  */
1610     }
1611   else
1612     {
1613       TC_DWARF2_EMIT_OFFSET (cie->start_address, offset_size);
1614     }
1615
1616   if (eh_frame)
1617     {
1618       exp.X_op = O_subtract;
1619       exp.X_add_number = 0;
1620 #if CFI_DIFF_EXPR_OK
1621       exp.X_add_symbol = fde->start_address;
1622       exp.X_op_symbol = symbol_temp_new_now ();
1623       emit_expr (&exp, DWARF2_FDE_RELOC_SIZE);  /* Code offset.  */
1624 #else
1625       exp.X_op = O_symbol;
1626       exp.X_add_symbol = fde->start_address;
1627 #ifdef tc_cfi_emit_pcrel_expr
1628       tc_cfi_emit_pcrel_expr (&exp, DWARF2_FDE_RELOC_SIZE);      /* Code offset.  */
1629 #else
1630       emit_expr (&exp, DWARF2_FDE_RELOC_SIZE);  /* Code offset.  */
1631 #endif
1632 #endif
1633       addr_size = DWARF2_FDE_RELOC_SIZE;
1634     }
1635   else
1636     {
1637       exp.X_op = O_symbol;
1638       exp.X_add_symbol = fde->start_address;
1639       exp.X_add_number = 0;
1640       addr_size = DWARF2_ADDR_SIZE (stdoutput);
1641       emit_expr (&exp, addr_size);
1642     }
1643
1644   exp.X_op = O_subtract;
1645   exp.X_add_symbol = fde->end_address;
1646   exp.X_op_symbol = fde->start_address;         /* Code length.  */
1647   exp.X_add_number = 0;
1648   emit_expr (&exp, addr_size);
1649
1650   augmentation_size = encoding_size (fde->lsda_encoding);
1651   if (eh_frame)
1652     out_uleb128 (augmentation_size);            /* Augmentation size.  */
1653
1654   if (fde->lsda_encoding != DW_EH_PE_omit)
1655     {
1656       exp = fde->lsda;
1657       if ((fde->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
1658         {
1659 #if CFI_DIFF_LSDA_OK
1660           exp.X_op = O_subtract;
1661           exp.X_op_symbol = symbol_temp_new_now ();
1662           emit_expr (&exp, augmentation_size);
1663 #elif defined (tc_cfi_emit_pcrel_expr)
1664           tc_cfi_emit_pcrel_expr (&exp, augmentation_size);
1665 #else
1666           abort ();
1667 #endif
1668         }
1669       else
1670         emit_expr (&exp, augmentation_size);
1671     }
1672
1673   for (; first; first = first->next)
1674     if (CUR_SEG (first) == CUR_SEG (fde))
1675       output_cfi_insn (first);
1676
1677   frag_align (align, DW_CFA_nop, 0);
1678   symbol_set_value_now (end_address);
1679 }
1680
1681 static struct cie_entry *
1682 select_cie_for_fde (struct fde_entry *fde, bfd_boolean eh_frame,
1683                     struct cfi_insn_data **pfirst, int align)
1684 {
1685   struct cfi_insn_data *i, *j;
1686   struct cie_entry *cie;
1687
1688   for (cie = cie_root; cie; cie = cie->next)
1689     {
1690       if (CUR_SEG (cie) != CUR_SEG (fde))
1691         continue;
1692       if (cie->return_column != fde->return_column
1693           || cie->signal_frame != fde->signal_frame
1694           || cie->per_encoding != fde->per_encoding
1695           || cie->lsda_encoding != fde->lsda_encoding)
1696         continue;
1697       if (cie->per_encoding != DW_EH_PE_omit)
1698         {
1699           if (cie->personality.X_op != fde->personality.X_op
1700               || cie->personality.X_add_number
1701                  != fde->personality.X_add_number)
1702             continue;
1703           switch (cie->personality.X_op)
1704             {
1705             case O_constant:
1706               if (cie->personality.X_unsigned != fde->personality.X_unsigned)
1707                 continue;
1708               break;
1709             case O_symbol:
1710               if (cie->personality.X_add_symbol
1711                   != fde->personality.X_add_symbol)
1712                 continue;
1713               break;
1714             default:
1715               abort ();
1716             }
1717         }
1718       for (i = cie->first, j = fde->data;
1719            i != cie->last && j != NULL;
1720            i = i->next, j = j->next)
1721         {
1722           if (i->insn != j->insn)
1723             goto fail;
1724           switch (i->insn)
1725             {
1726             case DW_CFA_advance_loc:
1727             case DW_CFA_remember_state:
1728               /* We reached the first advance/remember in the FDE,
1729                  but did not reach the end of the CIE list.  */
1730               goto fail;
1731
1732             case DW_CFA_offset:
1733             case DW_CFA_def_cfa:
1734               if (i->u.ri.reg != j->u.ri.reg)
1735                 goto fail;
1736               if (i->u.ri.offset != j->u.ri.offset)
1737                 goto fail;
1738               break;
1739
1740             case DW_CFA_register:
1741               if (i->u.rr.reg1 != j->u.rr.reg1)
1742                 goto fail;
1743               if (i->u.rr.reg2 != j->u.rr.reg2)
1744                 goto fail;
1745               break;
1746
1747             case DW_CFA_def_cfa_register:
1748             case DW_CFA_restore:
1749             case DW_CFA_undefined:
1750             case DW_CFA_same_value:
1751               if (i->u.r != j->u.r)
1752                 goto fail;
1753               break;
1754
1755             case DW_CFA_def_cfa_offset:
1756               if (i->u.i != j->u.i)
1757                 goto fail;
1758               break;
1759
1760             case CFI_escape:
1761             case CFI_val_encoded_addr:
1762             case CFI_label:
1763               /* Don't bother matching these for now.  */
1764               goto fail;
1765
1766             default:
1767               abort ();
1768             }
1769         }
1770
1771       /* Success if we reached the end of the CIE list, and we've either
1772          run out of FDE entries or we've encountered an advance,
1773          remember, or escape.  */
1774       if (i == cie->last
1775           && (!j
1776               || j->insn == DW_CFA_advance_loc
1777               || j->insn == DW_CFA_remember_state
1778               || j->insn == CFI_escape
1779               || j->insn == CFI_val_encoded_addr
1780               || j->insn == CFI_label))
1781         {
1782           *pfirst = j;
1783           return cie;
1784         }
1785
1786     fail:;
1787     }
1788
1789   cie = (struct cie_entry *) xmalloc (sizeof (struct cie_entry));
1790   cie->next = cie_root;
1791   cie_root = cie;
1792   SET_CUR_SEG (cie, CUR_SEG (fde));
1793   cie->return_column = fde->return_column;
1794   cie->signal_frame = fde->signal_frame;
1795   cie->per_encoding = fde->per_encoding;
1796   cie->lsda_encoding = fde->lsda_encoding;
1797   cie->personality = fde->personality;
1798   cie->first = fde->data;
1799
1800   for (i = cie->first; i ; i = i->next)
1801     if (i->insn == DW_CFA_advance_loc
1802         || i->insn == DW_CFA_remember_state
1803         || i->insn == CFI_escape
1804         || i->insn == CFI_val_encoded_addr
1805         || i->insn == CFI_label)
1806       break;
1807
1808   cie->last = i;
1809   *pfirst = i;
1810
1811   output_cie (cie, eh_frame, align);
1812
1813   return cie;
1814 }
1815
1816 #ifdef md_reg_eh_frame_to_debug_frame
1817 static void
1818 cfi_change_reg_numbers (struct cfi_insn_data *insn, segT ccseg)
1819 {
1820   for (; insn; insn = insn->next)
1821     {
1822       if (CUR_SEG (insn) != ccseg)
1823         continue;
1824       switch (insn->insn)
1825         {
1826         case DW_CFA_advance_loc:
1827         case DW_CFA_def_cfa_offset:
1828         case DW_CFA_remember_state:
1829         case DW_CFA_restore_state:
1830         case DW_CFA_GNU_window_save:
1831         case CFI_escape:
1832         case CFI_label:
1833           break;
1834
1835         case DW_CFA_def_cfa:
1836         case DW_CFA_offset:
1837           insn->u.ri.reg = md_reg_eh_frame_to_debug_frame (insn->u.ri.reg);
1838           break;
1839
1840         case DW_CFA_def_cfa_register:
1841         case DW_CFA_undefined:
1842         case DW_CFA_same_value:
1843         case DW_CFA_restore:
1844           insn->u.r = md_reg_eh_frame_to_debug_frame (insn->u.r);
1845           break;
1846
1847         case DW_CFA_register:
1848           insn->u.rr.reg1 = md_reg_eh_frame_to_debug_frame (insn->u.rr.reg1);
1849           insn->u.rr.reg2 = md_reg_eh_frame_to_debug_frame (insn->u.rr.reg2);
1850           break;
1851
1852         case CFI_val_encoded_addr:
1853           insn->u.ea.reg = md_reg_eh_frame_to_debug_frame (insn->u.ea.reg);
1854           break;
1855
1856         default:
1857           abort ();
1858         }
1859     }
1860 }
1861 #else
1862 #define cfi_change_reg_numbers(insn, cseg) do { } while (0)
1863 #endif
1864
1865 static segT
1866 get_cfi_seg (segT cseg, const char *base, flagword flags, int align)
1867 {
1868   if (SUPPORT_FRAME_LINKONCE)
1869     {
1870       struct dwcfi_seg_list *l;
1871
1872       l = dwcfi_hash_find_or_make (cseg, base, flags);
1873
1874       cseg = l->seg;
1875       subseg_set (cseg, l->subseg);
1876     }
1877   else
1878     {
1879       cseg = subseg_new (base, 0);
1880       bfd_set_section_flags (stdoutput, cseg, flags);
1881     }
1882   record_alignment (cseg, align);
1883   return cseg;
1884 }
1885
1886 void
1887 cfi_finish (void)
1888 {
1889   struct cie_entry *cie, *cie_next;
1890   segT cfi_seg, ccseg;
1891   struct fde_entry *fde;
1892   struct cfi_insn_data *first;
1893   int save_flag_traditional_format, seek_next_seg;
1894
1895   if (all_fde_data == 0)
1896     return;
1897
1898   if ((cfi_sections & CFI_EMIT_eh_frame) != 0)
1899     {
1900       /* Make sure check_eh_frame doesn't do anything with our output.  */
1901       save_flag_traditional_format = flag_traditional_format;
1902       flag_traditional_format = 1;
1903
1904       if (!SUPPORT_FRAME_LINKONCE)
1905         {
1906           /* Open .eh_frame section.  */
1907           cfi_seg = get_cfi_seg (NULL, ".eh_frame",
1908                                  (SEC_ALLOC | SEC_LOAD | SEC_DATA
1909                                   | DWARF2_EH_FRAME_READ_ONLY),
1910                                  EH_FRAME_ALIGNMENT);
1911 #ifdef md_fix_up_eh_frame
1912           md_fix_up_eh_frame (cfi_seg);
1913 #else
1914           (void) cfi_seg;
1915 #endif
1916         }
1917
1918       do
1919         {
1920           ccseg = NULL;
1921           seek_next_seg = 0;
1922
1923           for (cie = cie_root; cie; cie = cie_next)
1924             {
1925               cie_next = cie->next;
1926               free ((void *) cie);
1927             }
1928           cie_root = NULL;
1929
1930           for (fde = all_fde_data; fde ; fde = fde->next)
1931             {
1932               if (SUPPORT_FRAME_LINKONCE)
1933                 {
1934                   if (HANDLED (fde))
1935                     continue;
1936                   if (seek_next_seg && CUR_SEG (fde) != ccseg)
1937                     {
1938                       seek_next_seg = 2;
1939                       continue;
1940                     }
1941                   if (!seek_next_seg)
1942                     {
1943                       ccseg = CUR_SEG (fde);
1944                       /* Open .eh_frame section.  */
1945                       cfi_seg = get_cfi_seg (ccseg, ".eh_frame",
1946                                              (SEC_ALLOC | SEC_LOAD | SEC_DATA
1947                                               | DWARF2_EH_FRAME_READ_ONLY),
1948                                              EH_FRAME_ALIGNMENT);
1949 #ifdef md_fix_up_eh_frame
1950                       md_fix_up_eh_frame (cfi_seg);
1951 #else
1952                       (void) cfi_seg;
1953 #endif
1954                       seek_next_seg = 1;
1955                     }
1956                   SET_HANDLED (fde, 1);
1957                 }
1958
1959               if (fde->end_address == NULL)
1960                 {
1961                   as_bad (_("open CFI at the end of file; missing .cfi_endproc directive"));
1962                   fde->end_address = fde->start_address;
1963                 }
1964
1965               cie = select_cie_for_fde (fde, TRUE, &first, 2);
1966               output_fde (fde, cie, TRUE, first,
1967                           fde->next == NULL ? EH_FRAME_ALIGNMENT : 2);
1968             }
1969         }
1970       while (SUPPORT_FRAME_LINKONCE && seek_next_seg == 2);
1971
1972       if (SUPPORT_FRAME_LINKONCE)
1973         for (fde = all_fde_data; fde ; fde = fde->next)
1974           SET_HANDLED (fde, 0);
1975
1976       flag_traditional_format = save_flag_traditional_format;
1977     }
1978
1979   if ((cfi_sections & CFI_EMIT_debug_frame) != 0)
1980     {
1981       int alignment = ffs (DWARF2_ADDR_SIZE (stdoutput)) - 1;
1982
1983       if (!SUPPORT_FRAME_LINKONCE)
1984         get_cfi_seg (NULL, ".debug_frame",
1985                      SEC_READONLY | SEC_DEBUGGING,
1986                      alignment);
1987
1988       do
1989         {
1990           ccseg = NULL;
1991           seek_next_seg = 0;
1992
1993           for (cie = cie_root; cie; cie = cie_next)
1994             {
1995               cie_next = cie->next;
1996               free ((void *) cie);
1997             }
1998           cie_root = NULL;
1999
2000           for (fde = all_fde_data; fde ; fde = fde->next)
2001             {
2002               if (SUPPORT_FRAME_LINKONCE)
2003                 {
2004                   if (HANDLED (fde))
2005                     continue;
2006                   if (seek_next_seg && CUR_SEG (fde) != ccseg)
2007                     {
2008                       seek_next_seg = 2;
2009                       continue;
2010                     }
2011                   if (!seek_next_seg)
2012                     {
2013                       ccseg = CUR_SEG (fde);
2014                       /* Open .debug_frame section.  */
2015                       get_cfi_seg (ccseg, ".debug_frame",
2016                                    SEC_READONLY | SEC_DEBUGGING,
2017                                    alignment);
2018                       seek_next_seg = 1;
2019                     }
2020                   SET_HANDLED (fde, 1);
2021                 }
2022               if (fde->end_address == NULL)
2023                 {
2024                   as_bad (_("open CFI at the end of file; missing .cfi_endproc directive"));
2025                   fde->end_address = fde->start_address;
2026                 }
2027
2028               fde->per_encoding = DW_EH_PE_omit;
2029               fde->lsda_encoding = DW_EH_PE_omit;
2030               cfi_change_reg_numbers (fde->data, ccseg);
2031               cie = select_cie_for_fde (fde, FALSE, &first, alignment);
2032               output_fde (fde, cie, FALSE, first, alignment);
2033             }
2034         }
2035       while (SUPPORT_FRAME_LINKONCE && seek_next_seg == 2);
2036
2037       if (SUPPORT_FRAME_LINKONCE)
2038         for (fde = all_fde_data; fde ; fde = fde->next)
2039           SET_HANDLED (fde, 0);
2040     }
2041 }
2042
2043 #else /* TARGET_USE_CFIPOP */
2044
2045 /* Emit an intelligible error message for missing support.  */
2046
2047 static void
2048 dot_cfi_dummy (int ignored ATTRIBUTE_UNUSED)
2049 {
2050   as_bad (_("CFI is not supported for this target"));
2051   ignore_rest_of_line ();
2052 }
2053
2054 const pseudo_typeS cfi_pseudo_table[] =
2055   {
2056     { "cfi_sections", dot_cfi_dummy, 0 },
2057     { "cfi_startproc", dot_cfi_dummy, 0 },
2058     { "cfi_endproc", dot_cfi_dummy, 0 },
2059     { "cfi_def_cfa", dot_cfi_dummy, 0 },
2060     { "cfi_def_cfa_register", dot_cfi_dummy, 0 },
2061     { "cfi_def_cfa_offset", dot_cfi_dummy, 0 },
2062     { "cfi_adjust_cfa_offset", dot_cfi_dummy, 0 },
2063     { "cfi_offset", dot_cfi_dummy, 0 },
2064     { "cfi_rel_offset", dot_cfi_dummy, 0 },
2065     { "cfi_register", dot_cfi_dummy, 0 },
2066     { "cfi_return_column", dot_cfi_dummy, 0 },
2067     { "cfi_restore", dot_cfi_dummy, 0 },
2068     { "cfi_undefined", dot_cfi_dummy, 0 },
2069     { "cfi_same_value", dot_cfi_dummy, 0 },
2070     { "cfi_remember_state", dot_cfi_dummy, 0 },
2071     { "cfi_restore_state", dot_cfi_dummy, 0 },
2072     { "cfi_window_save", dot_cfi_dummy, 0 },
2073     { "cfi_escape", dot_cfi_dummy, 0 },
2074     { "cfi_signal_frame", dot_cfi_dummy, 0 },
2075     { "cfi_personality", dot_cfi_dummy, 0 },
2076     { "cfi_lsda", dot_cfi_dummy, 0 },
2077     { "cfi_val_encoded_addr", dot_cfi_dummy, 0 },
2078     { "cfi_label", dot_cfi_dummy, 0 },
2079     { NULL, NULL, 0 }
2080   };
2081
2082 void
2083 cfi_finish (void)
2084 {
2085 }
2086 #endif /* TARGET_USE_CFIPOP */