gas/dw2gencfi.c

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