gas/
[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       for (;;)
506         {
507           reg1 = cfi_parse_reg ();
508           cfi_add_CFA_restore (reg1);
509           SKIP_WHITESPACE ();
510           if (*input_line_pointer != ',')
511             break;
512           ++input_line_pointer;
513         }
514       break;
515
516     case DW_CFA_undefined:
517       for (;;)
518         {
519           reg1 = cfi_parse_reg ();
520           cfi_add_CFA_undefined (reg1);
521           SKIP_WHITESPACE ();
522           if (*input_line_pointer != ',')
523             break;
524           ++input_line_pointer;
525         }
526       break;
527
528     case DW_CFA_same_value:
529       reg1 = cfi_parse_reg ();
530       cfi_add_CFA_same_value (reg1);
531       break;
532
533     case CFI_return_column:
534       reg1 = cfi_parse_reg ();
535       cfi_set_return_column (reg1);
536       break;
537
538     case DW_CFA_remember_state:
539       cfi_add_CFA_remember_state ();
540       break;
541
542     case DW_CFA_restore_state:
543       cfi_add_CFA_restore_state ();
544       break;
545
546     case DW_CFA_GNU_window_save:
547       cfi_add_CFA_insn (DW_CFA_GNU_window_save);
548       break;
549
550     default:
551       abort ();
552     }
553
554   demand_empty_rest_of_line ();
555 }
556
557 static void
558 dot_cfi_escape (int ignored ATTRIBUTE_UNUSED)
559 {
560   struct cfi_escape_data *head, **tail, *e;
561   struct cfi_insn_data *insn;
562
563   if (!cur_fde_data)
564     {
565       as_bad (_("CFI instruction used without previous .cfi_startproc"));
566       ignore_rest_of_line ();
567       return;
568     }
569
570   /* If the last address was not at the current PC, advance to current.  */
571   if (symbol_get_frag (last_address) != frag_now
572       || S_GET_VALUE (last_address) != frag_now_fix ())
573     cfi_add_advance_loc (symbol_temp_new_now ());
574
575   tail = &head;
576   do
577     {
578       e = xmalloc (sizeof (*e));
579       do_parse_cons_expression (&e->exp, 1);
580       *tail = e;
581       tail = &e->next;
582     }
583   while (*input_line_pointer++ == ',');
584   *tail = NULL;
585
586   insn = alloc_cfi_insn_data ();
587   insn->insn = CFI_escape;
588   insn->u.esc = head;
589
590   --input_line_pointer;
591   demand_empty_rest_of_line ();
592 }
593
594 static void
595 dot_cfi_startproc (int ignored ATTRIBUTE_UNUSED)
596 {
597   int simple = 0;
598
599   if (cur_fde_data)
600     {
601       as_bad (_("previous CFI entry not closed (missing .cfi_endproc)"));
602       ignore_rest_of_line ();
603       return;
604     }
605
606   cfi_new_fde (symbol_temp_new_now ());
607
608   SKIP_WHITESPACE ();
609   if (is_name_beginner (*input_line_pointer))
610     {
611       char *name, c;
612
613       name = input_line_pointer;
614       c = get_symbol_end ();
615
616       if (strcmp (name, "simple") == 0)
617         {
618           simple = 1;
619           *input_line_pointer = c;
620         }
621       else
622         input_line_pointer = name;
623     }
624   demand_empty_rest_of_line ();
625
626   cur_cfa_offset = 0;
627   if (!simple)
628     tc_cfi_frame_initial_instructions ();
629 }
630
631 static void
632 dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED)
633 {
634   if (! cur_fde_data)
635     {
636       as_bad (_(".cfi_endproc without corresponding .cfi_startproc"));
637       ignore_rest_of_line ();
638       return;
639     }
640
641   cfi_end_fde (symbol_temp_new_now ());
642
643   demand_empty_rest_of_line ();
644 }
645
646 \f
647 /* Emit a single byte into the current segment.  */
648
649 static inline void
650 out_one (int byte)
651 {
652   FRAG_APPEND_1_CHAR (byte);
653 }
654
655 /* Emit a two-byte word into the current segment.  */
656
657 static inline void
658 out_two (int data)
659 {
660   md_number_to_chars (frag_more (2), data, 2);
661 }
662
663 /* Emit a four byte word into the current segment.  */
664
665 static inline void
666 out_four (int data)
667 {
668   md_number_to_chars (frag_more (4), data, 4);
669 }
670
671 /* Emit an unsigned "little-endian base 128" number.  */
672
673 static void
674 out_uleb128 (addressT value)
675 {
676   output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
677 }
678
679 /* Emit an unsigned "little-endian base 128" number.  */
680
681 static void
682 out_sleb128 (offsetT value)
683 {
684   output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1);
685 }
686
687 static void
688 output_cfi_insn (struct cfi_insn_data *insn)
689 {
690   offsetT offset;
691   unsigned int regno;
692
693   switch (insn->insn)
694     {
695     case DW_CFA_advance_loc:
696       {
697         symbolS *from = insn->u.ll.lab1;
698         symbolS *to = insn->u.ll.lab2;
699
700         if (symbol_get_frag (to) == symbol_get_frag (from))
701           {
702             addressT delta = S_GET_VALUE (to) - S_GET_VALUE (from);
703             addressT scaled = delta / DWARF2_LINE_MIN_INSN_LENGTH;
704
705             if (scaled <= 0x3F)
706               out_one (DW_CFA_advance_loc + scaled);
707             else if (delta <= 0xFF)
708               {
709                 out_one (DW_CFA_advance_loc1);
710                 out_one (delta);
711               }
712             else if (delta <= 0xFFFF)
713               {
714                 out_one (DW_CFA_advance_loc2);
715                 out_two (delta);
716               }
717             else
718               {
719                 out_one (DW_CFA_advance_loc4);
720                 out_four (delta);
721               }
722           }
723         else
724           {
725             expressionS exp;
726
727             exp.X_op = O_subtract;
728             exp.X_add_symbol = to;
729             exp.X_op_symbol = from;
730             exp.X_add_number = 0;
731
732             /* The code in ehopt.c expects that one byte of the encoding
733                is already allocated to the frag.  This comes from the way
734                that it scans the .eh_frame section looking first for the
735                .byte DW_CFA_advance_loc4.  */
736             frag_more (1);
737
738             frag_var (rs_cfa, 4, 0, DWARF2_LINE_MIN_INSN_LENGTH << 3,
739                       make_expr_symbol (&exp), frag_now_fix () - 1,
740                       (char *) frag_now);
741           }
742       }
743       break;
744
745     case DW_CFA_def_cfa:
746       offset = insn->u.ri.offset;
747       if (offset < 0)
748         {
749           out_one (DW_CFA_def_cfa_sf);
750           out_uleb128 (insn->u.ri.reg);
751           out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
752         }
753       else
754         {
755           out_one (DW_CFA_def_cfa);
756           out_uleb128 (insn->u.ri.reg);
757           out_uleb128 (offset);
758         }
759       break;
760
761     case DW_CFA_def_cfa_register:
762     case DW_CFA_undefined:
763     case DW_CFA_same_value:
764       out_one (insn->insn);
765       out_uleb128 (insn->u.r);
766       break;
767
768     case DW_CFA_def_cfa_offset:
769       offset = insn->u.i;
770       if (offset < 0)
771         {
772           out_one (DW_CFA_def_cfa_offset_sf);
773           out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
774         }
775       else
776         {
777           out_one (DW_CFA_def_cfa_offset);
778           out_uleb128 (offset);
779         }
780       break;
781
782     case DW_CFA_restore:
783       regno = insn->u.r;
784       if (regno <= 0x3F)
785         {
786           out_one (DW_CFA_restore + regno);
787         }
788       else
789         {
790           out_one (DW_CFA_restore_extended);
791           out_uleb128 (regno);
792         }
793       break;
794
795     case DW_CFA_offset:
796       regno = insn->u.ri.reg;
797       offset = insn->u.ri.offset / DWARF2_CIE_DATA_ALIGNMENT;
798       if (offset < 0)
799         {
800           out_one (DW_CFA_offset_extended_sf);
801           out_uleb128 (regno);
802           out_sleb128 (offset);
803         }
804       else if (regno <= 0x3F)
805         {
806           out_one (DW_CFA_offset + regno);
807           out_uleb128 (offset);
808         }
809       else
810         {
811           out_one (DW_CFA_offset_extended);
812           out_uleb128 (regno);
813           out_uleb128 (offset);
814         }
815       break;
816
817     case DW_CFA_register:
818       out_one (DW_CFA_register);
819       out_uleb128 (insn->u.rr.reg1);
820       out_uleb128 (insn->u.rr.reg2);
821       break;
822
823     case DW_CFA_remember_state:
824     case DW_CFA_restore_state:
825       out_one (insn->insn);
826       break;
827
828     case DW_CFA_GNU_window_save:
829       out_one (DW_CFA_GNU_window_save);
830       break;
831
832     case CFI_escape:
833       {
834         struct cfi_escape_data *e;
835         for (e = insn->u.esc; e ; e = e->next)
836           emit_expr (&e->exp, 1);
837         break;
838       }
839
840     default:
841       abort ();
842     }
843 }
844
845 static void
846 output_cie (struct cie_entry *cie)
847 {
848   symbolS *after_size_address, *end_address;
849   expressionS exp;
850   struct cfi_insn_data *i;
851
852   cie->start_address = symbol_temp_new_now ();
853   after_size_address = symbol_temp_make ();
854   end_address = symbol_temp_make ();
855
856   exp.X_op = O_subtract;
857   exp.X_add_symbol = end_address;
858   exp.X_op_symbol = after_size_address;
859   exp.X_add_number = 0;
860
861   emit_expr (&exp, 4);                          /* Length.  */
862   symbol_set_value_now (after_size_address);
863   out_four (0);                                 /* CIE id.  */
864   out_one (DW_CIE_VERSION);                     /* Version.  */
865   out_one ('z');                                /* Augmentation.  */
866   out_one ('R');
867   out_one (0);
868   out_uleb128 (DWARF2_LINE_MIN_INSN_LENGTH);    /* Code alignment.  */
869   out_sleb128 (DWARF2_CIE_DATA_ALIGNMENT);      /* Data alignment.  */
870   if (DW_CIE_VERSION == 1)                      /* Return column.  */
871     out_one (cie->return_column);
872   else
873     out_uleb128 (cie->return_column);
874   out_uleb128 (1);                              /* Augmentation size.  */
875 #if defined DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
876   out_one (DW_EH_PE_pcrel | DW_EH_PE_sdata4);
877 #else
878   out_one (DW_EH_PE_sdata4);
879 #endif
880
881   if (cie->first)
882     for (i = cie->first; i != cie->last; i = i->next)
883       output_cfi_insn (i);
884
885   frag_align (2, DW_CFA_nop, 0);
886   symbol_set_value_now (end_address);
887 }
888
889 static void
890 output_fde (struct fde_entry *fde, struct cie_entry *cie,
891             struct cfi_insn_data *first, int align)
892 {
893   symbolS *after_size_address, *end_address;
894   expressionS exp;
895
896   after_size_address = symbol_temp_make ();
897   end_address = symbol_temp_make ();
898
899   exp.X_op = O_subtract;
900   exp.X_add_symbol = end_address;
901   exp.X_op_symbol = after_size_address;
902   exp.X_add_number = 0;
903   emit_expr (&exp, 4);                          /* Length.  */
904   symbol_set_value_now (after_size_address);
905
906   exp.X_add_symbol = after_size_address;
907   exp.X_op_symbol = cie->start_address;
908   emit_expr (&exp, 4);                          /* CIE offset.  */
909
910 #ifdef DIFF_EXPR_OK  
911   exp.X_add_symbol = fde->start_address;
912   exp.X_op_symbol = symbol_temp_new_now ();
913   emit_expr (&exp, 4);                          /* Code offset.  */
914 #else
915   exp.X_op = O_symbol;
916   exp.X_add_symbol = fde->start_address;
917   exp.X_op_symbol = NULL;
918 #ifdef tc_cfi_emit_pcrel_expr
919   tc_cfi_emit_pcrel_expr (&exp, 4);             /* Code offset.  */
920 #else
921   emit_expr (&exp, 4);                          /* Code offset.  */
922 #endif
923   exp.X_op = O_subtract;
924 #endif
925
926   exp.X_add_symbol = fde->end_address;
927   exp.X_op_symbol = fde->start_address;         /* Code length.  */
928   emit_expr (&exp, 4);
929
930   out_uleb128 (0);                              /* Augmentation size.  */
931
932   for (; first; first = first->next)
933     output_cfi_insn (first);
934
935   frag_align (align, DW_CFA_nop, 0);
936   symbol_set_value_now (end_address);
937 }
938
939 static struct cie_entry *
940 select_cie_for_fde (struct fde_entry *fde, struct cfi_insn_data **pfirst)
941 {
942   struct cfi_insn_data *i, *j;
943   struct cie_entry *cie;
944
945   for (cie = cie_root; cie; cie = cie->next)
946     {
947       if (cie->return_column != fde->return_column)
948         continue;
949       for (i = cie->first, j = fde->data;
950            i != cie->last && j != NULL;
951            i = i->next, j = j->next)
952         {
953           if (i->insn != j->insn)
954             goto fail;
955           switch (i->insn)
956             {
957             case DW_CFA_advance_loc:
958             case DW_CFA_remember_state:
959               /* We reached the first advance/remember in the FDE,
960                  but did not reach the end of the CIE list.  */
961               goto fail;
962
963             case DW_CFA_offset:
964             case DW_CFA_def_cfa:
965               if (i->u.ri.reg != j->u.ri.reg)
966                 goto fail;
967               if (i->u.ri.offset != j->u.ri.offset)
968                 goto fail;
969               break;
970
971             case DW_CFA_register:
972               if (i->u.rr.reg1 != j->u.rr.reg1)
973                 goto fail;
974               if (i->u.rr.reg2 != j->u.rr.reg2)
975                 goto fail;
976               break;
977
978             case DW_CFA_def_cfa_register:
979             case DW_CFA_restore:
980             case DW_CFA_undefined:
981             case DW_CFA_same_value:
982               if (i->u.r != j->u.r)
983                 goto fail;
984               break;
985
986             case DW_CFA_def_cfa_offset:
987               if (i->u.i != j->u.i)
988                 goto fail;
989               break;
990
991             case CFI_escape:
992               /* Don't bother matching these for now.  */
993               goto fail;
994
995             default:
996               abort ();
997             }
998         }
999
1000       /* Success if we reached the end of the CIE list, and we've either
1001          run out of FDE entries or we've encountered an advance,
1002          remember, or escape.  */
1003       if (i == cie->last
1004           && (!j
1005               || j->insn == DW_CFA_advance_loc
1006               || j->insn == DW_CFA_remember_state
1007               || j->insn == CFI_escape))
1008         {
1009           *pfirst = j;
1010           return cie;
1011         }
1012
1013     fail:;
1014     }
1015
1016   cie = xmalloc (sizeof (struct cie_entry));
1017   cie->next = cie_root;
1018   cie_root = cie;
1019   cie->return_column = fde->return_column;
1020   cie->first = fde->data;
1021
1022   for (i = cie->first; i ; i = i->next)
1023     if (i->insn == DW_CFA_advance_loc
1024         || i->insn == DW_CFA_remember_state
1025         || i->insn == CFI_escape)
1026       break;
1027
1028   cie->last = i;
1029   *pfirst = i;
1030    
1031   output_cie (cie);
1032
1033   return cie;
1034 }
1035
1036 void
1037 cfi_finish (void)
1038 {
1039   segT cfi_seg;
1040   struct fde_entry *fde;
1041   int save_flag_traditional_format;
1042
1043   if (cur_fde_data)
1044     {
1045       as_bad (_("open CFI at the end of file; missing .cfi_endproc directive"));
1046       cur_fde_data->end_address = cur_fde_data->start_address;
1047     }
1048
1049   if (all_fde_data == 0)
1050     return;
1051
1052   /* Open .eh_frame section.  */
1053   cfi_seg = subseg_new (".eh_frame", 0);
1054   bfd_set_section_flags (stdoutput, cfi_seg,
1055                          SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY);
1056   subseg_set (cfi_seg, 0);
1057   record_alignment (cfi_seg, EH_FRAME_ALIGNMENT);
1058
1059   /* Make sure check_eh_frame doesn't do anything with our output.  */
1060   save_flag_traditional_format = flag_traditional_format;
1061   flag_traditional_format = 1;
1062
1063   for (fde = all_fde_data; fde ; fde = fde->next)
1064     {
1065       struct cfi_insn_data *first;
1066       struct cie_entry *cie;
1067
1068       cie = select_cie_for_fde (fde, &first);
1069       output_fde (fde, cie, first, fde->next == NULL ? EH_FRAME_ALIGNMENT : 2);
1070     }
1071
1072   flag_traditional_format = save_flag_traditional_format;
1073 }