gas/dw2gencfi.c

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