gas/dw2gencfi.c

   1 /* dw2gencfi.c - Support for generating Dwarf2 CFI information.
   2    Copyright 2003, 2004, 2005 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 2, 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
  25
  26 /* We re-use DWARF2_LINE_MIN_INSN_LENGTH for the code alignment field
  27    of the CIE.  Default to 1 if not otherwise specified.  */
  28 #ifndef  DWARF2_LINE_MIN_INSN_LENGTH
  29 # define DWARF2_LINE_MIN_INSN_LENGTH 1
  30 #endif
  31
  32 /* If TARGET_USE_CFIPOP is defined, it is required that the target
  33    provide the following definitions.  Otherwise provide them to
  34    allow compilation to continue.  */
  35 #ifndef TARGET_USE_CFIPOP
  36 # ifndef  DWARF2_DEFAULT_RETURN_COLUMN
  37 #  define DWARF2_DEFAULT_RETURN_COLUMN 0
  38 # endif
  39 # ifndef  DWARF2_CIE_DATA_ALIGNMENT
  40 #  define DWARF2_CIE_DATA_ALIGNMENT 1
  41 # endif
  42 #endif
  43
  44 #ifndef EH_FRAME_ALIGNMENT
  45 # define EH_FRAME_ALIGNMENT (bfd_get_arch_size (stdoutput) == 64 ? 3 : 2)
  46 #endif
  47
  48 #ifndef tc_cfi_frame_initial_instructions
  49 # define tc_cfi_frame_initial_instructions() ((void)0)
  50 #endif
  51
  52
  53 struct cfi_insn_data
  54 {
  55   struct cfi_insn_data *next;
  56   int insn;
  57   union {
  58     struct {
  59       unsigned reg;
  60       offsetT offset;
  61     } ri;
  62
  63     struct {
  64       unsigned reg1;
  65       unsigned reg2;
  66     } rr;
  67
  68     unsigned r;
  69     offsetT i;
  70
  71     struct {
  72       symbolS *lab1;
  73       symbolS *lab2;
  74     } ll;
  75
  76     struct cfi_escape_data {
  77       struct cfi_escape_data *next;
  78       expressionS exp;
  79     } *esc;
  80   } u;
  81 };
  82
  83 struct fde_entry
  84 {
  85   struct fde_entry *next;
  86   symbolS *start_address;
  87   symbolS *end_address;
  88   struct cfi_insn_data *data;
  89   struct cfi_insn_data **last;
  90   unsigned int return_column;
  91 };
  92
  93 struct cie_entry
  94 {
  95   struct cie_entry *next;
  96   symbolS *start_address;
  97   unsigned int return_column;
  98   struct cfi_insn_data *first, *last;
  99 };
 100
 101
 102 /* Current open FDE entry.  */
 103 static struct fde_entry *cur_fde_data;
 104 static symbolS *last_address;
 105 static offsetT cur_cfa_offset;
 106
 107 /* List of FDE entries.  */
 108 static struct fde_entry *all_fde_data;
 109 static struct fde_entry **last_fde_data = &all_fde_data;
 110
 111 /* List of CIEs so that they could be reused.  */
 112 static struct cie_entry *cie_root;
 113
 114 /* Stack of old CFI data, for save/restore.  */
 115 struct cfa_save_data
 116 {
 117   struct cfa_save_data *next;
 118   offsetT cfa_offset;
 119 };
 120
 121 static struct cfa_save_data *cfa_save_stack;
 122 \f
 123 /* Construct a new FDE structure and add it to the end of the fde list.  */
 124
 125 static struct fde_entry *
 126 alloc_fde_entry (void)
 127 {
 128   struct fde_entry *fde = xcalloc (1, sizeof (struct fde_entry));
 129
 130   cur_fde_data = fde;
 131   *last_fde_data = fde;
 132   last_fde_data = &fde->next;
 133
 134   fde->last = &fde->data;
 135   fde->return_column = DWARF2_DEFAULT_RETURN_COLUMN;
 136
 137   return fde;
 138 }
 139
 140 /* The following functions are available for a backend to construct its
 141    own unwind information, usually from legacy unwind directives.  */
 142
 143 /* Construct a new INSN structure and add it to the end of the insn list
 144    for the currently active FDE.  */
 145
 146 static struct cfi_insn_data *
 147 alloc_cfi_insn_data (void)
 148 {
 149   struct cfi_insn_data *insn = xcalloc (1, sizeof (struct cfi_insn_data));
 150
 151   *cur_fde_data->last = insn;
 152   cur_fde_data->last = &insn->next;
 153
 154   return insn;
 155 }
 156
 157 /* Construct a new FDE structure that begins at LABEL.  */
 158
 159 void
 160 cfi_new_fde (symbolS *label)
 161 {
 162   struct fde_entry *fde = alloc_fde_entry ();
 163   fde->start_address = label;
 164   last_address = label;
 165 }
 166
 167 /* End the currently open FDE.  */
 168
 169 void
 170 cfi_end_fde (symbolS *label)
 171 {
 172   cur_fde_data->end_address = label;
 173   cur_fde_data = NULL;
 174 }
 175
 176 /* Set the return column for the current FDE.  */
 177
 178 void
 179 cfi_set_return_column (unsigned regno)
 180 {
 181   cur_fde_data->return_column = regno;
 182 }
 183
 184 /* Universal functions to store new instructions.  */
 185
 186 static void
 187 cfi_add_CFA_insn(int insn)
 188 {
 189   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
 190
 191   insn_ptr->insn = insn;
 192 }
 193
 194 static void
 195 cfi_add_CFA_insn_reg (int insn, unsigned regno)
 196 {
 197   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
 198
 199   insn_ptr->insn = insn;
 200   insn_ptr->u.r = regno;
 201 }
 202
 203 static void
 204 cfi_add_CFA_insn_offset (int insn, offsetT offset)
 205 {
 206   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
 207
 208   insn_ptr->insn = insn;
 209   insn_ptr->u.i = offset;
 210 }
 211
 212 static void
 213 cfi_add_CFA_insn_reg_reg (int insn, unsigned reg1, unsigned reg2)
 214 {
 215   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
 216
 217   insn_ptr->insn = insn;
 218   insn_ptr->u.rr.reg1 = reg1;
 219   insn_ptr->u.rr.reg2 = reg2;
 220 }
 221
 222 static void
 223 cfi_add_CFA_insn_reg_offset (int insn, unsigned regno, offsetT offset)
 224 {
 225   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
 226
 227   insn_ptr->insn = insn;
 228   insn_ptr->u.ri.reg = regno;
 229   insn_ptr->u.ri.offset = offset;
 230 }
 231
 232 /* Add a CFI insn to advance the PC from the last address to LABEL.  */
 233
 234 void
 235 cfi_add_advance_loc (symbolS *label)
 236 {
 237   struct cfi_insn_data *insn = alloc_cfi_insn_data ();
 238
 239   insn->insn = DW_CFA_advance_loc;
 240   insn->u.ll.lab1 = last_address;
 241   insn->u.ll.lab2 = label;
 242
 243   last_address = label;
 244 }
 245
 246 /* Add a DW_CFA_offset record to the CFI data.  */
 247
 248 void
 249 cfi_add_CFA_offset (unsigned regno, offsetT offset)
 250 {
 251   unsigned int abs_data_align;
 252
 253   cfi_add_CFA_insn_reg_offset (DW_CFA_offset, regno, offset);
 254
 255   abs_data_align = (DWARF2_CIE_DATA_ALIGNMENT < 0
 256                     ? -DWARF2_CIE_DATA_ALIGNMENT : DWARF2_CIE_DATA_ALIGNMENT);
 257   if (offset % abs_data_align)
 258     as_bad (_("register save offset not a multiple of %u"), abs_data_align);
 259 }
 260
 261 /* Add a DW_CFA_def_cfa record to the CFI data.  */
 262
 263 void
 264 cfi_add_CFA_def_cfa (unsigned regno, offsetT offset)
 265 {
 266   cfi_add_CFA_insn_reg_offset (DW_CFA_def_cfa, regno, offset);
 267   cur_cfa_offset = offset;
 268 }
 269
 270 /* Add a DW_CFA_register record to the CFI data.  */
 271
 272 void
 273 cfi_add_CFA_register (unsigned reg1, unsigned reg2)
 274 {
 275   cfi_add_CFA_insn_reg_reg (DW_CFA_register, reg1, reg2);
 276 }
 277
 278 /* Add a DW_CFA_def_cfa_register record to the CFI data.  */
 279
 280 void
 281 cfi_add_CFA_def_cfa_register (unsigned regno)
 282 {
 283   cfi_add_CFA_insn_reg (DW_CFA_def_cfa_register, regno);
 284 }
 285
 286 /* Add a DW_CFA_def_cfa_offset record to the CFI data.  */
 287
 288 void
 289 cfi_add_CFA_def_cfa_offset (offsetT offset)
 290 {
 291   cfi_add_CFA_insn_offset (DW_CFA_def_cfa_offset, offset);
 292   cur_cfa_offset = offset;
 293 }
 294
 295 void
 296 cfi_add_CFA_restore (unsigned regno)
 297 {
 298   cfi_add_CFA_insn_reg (DW_CFA_restore, regno);
 299 }
 300
 301 void
 302 cfi_add_CFA_undefined (unsigned regno)
 303 {
 304   cfi_add_CFA_insn_reg (DW_CFA_undefined, regno);
 305 }
 306
 307 void
 308 cfi_add_CFA_same_value (unsigned regno)
 309 {
 310   cfi_add_CFA_insn_reg (DW_CFA_same_value, regno);
 311 }
 312
 313 void
 314 cfi_add_CFA_remember_state (void)
 315 {
 316   struct cfa_save_data *p;
 317
 318   cfi_add_CFA_insn (DW_CFA_remember_state);
 319
 320   p = xmalloc (sizeof (*p));
 321   p->cfa_offset = cur_cfa_offset;
 322   p->next = cfa_save_stack;
 323   cfa_save_stack = p;
 324 }
 325
 326 void
 327 cfi_add_CFA_restore_state (void)
 328 {
 329   struct cfa_save_data *p;
 330
 331   cfi_add_CFA_insn (DW_CFA_restore_state);
 332
 333   p = cfa_save_stack;
 334   if (p)
 335     {
 336       cur_cfa_offset = p->cfa_offset;
 337       cfa_save_stack = p->next;
 338       free (p);
 339     }
 340   else
 341     as_bad (_("CFI state restore without previous remember"));
 342 }
 343
 344 \f
 345 /* Parse CFI assembler directives.  */
 346
 347 static void dot_cfi (int);
 348 static void dot_cfi_escape (int);
 349 static void dot_cfi_startproc (int);
 350 static void dot_cfi_endproc (int);
 351
 352 /* Fake CFI type; outside the byte range of any real CFI insn.  */
 353 #define CFI_adjust_cfa_offset   0x100
 354 #define CFI_return_column       0x101
 355 #define CFI_rel_offset          0x102
 356 #define CFI_escape              0x103
 357
 358 const pseudo_typeS cfi_pseudo_table[] =
 359   {
 360     { "cfi_startproc", dot_cfi_startproc, 0 },
 361     { "cfi_endproc", dot_cfi_endproc, 0 },
 362     { "cfi_def_cfa", dot_cfi, DW_CFA_def_cfa },
 363     { "cfi_def_cfa_register", dot_cfi, DW_CFA_def_cfa_register },
 364     { "cfi_def_cfa_offset", dot_cfi, DW_CFA_def_cfa_offset },
 365     { "cfi_adjust_cfa_offset", dot_cfi, CFI_adjust_cfa_offset },
 366     { "cfi_offset", dot_cfi, DW_CFA_offset },
 367     { "cfi_rel_offset", dot_cfi, CFI_rel_offset },
 368     { "cfi_register", dot_cfi, DW_CFA_register },
 369     { "cfi_return_column", dot_cfi, CFI_return_column },
 370     { "cfi_restore", dot_cfi, DW_CFA_restore },
 371     { "cfi_undefined", dot_cfi, DW_CFA_undefined },
 372     { "cfi_same_value", dot_cfi, DW_CFA_same_value },
 373     { "cfi_remember_state", dot_cfi, DW_CFA_remember_state },
 374     { "cfi_restore_state", dot_cfi, DW_CFA_restore_state },
 375     { "cfi_window_save", dot_cfi, DW_CFA_GNU_window_save },
 376     { "cfi_escape", dot_cfi_escape, 0 },
 377     { NULL, NULL, 0 }
 378   };
 379
 380 static void
 381 cfi_parse_separator (void)
 382 {
 383   SKIP_WHITESPACE ();
 384   if (*input_line_pointer == ',')
 385     input_line_pointer++;
 386   else
 387     as_bad (_("missing separator"));
 388 }
 389
 390 static unsigned
 391 cfi_parse_reg (void)
 392 {
 393   int regno;
 394   expressionS exp;
 395
 396 #ifdef tc_regname_to_dw2regnum
 397   SKIP_WHITESPACE ();
 398   if (is_name_beginner (*input_line_pointer)
 399       || (*input_line_pointer == '%'
 400           && is_name_beginner (*++input_line_pointer)))
 401     {
 402       char *name, c;
 403
 404       name = input_line_pointer;
 405       c = get_symbol_end ();
 406
 407       if ((regno = tc_regname_to_dw2regnum (name)) < 0)
 408         {
 409           as_bad (_("bad register expression"));
 410           regno = 0;
 411         }
 412
 413       *input_line_pointer = c;
 414       return regno;
 415     }
 416 #endif
 417
 418   expression_and_evaluate (&exp);
 419   switch (exp.X_op)
 420     {
 421     case O_register:
 422     case O_constant:
 423       regno = exp.X_add_number;
 424       break;
 425
 426     default:
 427       as_bad (_("bad register expression"));
 428       regno = 0;
 429       break;
 430     }
 431
 432   return regno;
 433 }
 434
 435 static offsetT
 436 cfi_parse_const (void)
 437 {
 438   return get_absolute_expression ();
 439 }
 440
 441 static void
 442 dot_cfi (int arg)
 443 {
 444   offsetT offset;
 445   unsigned reg1, reg2;
 446
 447   if (!cur_fde_data)
 448     {
 449       as_bad (_("CFI instruction used without previous .cfi_startproc"));
 450       ignore_rest_of_line ();
 451       return;
 452     }
 453
 454   /* If the last address was not at the current PC, advance to current.  */
 455   if (symbol_get_frag (last_address) != frag_now
 456       || S_GET_VALUE (last_address) != frag_now_fix ())
 457     cfi_add_advance_loc (symbol_temp_new_now ());
 458
 459   switch (arg)
 460     {
 461     case DW_CFA_offset:
 462       reg1 = cfi_parse_reg ();
 463       cfi_parse_separator ();
 464       offset = cfi_parse_const ();
 465       cfi_add_CFA_offset (reg1, offset);
 466       break;
 467
 468     case CFI_rel_offset:
 469       reg1 = cfi_parse_reg ();
 470       cfi_parse_separator ();
 471       offset = cfi_parse_const ();
 472       cfi_add_CFA_offset (reg1, offset - cur_cfa_offset);
 473       break;
 474
 475     case DW_CFA_def_cfa:
 476       reg1 = cfi_parse_reg ();
 477       cfi_parse_separator ();
 478       offset = cfi_parse_const ();
 479       cfi_add_CFA_def_cfa (reg1, offset);
 480       break;
 481
 482     case DW_CFA_register:
 483       reg1 = cfi_parse_reg ();
 484       cfi_parse_separator ();
 485       reg2 = cfi_parse_reg ();
 486       cfi_add_CFA_register (reg1, reg2);
 487       break;
 488
 489     case DW_CFA_def_cfa_register:
 490       reg1 = cfi_parse_reg ();
 491       cfi_add_CFA_def_cfa_register (reg1);
 492       break;
 493
 494     case DW_CFA_def_cfa_offset:
 495       offset = cfi_parse_const ();
 496       cfi_add_CFA_def_cfa_offset (offset);
 497       break;
 498
 499     case CFI_adjust_cfa_offset:
 500       offset = cfi_parse_const ();
 501       cfi_add_CFA_def_cfa_offset (cur_cfa_offset + offset);
 502       break;
 503
 504     case DW_CFA_restore:
 505       for (;;)
 506         {
 507           reg1 = cfi_parse_reg ();
 508           cfi_add_CFA_restore (reg1);
 509           SKIP_WHITESPACE ();
 510           if (*input_line_pointer != ',')
 511             break;
 512           ++input_line_pointer;
 513         }
 514       break;
 515
 516     case DW_CFA_undefined:
 517       for (;;)
 518         {
 519           reg1 = cfi_parse_reg ();
 520           cfi_add_CFA_undefined (reg1);
 521           SKIP_WHITESPACE ();
 522           if (*input_line_pointer != ',')
 523             break;
 524           ++input_line_pointer;
 525         }
 526       break;
 527
 528     case DW_CFA_same_value:
 529       reg1 = cfi_parse_reg ();
 530       cfi_add_CFA_same_value (reg1);
 531       break;
 532
 533     case CFI_return_column:
 534       reg1 = cfi_parse_reg ();
 535       cfi_set_return_column (reg1);
 536       break;
 537
 538     case DW_CFA_remember_state:
 539       cfi_add_CFA_remember_state ();
 540       break;
 541
 542     case DW_CFA_restore_state:
 543       cfi_add_CFA_restore_state ();
 544       break;
 545
 546     case DW_CFA_GNU_window_save:
 547       cfi_add_CFA_insn (DW_CFA_GNU_window_save);
 548       break;
 549
 550     default:
 551       abort ();
 552     }
 553
 554   demand_empty_rest_of_line ();
 555 }
 556
 557 static void
 558 dot_cfi_escape (int ignored ATTRIBUTE_UNUSED)
 559 {
 560   struct cfi_escape_data *head, **tail, *e;
 561   struct cfi_insn_data *insn;
 562
 563   if (!cur_fde_data)
 564     {
 565       as_bad (_("CFI instruction used without previous .cfi_startproc"));
 566       ignore_rest_of_line ();
 567       return;
 568     }
 569
 570   /* If the last address was not at the current PC, advance to current.  */
 571   if (symbol_get_frag (last_address) != frag_now
 572       || S_GET_VALUE (last_address) != frag_now_fix ())
 573     cfi_add_advance_loc (symbol_temp_new_now ());
 574
 575   tail = &head;
 576   do
 577     {
 578       e = xmalloc (sizeof (*e));
 579       do_parse_cons_expression (&e->exp, 1);
 580       *tail = e;
 581       tail = &e->next;
 582     }
 583   while (*input_line_pointer++ == ',');
 584   *tail = NULL;
 585
 586   insn = alloc_cfi_insn_data ();
 587   insn->insn = CFI_escape;
 588   insn->u.esc = head;
 589
 590   --input_line_pointer;
 591   demand_empty_rest_of_line ();
 592 }
 593
 594 static void
 595 dot_cfi_startproc (int ignored ATTRIBUTE_UNUSED)
 596 {
 597   int simple = 0;
 598
 599   if (cur_fde_data)
 600     {
 601       as_bad (_("previous CFI entry not closed (missing .cfi_endproc)"));
 602       ignore_rest_of_line ();
 603       return;
 604     }
 605
 606   cfi_new_fde (symbol_temp_new_now ());
 607
 608   SKIP_WHITESPACE ();
 609   if (is_name_beginner (*input_line_pointer))
 610     {
 611       char *name, c;
 612
 613       name = input_line_pointer;
 614       c = get_symbol_end ();
 615
 616       if (strcmp (name, "simple") == 0)
 617         {
 618           simple = 1;
 619           *input_line_pointer = c;
 620         }
 621       else
 622         input_line_pointer = name;
 623     }
 624   demand_empty_rest_of_line ();
 625
 626   cur_cfa_offset = 0;
 627   if (!simple)
 628     tc_cfi_frame_initial_instructions ();
 629 }
 630
 631 static void
 632 dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED)
 633 {
 634   if (! cur_fde_data)
 635     {
 636       as_bad (_(".cfi_endproc without corresponding .cfi_startproc"));
 637       ignore_rest_of_line ();
 638       return;
 639     }
 640
 641   cfi_end_fde (symbol_temp_new_now ());
 642
 643   demand_empty_rest_of_line ();
 644 }
 645
 646 \f
 647 /* Emit a single byte into the current segment.  */
 648
 649 static inline void
 650 out_one (int byte)
 651 {
 652   FRAG_APPEND_1_CHAR (byte);
 653 }
 654
 655 /* Emit a two-byte word into the current segment.  */
 656
 657 static inline void
 658 out_two (int data)
 659 {
 660   md_number_to_chars (frag_more (2), data, 2);
 661 }
 662
 663 /* Emit a four byte word into the current segment.  */
 664
 665 static inline void
 666 out_four (int data)
 667 {
 668   md_number_to_chars (frag_more (4), data, 4);
 669 }
 670
 671 /* Emit an unsigned "little-endian base 128" number.  */
 672
 673 static void
 674 out_uleb128 (addressT value)
 675 {
 676   output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
 677 }
 678
 679 /* Emit an unsigned "little-endian base 128" number.  */
 680
 681 static void
 682 out_sleb128 (offsetT value)
 683 {
 684   output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1);
 685 }
 686
 687 static void
 688 output_cfi_insn (struct cfi_insn_data *insn)
 689 {
 690   offsetT offset;
 691   unsigned int regno;
 692
 693   switch (insn->insn)
 694     {
 695     case DW_CFA_advance_loc:
 696       {
 697         symbolS *from = insn->u.ll.lab1;
 698         symbolS *to = insn->u.ll.lab2;
 699
 700         if (symbol_get_frag (to) == symbol_get_frag (from))
 701           {
 702             addressT delta = S_GET_VALUE (to) - S_GET_VALUE (from);
 703             addressT scaled = delta / DWARF2_LINE_MIN_INSN_LENGTH;
 704
 705             if (scaled <= 0x3F)
 706               out_one (DW_CFA_advance_loc + scaled);
 707             else if (delta <= 0xFF)
 708               {
 709                 out_one (DW_CFA_advance_loc1);
 710                 out_one (delta);
 711               }
 712             else if (delta <= 0xFFFF)
 713               {
 714                 out_one (DW_CFA_advance_loc2);
 715                 out_two (delta);
 716               }
 717             else
 718               {
 719                 out_one (DW_CFA_advance_loc4);
 720                 out_four (delta);
 721               }
 722           }
 723         else
 724           {
 725             expressionS exp;
 726
 727             exp.X_op = O_subtract;
 728             exp.X_add_symbol = to;
 729             exp.X_op_symbol = from;
 730             exp.X_add_number = 0;
 731
 732             /* The code in ehopt.c expects that one byte of the encoding
 733                is already allocated to the frag.  This comes from the way
 734                that it scans the .eh_frame section looking first for the
 735                .byte DW_CFA_advance_loc4.  */
 736             frag_more (1);
 737
 738             frag_var (rs_cfa, 4, 0, DWARF2_LINE_MIN_INSN_LENGTH << 3,
 739                       make_expr_symbol (&exp), frag_now_fix () - 1,
 740                       (char *) frag_now);
 741           }
 742       }
 743       break;
 744
 745     case DW_CFA_def_cfa:
 746       offset = insn->u.ri.offset;
 747       if (offset < 0)
 748         {
 749           out_one (DW_CFA_def_cfa_sf);
 750           out_uleb128 (insn->u.ri.reg);
 751           out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
 752         }
 753       else
 754         {
 755           out_one (DW_CFA_def_cfa);
 756           out_uleb128 (insn->u.ri.reg);
 757           out_uleb128 (offset);
 758         }
 759       break;
 760
 761     case DW_CFA_def_cfa_register:
 762     case DW_CFA_undefined:
 763     case DW_CFA_same_value:
 764       out_one (insn->insn);
 765       out_uleb128 (insn->u.r);
 766       break;
 767
 768     case DW_CFA_def_cfa_offset:
 769       offset = insn->u.i;
 770       if (offset < 0)
 771         {
 772           out_one (DW_CFA_def_cfa_offset_sf);
 773           out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
 774         }
 775       else
 776         {
 777           out_one (DW_CFA_def_cfa_offset);
 778           out_uleb128 (offset);
 779         }
 780       break;
 781
 782     case DW_CFA_restore:
 783       regno = insn->u.r;
 784       if (regno <= 0x3F)
 785         {
 786           out_one (DW_CFA_restore + regno);
 787         }
 788       else
 789         {
 790           out_one (DW_CFA_restore_extended);
 791           out_uleb128 (regno);
 792         }
 793       break;
 794
 795     case DW_CFA_offset:
 796       regno = insn->u.ri.reg;
 797       offset = insn->u.ri.offset / DWARF2_CIE_DATA_ALIGNMENT;
 798       if (offset < 0)
 799         {
 800           out_one (DW_CFA_offset_extended_sf);
 801           out_uleb128 (regno);
 802           out_sleb128 (offset);
 803         }
 804       else if (regno <= 0x3F)
 805         {
 806           out_one (DW_CFA_offset + regno);
 807           out_uleb128 (offset);
 808         }
 809       else
 810         {
 811           out_one (DW_CFA_offset_extended);
 812           out_uleb128 (regno);
 813           out_uleb128 (offset);
 814         }
 815       break;
 816
 817     case DW_CFA_register:
 818       out_one (DW_CFA_register);
 819       out_uleb128 (insn->u.rr.reg1);
 820       out_uleb128 (insn->u.rr.reg2);
 821       break;
 822
 823     case DW_CFA_remember_state:
 824     case DW_CFA_restore_state:
 825       out_one (insn->insn);
 826       break;
 827
 828     case DW_CFA_GNU_window_save:
 829       out_one (DW_CFA_GNU_window_save);
 830       break;
 831
 832     case CFI_escape:
 833       {
 834         struct cfi_escape_data *e;
 835         for (e = insn->u.esc; e ; e = e->next)
 836           emit_expr (&e->exp, 1);
 837         break;
 838       }
 839
 840     default:
 841       abort ();
 842     }
 843 }
 844
 845 static void
 846 output_cie (struct cie_entry *cie)
 847 {
 848   symbolS *after_size_address, *end_address;
 849   expressionS exp;
 850   struct cfi_insn_data *i;
 851
 852   cie->start_address = symbol_temp_new_now ();
 853   after_size_address = symbol_temp_make ();
 854   end_address = symbol_temp_make ();
 855
 856   exp.X_op = O_subtract;
 857   exp.X_add_symbol = end_address;
 858   exp.X_op_symbol = after_size_address;
 859   exp.X_add_number = 0;
 860
 861   emit_expr (&exp, 4);                          /* Length.  */
 862   symbol_set_value_now (after_size_address);
 863   out_four (0);                                 /* CIE id.  */
 864   out_one (DW_CIE_VERSION);                     /* Version.  */
 865   out_one ('z');                                /* Augmentation.  */
 866   out_one ('R');
 867   out_one (0);
 868   out_uleb128 (DWARF2_LINE_MIN_INSN_LENGTH);    /* Code alignment.  */
 869   out_sleb128 (DWARF2_CIE_DATA_ALIGNMENT);      /* Data alignment.  */
 870   if (DW_CIE_VERSION == 1)                      /* Return column.  */
 871     out_one (cie->return_column);
 872   else
 873     out_uleb128 (cie->return_column);
 874   out_uleb128 (1);                              /* Augmentation size.  */
 875 #if defined DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
 876   out_one (DW_EH_PE_pcrel | DW_EH_PE_sdata4);
 877 #else
 878   out_one (DW_EH_PE_sdata4);
 879 #endif
 880
 881   if (cie->first)
 882     for (i = cie->first; i != cie->last; i = i->next)
 883       output_cfi_insn (i);
 884
 885   frag_align (2, DW_CFA_nop, 0);
 886   symbol_set_value_now (end_address);
 887 }
 888
 889 static void
 890 output_fde (struct fde_entry *fde, struct cie_entry *cie,
 891             struct cfi_insn_data *first, int align)
 892 {
 893   symbolS *after_size_address, *end_address;
 894   expressionS exp;
 895
 896   after_size_address = symbol_temp_make ();
 897   end_address = symbol_temp_make ();
 898
 899   exp.X_op = O_subtract;
 900   exp.X_add_symbol = end_address;
 901   exp.X_op_symbol = after_size_address;
 902   exp.X_add_number = 0;
 903   emit_expr (&exp, 4);                          /* Length.  */
 904   symbol_set_value_now (after_size_address);
 905
 906   exp.X_add_symbol = after_size_address;
 907   exp.X_op_symbol = cie->start_address;
 908   emit_expr (&exp, 4);                          /* CIE offset.  */
 909
 910 #ifdef DIFF_EXPR_OK
 911   exp.X_add_symbol = fde->start_address;
 912   exp.X_op_symbol = symbol_temp_new_now ();
 913   emit_expr (&exp, 4);                          /* Code offset.  */
 914 #else
 915   exp.X_op = O_symbol;
 916   exp.X_add_symbol = fde->start_address;
 917   exp.X_op_symbol = NULL;
 918 #ifdef tc_cfi_emit_pcrel_expr
 919   tc_cfi_emit_pcrel_expr (&exp, 4);             /* Code offset.  */
 920 #else
 921   emit_expr (&exp, 4);                          /* Code offset.  */
 922 #endif
 923   exp.X_op = O_subtract;
 924 #endif
 925
 926   exp.X_add_symbol = fde->end_address;
 927   exp.X_op_symbol = fde->start_address;         /* Code length.  */
 928   emit_expr (&exp, 4);
 929
 930   out_uleb128 (0);                              /* Augmentation size.  */
 931
 932   for (; first; first = first->next)
 933     output_cfi_insn (first);
 934
 935   frag_align (align, DW_CFA_nop, 0);
 936   symbol_set_value_now (end_address);
 937 }
 938
 939 static struct cie_entry *
 940 select_cie_for_fde (struct fde_entry *fde, struct cfi_insn_data **pfirst)
 941 {
 942   struct cfi_insn_data *i, *j;
 943   struct cie_entry *cie;
 944
 945   for (cie = cie_root; cie; cie = cie->next)
 946     {
 947       if (cie->return_column != fde->return_column)
 948         continue;
 949       for (i = cie->first, j = fde->data;
 950            i != cie->last && j != NULL;
 951            i = i->next, j = j->next)
 952         {
 953           if (i->insn != j->insn)
 954             goto fail;
 955           switch (i->insn)
 956             {
 957             case DW_CFA_advance_loc:
 958             case DW_CFA_remember_state:
 959               /* We reached the first advance/remember in the FDE,
 960                  but did not reach the end of the CIE list.  */
 961               goto fail;
 962
 963             case DW_CFA_offset:
 964             case DW_CFA_def_cfa:
 965               if (i->u.ri.reg != j->u.ri.reg)
 966                 goto fail;
 967               if (i->u.ri.offset != j->u.ri.offset)
 968                 goto fail;
 969               break;
 970
 971             case DW_CFA_register:
 972               if (i->u.rr.reg1 != j->u.rr.reg1)
 973                 goto fail;
 974               if (i->u.rr.reg2 != j->u.rr.reg2)
 975                 goto fail;
 976               break;
 977
 978             case DW_CFA_def_cfa_register:
 979             case DW_CFA_restore:
 980             case DW_CFA_undefined:
 981             case DW_CFA_same_value:
 982               if (i->u.r != j->u.r)
 983                 goto fail;
 984               break;
 985
 986             case DW_CFA_def_cfa_offset:
 987               if (i->u.i != j->u.i)
 988                 goto fail;
 989               break;
 990
 991             case CFI_escape:
 992               /* Don't bother matching these for now.  */
 993               goto fail;
 994
 995             default:
 996               abort ();
 997             }
 998         }
 999
1000       /* Success if we reached the end of the CIE list, and we've either
1001          run out of FDE entries or we've encountered an advance,
1002          remember, or escape.  */
1003       if (i == cie->last
1004           && (!j
1005               || j->insn == DW_CFA_advance_loc
1006               || j->insn == DW_CFA_remember_state
1007               || j->insn == CFI_escape))
1008         {
1009           *pfirst = j;
1010           return cie;
1011         }
1012
1013     fail:;
1014     }
1015
1016   cie = xmalloc (sizeof (struct cie_entry));
1017   cie->next = cie_root;
1018   cie_root = cie;
1019   cie->return_column = fde->return_column;
1020   cie->first = fde->data;
1021
1022   for (i = cie->first; i ; i = i->next)
1023     if (i->insn == DW_CFA_advance_loc
1024         || i->insn == DW_CFA_remember_state
1025         || i->insn == CFI_escape)
1026       break;
1027
1028   cie->last = i;
1029   *pfirst = i;
1030
1031   output_cie (cie);
1032
1033   return cie;
1034 }
1035
1036 void
1037 cfi_finish (void)
1038 {
1039   segT cfi_seg;
1040   struct fde_entry *fde;
1041   int save_flag_traditional_format;
1042
1043   if (cur_fde_data)
1044     {
1045       as_bad (_("open CFI at the end of file; missing .cfi_endproc directive"));
1046       cur_fde_data->end_address = cur_fde_data->start_address;
1047     }
1048
1049   if (all_fde_data == 0)
1050     return;
1051
1052   /* Open .eh_frame section.  */
1053   cfi_seg = subseg_new (".eh_frame", 0);
1054   bfd_set_section_flags (stdoutput, cfi_seg,
1055                          SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY);
1056   subseg_set (cfi_seg, 0);
1057   record_alignment (cfi_seg, EH_FRAME_ALIGNMENT);
1058
1059   /* Make sure check_eh_frame doesn't do anything with our output.  */
1060   save_flag_traditional_format = flag_traditional_format;
1061   flag_traditional_format = 1;
1062
1063   for (fde = all_fde_data; fde ; fde = fde->next)
1064     {
1065       struct cfi_insn_data *first;
1066       struct cie_entry *cie;
1067
1068       cie = select_cie_for_fde (fde, &first);
1069       output_fde (fde, cie, first, fde->next == NULL ? EH_FRAME_ALIGNMENT : 2);
1070     }
1071
1072   flag_traditional_format = save_flag_traditional_format;
1073 }