gas/dw2gencfi.c

   1 /* dw2gencfi.c - Support for generating Dwarf2 CFI information.
   2    Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   3    Free Software Foundation, Inc.
   4    Contributed by Michal Ludvig <mludvig@suse.cz>
   5
   6    This file is part of GAS, the GNU Assembler.
   7
   8    GAS is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3, or (at your option)
  11    any later version.
  12
  13    GAS is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with GAS; see the file COPYING.  If not, write to the Free
  20    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
  21    02110-1301, USA.  */
  22
  23 #include "as.h"
  24 #include "dw2gencfi.h"
  25 #include "subsegs.h"
  26 #include "dwarf2dbg.h"
  27
  28 #ifdef TARGET_USE_CFIPOP
  29
  30 /* By default, use difference expressions if DIFF_EXPR_OK is defined.  */
  31 #ifndef CFI_DIFF_EXPR_OK
  32 # ifdef DIFF_EXPR_OK
  33 #  define CFI_DIFF_EXPR_OK 1
  34 # else
  35 #  define CFI_DIFF_EXPR_OK 0
  36 # endif
  37 #endif
  38
  39 #ifndef CFI_DIFF_LSDA_OK
  40 # define CFI_DIFF_LSDA_OK CFI_DIFF_EXPR_OK
  41 #endif
  42
  43 #if CFI_DIFF_EXPR_OK == 1 && CFI_DIFF_LSDA_OK == 0
  44 # error "CFI_DIFF_EXPR_OK should imply CFI_DIFF_LSDA_OK"
  45 #endif
  46
  47 /* We re-use DWARF2_LINE_MIN_INSN_LENGTH for the code alignment field
  48    of the CIE.  Default to 1 if not otherwise specified.  */
  49 #ifndef  DWARF2_LINE_MIN_INSN_LENGTH
  50 # define DWARF2_LINE_MIN_INSN_LENGTH 1
  51 #endif
  52
  53 /* By default, use 32-bit relocations from .eh_frame into .text.  */
  54 #ifndef DWARF2_FDE_RELOC_SIZE
  55 # define DWARF2_FDE_RELOC_SIZE 4
  56 #endif
  57
  58 /* By default, use a read-only .eh_frame section.  */
  59 #ifndef DWARF2_EH_FRAME_READ_ONLY
  60 # define DWARF2_EH_FRAME_READ_ONLY SEC_READONLY
  61 #endif
  62
  63 #ifndef EH_FRAME_ALIGNMENT
  64 # define EH_FRAME_ALIGNMENT (bfd_get_arch_size (stdoutput) == 64 ? 3 : 2)
  65 #endif
  66
  67 #ifndef tc_cfi_frame_initial_instructions
  68 # define tc_cfi_frame_initial_instructions() ((void)0)
  69 #endif
  70
  71 #ifndef DWARF2_FORMAT
  72 # define DWARF2_FORMAT(SEC) dwarf2_format_32bit
  73 #endif
  74
  75 #ifndef DWARF2_ADDR_SIZE
  76 # define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
  77 #endif
  78
  79 struct cfi_escape_data {
  80   struct cfi_escape_data *next;
  81   expressionS exp;
  82 };
  83
  84 struct cfi_insn_data
  85 {
  86   struct cfi_insn_data *next;
  87   int insn;
  88   union {
  89     struct {
  90       unsigned reg;
  91       offsetT offset;
  92     } ri;
  93
  94     struct {
  95       unsigned reg1;
  96       unsigned reg2;
  97     } rr;
  98
  99     unsigned r;
 100     offsetT i;
 101
 102     struct {
 103       symbolS *lab1;
 104       symbolS *lab2;
 105     } ll;
 106
 107     struct cfi_escape_data *esc;
 108
 109     struct {
 110       unsigned reg, encoding;
 111       expressionS exp;
 112     } ea;
 113   } u;
 114 };
 115
 116 struct fde_entry
 117 {
 118   struct fde_entry *next;
 119   symbolS *start_address;
 120   symbolS *end_address;
 121   struct cfi_insn_data *data;
 122   struct cfi_insn_data **last;
 123   unsigned char per_encoding;
 124   unsigned char lsda_encoding;
 125   expressionS personality;
 126   expressionS lsda;
 127   unsigned int return_column;
 128   unsigned int signal_frame;
 129 };
 130
 131 struct cie_entry
 132 {
 133   struct cie_entry *next;
 134   symbolS *start_address;
 135   unsigned int return_column;
 136   unsigned int signal_frame;
 137   unsigned char per_encoding;
 138   unsigned char lsda_encoding;
 139   expressionS personality;
 140   struct cfi_insn_data *first, *last;
 141 };
 142
 143
 144 /* List of FDE entries.  */
 145 static struct fde_entry *all_fde_data;
 146 static struct fde_entry **last_fde_data = &all_fde_data;
 147
 148 /* List of CIEs so that they could be reused.  */
 149 static struct cie_entry *cie_root;
 150
 151 /* Stack of old CFI data, for save/restore.  */
 152 struct cfa_save_data
 153 {
 154   struct cfa_save_data *next;
 155   offsetT cfa_offset;
 156 };
 157
 158 /* Current open FDE entry.  */
 159 struct frch_cfi_data
 160 {
 161   struct fde_entry *cur_fde_data;
 162   symbolS *last_address;
 163   offsetT cur_cfa_offset;
 164   struct cfa_save_data *cfa_save_stack;
 165 };
 166 \f
 167 /* Construct a new FDE structure and add it to the end of the fde list.  */
 168
 169 static struct fde_entry *
 170 alloc_fde_entry (void)
 171 {
 172   struct fde_entry *fde = (struct fde_entry *)
 173       xcalloc (1, sizeof (struct fde_entry));
 174
 175   frchain_now->frch_cfi_data = (struct frch_cfi_data *)
 176       xcalloc (1, sizeof (struct frch_cfi_data));
 177   frchain_now->frch_cfi_data->cur_fde_data = fde;
 178   *last_fde_data = fde;
 179   last_fde_data = &fde->next;
 180
 181   fde->last = &fde->data;
 182   fde->return_column = DWARF2_DEFAULT_RETURN_COLUMN;
 183   fde->per_encoding = DW_EH_PE_omit;
 184   fde->lsda_encoding = DW_EH_PE_omit;
 185
 186   return fde;
 187 }
 188
 189 /* The following functions are available for a backend to construct its
 190    own unwind information, usually from legacy unwind directives.  */
 191
 192 /* Construct a new INSN structure and add it to the end of the insn list
 193    for the currently active FDE.  */
 194
 195 static struct cfi_insn_data *
 196 alloc_cfi_insn_data (void)
 197 {
 198   struct cfi_insn_data *insn = (struct cfi_insn_data *)
 199       xcalloc (1, sizeof (struct cfi_insn_data));
 200   struct fde_entry *cur_fde_data = frchain_now->frch_cfi_data->cur_fde_data;
 201
 202   *cur_fde_data->last = insn;
 203   cur_fde_data->last = &insn->next;
 204
 205   return insn;
 206 }
 207
 208 /* Construct a new FDE structure that begins at LABEL.  */
 209
 210 void
 211 cfi_new_fde (symbolS *label)
 212 {
 213   struct fde_entry *fde = alloc_fde_entry ();
 214   fde->start_address = label;
 215   frchain_now->frch_cfi_data->last_address = label;
 216 }
 217
 218 /* End the currently open FDE.  */
 219
 220 void
 221 cfi_end_fde (symbolS *label)
 222 {
 223   frchain_now->frch_cfi_data->cur_fde_data->end_address = label;
 224   free (frchain_now->frch_cfi_data);
 225   frchain_now->frch_cfi_data = NULL;
 226 }
 227
 228 /* Set the return column for the current FDE.  */
 229
 230 void
 231 cfi_set_return_column (unsigned regno)
 232 {
 233   frchain_now->frch_cfi_data->cur_fde_data->return_column = regno;
 234 }
 235
 236 /* Universal functions to store new instructions.  */
 237
 238 static void
 239 cfi_add_CFA_insn(int insn)
 240 {
 241   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
 242
 243   insn_ptr->insn = insn;
 244 }
 245
 246 static void
 247 cfi_add_CFA_insn_reg (int insn, unsigned regno)
 248 {
 249   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
 250
 251   insn_ptr->insn = insn;
 252   insn_ptr->u.r = regno;
 253 }
 254
 255 static void
 256 cfi_add_CFA_insn_offset (int insn, offsetT offset)
 257 {
 258   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
 259
 260   insn_ptr->insn = insn;
 261   insn_ptr->u.i = offset;
 262 }
 263
 264 static void
 265 cfi_add_CFA_insn_reg_reg (int insn, unsigned reg1, unsigned reg2)
 266 {
 267   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
 268
 269   insn_ptr->insn = insn;
 270   insn_ptr->u.rr.reg1 = reg1;
 271   insn_ptr->u.rr.reg2 = reg2;
 272 }
 273
 274 static void
 275 cfi_add_CFA_insn_reg_offset (int insn, unsigned regno, offsetT offset)
 276 {
 277   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
 278
 279   insn_ptr->insn = insn;
 280   insn_ptr->u.ri.reg = regno;
 281   insn_ptr->u.ri.offset = offset;
 282 }
 283
 284 /* Add a CFI insn to advance the PC from the last address to LABEL.  */
 285
 286 void
 287 cfi_add_advance_loc (symbolS *label)
 288 {
 289   struct cfi_insn_data *insn = alloc_cfi_insn_data ();
 290
 291   insn->insn = DW_CFA_advance_loc;
 292   insn->u.ll.lab1 = frchain_now->frch_cfi_data->last_address;
 293   insn->u.ll.lab2 = label;
 294
 295   frchain_now->frch_cfi_data->last_address = label;
 296 }
 297
 298 /* Add a DW_CFA_offset record to the CFI data.  */
 299
 300 void
 301 cfi_add_CFA_offset (unsigned regno, offsetT offset)
 302 {
 303   unsigned int abs_data_align;
 304
 305   gas_assert (DWARF2_CIE_DATA_ALIGNMENT != 0);
 306   cfi_add_CFA_insn_reg_offset (DW_CFA_offset, regno, offset);
 307
 308   abs_data_align = (DWARF2_CIE_DATA_ALIGNMENT < 0
 309                     ? -DWARF2_CIE_DATA_ALIGNMENT : DWARF2_CIE_DATA_ALIGNMENT);
 310   if (offset % abs_data_align)
 311     as_bad (_("register save offset not a multiple of %u"), abs_data_align);
 312 }
 313
 314 /* Add a DW_CFA_def_cfa record to the CFI data.  */
 315
 316 void
 317 cfi_add_CFA_def_cfa (unsigned regno, offsetT offset)
 318 {
 319   cfi_add_CFA_insn_reg_offset (DW_CFA_def_cfa, regno, offset);
 320   frchain_now->frch_cfi_data->cur_cfa_offset = offset;
 321 }
 322
 323 /* Add a DW_CFA_register record to the CFI data.  */
 324
 325 void
 326 cfi_add_CFA_register (unsigned reg1, unsigned reg2)
 327 {
 328   cfi_add_CFA_insn_reg_reg (DW_CFA_register, reg1, reg2);
 329 }
 330
 331 /* Add a DW_CFA_def_cfa_register record to the CFI data.  */
 332
 333 void
 334 cfi_add_CFA_def_cfa_register (unsigned regno)
 335 {
 336   cfi_add_CFA_insn_reg (DW_CFA_def_cfa_register, regno);
 337 }
 338
 339 /* Add a DW_CFA_def_cfa_offset record to the CFI data.  */
 340
 341 void
 342 cfi_add_CFA_def_cfa_offset (offsetT offset)
 343 {
 344   cfi_add_CFA_insn_offset (DW_CFA_def_cfa_offset, offset);
 345   frchain_now->frch_cfi_data->cur_cfa_offset = offset;
 346 }
 347
 348 void
 349 cfi_add_CFA_restore (unsigned regno)
 350 {
 351   cfi_add_CFA_insn_reg (DW_CFA_restore, regno);
 352 }
 353
 354 void
 355 cfi_add_CFA_undefined (unsigned regno)
 356 {
 357   cfi_add_CFA_insn_reg (DW_CFA_undefined, regno);
 358 }
 359
 360 void
 361 cfi_add_CFA_same_value (unsigned regno)
 362 {
 363   cfi_add_CFA_insn_reg (DW_CFA_same_value, regno);
 364 }
 365
 366 void
 367 cfi_add_CFA_remember_state (void)
 368 {
 369   struct cfa_save_data *p;
 370
 371   cfi_add_CFA_insn (DW_CFA_remember_state);
 372
 373   p = (struct cfa_save_data *) xmalloc (sizeof (*p));
 374   p->cfa_offset = frchain_now->frch_cfi_data->cur_cfa_offset;
 375   p->next = frchain_now->frch_cfi_data->cfa_save_stack;
 376   frchain_now->frch_cfi_data->cfa_save_stack = p;
 377 }
 378
 379 void
 380 cfi_add_CFA_restore_state (void)
 381 {
 382   struct cfa_save_data *p;
 383
 384   cfi_add_CFA_insn (DW_CFA_restore_state);
 385
 386   p = frchain_now->frch_cfi_data->cfa_save_stack;
 387   if (p)
 388     {
 389       frchain_now->frch_cfi_data->cur_cfa_offset = p->cfa_offset;
 390       frchain_now->frch_cfi_data->cfa_save_stack = p->next;
 391       free (p);
 392     }
 393   else
 394     as_bad (_("CFI state restore without previous remember"));
 395 }
 396
 397 \f
 398 /* Parse CFI assembler directives.  */
 399
 400 static void dot_cfi (int);
 401 static void dot_cfi_escape (int);
 402 static void dot_cfi_sections (int);
 403 static void dot_cfi_startproc (int);
 404 static void dot_cfi_endproc (int);
 405 static void dot_cfi_personality (int);
 406 static void dot_cfi_lsda (int);
 407 static void dot_cfi_val_encoded_addr (int);
 408
 409 /* Fake CFI type; outside the byte range of any real CFI insn.  */
 410 #define CFI_adjust_cfa_offset   0x100
 411 #define CFI_return_column       0x101
 412 #define CFI_rel_offset          0x102
 413 #define CFI_escape              0x103
 414 #define CFI_signal_frame        0x104
 415 #define CFI_val_encoded_addr    0x105
 416
 417 const pseudo_typeS cfi_pseudo_table[] =
 418   {
 419     { "cfi_sections", dot_cfi_sections, 0 },
 420     { "cfi_startproc", dot_cfi_startproc, 0 },
 421     { "cfi_endproc", dot_cfi_endproc, 0 },
 422     { "cfi_def_cfa", dot_cfi, DW_CFA_def_cfa },
 423     { "cfi_def_cfa_register", dot_cfi, DW_CFA_def_cfa_register },
 424     { "cfi_def_cfa_offset", dot_cfi, DW_CFA_def_cfa_offset },
 425     { "cfi_adjust_cfa_offset", dot_cfi, CFI_adjust_cfa_offset },
 426     { "cfi_offset", dot_cfi, DW_CFA_offset },
 427     { "cfi_rel_offset", dot_cfi, CFI_rel_offset },
 428     { "cfi_register", dot_cfi, DW_CFA_register },
 429     { "cfi_return_column", dot_cfi, CFI_return_column },
 430     { "cfi_restore", dot_cfi, DW_CFA_restore },
 431     { "cfi_undefined", dot_cfi, DW_CFA_undefined },
 432     { "cfi_same_value", dot_cfi, DW_CFA_same_value },
 433     { "cfi_remember_state", dot_cfi, DW_CFA_remember_state },
 434     { "cfi_restore_state", dot_cfi, DW_CFA_restore_state },
 435     { "cfi_window_save", dot_cfi, DW_CFA_GNU_window_save },
 436     { "cfi_escape", dot_cfi_escape, 0 },
 437     { "cfi_signal_frame", dot_cfi, CFI_signal_frame },
 438     { "cfi_personality", dot_cfi_personality, 0 },
 439     { "cfi_lsda", dot_cfi_lsda, 0 },
 440     { "cfi_val_encoded_addr", dot_cfi_val_encoded_addr, 0 },
 441     { NULL, NULL, 0 }
 442   };
 443
 444 static void
 445 cfi_parse_separator (void)
 446 {
 447   SKIP_WHITESPACE ();
 448   if (*input_line_pointer == ',')
 449     input_line_pointer++;
 450   else
 451     as_bad (_("missing separator"));
 452 }
 453
 454 #ifndef tc_parse_to_dw2regnum
 455 static void
 456 tc_parse_to_dw2regnum(expressionS *exp)
 457 {
 458 # ifdef tc_regname_to_dw2regnum
 459   SKIP_WHITESPACE ();
 460   if (is_name_beginner (*input_line_pointer)
 461       || (*input_line_pointer == '%'
 462           && is_name_beginner (*++input_line_pointer)))
 463     {
 464       char *name, c;
 465
 466       name = input_line_pointer;
 467       c = get_symbol_end ();
 468
 469       exp->X_op = O_constant;
 470       exp->X_add_number = tc_regname_to_dw2regnum (name);
 471
 472       *input_line_pointer = c;
 473     }
 474   else
 475 # endif
 476     expression_and_evaluate (exp);
 477 }
 478 #endif
 479
 480 static unsigned
 481 cfi_parse_reg (void)
 482 {
 483   int regno;
 484   expressionS exp;
 485
 486   tc_parse_to_dw2regnum (&exp);
 487   switch (exp.X_op)
 488     {
 489     case O_register:
 490     case O_constant:
 491       regno = exp.X_add_number;
 492       break;
 493
 494     default:
 495       regno = -1;
 496       break;
 497     }
 498
 499   if (regno < 0)
 500     {
 501       as_bad (_("bad register expression"));
 502       regno = 0;
 503     }
 504
 505   return regno;
 506 }
 507
 508 static offsetT
 509 cfi_parse_const (void)
 510 {
 511   return get_absolute_expression ();
 512 }
 513
 514 static void
 515 dot_cfi (int arg)
 516 {
 517   offsetT offset;
 518   unsigned reg1, reg2;
 519
 520   if (frchain_now->frch_cfi_data == NULL)
 521     {
 522       as_bad (_("CFI instruction used without previous .cfi_startproc"));
 523       ignore_rest_of_line ();
 524       return;
 525     }
 526
 527   /* If the last address was not at the current PC, advance to current.  */
 528   if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now
 529       || S_GET_VALUE (frchain_now->frch_cfi_data->last_address)
 530          != frag_now_fix ())
 531     cfi_add_advance_loc (symbol_temp_new_now ());
 532
 533   switch (arg)
 534     {
 535     case DW_CFA_offset:
 536       reg1 = cfi_parse_reg ();
 537       cfi_parse_separator ();
 538       offset = cfi_parse_const ();
 539       cfi_add_CFA_offset (reg1, offset);
 540       break;
 541
 542     case CFI_rel_offset:
 543       reg1 = cfi_parse_reg ();
 544       cfi_parse_separator ();
 545       offset = cfi_parse_const ();
 546       cfi_add_CFA_offset (reg1,
 547                           offset - frchain_now->frch_cfi_data->cur_cfa_offset);
 548       break;
 549
 550     case DW_CFA_def_cfa:
 551       reg1 = cfi_parse_reg ();
 552       cfi_parse_separator ();
 553       offset = cfi_parse_const ();
 554       cfi_add_CFA_def_cfa (reg1, offset);
 555       break;
 556
 557     case DW_CFA_register:
 558       reg1 = cfi_parse_reg ();
 559       cfi_parse_separator ();
 560       reg2 = cfi_parse_reg ();
 561       cfi_add_CFA_register (reg1, reg2);
 562       break;
 563
 564     case DW_CFA_def_cfa_register:
 565       reg1 = cfi_parse_reg ();
 566       cfi_add_CFA_def_cfa_register (reg1);
 567       break;
 568
 569     case DW_CFA_def_cfa_offset:
 570       offset = cfi_parse_const ();
 571       cfi_add_CFA_def_cfa_offset (offset);
 572       break;
 573
 574     case CFI_adjust_cfa_offset:
 575       offset = cfi_parse_const ();
 576       cfi_add_CFA_def_cfa_offset (frchain_now->frch_cfi_data->cur_cfa_offset
 577                                   + offset);
 578       break;
 579
 580     case DW_CFA_restore:
 581       for (;;)
 582         {
 583           reg1 = cfi_parse_reg ();
 584           cfi_add_CFA_restore (reg1);
 585           SKIP_WHITESPACE ();
 586           if (*input_line_pointer != ',')
 587             break;
 588           ++input_line_pointer;
 589         }
 590       break;
 591
 592     case DW_CFA_undefined:
 593       for (;;)
 594         {
 595           reg1 = cfi_parse_reg ();
 596           cfi_add_CFA_undefined (reg1);
 597           SKIP_WHITESPACE ();
 598           if (*input_line_pointer != ',')
 599             break;
 600           ++input_line_pointer;
 601         }
 602       break;
 603
 604     case DW_CFA_same_value:
 605       reg1 = cfi_parse_reg ();
 606       cfi_add_CFA_same_value (reg1);
 607       break;
 608
 609     case CFI_return_column:
 610       reg1 = cfi_parse_reg ();
 611       cfi_set_return_column (reg1);
 612       break;
 613
 614     case DW_CFA_remember_state:
 615       cfi_add_CFA_remember_state ();
 616       break;
 617
 618     case DW_CFA_restore_state:
 619       cfi_add_CFA_restore_state ();
 620       break;
 621
 622     case DW_CFA_GNU_window_save:
 623       cfi_add_CFA_insn (DW_CFA_GNU_window_save);
 624       break;
 625
 626     case CFI_signal_frame:
 627       frchain_now->frch_cfi_data->cur_fde_data->signal_frame = 1;
 628       break;
 629
 630     default:
 631       abort ();
 632     }
 633
 634   demand_empty_rest_of_line ();
 635 }
 636
 637 static void
 638 dot_cfi_escape (int ignored ATTRIBUTE_UNUSED)
 639 {
 640   struct cfi_escape_data *head, **tail, *e;
 641   struct cfi_insn_data *insn;
 642
 643   if (frchain_now->frch_cfi_data == NULL)
 644     {
 645       as_bad (_("CFI instruction used without previous .cfi_startproc"));
 646       ignore_rest_of_line ();
 647       return;
 648     }
 649
 650   /* If the last address was not at the current PC, advance to current.  */
 651   if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now
 652       || S_GET_VALUE (frchain_now->frch_cfi_data->last_address)
 653          != frag_now_fix ())
 654     cfi_add_advance_loc (symbol_temp_new_now ());
 655
 656   tail = &head;
 657   do
 658     {
 659       e = (struct cfi_escape_data *) xmalloc (sizeof (*e));
 660       do_parse_cons_expression (&e->exp, 1);
 661       *tail = e;
 662       tail = &e->next;
 663     }
 664   while (*input_line_pointer++ == ',');
 665   *tail = NULL;
 666
 667   insn = alloc_cfi_insn_data ();
 668   insn->insn = CFI_escape;
 669   insn->u.esc = head;
 670
 671   --input_line_pointer;
 672   demand_empty_rest_of_line ();
 673 }
 674
 675 static void
 676 dot_cfi_personality (int ignored ATTRIBUTE_UNUSED)
 677 {
 678   struct fde_entry *fde;
 679   offsetT encoding;
 680
 681   if (frchain_now->frch_cfi_data == NULL)
 682     {
 683       as_bad (_("CFI instruction used without previous .cfi_startproc"));
 684       ignore_rest_of_line ();
 685       return;
 686     }
 687
 688   fde = frchain_now->frch_cfi_data->cur_fde_data;
 689   encoding = cfi_parse_const ();
 690   if (encoding == DW_EH_PE_omit)
 691     {
 692       demand_empty_rest_of_line ();
 693       fde->per_encoding = encoding;
 694       return;
 695     }
 696
 697   if ((encoding & 0xff) != encoding
 698       || ((encoding & 0x70) != 0
 699 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
 700           && (encoding & 0x70) != DW_EH_PE_pcrel
 701 #endif
 702           )
 703          /* leb128 can be handled, but does something actually need it?  */
 704       || (encoding & 7) == DW_EH_PE_uleb128
 705       || (encoding & 7) > DW_EH_PE_udata8)
 706     {
 707       as_bad (_("invalid or unsupported encoding in .cfi_personality"));
 708       ignore_rest_of_line ();
 709       return;
 710     }
 711
 712   if (*input_line_pointer++ != ',')
 713     {
 714       as_bad (_(".cfi_personality requires encoding and symbol arguments"));
 715       ignore_rest_of_line ();
 716       return;
 717     }
 718
 719   expression_and_evaluate (&fde->personality);
 720   switch (fde->personality.X_op)
 721     {
 722     case O_symbol:
 723       break;
 724     case O_constant:
 725       if ((encoding & 0x70) == DW_EH_PE_pcrel)
 726         encoding = DW_EH_PE_omit;
 727       break;
 728     default:
 729       encoding = DW_EH_PE_omit;
 730       break;
 731     }
 732
 733   fde->per_encoding = encoding;
 734
 735   if (encoding == DW_EH_PE_omit)
 736     {
 737       as_bad (_("wrong second argument to .cfi_personality"));
 738       ignore_rest_of_line ();
 739       return;
 740     }
 741
 742   demand_empty_rest_of_line ();
 743 }
 744
 745 static void
 746 dot_cfi_lsda (int ignored ATTRIBUTE_UNUSED)
 747 {
 748   struct fde_entry *fde;
 749   offsetT encoding;
 750
 751   if (frchain_now->frch_cfi_data == NULL)
 752     {
 753       as_bad (_("CFI instruction used without previous .cfi_startproc"));
 754       ignore_rest_of_line ();
 755       return;
 756     }
 757
 758   fde = frchain_now->frch_cfi_data->cur_fde_data;
 759   encoding = cfi_parse_const ();
 760   if (encoding == DW_EH_PE_omit)
 761     {
 762       demand_empty_rest_of_line ();
 763       fde->lsda_encoding = encoding;
 764       return;
 765     }
 766
 767   if ((encoding & 0xff) != encoding
 768       || ((encoding & 0x70) != 0
 769 #if CFI_DIFF_LSDA_OK || defined tc_cfi_emit_pcrel_expr
 770           && (encoding & 0x70) != DW_EH_PE_pcrel
 771 #endif
 772           )
 773          /* leb128 can be handled, but does something actually need it?  */
 774       || (encoding & 7) == DW_EH_PE_uleb128
 775       || (encoding & 7) > DW_EH_PE_udata8)
 776     {
 777       as_bad (_("invalid or unsupported encoding in .cfi_lsda"));
 778       ignore_rest_of_line ();
 779       return;
 780     }
 781
 782   if (*input_line_pointer++ != ',')
 783     {
 784       as_bad (_(".cfi_lsda requires encoding and symbol arguments"));
 785       ignore_rest_of_line ();
 786       return;
 787     }
 788
 789   fde->lsda_encoding = encoding;
 790
 791   expression_and_evaluate (&fde->lsda);
 792   switch (fde->lsda.X_op)
 793     {
 794     case O_symbol:
 795       break;
 796     case O_constant:
 797       if ((encoding & 0x70) == DW_EH_PE_pcrel)
 798         encoding = DW_EH_PE_omit;
 799       break;
 800     default:
 801       encoding = DW_EH_PE_omit;
 802       break;
 803     }
 804
 805   fde->lsda_encoding = encoding;
 806
 807   if (encoding == DW_EH_PE_omit)
 808     {
 809       as_bad (_("wrong second argument to .cfi_lsda"));
 810       ignore_rest_of_line ();
 811       return;
 812     }
 813
 814   demand_empty_rest_of_line ();
 815 }
 816
 817 static void
 818 dot_cfi_val_encoded_addr (int ignored ATTRIBUTE_UNUSED)
 819 {
 820   struct cfi_insn_data *insn_ptr;
 821   offsetT encoding;
 822
 823   if (frchain_now->frch_cfi_data == NULL)
 824     {
 825       as_bad (_("CFI instruction used without previous .cfi_startproc"));
 826       ignore_rest_of_line ();
 827       return;
 828     }
 829
 830   /* If the last address was not at the current PC, advance to current.  */
 831   if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now
 832       || S_GET_VALUE (frchain_now->frch_cfi_data->last_address)
 833          != frag_now_fix ())
 834     cfi_add_advance_loc (symbol_temp_new_now ());
 835
 836   insn_ptr = alloc_cfi_insn_data ();
 837   insn_ptr->insn = CFI_val_encoded_addr;
 838
 839   insn_ptr->u.ea.reg = cfi_parse_reg ();
 840
 841   cfi_parse_separator ();
 842   encoding = cfi_parse_const ();
 843   if ((encoding & 0xff) != encoding
 844       || ((encoding & 0x70) != 0
 845 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
 846           && (encoding & 0x70) != DW_EH_PE_pcrel
 847 #endif
 848           )
 849          /* leb128 can be handled, but does something actually need it?  */
 850       || (encoding & 7) == DW_EH_PE_uleb128
 851       || (encoding & 7) > DW_EH_PE_udata8)
 852     {
 853       as_bad (_("invalid or unsupported encoding in .cfi_lsda"));
 854       encoding = DW_EH_PE_omit;
 855     }
 856
 857   cfi_parse_separator ();
 858   expression_and_evaluate (&insn_ptr->u.ea.exp);
 859   switch (insn_ptr->u.ea.exp.X_op)
 860     {
 861     case O_symbol:
 862       break;
 863     case O_constant:
 864       if ((encoding & 0x70) != DW_EH_PE_pcrel)
 865         break;
 866     default:
 867       encoding = DW_EH_PE_omit;
 868       break;
 869     }
 870
 871   insn_ptr->u.ea.encoding = encoding;
 872   if (encoding == DW_EH_PE_omit)
 873     {
 874       as_bad (_("wrong third argument to .cfi_val_encoded_addr"));
 875       ignore_rest_of_line ();
 876       return;
 877     }
 878
 879   demand_empty_rest_of_line ();
 880 }
 881
 882 /* By default emit .eh_frame only, not .debug_frame.  */
 883 #define CFI_EMIT_eh_frame       (1 << 0)
 884 #define CFI_EMIT_debug_frame    (1 << 1)
 885 static int cfi_sections = CFI_EMIT_eh_frame;
 886
 887 static void
 888 dot_cfi_sections (int ignored ATTRIBUTE_UNUSED)
 889 {
 890   int sections = 0;
 891
 892   SKIP_WHITESPACE ();
 893   if (is_name_beginner (*input_line_pointer))
 894     while (1)
 895       {
 896         char *name, c;
 897
 898         name = input_line_pointer;
 899         c = get_symbol_end ();
 900
 901         if (strcmp (name, ".eh_frame") == 0)
 902           sections |= CFI_EMIT_eh_frame;
 903         else if (strcmp (name, ".debug_frame") == 0)
 904           sections |= CFI_EMIT_debug_frame;
 905         else
 906           {
 907             *input_line_pointer = c;
 908             input_line_pointer = name;
 909             break;
 910           }
 911
 912         *input_line_pointer = c;
 913         SKIP_WHITESPACE ();
 914         if (*input_line_pointer == ',')
 915           {
 916             name = input_line_pointer++;
 917             SKIP_WHITESPACE ();
 918             if (!is_name_beginner (*input_line_pointer))
 919               {
 920                 input_line_pointer = name;
 921                 break;
 922               }
 923           }
 924         else if (is_name_beginner (*input_line_pointer))
 925           break;
 926       }
 927
 928   demand_empty_rest_of_line ();
 929   cfi_sections = sections;
 930 }
 931
 932 static void
 933 dot_cfi_startproc (int ignored ATTRIBUTE_UNUSED)
 934 {
 935   int simple = 0;
 936
 937   if (frchain_now->frch_cfi_data != NULL)
 938     {
 939       as_bad (_("previous CFI entry not closed (missing .cfi_endproc)"));
 940       ignore_rest_of_line ();
 941       return;
 942     }
 943
 944   cfi_new_fde (symbol_temp_new_now ());
 945
 946   SKIP_WHITESPACE ();
 947   if (is_name_beginner (*input_line_pointer))
 948     {
 949       char *name, c;
 950
 951       name = input_line_pointer;
 952       c = get_symbol_end ();
 953
 954       if (strcmp (name, "simple") == 0)
 955         {
 956           simple = 1;
 957           *input_line_pointer = c;
 958         }
 959       else
 960         input_line_pointer = name;
 961     }
 962   demand_empty_rest_of_line ();
 963
 964   frchain_now->frch_cfi_data->cur_cfa_offset = 0;
 965   if (!simple)
 966     tc_cfi_frame_initial_instructions ();
 967 }
 968
 969 static void
 970 dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED)
 971 {
 972   if (frchain_now->frch_cfi_data == NULL)
 973     {
 974       as_bad (_(".cfi_endproc without corresponding .cfi_startproc"));
 975       ignore_rest_of_line ();
 976       return;
 977     }
 978
 979   cfi_end_fde (symbol_temp_new_now ());
 980
 981   demand_empty_rest_of_line ();
 982 }
 983
 984 \f
 985 /* Emit a single byte into the current segment.  */
 986
 987 static inline void
 988 out_one (int byte)
 989 {
 990   FRAG_APPEND_1_CHAR (byte);
 991 }
 992
 993 /* Emit a two-byte word into the current segment.  */
 994
 995 static inline void
 996 out_two (int data)
 997 {
 998   md_number_to_chars (frag_more (2), data, 2);
 999 }
1000
1001 /* Emit a four byte word into the current segment.  */
1002
1003 static inline void
1004 out_four (int data)
1005 {
1006   md_number_to_chars (frag_more (4), data, 4);
1007 }
1008
1009 /* Emit an unsigned "little-endian base 128" number.  */
1010
1011 static void
1012 out_uleb128 (addressT value)
1013 {
1014   output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
1015 }
1016
1017 /* Emit an unsigned "little-endian base 128" number.  */
1018
1019 static void
1020 out_sleb128 (offsetT value)
1021 {
1022   output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1);
1023 }
1024
1025 static void
1026 output_cfi_insn (struct cfi_insn_data *insn)
1027 {
1028   offsetT offset;
1029   unsigned int regno;
1030
1031   switch (insn->insn)
1032     {
1033     case DW_CFA_advance_loc:
1034       {
1035         symbolS *from = insn->u.ll.lab1;
1036         symbolS *to = insn->u.ll.lab2;
1037
1038         if (symbol_get_frag (to) == symbol_get_frag (from))
1039           {
1040             addressT delta = S_GET_VALUE (to) - S_GET_VALUE (from);
1041             addressT scaled = delta / DWARF2_LINE_MIN_INSN_LENGTH;
1042
1043             if (scaled <= 0x3F)
1044               out_one (DW_CFA_advance_loc + scaled);
1045             else if (scaled <= 0xFF)
1046               {
1047                 out_one (DW_CFA_advance_loc1);
1048                 out_one (scaled);
1049               }
1050             else if (scaled <= 0xFFFF)
1051               {
1052                 out_one (DW_CFA_advance_loc2);
1053                 out_two (scaled);
1054               }
1055             else
1056               {
1057                 out_one (DW_CFA_advance_loc4);
1058                 out_four (scaled);
1059               }
1060           }
1061         else
1062           {
1063             expressionS exp;
1064
1065             exp.X_op = O_subtract;
1066             exp.X_add_symbol = to;
1067             exp.X_op_symbol = from;
1068             exp.X_add_number = 0;
1069
1070             /* The code in ehopt.c expects that one byte of the encoding
1071                is already allocated to the frag.  This comes from the way
1072                that it scans the .eh_frame section looking first for the
1073                .byte DW_CFA_advance_loc4.  */
1074             *frag_more (1) = DW_CFA_advance_loc4;
1075
1076             frag_var (rs_cfa, 4, 0, DWARF2_LINE_MIN_INSN_LENGTH << 3,
1077                       make_expr_symbol (&exp), frag_now_fix () - 1,
1078                       (char *) frag_now);
1079           }
1080       }
1081       break;
1082
1083     case DW_CFA_def_cfa:
1084       offset = insn->u.ri.offset;
1085       if (offset < 0)
1086         {
1087           out_one (DW_CFA_def_cfa_sf);
1088           out_uleb128 (insn->u.ri.reg);
1089           out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
1090         }
1091       else
1092         {
1093           out_one (DW_CFA_def_cfa);
1094           out_uleb128 (insn->u.ri.reg);
1095           out_uleb128 (offset);
1096         }
1097       break;
1098
1099     case DW_CFA_def_cfa_register:
1100     case DW_CFA_undefined:
1101     case DW_CFA_same_value:
1102       out_one (insn->insn);
1103       out_uleb128 (insn->u.r);
1104       break;
1105
1106     case DW_CFA_def_cfa_offset:
1107       offset = insn->u.i;
1108       if (offset < 0)
1109         {
1110           out_one (DW_CFA_def_cfa_offset_sf);
1111           out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
1112         }
1113       else
1114         {
1115           out_one (DW_CFA_def_cfa_offset);
1116           out_uleb128 (offset);
1117         }
1118       break;
1119
1120     case DW_CFA_restore:
1121       regno = insn->u.r;
1122       if (regno <= 0x3F)
1123         {
1124           out_one (DW_CFA_restore + regno);
1125         }
1126       else
1127         {
1128           out_one (DW_CFA_restore_extended);
1129           out_uleb128 (regno);
1130         }
1131       break;
1132
1133     case DW_CFA_offset:
1134       regno = insn->u.ri.reg;
1135       offset = insn->u.ri.offset / DWARF2_CIE_DATA_ALIGNMENT;
1136       if (offset < 0)
1137         {
1138           out_one (DW_CFA_offset_extended_sf);
1139           out_uleb128 (regno);
1140           out_sleb128 (offset);
1141         }
1142       else if (regno <= 0x3F)
1143         {
1144           out_one (DW_CFA_offset + regno);
1145           out_uleb128 (offset);
1146         }
1147       else
1148         {
1149           out_one (DW_CFA_offset_extended);
1150           out_uleb128 (regno);
1151           out_uleb128 (offset);
1152         }
1153       break;
1154
1155     case DW_CFA_register:
1156       out_one (DW_CFA_register);
1157       out_uleb128 (insn->u.rr.reg1);
1158       out_uleb128 (insn->u.rr.reg2);
1159       break;
1160
1161     case DW_CFA_remember_state:
1162     case DW_CFA_restore_state:
1163       out_one (insn->insn);
1164       break;
1165
1166     case DW_CFA_GNU_window_save:
1167       out_one (DW_CFA_GNU_window_save);
1168       break;
1169
1170     case CFI_escape:
1171       {
1172         struct cfi_escape_data *e;
1173         for (e = insn->u.esc; e ; e = e->next)
1174           emit_expr (&e->exp, 1);
1175         break;
1176       }
1177
1178     case CFI_val_encoded_addr:
1179       {
1180         unsigned encoding = insn->u.ea.encoding;
1181         offsetT encoding_size;
1182
1183         if (encoding == DW_EH_PE_omit)
1184           break;
1185         out_one (DW_CFA_val_expression);
1186         out_uleb128 (insn->u.ea.reg);
1187
1188         switch (encoding & 0x7)
1189           {
1190           case DW_EH_PE_absptr:
1191             encoding_size = DWARF2_ADDR_SIZE (stdoutput);
1192             break;
1193           case DW_EH_PE_udata2:
1194             encoding_size = 2;
1195             break;
1196           case DW_EH_PE_udata4:
1197             encoding_size = 4;
1198             break;
1199           case DW_EH_PE_udata8:
1200             encoding_size = 8;
1201             break;
1202           default:
1203             abort ();
1204           }
1205
1206         /* If the user has requested absolute encoding,
1207            then use the smaller DW_OP_addr encoding.  */
1208         if (insn->u.ea.encoding == DW_EH_PE_absptr)
1209           {
1210             out_uleb128 (1 + encoding_size);
1211             out_one (DW_OP_addr);
1212           }
1213         else
1214           {
1215             out_uleb128 (1 + 1 + encoding_size);
1216             out_one (DW_OP_GNU_encoded_addr);
1217             out_one (encoding);
1218
1219             if ((encoding & 0x70) == DW_EH_PE_pcrel)
1220               {
1221 #if CFI_DIFF_EXPR_OK
1222                 insn->u.ea.exp.X_op = O_subtract;
1223                 insn->u.ea.exp.X_op_symbol = symbol_temp_new_now ();
1224 #elif defined (tc_cfi_emit_pcrel_expr)
1225                 tc_cfi_emit_pcrel_expr (&insn->u.ea.exp, encoding_size);
1226                 break;
1227 #else
1228                 abort ();
1229 #endif
1230               }
1231           }
1232         emit_expr (&insn->u.ea.exp, encoding_size);
1233       }
1234       break;
1235
1236     default:
1237       abort ();
1238     }
1239 }
1240
1241 static offsetT
1242 encoding_size (unsigned char encoding)
1243 {
1244   if (encoding == DW_EH_PE_omit)
1245     return 0;
1246   switch (encoding & 0x7)
1247     {
1248     case 0:
1249       return bfd_get_arch_size (stdoutput) == 64 ? 8 : 4;
1250     case DW_EH_PE_udata2:
1251       return 2;
1252     case DW_EH_PE_udata4:
1253       return 4;
1254     case DW_EH_PE_udata8:
1255       return 8;
1256     default:
1257       abort ();
1258     }
1259 }
1260
1261 static void
1262 output_cie (struct cie_entry *cie, bfd_boolean eh_frame, int align)
1263 {
1264   symbolS *after_size_address, *end_address;
1265   expressionS exp;
1266   struct cfi_insn_data *i;
1267   offsetT augmentation_size;
1268   int enc;
1269   enum dwarf2_format fmt = DWARF2_FORMAT (now_seg);
1270
1271   cie->start_address = symbol_temp_new_now ();
1272   after_size_address = symbol_temp_make ();
1273   end_address = symbol_temp_make ();
1274
1275   exp.X_op = O_subtract;
1276   exp.X_add_symbol = end_address;
1277   exp.X_op_symbol = after_size_address;
1278   exp.X_add_number = 0;
1279
1280   if (eh_frame || fmt == dwarf2_format_32bit)
1281     emit_expr (&exp, 4);                        /* Length.  */
1282   else
1283     {
1284       if (fmt == dwarf2_format_64bit)
1285         out_four (-1);
1286       emit_expr (&exp, 8);                      /* Length.  */
1287     }
1288   symbol_set_value_now (after_size_address);
1289   if (eh_frame)
1290     out_four (0);                               /* CIE id.  */
1291   else
1292     {
1293       out_four (-1);                            /* CIE id.  */
1294       if (fmt != dwarf2_format_32bit)
1295         out_four (-1);
1296     }
1297   out_one (DW_CIE_VERSION);                     /* Version.  */
1298   if (eh_frame)
1299     {
1300       out_one ('z');                            /* Augmentation.  */
1301       if (cie->per_encoding != DW_EH_PE_omit)
1302         out_one ('P');
1303       if (cie->lsda_encoding != DW_EH_PE_omit)
1304         out_one ('L');
1305       out_one ('R');
1306       if (cie->signal_frame)
1307         out_one ('S');
1308     }
1309   out_one (0);
1310   out_uleb128 (DWARF2_LINE_MIN_INSN_LENGTH);    /* Code alignment.  */
1311   out_sleb128 (DWARF2_CIE_DATA_ALIGNMENT);      /* Data alignment.  */
1312   if (DW_CIE_VERSION == 1)                      /* Return column.  */
1313     out_one (cie->return_column);
1314   else
1315     out_uleb128 (cie->return_column);
1316   if (eh_frame)
1317     {
1318       augmentation_size = 1 + (cie->lsda_encoding != DW_EH_PE_omit);
1319       if (cie->per_encoding != DW_EH_PE_omit)
1320         augmentation_size += 1 + encoding_size (cie->per_encoding);
1321       out_uleb128 (augmentation_size);          /* Augmentation size.  */
1322
1323       if (cie->per_encoding != DW_EH_PE_omit)
1324         {
1325           offsetT size = encoding_size (cie->per_encoding);
1326           out_one (cie->per_encoding);
1327           exp = cie->personality;
1328           if ((cie->per_encoding & 0x70) == DW_EH_PE_pcrel)
1329             {
1330 #if CFI_DIFF_EXPR_OK
1331               exp.X_op = O_subtract;
1332               exp.X_op_symbol = symbol_temp_new_now ();
1333               emit_expr (&exp, size);
1334 #elif defined (tc_cfi_emit_pcrel_expr)
1335               tc_cfi_emit_pcrel_expr (&exp, size);
1336 #else
1337               abort ();
1338 #endif
1339             }
1340           else
1341             emit_expr (&exp, size);
1342         }
1343
1344       if (cie->lsda_encoding != DW_EH_PE_omit)
1345         out_one (cie->lsda_encoding);
1346     }
1347
1348   switch (DWARF2_FDE_RELOC_SIZE)
1349     {
1350     case 2:
1351       enc = DW_EH_PE_sdata2;
1352       break;
1353     case 4:
1354       enc = DW_EH_PE_sdata4;
1355       break;
1356     case 8:
1357       enc = DW_EH_PE_sdata8;
1358       break;
1359     default:
1360       abort ();
1361     }
1362 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
1363   enc |= DW_EH_PE_pcrel;
1364 #endif
1365   if (eh_frame)
1366     out_one (enc);
1367
1368   if (cie->first)
1369     for (i = cie->first; i != cie->last; i = i->next)
1370       output_cfi_insn (i);
1371
1372   frag_align (align, DW_CFA_nop, 0);
1373   symbol_set_value_now (end_address);
1374 }
1375
1376 static void
1377 output_fde (struct fde_entry *fde, struct cie_entry *cie,
1378             bfd_boolean eh_frame, struct cfi_insn_data *first,
1379             int align)
1380 {
1381   symbolS *after_size_address, *end_address;
1382   expressionS exp;
1383   offsetT augmentation_size;
1384   enum dwarf2_format fmt = DWARF2_FORMAT (now_seg);
1385   int offset_size;
1386   int addr_size;
1387
1388   after_size_address = symbol_temp_make ();
1389   end_address = symbol_temp_make ();
1390
1391   exp.X_op = O_subtract;
1392   exp.X_add_symbol = end_address;
1393   exp.X_op_symbol = after_size_address;
1394   exp.X_add_number = 0;
1395   if (eh_frame || fmt == dwarf2_format_32bit)
1396     offset_size = 4;
1397   else
1398     {
1399       if (fmt == dwarf2_format_64bit)
1400         out_four (-1);
1401       offset_size = 8;
1402     }
1403   emit_expr (&exp, offset_size);                /* Length.  */
1404   symbol_set_value_now (after_size_address);
1405
1406   if (eh_frame)
1407     {
1408       exp.X_add_symbol = after_size_address;
1409       exp.X_op_symbol = cie->start_address;
1410     }
1411   else
1412     {
1413       exp.X_op = O_symbol;
1414       exp.X_add_symbol = cie->start_address;
1415       exp.X_op_symbol = NULL;
1416     }
1417   emit_expr (&exp, offset_size);                /* CIE offset.  */
1418
1419   if (eh_frame)
1420     {
1421 #if CFI_DIFF_EXPR_OK
1422       exp.X_add_symbol = fde->start_address;
1423       exp.X_op_symbol = symbol_temp_new_now ();
1424       emit_expr (&exp, DWARF2_FDE_RELOC_SIZE);  /* Code offset.  */
1425 #else
1426       exp.X_op = O_symbol;
1427       exp.X_add_symbol = fde->start_address;
1428       exp.X_op_symbol = NULL;
1429 #ifdef tc_cfi_emit_pcrel_expr
1430       tc_cfi_emit_pcrel_expr (&exp, DWARF2_FDE_RELOC_SIZE);      /* Code offset.  */
1431 #else
1432       emit_expr (&exp, DWARF2_FDE_RELOC_SIZE);  /* Code offset.  */
1433 #endif
1434 #endif
1435       addr_size = DWARF2_FDE_RELOC_SIZE;
1436     }
1437   else
1438     {
1439       exp.X_add_symbol = fde->start_address;
1440       addr_size = DWARF2_ADDR_SIZE (stdoutput);
1441       emit_expr (&exp, addr_size);
1442     }
1443
1444   exp.X_op = O_subtract;
1445   exp.X_add_symbol = fde->end_address;
1446   exp.X_op_symbol = fde->start_address;         /* Code length.  */
1447   emit_expr (&exp, addr_size);
1448
1449   augmentation_size = encoding_size (fde->lsda_encoding);
1450   if (eh_frame)
1451     out_uleb128 (augmentation_size);            /* Augmentation size.  */
1452
1453   if (fde->lsda_encoding != DW_EH_PE_omit)
1454     {
1455       exp = fde->lsda;
1456       if ((fde->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
1457         {
1458 #if CFI_DIFF_LSDA_OK
1459           exp.X_op = O_subtract;
1460           exp.X_op_symbol = symbol_temp_new_now ();
1461           emit_expr (&exp, augmentation_size);
1462 #elif defined (tc_cfi_emit_pcrel_expr)
1463           tc_cfi_emit_pcrel_expr (&exp, augmentation_size);
1464 #else
1465           abort ();
1466 #endif
1467         }
1468       else
1469         emit_expr (&exp, augmentation_size);
1470     }
1471
1472   for (; first; first = first->next)
1473     output_cfi_insn (first);
1474
1475   frag_align (align, DW_CFA_nop, 0);
1476   symbol_set_value_now (end_address);
1477 }
1478
1479 static struct cie_entry *
1480 select_cie_for_fde (struct fde_entry *fde, bfd_boolean eh_frame,
1481                     struct cfi_insn_data **pfirst, int align)
1482 {
1483   struct cfi_insn_data *i, *j;
1484   struct cie_entry *cie;
1485
1486   for (cie = cie_root; cie; cie = cie->next)
1487     {
1488       if (cie->return_column != fde->return_column
1489           || cie->signal_frame != fde->signal_frame
1490           || cie->per_encoding != fde->per_encoding
1491           || cie->lsda_encoding != fde->lsda_encoding)
1492         continue;
1493       if (cie->per_encoding != DW_EH_PE_omit)
1494         {
1495           if (cie->personality.X_op != fde->personality.X_op
1496               || cie->personality.X_add_number
1497                  != fde->personality.X_add_number)
1498             continue;
1499           switch (cie->personality.X_op)
1500             {
1501             case O_constant:
1502               if (cie->personality.X_unsigned != fde->personality.X_unsigned)
1503                 continue;
1504               break;
1505             case O_symbol:
1506               if (cie->personality.X_add_symbol
1507                   != fde->personality.X_add_symbol)
1508                 continue;
1509               break;
1510             default:
1511               abort ();
1512             }
1513         }
1514       for (i = cie->first, j = fde->data;
1515            i != cie->last && j != NULL;
1516            i = i->next, j = j->next)
1517         {
1518           if (i->insn != j->insn)
1519             goto fail;
1520           switch (i->insn)
1521             {
1522             case DW_CFA_advance_loc:
1523             case DW_CFA_remember_state:
1524               /* We reached the first advance/remember in the FDE,
1525                  but did not reach the end of the CIE list.  */
1526               goto fail;
1527
1528             case DW_CFA_offset:
1529             case DW_CFA_def_cfa:
1530               if (i->u.ri.reg != j->u.ri.reg)
1531                 goto fail;
1532               if (i->u.ri.offset != j->u.ri.offset)
1533                 goto fail;
1534               break;
1535
1536             case DW_CFA_register:
1537               if (i->u.rr.reg1 != j->u.rr.reg1)
1538                 goto fail;
1539               if (i->u.rr.reg2 != j->u.rr.reg2)
1540                 goto fail;
1541               break;
1542
1543             case DW_CFA_def_cfa_register:
1544             case DW_CFA_restore:
1545             case DW_CFA_undefined:
1546             case DW_CFA_same_value:
1547               if (i->u.r != j->u.r)
1548                 goto fail;
1549               break;
1550
1551             case DW_CFA_def_cfa_offset:
1552               if (i->u.i != j->u.i)
1553                 goto fail;
1554               break;
1555
1556             case CFI_escape:
1557             case CFI_val_encoded_addr:
1558               /* Don't bother matching these for now.  */
1559               goto fail;
1560
1561             default:
1562               abort ();
1563             }
1564         }
1565
1566       /* Success if we reached the end of the CIE list, and we've either
1567          run out of FDE entries or we've encountered an advance,
1568          remember, or escape.  */
1569       if (i == cie->last
1570           && (!j
1571               || j->insn == DW_CFA_advance_loc
1572               || j->insn == DW_CFA_remember_state
1573               || j->insn == CFI_escape
1574               || j->insn == CFI_val_encoded_addr))
1575         {
1576           *pfirst = j;
1577           return cie;
1578         }
1579
1580     fail:;
1581     }
1582
1583   cie = (struct cie_entry *) xmalloc (sizeof (struct cie_entry));
1584   cie->next = cie_root;
1585   cie_root = cie;
1586   cie->return_column = fde->return_column;
1587   cie->signal_frame = fde->signal_frame;
1588   cie->per_encoding = fde->per_encoding;
1589   cie->lsda_encoding = fde->lsda_encoding;
1590   cie->personality = fde->personality;
1591   cie->first = fde->data;
1592
1593   for (i = cie->first; i ; i = i->next)
1594     if (i->insn == DW_CFA_advance_loc
1595         || i->insn == DW_CFA_remember_state
1596         || i->insn == CFI_escape
1597         || i->insn == CFI_val_encoded_addr)
1598       break;
1599
1600   cie->last = i;
1601   *pfirst = i;
1602
1603   output_cie (cie, eh_frame, align);
1604
1605   return cie;
1606 }
1607
1608 #ifdef md_reg_eh_frame_to_debug_frame
1609 static void
1610 cfi_change_reg_numbers (struct cfi_insn_data *insn)
1611 {
1612   for (; insn; insn = insn->next)
1613     switch (insn->insn)
1614       {
1615       case DW_CFA_advance_loc:
1616       case DW_CFA_def_cfa_offset:
1617       case DW_CFA_remember_state:
1618       case DW_CFA_restore_state:
1619       case DW_CFA_GNU_window_save:
1620       case CFI_escape:
1621         break;
1622
1623       case DW_CFA_def_cfa:
1624       case DW_CFA_offset:
1625         insn->u.ri.reg = md_reg_eh_frame_to_debug_frame (insn->u.ri.reg);
1626         break;
1627
1628       case DW_CFA_def_cfa_register:
1629       case DW_CFA_undefined:
1630       case DW_CFA_same_value:
1631       case DW_CFA_restore:
1632         insn->u.r = md_reg_eh_frame_to_debug_frame (insn->u.r);
1633         break;
1634
1635       case DW_CFA_register:
1636         insn->u.rr.reg1 = md_reg_eh_frame_to_debug_frame (insn->u.rr.reg1);
1637         insn->u.rr.reg2 = md_reg_eh_frame_to_debug_frame (insn->u.rr.reg2);
1638         break;
1639
1640       case CFI_val_encoded_addr:
1641         insn->u.ea.reg = md_reg_eh_frame_to_debug_frame (insn->u.ea.reg);
1642         break;
1643
1644       default:
1645         abort ();
1646       }
1647 }
1648 #else
1649 #define cfi_change_reg_numbers(insn) do { } while (0)
1650 #endif
1651
1652 void
1653 cfi_finish (void)
1654 {
1655   segT cfi_seg;
1656   struct fde_entry *fde;
1657   int save_flag_traditional_format;
1658
1659   if (all_fde_data == 0)
1660     return;
1661
1662   if ((cfi_sections & CFI_EMIT_eh_frame) != 0)
1663     {
1664       /* Open .eh_frame section.  */
1665       cfi_seg = subseg_new (".eh_frame", 0);
1666       bfd_set_section_flags (stdoutput, cfi_seg,
1667                              SEC_ALLOC | SEC_LOAD | SEC_DATA
1668                              | DWARF2_EH_FRAME_READ_ONLY);
1669       subseg_set (cfi_seg, 0);
1670       record_alignment (cfi_seg, EH_FRAME_ALIGNMENT);
1671
1672 #ifdef md_fix_up_eh_frame
1673       md_fix_up_eh_frame (cfi_seg);
1674 #endif
1675
1676       /* Make sure check_eh_frame doesn't do anything with our output.  */
1677       save_flag_traditional_format = flag_traditional_format;
1678       flag_traditional_format = 1;
1679
1680       for (fde = all_fde_data; fde ; fde = fde->next)
1681         {
1682           struct cfi_insn_data *first;
1683           struct cie_entry *cie;
1684
1685           if (fde->end_address == NULL)
1686             {
1687               as_bad (_("open CFI at the end of file; missing .cfi_endproc directive"));
1688               fde->end_address = fde->start_address;
1689             }
1690
1691           cie = select_cie_for_fde (fde, TRUE, &first, 2);
1692           output_fde (fde, cie, TRUE, first,
1693                       fde->next == NULL ? EH_FRAME_ALIGNMENT : 2);
1694         }
1695
1696       flag_traditional_format = save_flag_traditional_format;
1697     }
1698
1699   if ((cfi_sections & CFI_EMIT_debug_frame) != 0)
1700     {
1701       struct cie_entry *cie, *cie_next;
1702       int alignment = ffs (DWARF2_ADDR_SIZE (stdoutput)) - 1;
1703
1704       for (cie = cie_root; cie; cie = cie_next)
1705         {
1706           cie_next = cie->next;
1707           free ((void *) cie);
1708         }
1709       cie_root = NULL;
1710
1711       /* Open .debug_frame section.  */
1712       cfi_seg = subseg_new (".debug_frame", 0);
1713       bfd_set_section_flags (stdoutput, cfi_seg,
1714                              SEC_READONLY | SEC_DEBUGGING);
1715       subseg_set (cfi_seg, 0);
1716       record_alignment (cfi_seg, alignment);
1717
1718       for (fde = all_fde_data; fde ; fde = fde->next)
1719         {
1720           struct cfi_insn_data *first;
1721
1722           if (fde->end_address == NULL)
1723             {
1724               as_bad (_("open CFI at the end of file; missing .cfi_endproc directive"));
1725               fde->end_address = fde->start_address;
1726             }
1727
1728           fde->per_encoding = DW_EH_PE_omit;
1729           fde->lsda_encoding = DW_EH_PE_omit;
1730           cfi_change_reg_numbers (fde->data);
1731           cie = select_cie_for_fde (fde, FALSE, &first, alignment);
1732           output_fde (fde, cie, FALSE, first, alignment);
1733         }
1734     }
1735 }
1736
1737 #else /* TARGET_USE_CFIPOP */
1738 void
1739 cfi_finish (void)
1740 {
1741 }
1742 #endif /* TARGET_USE_CFIPOP */