Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

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