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