This adjusts equate handling by
[external/binutils.git] / gas / dw2gencfi.c
1 /* dw2gencfi.c - Support for generating Dwarf2 CFI information.
2    Copyright 2003, 2004, 2005 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 2, 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
25
26 /* We re-use DWARF2_LINE_MIN_INSN_LENGTH for the code alignment field
27    of the CIE.  Default to 1 if not otherwise specified.  */
28 #ifndef  DWARF2_LINE_MIN_INSN_LENGTH
29 # define DWARF2_LINE_MIN_INSN_LENGTH 1
30 #endif
31
32 /* If TARGET_USE_CFIPOP is defined, it is required that the target
33    provide the following definitions.  Otherwise provide them to 
34    allow compilation to continue.  */
35 #ifndef TARGET_USE_CFIPOP
36 # ifndef  DWARF2_DEFAULT_RETURN_COLUMN
37 #  define DWARF2_DEFAULT_RETURN_COLUMN 0
38 # endif
39 # ifndef  DWARF2_CIE_DATA_ALIGNMENT
40 #  define DWARF2_CIE_DATA_ALIGNMENT 1
41 # endif
42 #endif
43
44 #ifndef EH_FRAME_ALIGNMENT
45 # define EH_FRAME_ALIGNMENT (bfd_get_arch_size (stdoutput) == 64 ? 3 : 2)
46 #endif
47
48 #ifndef tc_cfi_frame_initial_instructions
49 # define tc_cfi_frame_initial_instructions() ((void)0)
50 #endif
51
52
53 struct cfi_insn_data
54 {
55   struct cfi_insn_data *next;
56   int insn;
57   union {
58     struct {
59       unsigned reg;
60       offsetT offset;
61     } ri;
62
63     struct {
64       unsigned reg1;
65       unsigned reg2;
66     } rr;
67
68     unsigned r;
69     offsetT i;
70
71     struct {
72       symbolS *lab1;
73       symbolS *lab2;
74     } ll;
75
76     struct cfi_escape_data {
77       struct cfi_escape_data *next;
78       expressionS exp;
79     } *esc;
80   } u;
81 };
82
83 struct fde_entry
84 {
85   struct fde_entry *next;
86   symbolS *start_address;
87   symbolS *end_address;
88   struct cfi_insn_data *data;
89   struct cfi_insn_data **last;
90   unsigned int return_column;
91 };
92
93 struct cie_entry
94 {
95   struct cie_entry *next;
96   symbolS *start_address;
97   unsigned int return_column;
98   struct cfi_insn_data *first, *last;
99 };
100
101
102 /* Current open FDE entry.  */
103 static struct fde_entry *cur_fde_data;
104 static symbolS *last_address;
105 static offsetT cur_cfa_offset;
106
107 /* List of FDE entries.  */
108 static struct fde_entry *all_fde_data;
109 static struct fde_entry **last_fde_data = &all_fde_data;
110
111 /* List of CIEs so that they could be reused.  */
112 static struct cie_entry *cie_root;
113
114 /* Stack of old CFI data, for save/restore.  */
115 struct cfa_save_data
116 {
117   struct cfa_save_data *next;
118   offsetT cfa_offset;
119 };
120
121 static struct cfa_save_data *cfa_save_stack;
122 \f
123 /* Construct a new FDE structure and add it to the end of the fde list.  */
124
125 static struct fde_entry *
126 alloc_fde_entry (void)
127 {
128   struct fde_entry *fde = xcalloc (1, sizeof (struct fde_entry));
129
130   cur_fde_data = fde;
131   *last_fde_data = fde;
132   last_fde_data = &fde->next;
133
134   fde->last = &fde->data;
135   fde->return_column = DWARF2_DEFAULT_RETURN_COLUMN;
136
137   return fde;
138 }
139
140 /* The following functions are available for a backend to construct its
141    own unwind information, usually from legacy unwind directives.  */
142
143 /* Construct a new INSN structure and add it to the end of the insn list
144    for the currently active FDE.  */
145
146 static struct cfi_insn_data *
147 alloc_cfi_insn_data (void)
148 {
149   struct cfi_insn_data *insn = xcalloc (1, sizeof (struct cfi_insn_data));
150
151   *cur_fde_data->last = insn;
152   cur_fde_data->last = &insn->next;
153
154   return insn;
155 }
156
157 /* Construct a new FDE structure that begins at LABEL.  */
158
159 void 
160 cfi_new_fde (symbolS *label)
161 {
162   struct fde_entry *fde = alloc_fde_entry ();
163   fde->start_address = label;
164   last_address = label;
165 }
166
167 /* End the currently open FDE.  */
168
169 void 
170 cfi_end_fde (symbolS *label)
171 {
172   cur_fde_data->end_address = label;
173   cur_fde_data = NULL;
174 }
175
176 /* Set the return column for the current FDE.  */
177
178 void
179 cfi_set_return_column (unsigned regno)
180 {
181   cur_fde_data->return_column = regno;
182 }
183
184 /* Universal functions to store new instructions.  */
185
186 static void
187 cfi_add_CFA_insn(int insn)
188 {
189   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
190
191   insn_ptr->insn = insn;
192 }
193
194 static void
195 cfi_add_CFA_insn_reg (int insn, unsigned regno)
196 {
197   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
198
199   insn_ptr->insn = insn;
200   insn_ptr->u.r = regno;
201 }
202
203 static void
204 cfi_add_CFA_insn_offset (int insn, offsetT offset)
205 {
206   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
207
208   insn_ptr->insn = insn;
209   insn_ptr->u.i = offset;
210 }
211
212 static void
213 cfi_add_CFA_insn_reg_reg (int insn, unsigned reg1, unsigned reg2)
214 {
215   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
216
217   insn_ptr->insn = insn;
218   insn_ptr->u.rr.reg1 = reg1;
219   insn_ptr->u.rr.reg2 = reg2;
220 }
221
222 static void
223 cfi_add_CFA_insn_reg_offset (int insn, unsigned regno, offsetT offset)
224 {
225   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
226
227   insn_ptr->insn = insn;
228   insn_ptr->u.ri.reg = regno;
229   insn_ptr->u.ri.offset = offset;
230 }
231
232 /* Add a CFI insn to advance the PC from the last address to LABEL.  */
233
234 void
235 cfi_add_advance_loc (symbolS *label)
236 {
237   struct cfi_insn_data *insn = alloc_cfi_insn_data ();
238
239   insn->insn = DW_CFA_advance_loc;
240   insn->u.ll.lab1 = last_address;
241   insn->u.ll.lab2 = label;
242
243   last_address = label;
244 }
245
246 /* Add a DW_CFA_offset record to the CFI data.  */
247
248 void
249 cfi_add_CFA_offset (unsigned regno, offsetT offset)
250 {
251   unsigned int abs_data_align;
252
253   cfi_add_CFA_insn_reg_offset (DW_CFA_offset, regno, offset);
254
255   abs_data_align = (DWARF2_CIE_DATA_ALIGNMENT < 0
256                     ? -DWARF2_CIE_DATA_ALIGNMENT : DWARF2_CIE_DATA_ALIGNMENT);
257   if (offset % abs_data_align)
258     as_bad (_("register save offset not a multiple of %u"), abs_data_align);
259 }
260
261 /* Add a DW_CFA_def_cfa record to the CFI data.  */
262
263 void
264 cfi_add_CFA_def_cfa (unsigned regno, offsetT offset)
265 {
266   cfi_add_CFA_insn_reg_offset (DW_CFA_def_cfa, regno, offset);
267   cur_cfa_offset = offset;
268 }
269
270 /* Add a DW_CFA_register record to the CFI data.  */
271
272 void
273 cfi_add_CFA_register (unsigned reg1, unsigned reg2)
274 {
275   cfi_add_CFA_insn_reg_reg (DW_CFA_register, reg1, reg2);
276 }
277
278 /* Add a DW_CFA_def_cfa_register record to the CFI data.  */
279
280 void
281 cfi_add_CFA_def_cfa_register (unsigned regno)
282 {
283   cfi_add_CFA_insn_reg (DW_CFA_def_cfa_register, regno);
284 }
285
286 /* Add a DW_CFA_def_cfa_offset record to the CFI data.  */
287
288 void
289 cfi_add_CFA_def_cfa_offset (offsetT offset)
290 {
291   cfi_add_CFA_insn_offset (DW_CFA_def_cfa_offset, offset);
292   cur_cfa_offset = offset;
293 }
294
295 void
296 cfi_add_CFA_restore (unsigned regno)
297 {
298   cfi_add_CFA_insn_reg (DW_CFA_restore, regno);
299 }
300
301 void
302 cfi_add_CFA_undefined (unsigned regno)
303 {
304   cfi_add_CFA_insn_reg (DW_CFA_undefined, regno);
305 }
306
307 void
308 cfi_add_CFA_same_value (unsigned regno)
309 {
310   cfi_add_CFA_insn_reg (DW_CFA_same_value, regno);
311 }
312
313 void
314 cfi_add_CFA_remember_state (void)
315 {
316   struct cfa_save_data *p;
317
318   cfi_add_CFA_insn (DW_CFA_remember_state);
319
320   p = xmalloc (sizeof (*p));
321   p->cfa_offset = cur_cfa_offset;
322   p->next = cfa_save_stack;
323   cfa_save_stack = p;
324 }
325
326 void
327 cfi_add_CFA_restore_state (void)
328 {
329   struct cfa_save_data *p;
330
331   cfi_add_CFA_insn (DW_CFA_restore_state);
332
333   p = cfa_save_stack;
334   if (p)
335     {
336       cur_cfa_offset = p->cfa_offset;
337       cfa_save_stack = p->next;
338       free (p);
339     }
340   else
341     as_bad (_("CFI state restore without previous remember"));
342 }
343
344 \f
345 /* Parse CFI assembler directives.  */
346
347 static void dot_cfi (int);
348 static void dot_cfi_escape (int);
349 static void dot_cfi_startproc (int);
350 static void dot_cfi_endproc (int);
351
352 /* Fake CFI type; outside the byte range of any real CFI insn.  */
353 #define CFI_adjust_cfa_offset   0x100
354 #define CFI_return_column       0x101
355 #define CFI_rel_offset          0x102
356 #define CFI_escape              0x103
357
358 const pseudo_typeS cfi_pseudo_table[] =
359   {
360     { "cfi_startproc", dot_cfi_startproc, 0 },
361     { "cfi_endproc", dot_cfi_endproc, 0 },
362     { "cfi_def_cfa", dot_cfi, DW_CFA_def_cfa },
363     { "cfi_def_cfa_register", dot_cfi, DW_CFA_def_cfa_register },
364     { "cfi_def_cfa_offset", dot_cfi, DW_CFA_def_cfa_offset },
365     { "cfi_adjust_cfa_offset", dot_cfi, CFI_adjust_cfa_offset },
366     { "cfi_offset", dot_cfi, DW_CFA_offset },
367     { "cfi_rel_offset", dot_cfi, CFI_rel_offset },
368     { "cfi_register", dot_cfi, DW_CFA_register },
369     { "cfi_return_column", dot_cfi, CFI_return_column },
370     { "cfi_restore", dot_cfi, DW_CFA_restore },
371     { "cfi_undefined", dot_cfi, DW_CFA_undefined },
372     { "cfi_same_value", dot_cfi, DW_CFA_same_value },
373     { "cfi_remember_state", dot_cfi, DW_CFA_remember_state },
374     { "cfi_restore_state", dot_cfi, DW_CFA_restore_state },
375     { "cfi_window_save", dot_cfi, DW_CFA_GNU_window_save },
376     { "cfi_escape", dot_cfi_escape, 0 },
377     { NULL, NULL, 0 }
378   };
379
380 static void
381 cfi_parse_separator (void)
382 {
383   SKIP_WHITESPACE ();
384   if (*input_line_pointer == ',')
385     input_line_pointer++;
386   else
387     as_bad (_("missing separator"));
388 }
389
390 static unsigned
391 cfi_parse_reg (void)
392 {
393   int regno;
394   expressionS exp;
395
396 #ifdef tc_regname_to_dw2regnum
397   SKIP_WHITESPACE ();
398   if (is_name_beginner (*input_line_pointer)
399       || (*input_line_pointer == '%'
400           && is_name_beginner (*++input_line_pointer)))
401     {
402       char *name, c;
403
404       name = input_line_pointer;
405       c = get_symbol_end ();
406
407       if ((regno = tc_regname_to_dw2regnum (name)) < 0)
408         {
409           as_bad (_("bad register expression"));
410           regno = 0;
411         }
412
413       *input_line_pointer = c;
414       return regno;
415     }
416 #endif
417
418   expression_and_evaluate (&exp);
419   switch (exp.X_op)
420     {
421     case O_register:
422     case O_constant:
423       regno = exp.X_add_number;
424       break;
425
426     default:
427       as_bad (_("bad register expression"));
428       regno = 0;
429       break;
430     }
431
432   return regno;
433 }
434
435 static offsetT
436 cfi_parse_const (void)
437 {
438   return get_absolute_expression ();
439 }
440
441 static void
442 dot_cfi (int arg)
443 {
444   offsetT offset;
445   unsigned reg1, reg2;
446
447   if (!cur_fde_data)
448     {
449       as_bad (_("CFI instruction used without previous .cfi_startproc"));
450       ignore_rest_of_line ();
451       return;
452     }
453
454   /* If the last address was not at the current PC, advance to current.  */
455   if (symbol_get_frag (last_address) != frag_now
456       || S_GET_VALUE (last_address) != frag_now_fix ())
457     cfi_add_advance_loc (symbol_temp_new_now ());
458
459   switch (arg)
460     {
461     case DW_CFA_offset:
462       reg1 = cfi_parse_reg ();
463       cfi_parse_separator ();
464       offset = cfi_parse_const ();
465       cfi_add_CFA_offset (reg1, offset);
466       break;
467
468     case CFI_rel_offset:
469       reg1 = cfi_parse_reg ();
470       cfi_parse_separator ();
471       offset = cfi_parse_const ();
472       cfi_add_CFA_offset (reg1, offset - cur_cfa_offset);
473       break;
474
475     case DW_CFA_def_cfa:
476       reg1 = cfi_parse_reg ();
477       cfi_parse_separator ();
478       offset = cfi_parse_const ();
479       cfi_add_CFA_def_cfa (reg1, offset);
480       break;
481
482     case DW_CFA_register:
483       reg1 = cfi_parse_reg ();
484       cfi_parse_separator ();
485       reg2 = cfi_parse_reg ();
486       cfi_add_CFA_register (reg1, reg2);
487       break;
488
489     case DW_CFA_def_cfa_register:
490       reg1 = cfi_parse_reg ();
491       cfi_add_CFA_def_cfa_register (reg1);
492       break;
493
494     case DW_CFA_def_cfa_offset:
495       offset = cfi_parse_const ();
496       cfi_add_CFA_def_cfa_offset (offset);
497       break;
498
499     case CFI_adjust_cfa_offset:
500       offset = cfi_parse_const ();
501       cfi_add_CFA_def_cfa_offset (cur_cfa_offset + offset);
502       break;
503
504     case DW_CFA_restore:
505       reg1 = cfi_parse_reg ();
506       cfi_add_CFA_restore (reg1);
507       break;
508
509     case DW_CFA_undefined:
510       reg1 = cfi_parse_reg ();
511       cfi_add_CFA_undefined (reg1);
512       break;
513
514     case DW_CFA_same_value:
515       reg1 = cfi_parse_reg ();
516       cfi_add_CFA_same_value (reg1);
517       break;
518
519     case CFI_return_column:
520       reg1 = cfi_parse_reg ();
521       cfi_set_return_column (reg1);
522       break;
523
524     case DW_CFA_remember_state:
525       cfi_add_CFA_remember_state ();
526       break;
527
528     case DW_CFA_restore_state:
529       cfi_add_CFA_restore_state ();
530       break;
531
532     case DW_CFA_GNU_window_save:
533       cfi_add_CFA_insn (DW_CFA_GNU_window_save);
534       break;
535
536     default:
537       abort ();
538     }
539
540   demand_empty_rest_of_line ();
541 }
542
543 static void
544 dot_cfi_escape (int ignored ATTRIBUTE_UNUSED)
545 {
546   struct cfi_escape_data *head, **tail, *e;
547   struct cfi_insn_data *insn;
548
549   if (!cur_fde_data)
550     {
551       as_bad (_("CFI instruction used without previous .cfi_startproc"));
552       ignore_rest_of_line ();
553       return;
554     }
555
556   /* If the last address was not at the current PC, advance to current.  */
557   if (symbol_get_frag (last_address) != frag_now
558       || S_GET_VALUE (last_address) != frag_now_fix ())
559     cfi_add_advance_loc (symbol_temp_new_now ());
560
561   tail = &head;
562   do
563     {
564       e = xmalloc (sizeof (*e));
565       do_parse_cons_expression (&e->exp, 1);
566       *tail = e;
567       tail = &e->next;
568     }
569   while (*input_line_pointer++ == ',');
570   *tail = NULL;
571
572   insn = alloc_cfi_insn_data ();
573   insn->insn = CFI_escape;
574   insn->u.esc = head;
575
576   --input_line_pointer;
577   demand_empty_rest_of_line ();
578 }
579
580 static void
581 dot_cfi_startproc (int ignored ATTRIBUTE_UNUSED)
582 {
583   int simple = 0;
584
585   if (cur_fde_data)
586     {
587       as_bad (_("previous CFI entry not closed (missing .cfi_endproc)"));
588       ignore_rest_of_line ();
589       return;
590     }
591
592   cfi_new_fde (symbol_temp_new_now ());
593
594   SKIP_WHITESPACE ();
595   if (is_name_beginner (*input_line_pointer))
596     {
597       char *name, c;
598
599       name = input_line_pointer;
600       c = get_symbol_end ();
601
602       if (strcmp (name, "simple") == 0)
603         {
604           simple = 1;
605           *input_line_pointer = c;
606         }
607       else
608         input_line_pointer = name;
609     }
610   demand_empty_rest_of_line ();
611
612   cur_cfa_offset = 0;
613   if (!simple)
614     tc_cfi_frame_initial_instructions ();
615 }
616
617 static void
618 dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED)
619 {
620   if (! cur_fde_data)
621     {
622       as_bad (_(".cfi_endproc without corresponding .cfi_startproc"));
623       ignore_rest_of_line ();
624       return;
625     }
626
627   cfi_end_fde (symbol_temp_new_now ());
628
629   demand_empty_rest_of_line ();
630 }
631
632 \f
633 /* Emit a single byte into the current segment.  */
634
635 static inline void
636 out_one (int byte)
637 {
638   FRAG_APPEND_1_CHAR (byte);
639 }
640
641 /* Emit a two-byte word into the current segment.  */
642
643 static inline void
644 out_two (int data)
645 {
646   md_number_to_chars (frag_more (2), data, 2);
647 }
648
649 /* Emit a four byte word into the current segment.  */
650
651 static inline void
652 out_four (int data)
653 {
654   md_number_to_chars (frag_more (4), data, 4);
655 }
656
657 /* Emit an unsigned "little-endian base 128" number.  */
658
659 static void
660 out_uleb128 (addressT value)
661 {
662   output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
663 }
664
665 /* Emit an unsigned "little-endian base 128" number.  */
666
667 static void
668 out_sleb128 (offsetT value)
669 {
670   output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1);
671 }
672
673 static void
674 output_cfi_insn (struct cfi_insn_data *insn)
675 {
676   offsetT offset;
677   unsigned int regno;
678
679   switch (insn->insn)
680     {
681     case DW_CFA_advance_loc:
682       {
683         symbolS *from = insn->u.ll.lab1;
684         symbolS *to = insn->u.ll.lab2;
685
686         if (symbol_get_frag (to) == symbol_get_frag (from))
687           {
688             addressT delta = S_GET_VALUE (to) - S_GET_VALUE (from);
689             addressT scaled = delta / DWARF2_LINE_MIN_INSN_LENGTH;
690
691             if (scaled <= 0x3F)
692               out_one (DW_CFA_advance_loc + scaled);
693             else if (delta <= 0xFF)
694               {
695                 out_one (DW_CFA_advance_loc1);
696                 out_one (delta);
697               }
698             else if (delta <= 0xFFFF)
699               {
700                 out_one (DW_CFA_advance_loc2);
701                 out_two (delta);
702               }
703             else
704               {
705                 out_one (DW_CFA_advance_loc4);
706                 out_four (delta);
707               }
708           }
709         else
710           {
711             expressionS exp;
712
713             exp.X_op = O_subtract;
714             exp.X_add_symbol = to;
715             exp.X_op_symbol = from;
716             exp.X_add_number = 0;
717
718             /* The code in ehopt.c expects that one byte of the encoding
719                is already allocated to the frag.  This comes from the way
720                that it scans the .eh_frame section looking first for the
721                .byte DW_CFA_advance_loc4.  */
722             frag_more (1);
723
724             frag_var (rs_cfa, 4, 0, DWARF2_LINE_MIN_INSN_LENGTH << 3,
725                       make_expr_symbol (&exp), frag_now_fix () - 1,
726                       (char *) frag_now);
727           }
728       }
729       break;
730
731     case DW_CFA_def_cfa:
732       offset = insn->u.ri.offset;
733       if (offset < 0)
734         {
735           out_one (DW_CFA_def_cfa_sf);
736           out_uleb128 (insn->u.ri.reg);
737           out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
738         }
739       else
740         {
741           out_one (DW_CFA_def_cfa);
742           out_uleb128 (insn->u.ri.reg);
743           out_uleb128 (offset);
744         }
745       break;
746
747     case DW_CFA_def_cfa_register:
748     case DW_CFA_undefined:
749     case DW_CFA_same_value:
750       out_one (insn->insn);
751       out_uleb128 (insn->u.r);
752       break;
753
754     case DW_CFA_def_cfa_offset:
755       offset = insn->u.i;
756       if (offset < 0)
757         {
758           out_one (DW_CFA_def_cfa_offset_sf);
759           out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
760         }
761       else
762         {
763           out_one (DW_CFA_def_cfa_offset);
764           out_uleb128 (offset);
765         }
766       break;
767
768     case DW_CFA_restore:
769       regno = insn->u.r;
770       if (regno <= 0x3F)
771         {
772           out_one (DW_CFA_restore + regno);
773         }
774       else
775         {
776           out_one (DW_CFA_restore_extended);
777           out_uleb128 (regno);
778         }
779       break;
780
781     case DW_CFA_offset:
782       regno = insn->u.ri.reg;
783       offset = insn->u.ri.offset / DWARF2_CIE_DATA_ALIGNMENT;
784       if (offset < 0)
785         {
786           out_one (DW_CFA_offset_extended_sf);
787           out_uleb128 (regno);
788           out_sleb128 (offset);
789         }
790       else if (regno <= 0x3F)
791         {
792           out_one (DW_CFA_offset + regno);
793           out_uleb128 (offset);
794         }
795       else
796         {
797           out_one (DW_CFA_offset_extended);
798           out_uleb128 (regno);
799           out_uleb128 (offset);
800         }
801       break;
802
803     case DW_CFA_register:
804       out_one (DW_CFA_register);
805       out_uleb128 (insn->u.rr.reg1);
806       out_uleb128 (insn->u.rr.reg2);
807       break;
808
809     case DW_CFA_remember_state:
810     case DW_CFA_restore_state:
811       out_one (insn->insn);
812       break;
813
814     case DW_CFA_GNU_window_save:
815       out_one (DW_CFA_GNU_window_save);
816       break;
817
818     case CFI_escape:
819       {
820         struct cfi_escape_data *e;
821         for (e = insn->u.esc; e ; e = e->next)
822           emit_expr (&e->exp, 1);
823         break;
824       }
825
826     default:
827       abort ();
828     }
829 }
830
831 static void
832 output_cie (struct cie_entry *cie)
833 {
834   symbolS *after_size_address, *end_address;
835   expressionS exp;
836   struct cfi_insn_data *i;
837
838   cie->start_address = symbol_temp_new_now ();
839   after_size_address = symbol_temp_make ();
840   end_address = symbol_temp_make ();
841
842   exp.X_op = O_subtract;
843   exp.X_add_symbol = end_address;
844   exp.X_op_symbol = after_size_address;
845   exp.X_add_number = 0;
846
847   emit_expr (&exp, 4);                          /* Length.  */
848   symbol_set_value_now (after_size_address);
849   out_four (0);                                 /* CIE id.  */
850   out_one (DW_CIE_VERSION);                     /* Version.  */
851   out_one ('z');                                /* Augmentation.  */
852   out_one ('R');
853   out_one (0);
854   out_uleb128 (DWARF2_LINE_MIN_INSN_LENGTH);    /* Code alignment.  */
855   out_sleb128 (DWARF2_CIE_DATA_ALIGNMENT);      /* Data alignment.  */
856   if (DW_CIE_VERSION == 1)                      /* Return column.  */
857     out_one (cie->return_column);
858   else
859     out_uleb128 (cie->return_column);
860   out_uleb128 (1);                              /* Augmentation size.  */
861 #if defined DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
862   out_one (DW_EH_PE_pcrel | DW_EH_PE_sdata4);
863 #else
864   out_one (DW_EH_PE_sdata4);
865 #endif
866
867   if (cie->first)
868     for (i = cie->first; i != cie->last; i = i->next)
869       output_cfi_insn (i);
870
871   frag_align (2, DW_CFA_nop, 0);
872   symbol_set_value_now (end_address);
873 }
874
875 static void
876 output_fde (struct fde_entry *fde, struct cie_entry *cie,
877             struct cfi_insn_data *first, int align)
878 {
879   symbolS *after_size_address, *end_address;
880   expressionS exp;
881
882   after_size_address = symbol_temp_make ();
883   end_address = symbol_temp_make ();
884
885   exp.X_op = O_subtract;
886   exp.X_add_symbol = end_address;
887   exp.X_op_symbol = after_size_address;
888   exp.X_add_number = 0;
889   emit_expr (&exp, 4);                          /* Length.  */
890   symbol_set_value_now (after_size_address);
891
892   exp.X_add_symbol = after_size_address;
893   exp.X_op_symbol = cie->start_address;
894   emit_expr (&exp, 4);                          /* CIE offset.  */
895
896 #ifdef DIFF_EXPR_OK  
897   exp.X_add_symbol = fde->start_address;
898   exp.X_op_symbol = symbol_temp_new_now ();
899   emit_expr (&exp, 4);                          /* Code offset.  */
900 #else
901   exp.X_op = O_symbol;
902   exp.X_add_symbol = fde->start_address;
903   exp.X_op_symbol = NULL;
904 #ifdef tc_cfi_emit_pcrel_expr
905   tc_cfi_emit_pcrel_expr (&exp, 4);             /* Code offset.  */
906 #else
907   emit_expr (&exp, 4);                          /* Code offset.  */
908 #endif
909   exp.X_op = O_subtract;
910 #endif
911
912   exp.X_add_symbol = fde->end_address;
913   exp.X_op_symbol = fde->start_address;         /* Code length.  */
914   emit_expr (&exp, 4);
915
916   out_uleb128 (0);                              /* Augmentation size.  */
917
918   for (; first; first = first->next)
919     output_cfi_insn (first);
920
921   frag_align (align, DW_CFA_nop, 0);
922   symbol_set_value_now (end_address);
923 }
924
925 static struct cie_entry *
926 select_cie_for_fde (struct fde_entry *fde, struct cfi_insn_data **pfirst)
927 {
928   struct cfi_insn_data *i, *j;
929   struct cie_entry *cie;
930
931   for (cie = cie_root; cie; cie = cie->next)
932     {
933       if (cie->return_column != fde->return_column)
934         continue;
935       for (i = cie->first, j = fde->data;
936            i != cie->last && j != NULL;
937            i = i->next, j = j->next)
938         {
939           if (i->insn != j->insn)
940             goto fail;
941           switch (i->insn)
942             {
943             case DW_CFA_advance_loc:
944             case DW_CFA_remember_state:
945               /* We reached the first advance/remember in the FDE,
946                  but did not reach the end of the CIE list.  */
947               goto fail;
948
949             case DW_CFA_offset:
950             case DW_CFA_def_cfa:
951               if (i->u.ri.reg != j->u.ri.reg)
952                 goto fail;
953               if (i->u.ri.offset != j->u.ri.offset)
954                 goto fail;
955               break;
956
957             case DW_CFA_register:
958               if (i->u.rr.reg1 != j->u.rr.reg1)
959                 goto fail;
960               if (i->u.rr.reg2 != j->u.rr.reg2)
961                 goto fail;
962               break;
963
964             case DW_CFA_def_cfa_register:
965             case DW_CFA_restore:
966             case DW_CFA_undefined:
967             case DW_CFA_same_value:
968               if (i->u.r != j->u.r)
969                 goto fail;
970               break;
971
972             case DW_CFA_def_cfa_offset:
973               if (i->u.i != j->u.i)
974                 goto fail;
975               break;
976
977             case CFI_escape:
978               /* Don't bother matching these for now.  */
979               goto fail;
980
981             default:
982               abort ();
983             }
984         }
985
986       /* Success if we reached the end of the CIE list, and we've either
987          run out of FDE entries or we've encountered an advance,
988          remember, or escape.  */
989       if (i == cie->last
990           && (!j
991               || j->insn == DW_CFA_advance_loc
992               || j->insn == DW_CFA_remember_state
993               || j->insn == CFI_escape))
994         {
995           *pfirst = j;
996           return cie;
997         }
998
999     fail:;
1000     }
1001
1002   cie = xmalloc (sizeof (struct cie_entry));
1003   cie->next = cie_root;
1004   cie_root = cie;
1005   cie->return_column = fde->return_column;
1006   cie->first = fde->data;
1007
1008   for (i = cie->first; i ; i = i->next)
1009     if (i->insn == DW_CFA_advance_loc
1010         || i->insn == DW_CFA_remember_state
1011         || i->insn == CFI_escape)
1012       break;
1013
1014   cie->last = i;
1015   *pfirst = i;
1016    
1017   output_cie (cie);
1018
1019   return cie;
1020 }
1021
1022 void
1023 cfi_finish (void)
1024 {
1025   segT cfi_seg;
1026   struct fde_entry *fde;
1027   int save_flag_traditional_format;
1028
1029   if (cur_fde_data)
1030     {
1031       as_bad (_("open CFI at the end of file; missing .cfi_endproc directive"));
1032       cur_fde_data->end_address = cur_fde_data->start_address;
1033     }
1034
1035   if (all_fde_data == 0)
1036     return;
1037
1038   /* Open .eh_frame section.  */
1039   cfi_seg = subseg_new (".eh_frame", 0);
1040   bfd_set_section_flags (stdoutput, cfi_seg,
1041                          SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY);
1042   subseg_set (cfi_seg, 0);
1043   record_alignment (cfi_seg, EH_FRAME_ALIGNMENT);
1044
1045   /* Make sure check_eh_frame doesn't do anything with our output.  */
1046   save_flag_traditional_format = flag_traditional_format;
1047   flag_traditional_format = 1;
1048
1049   for (fde = all_fde_data; fde ; fde = fde->next)
1050     {
1051       struct cfi_insn_data *first;
1052       struct cie_entry *cie;
1053
1054       cie = select_cie_for_fde (fde, &first);
1055       output_fde (fde, cie, first, fde->next == NULL ? EH_FRAME_ALIGNMENT : 2);
1056     }
1057
1058   flag_traditional_format = save_flag_traditional_format;
1059 }