gas/dw2gencfi.c

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