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