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