gas/
[external/binutils.git] / gas / dw2gencfi.c
1 /* dw2gencfi.c - Support for generating Dwarf2 CFI information.
2    Copyright 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
3    Contributed by Michal Ludvig <mludvig@suse.cz>
4
5    This file is part of GAS, the GNU Assembler.
6
7    GAS is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3, or (at your option)
10    any later version.
11
12    GAS is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with GAS; see the file COPYING.  If not, write to the Free
19    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
20    02110-1301, USA.  */
21
22 #include "as.h"
23 #include "dw2gencfi.h"
24 #include "subsegs.h"
25
26 #ifdef TARGET_USE_CFIPOP
27
28 /* We re-use DWARF2_LINE_MIN_INSN_LENGTH for the code alignment field
29    of the CIE.  Default to 1 if not otherwise specified.  */
30 #ifndef  DWARF2_LINE_MIN_INSN_LENGTH
31 # define DWARF2_LINE_MIN_INSN_LENGTH 1
32 #endif
33
34 #ifndef EH_FRAME_ALIGNMENT
35 # define EH_FRAME_ALIGNMENT (bfd_get_arch_size (stdoutput) == 64 ? 3 : 2)
36 #endif
37
38 #ifndef tc_cfi_frame_initial_instructions
39 # define tc_cfi_frame_initial_instructions() ((void)0)
40 #endif
41
42
43 struct cfi_insn_data
44 {
45   struct cfi_insn_data *next;
46   int insn;
47   union {
48     struct {
49       unsigned reg;
50       offsetT offset;
51     } ri;
52
53     struct {
54       unsigned reg1;
55       unsigned reg2;
56     } rr;
57
58     unsigned r;
59     offsetT i;
60
61     struct {
62       symbolS *lab1;
63       symbolS *lab2;
64     } ll;
65
66     struct cfi_escape_data {
67       struct cfi_escape_data *next;
68       expressionS exp;
69     } *esc;
70   } u;
71 };
72
73 struct fde_entry
74 {
75   struct fde_entry *next;
76   symbolS *start_address;
77   symbolS *end_address;
78   struct cfi_insn_data *data;
79   struct cfi_insn_data **last;
80   unsigned char per_encoding;
81   unsigned char lsda_encoding;
82   expressionS personality;
83   expressionS lsda;
84   unsigned int return_column;
85   unsigned int signal_frame;
86 };
87
88 struct cie_entry
89 {
90   struct cie_entry *next;
91   symbolS *start_address;
92   unsigned int return_column;
93   unsigned int signal_frame;
94   unsigned char per_encoding;
95   unsigned char lsda_encoding;
96   expressionS personality;
97   struct cfi_insn_data *first, *last;
98 };
99
100
101 /* List of FDE entries.  */
102 static struct fde_entry *all_fde_data;
103 static struct fde_entry **last_fde_data = &all_fde_data;
104
105 /* List of CIEs so that they could be reused.  */
106 static struct cie_entry *cie_root;
107
108 /* Stack of old CFI data, for save/restore.  */
109 struct cfa_save_data
110 {
111   struct cfa_save_data *next;
112   offsetT cfa_offset;
113 };
114
115 /* Current open FDE entry.  */
116 struct frch_cfi_data
117 {
118   struct fde_entry *cur_fde_data;
119   symbolS *last_address;
120   offsetT cur_cfa_offset;
121   struct cfa_save_data *cfa_save_stack;
122 };
123 \f
124 /* Construct a new FDE structure and add it to the end of the fde list.  */
125
126 static struct fde_entry *
127 alloc_fde_entry (void)
128 {
129   struct fde_entry *fde = xcalloc (1, sizeof (struct fde_entry));
130
131   frchain_now->frch_cfi_data = xcalloc (1, sizeof (struct frch_cfi_data));
132   frchain_now->frch_cfi_data->cur_fde_data = fde;
133   *last_fde_data = fde;
134   last_fde_data = &fde->next;
135
136   fde->last = &fde->data;
137   fde->return_column = DWARF2_DEFAULT_RETURN_COLUMN;
138   fde->per_encoding = DW_EH_PE_omit;
139   fde->lsda_encoding = DW_EH_PE_omit;
140
141   return fde;
142 }
143
144 /* The following functions are available for a backend to construct its
145    own unwind information, usually from legacy unwind directives.  */
146
147 /* Construct a new INSN structure and add it to the end of the insn list
148    for the currently active FDE.  */
149
150 static struct cfi_insn_data *
151 alloc_cfi_insn_data (void)
152 {
153   struct cfi_insn_data *insn = xcalloc (1, sizeof (struct cfi_insn_data));
154   struct fde_entry *cur_fde_data = frchain_now->frch_cfi_data->cur_fde_data;
155
156   *cur_fde_data->last = insn;
157   cur_fde_data->last = &insn->next;
158
159   return insn;
160 }
161
162 /* Construct a new FDE structure that begins at LABEL.  */
163
164 void 
165 cfi_new_fde (symbolS *label)
166 {
167   struct fde_entry *fde = alloc_fde_entry ();
168   fde->start_address = label;
169   frchain_now->frch_cfi_data->last_address = label;
170 }
171
172 /* End the currently open FDE.  */
173
174 void 
175 cfi_end_fde (symbolS *label)
176 {
177   frchain_now->frch_cfi_data->cur_fde_data->end_address = label;
178   free (frchain_now->frch_cfi_data);
179   frchain_now->frch_cfi_data = NULL;
180 }
181
182 /* Set the return column for the current FDE.  */
183
184 void
185 cfi_set_return_column (unsigned regno)
186 {
187   frchain_now->frch_cfi_data->cur_fde_data->return_column = regno;
188 }
189
190 /* Universal functions to store new instructions.  */
191
192 static void
193 cfi_add_CFA_insn(int insn)
194 {
195   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
196
197   insn_ptr->insn = insn;
198 }
199
200 static void
201 cfi_add_CFA_insn_reg (int insn, unsigned regno)
202 {
203   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
204
205   insn_ptr->insn = insn;
206   insn_ptr->u.r = regno;
207 }
208
209 static void
210 cfi_add_CFA_insn_offset (int insn, offsetT offset)
211 {
212   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
213
214   insn_ptr->insn = insn;
215   insn_ptr->u.i = offset;
216 }
217
218 static void
219 cfi_add_CFA_insn_reg_reg (int insn, unsigned reg1, unsigned reg2)
220 {
221   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
222
223   insn_ptr->insn = insn;
224   insn_ptr->u.rr.reg1 = reg1;
225   insn_ptr->u.rr.reg2 = reg2;
226 }
227
228 static void
229 cfi_add_CFA_insn_reg_offset (int insn, unsigned regno, offsetT offset)
230 {
231   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
232
233   insn_ptr->insn = insn;
234   insn_ptr->u.ri.reg = regno;
235   insn_ptr->u.ri.offset = offset;
236 }
237
238 /* Add a CFI insn to advance the PC from the last address to LABEL.  */
239
240 void
241 cfi_add_advance_loc (symbolS *label)
242 {
243   struct cfi_insn_data *insn = alloc_cfi_insn_data ();
244
245   insn->insn = DW_CFA_advance_loc;
246   insn->u.ll.lab1 = frchain_now->frch_cfi_data->last_address;
247   insn->u.ll.lab2 = label;
248
249   frchain_now->frch_cfi_data->last_address = label;
250 }
251
252 /* Add a DW_CFA_offset record to the CFI data.  */
253
254 void
255 cfi_add_CFA_offset (unsigned regno, offsetT offset)
256 {
257   unsigned int abs_data_align;
258
259   assert (DWARF2_CIE_DATA_ALIGNMENT != 0);
260   cfi_add_CFA_insn_reg_offset (DW_CFA_offset, regno, offset);
261
262   abs_data_align = (DWARF2_CIE_DATA_ALIGNMENT < 0
263                     ? -DWARF2_CIE_DATA_ALIGNMENT : DWARF2_CIE_DATA_ALIGNMENT);
264   if (offset % abs_data_align)
265     as_bad (_("register save offset not a multiple of %u"), abs_data_align);
266 }
267
268 /* Add a DW_CFA_def_cfa record to the CFI data.  */
269
270 void
271 cfi_add_CFA_def_cfa (unsigned regno, offsetT offset)
272 {
273   cfi_add_CFA_insn_reg_offset (DW_CFA_def_cfa, regno, offset);
274   frchain_now->frch_cfi_data->cur_cfa_offset = offset;
275 }
276
277 /* Add a DW_CFA_register record to the CFI data.  */
278
279 void
280 cfi_add_CFA_register (unsigned reg1, unsigned reg2)
281 {
282   cfi_add_CFA_insn_reg_reg (DW_CFA_register, reg1, reg2);
283 }
284
285 /* Add a DW_CFA_def_cfa_register record to the CFI data.  */
286
287 void
288 cfi_add_CFA_def_cfa_register (unsigned regno)
289 {
290   cfi_add_CFA_insn_reg (DW_CFA_def_cfa_register, regno);
291 }
292
293 /* Add a DW_CFA_def_cfa_offset record to the CFI data.  */
294
295 void
296 cfi_add_CFA_def_cfa_offset (offsetT offset)
297 {
298   cfi_add_CFA_insn_offset (DW_CFA_def_cfa_offset, offset);
299   frchain_now->frch_cfi_data->cur_cfa_offset = offset;
300 }
301
302 void
303 cfi_add_CFA_restore (unsigned regno)
304 {
305   cfi_add_CFA_insn_reg (DW_CFA_restore, regno);
306 }
307
308 void
309 cfi_add_CFA_undefined (unsigned regno)
310 {
311   cfi_add_CFA_insn_reg (DW_CFA_undefined, regno);
312 }
313
314 void
315 cfi_add_CFA_same_value (unsigned regno)
316 {
317   cfi_add_CFA_insn_reg (DW_CFA_same_value, regno);
318 }
319
320 void
321 cfi_add_CFA_remember_state (void)
322 {
323   struct cfa_save_data *p;
324
325   cfi_add_CFA_insn (DW_CFA_remember_state);
326
327   p = xmalloc (sizeof (*p));
328   p->cfa_offset = frchain_now->frch_cfi_data->cur_cfa_offset;
329   p->next = frchain_now->frch_cfi_data->cfa_save_stack;
330   frchain_now->frch_cfi_data->cfa_save_stack = p;
331 }
332
333 void
334 cfi_add_CFA_restore_state (void)
335 {
336   struct cfa_save_data *p;
337
338   cfi_add_CFA_insn (DW_CFA_restore_state);
339
340   p = frchain_now->frch_cfi_data->cfa_save_stack;
341   if (p)
342     {
343       frchain_now->frch_cfi_data->cur_cfa_offset = p->cfa_offset;
344       frchain_now->frch_cfi_data->cfa_save_stack = p->next;
345       free (p);
346     }
347   else
348     as_bad (_("CFI state restore without previous remember"));
349 }
350
351 \f
352 /* Parse CFI assembler directives.  */
353
354 static void dot_cfi (int);
355 static void dot_cfi_escape (int);
356 static void dot_cfi_startproc (int);
357 static void dot_cfi_endproc (int);
358 static void dot_cfi_personality (int);
359 static void dot_cfi_lsda (int);
360
361 /* Fake CFI type; outside the byte range of any real CFI insn.  */
362 #define CFI_adjust_cfa_offset   0x100
363 #define CFI_return_column       0x101
364 #define CFI_rel_offset          0x102
365 #define CFI_escape              0x103
366 #define CFI_signal_frame        0x104
367
368 const pseudo_typeS cfi_pseudo_table[] =
369   {
370     { "cfi_startproc", dot_cfi_startproc, 0 },
371     { "cfi_endproc", dot_cfi_endproc, 0 },
372     { "cfi_def_cfa", dot_cfi, DW_CFA_def_cfa },
373     { "cfi_def_cfa_register", dot_cfi, DW_CFA_def_cfa_register },
374     { "cfi_def_cfa_offset", dot_cfi, DW_CFA_def_cfa_offset },
375     { "cfi_adjust_cfa_offset", dot_cfi, CFI_adjust_cfa_offset },
376     { "cfi_offset", dot_cfi, DW_CFA_offset },
377     { "cfi_rel_offset", dot_cfi, CFI_rel_offset },
378     { "cfi_register", dot_cfi, DW_CFA_register },
379     { "cfi_return_column", dot_cfi, CFI_return_column },
380     { "cfi_restore", dot_cfi, DW_CFA_restore },
381     { "cfi_undefined", dot_cfi, DW_CFA_undefined },
382     { "cfi_same_value", dot_cfi, DW_CFA_same_value },
383     { "cfi_remember_state", dot_cfi, DW_CFA_remember_state },
384     { "cfi_restore_state", dot_cfi, DW_CFA_restore_state },
385     { "cfi_window_save", dot_cfi, DW_CFA_GNU_window_save },
386     { "cfi_escape", dot_cfi_escape, 0 },
387     { "cfi_signal_frame", dot_cfi, CFI_signal_frame },
388     { "cfi_personality", dot_cfi_personality, 0 },
389     { "cfi_lsda", dot_cfi_lsda, 0 },
390     { NULL, NULL, 0 }
391   };
392
393 static void
394 cfi_parse_separator (void)
395 {
396   SKIP_WHITESPACE ();
397   if (*input_line_pointer == ',')
398     input_line_pointer++;
399   else
400     as_bad (_("missing separator"));
401 }
402
403 #ifndef tc_parse_to_dw2regnum
404 static void
405 tc_parse_to_dw2regnum(expressionS *exp)
406 {
407 # ifdef tc_regname_to_dw2regnum
408   SKIP_WHITESPACE ();
409   if (is_name_beginner (*input_line_pointer)
410       || (*input_line_pointer == '%'
411           && is_name_beginner (*++input_line_pointer)))
412     {
413       char *name, c;
414
415       name = input_line_pointer;
416       c = get_symbol_end ();
417
418       exp->X_op = O_constant;
419       exp->X_add_number = tc_regname_to_dw2regnum (name);
420
421       *input_line_pointer = c;
422     }
423   else
424 # endif
425     expression_and_evaluate (exp);
426 }
427 #endif
428
429 static unsigned
430 cfi_parse_reg (void)
431 {
432   int regno;
433   expressionS exp;
434
435   tc_parse_to_dw2regnum (&exp);
436   switch (exp.X_op)
437     {
438     case O_register:
439     case O_constant:
440       regno = exp.X_add_number;
441       break;
442
443     default:
444       regno = -1;
445       break;
446     }
447
448   if (regno < 0)
449     {
450       as_bad (_("bad register expression"));
451       regno = 0;
452     }
453
454   return regno;
455 }
456
457 static offsetT
458 cfi_parse_const (void)
459 {
460   return get_absolute_expression ();
461 }
462
463 static void
464 dot_cfi (int arg)
465 {
466   offsetT offset;
467   unsigned reg1, reg2;
468
469   if (frchain_now->frch_cfi_data == NULL)
470     {
471       as_bad (_("CFI instruction used without previous .cfi_startproc"));
472       ignore_rest_of_line ();
473       return;
474     }
475
476   /* If the last address was not at the current PC, advance to current.  */
477   if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now
478       || S_GET_VALUE (frchain_now->frch_cfi_data->last_address)
479          != frag_now_fix ())
480     cfi_add_advance_loc (symbol_temp_new_now ());
481
482   switch (arg)
483     {
484     case DW_CFA_offset:
485       reg1 = cfi_parse_reg ();
486       cfi_parse_separator ();
487       offset = cfi_parse_const ();
488       cfi_add_CFA_offset (reg1, offset);
489       break;
490
491     case CFI_rel_offset:
492       reg1 = cfi_parse_reg ();
493       cfi_parse_separator ();
494       offset = cfi_parse_const ();
495       cfi_add_CFA_offset (reg1,
496                           offset - frchain_now->frch_cfi_data->cur_cfa_offset);
497       break;
498
499     case DW_CFA_def_cfa:
500       reg1 = cfi_parse_reg ();
501       cfi_parse_separator ();
502       offset = cfi_parse_const ();
503       cfi_add_CFA_def_cfa (reg1, offset);
504       break;
505
506     case DW_CFA_register:
507       reg1 = cfi_parse_reg ();
508       cfi_parse_separator ();
509       reg2 = cfi_parse_reg ();
510       cfi_add_CFA_register (reg1, reg2);
511       break;
512
513     case DW_CFA_def_cfa_register:
514       reg1 = cfi_parse_reg ();
515       cfi_add_CFA_def_cfa_register (reg1);
516       break;
517
518     case DW_CFA_def_cfa_offset:
519       offset = cfi_parse_const ();
520       cfi_add_CFA_def_cfa_offset (offset);
521       break;
522
523     case CFI_adjust_cfa_offset:
524       offset = cfi_parse_const ();
525       cfi_add_CFA_def_cfa_offset (frchain_now->frch_cfi_data->cur_cfa_offset
526                                   + offset);
527       break;
528
529     case DW_CFA_restore:
530       for (;;)
531         {
532           reg1 = cfi_parse_reg ();
533           cfi_add_CFA_restore (reg1);
534           SKIP_WHITESPACE ();
535           if (*input_line_pointer != ',')
536             break;
537           ++input_line_pointer;
538         }
539       break;
540
541     case DW_CFA_undefined:
542       for (;;)
543         {
544           reg1 = cfi_parse_reg ();
545           cfi_add_CFA_undefined (reg1);
546           SKIP_WHITESPACE ();
547           if (*input_line_pointer != ',')
548             break;
549           ++input_line_pointer;
550         }
551       break;
552
553     case DW_CFA_same_value:
554       reg1 = cfi_parse_reg ();
555       cfi_add_CFA_same_value (reg1);
556       break;
557
558     case CFI_return_column:
559       reg1 = cfi_parse_reg ();
560       cfi_set_return_column (reg1);
561       break;
562
563     case DW_CFA_remember_state:
564       cfi_add_CFA_remember_state ();
565       break;
566
567     case DW_CFA_restore_state:
568       cfi_add_CFA_restore_state ();
569       break;
570
571     case DW_CFA_GNU_window_save:
572       cfi_add_CFA_insn (DW_CFA_GNU_window_save);
573       break;
574
575     case CFI_signal_frame:
576       frchain_now->frch_cfi_data->cur_fde_data->signal_frame = 1;
577       break;
578
579     default:
580       abort ();
581     }
582
583   demand_empty_rest_of_line ();
584 }
585
586 static void
587 dot_cfi_escape (int ignored ATTRIBUTE_UNUSED)
588 {
589   struct cfi_escape_data *head, **tail, *e;
590   struct cfi_insn_data *insn;
591
592   if (frchain_now->frch_cfi_data == NULL)
593     {
594       as_bad (_("CFI instruction used without previous .cfi_startproc"));
595       ignore_rest_of_line ();
596       return;
597     }
598
599   /* If the last address was not at the current PC, advance to current.  */
600   if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now
601       || S_GET_VALUE (frchain_now->frch_cfi_data->last_address)
602          != frag_now_fix ())
603     cfi_add_advance_loc (symbol_temp_new_now ());
604
605   tail = &head;
606   do
607     {
608       e = xmalloc (sizeof (*e));
609       do_parse_cons_expression (&e->exp, 1);
610       *tail = e;
611       tail = &e->next;
612     }
613   while (*input_line_pointer++ == ',');
614   *tail = NULL;
615
616   insn = alloc_cfi_insn_data ();
617   insn->insn = CFI_escape;
618   insn->u.esc = head;
619
620   --input_line_pointer;
621   demand_empty_rest_of_line ();
622 }
623
624 static void
625 dot_cfi_personality (int ignored ATTRIBUTE_UNUSED)
626 {
627   struct fde_entry *fde;
628   offsetT encoding;
629
630   if (frchain_now->frch_cfi_data == NULL)
631     {
632       as_bad (_("CFI instruction used without previous .cfi_startproc"));
633       ignore_rest_of_line ();
634       return;
635     }
636
637   fde = frchain_now->frch_cfi_data->cur_fde_data;
638   encoding = get_absolute_expression ();
639   if (encoding == DW_EH_PE_omit)
640     {
641       demand_empty_rest_of_line ();
642       fde->per_encoding = encoding;
643       return;
644     }
645
646   if ((encoding & 0xff) != encoding
647       || ((encoding & 0x70) != 0
648 #if defined DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
649           && (encoding & 0x70) != DW_EH_PE_pcrel
650 #endif
651           )
652          /* leb128 can be handled, but does something actually need it?  */
653       || (encoding & 7) == DW_EH_PE_uleb128
654       || (encoding & 7) > DW_EH_PE_udata8)
655     {
656       as_bad (_("invalid or unsupported encoding in .cfi_personality"));
657       ignore_rest_of_line ();
658       return;
659     }
660
661   if (*input_line_pointer++ != ',')
662     {
663       as_bad (_(".cfi_personality requires encoding and symbol arguments"));
664       ignore_rest_of_line ();
665       return;
666     }
667
668   expression_and_evaluate (&fde->personality);
669   switch (fde->personality.X_op)
670     {
671     case O_symbol:
672       break;
673     case O_constant:
674       if ((encoding & 0x70) == DW_EH_PE_pcrel)
675         encoding = DW_EH_PE_omit;
676       break;
677     default:
678       encoding = DW_EH_PE_omit;
679       break;
680     }
681
682   fde->per_encoding = encoding;
683
684   if (encoding == DW_EH_PE_omit)
685     {
686       as_bad (_("wrong second argument to .cfi_personality"));
687       ignore_rest_of_line ();
688       return;
689     }
690
691   demand_empty_rest_of_line ();
692 }
693
694 static void
695 dot_cfi_lsda (int ignored ATTRIBUTE_UNUSED)
696 {
697   struct fde_entry *fde;
698   offsetT encoding;
699
700   if (frchain_now->frch_cfi_data == NULL)
701     {
702       as_bad (_("CFI instruction used without previous .cfi_startproc"));
703       ignore_rest_of_line ();
704       return;
705     }
706
707   fde = frchain_now->frch_cfi_data->cur_fde_data;
708   encoding = get_absolute_expression ();
709   if (encoding == DW_EH_PE_omit)
710     {
711       demand_empty_rest_of_line ();
712       fde->lsda_encoding = encoding;
713       return;
714     }
715
716   if ((encoding & 0xff) != encoding
717       || ((encoding & 0x70) != 0
718 #if defined DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
719           && (encoding & 0x70) != DW_EH_PE_pcrel
720 #endif
721           )
722          /* leb128 can be handled, but does something actually need it?  */
723       || (encoding & 7) == DW_EH_PE_uleb128
724       || (encoding & 7) > DW_EH_PE_udata8)
725     {
726       as_bad (_("invalid or unsupported encoding in .cfi_lsda"));
727       ignore_rest_of_line ();
728       return;
729     }
730
731   if (*input_line_pointer++ != ',')
732     {
733       as_bad (_(".cfi_lsda requires encoding and symbol arguments"));
734       ignore_rest_of_line ();
735       return;
736     }
737
738   fde->lsda_encoding = encoding;
739
740   expression_and_evaluate (&fde->lsda);
741   switch (fde->lsda.X_op)
742     {
743     case O_symbol:
744       break;
745     case O_constant:
746       if ((encoding & 0x70) == DW_EH_PE_pcrel)
747         encoding = DW_EH_PE_omit;
748       break;
749     default:
750       encoding = DW_EH_PE_omit;
751       break;
752     }
753
754   fde->lsda_encoding = encoding;
755
756   if (encoding == DW_EH_PE_omit)
757     {
758       as_bad (_("wrong second argument to .cfi_lsda"));
759       ignore_rest_of_line ();
760       return;
761     }
762
763   demand_empty_rest_of_line ();
764 }
765
766 static void
767 dot_cfi_startproc (int ignored ATTRIBUTE_UNUSED)
768 {
769   int simple = 0;
770
771   if (frchain_now->frch_cfi_data != NULL)
772     {
773       as_bad (_("previous CFI entry not closed (missing .cfi_endproc)"));
774       ignore_rest_of_line ();
775       return;
776     }
777
778   cfi_new_fde (symbol_temp_new_now ());
779
780   SKIP_WHITESPACE ();
781   if (is_name_beginner (*input_line_pointer))
782     {
783       char *name, c;
784
785       name = input_line_pointer;
786       c = get_symbol_end ();
787
788       if (strcmp (name, "simple") == 0)
789         {
790           simple = 1;
791           *input_line_pointer = c;
792         }
793       else
794         input_line_pointer = name;
795     }
796   demand_empty_rest_of_line ();
797
798   frchain_now->frch_cfi_data->cur_cfa_offset = 0;
799   if (!simple)
800     tc_cfi_frame_initial_instructions ();
801 }
802
803 static void
804 dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED)
805 {
806   if (frchain_now->frch_cfi_data == NULL)
807     {
808       as_bad (_(".cfi_endproc without corresponding .cfi_startproc"));
809       ignore_rest_of_line ();
810       return;
811     }
812
813   cfi_end_fde (symbol_temp_new_now ());
814
815   demand_empty_rest_of_line ();
816 }
817
818 \f
819 /* Emit a single byte into the current segment.  */
820
821 static inline void
822 out_one (int byte)
823 {
824   FRAG_APPEND_1_CHAR (byte);
825 }
826
827 /* Emit a two-byte word into the current segment.  */
828
829 static inline void
830 out_two (int data)
831 {
832   md_number_to_chars (frag_more (2), data, 2);
833 }
834
835 /* Emit a four byte word into the current segment.  */
836
837 static inline void
838 out_four (int data)
839 {
840   md_number_to_chars (frag_more (4), data, 4);
841 }
842
843 /* Emit an unsigned "little-endian base 128" number.  */
844
845 static void
846 out_uleb128 (addressT value)
847 {
848   output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
849 }
850
851 /* Emit an unsigned "little-endian base 128" number.  */
852
853 static void
854 out_sleb128 (offsetT value)
855 {
856   output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1);
857 }
858
859 static void
860 output_cfi_insn (struct cfi_insn_data *insn)
861 {
862   offsetT offset;
863   unsigned int regno;
864
865   switch (insn->insn)
866     {
867     case DW_CFA_advance_loc:
868       {
869         symbolS *from = insn->u.ll.lab1;
870         symbolS *to = insn->u.ll.lab2;
871
872         if (symbol_get_frag (to) == symbol_get_frag (from))
873           {
874             addressT delta = S_GET_VALUE (to) - S_GET_VALUE (from);
875             addressT scaled = delta / DWARF2_LINE_MIN_INSN_LENGTH;
876
877             if (scaled <= 0x3F)
878               out_one (DW_CFA_advance_loc + scaled);
879             else if (delta <= 0xFF)
880               {
881                 out_one (DW_CFA_advance_loc1);
882                 out_one (delta);
883               }
884             else if (delta <= 0xFFFF)
885               {
886                 out_one (DW_CFA_advance_loc2);
887                 out_two (delta);
888               }
889             else
890               {
891                 out_one (DW_CFA_advance_loc4);
892                 out_four (delta);
893               }
894           }
895         else
896           {
897             expressionS exp;
898
899             exp.X_op = O_subtract;
900             exp.X_add_symbol = to;
901             exp.X_op_symbol = from;
902             exp.X_add_number = 0;
903
904             /* The code in ehopt.c expects that one byte of the encoding
905                is already allocated to the frag.  This comes from the way
906                that it scans the .eh_frame section looking first for the
907                .byte DW_CFA_advance_loc4.  */
908             frag_more (1);
909
910             frag_var (rs_cfa, 4, 0, DWARF2_LINE_MIN_INSN_LENGTH << 3,
911                       make_expr_symbol (&exp), frag_now_fix () - 1,
912                       (char *) frag_now);
913           }
914       }
915       break;
916
917     case DW_CFA_def_cfa:
918       offset = insn->u.ri.offset;
919       if (offset < 0)
920         {
921           out_one (DW_CFA_def_cfa_sf);
922           out_uleb128 (insn->u.ri.reg);
923           out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
924         }
925       else
926         {
927           out_one (DW_CFA_def_cfa);
928           out_uleb128 (insn->u.ri.reg);
929           out_uleb128 (offset);
930         }
931       break;
932
933     case DW_CFA_def_cfa_register:
934     case DW_CFA_undefined:
935     case DW_CFA_same_value:
936       out_one (insn->insn);
937       out_uleb128 (insn->u.r);
938       break;
939
940     case DW_CFA_def_cfa_offset:
941       offset = insn->u.i;
942       if (offset < 0)
943         {
944           out_one (DW_CFA_def_cfa_offset_sf);
945           out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
946         }
947       else
948         {
949           out_one (DW_CFA_def_cfa_offset);
950           out_uleb128 (offset);
951         }
952       break;
953
954     case DW_CFA_restore:
955       regno = insn->u.r;
956       if (regno <= 0x3F)
957         {
958           out_one (DW_CFA_restore + regno);
959         }
960       else
961         {
962           out_one (DW_CFA_restore_extended);
963           out_uleb128 (regno);
964         }
965       break;
966
967     case DW_CFA_offset:
968       regno = insn->u.ri.reg;
969       offset = insn->u.ri.offset / DWARF2_CIE_DATA_ALIGNMENT;
970       if (offset < 0)
971         {
972           out_one (DW_CFA_offset_extended_sf);
973           out_uleb128 (regno);
974           out_sleb128 (offset);
975         }
976       else if (regno <= 0x3F)
977         {
978           out_one (DW_CFA_offset + regno);
979           out_uleb128 (offset);
980         }
981       else
982         {
983           out_one (DW_CFA_offset_extended);
984           out_uleb128 (regno);
985           out_uleb128 (offset);
986         }
987       break;
988
989     case DW_CFA_register:
990       out_one (DW_CFA_register);
991       out_uleb128 (insn->u.rr.reg1);
992       out_uleb128 (insn->u.rr.reg2);
993       break;
994
995     case DW_CFA_remember_state:
996     case DW_CFA_restore_state:
997       out_one (insn->insn);
998       break;
999
1000     case DW_CFA_GNU_window_save:
1001       out_one (DW_CFA_GNU_window_save);
1002       break;
1003
1004     case CFI_escape:
1005       {
1006         struct cfi_escape_data *e;
1007         for (e = insn->u.esc; e ; e = e->next)
1008           emit_expr (&e->exp, 1);
1009         break;
1010       }
1011
1012     default:
1013       abort ();
1014     }
1015 }
1016
1017 static offsetT
1018 encoding_size (unsigned char encoding)
1019 {
1020   if (encoding == DW_EH_PE_omit)
1021     return 0;
1022   switch (encoding & 0x7)
1023     {
1024     case 0:
1025       return bfd_get_arch_size (stdoutput) == 64 ? 8 : 4;
1026     case DW_EH_PE_udata2:
1027       return 2;
1028     case DW_EH_PE_udata4:
1029       return 4;
1030     case DW_EH_PE_udata8:
1031       return 8;
1032     default:
1033       abort ();
1034     }
1035 }
1036
1037 static void
1038 output_cie (struct cie_entry *cie)
1039 {
1040   symbolS *after_size_address, *end_address;
1041   expressionS exp;
1042   struct cfi_insn_data *i;
1043   offsetT augmentation_size;
1044
1045   cie->start_address = symbol_temp_new_now ();
1046   after_size_address = symbol_temp_make ();
1047   end_address = symbol_temp_make ();
1048
1049   exp.X_op = O_subtract;
1050   exp.X_add_symbol = end_address;
1051   exp.X_op_symbol = after_size_address;
1052   exp.X_add_number = 0;
1053
1054   emit_expr (&exp, 4);                          /* Length.  */
1055   symbol_set_value_now (after_size_address);
1056   out_four (0);                                 /* CIE id.  */
1057   out_one (DW_CIE_VERSION);                     /* Version.  */
1058   out_one ('z');                                /* Augmentation.  */
1059   if (cie->per_encoding != DW_EH_PE_omit)
1060     out_one ('P');
1061   if (cie->lsda_encoding != DW_EH_PE_omit)
1062     out_one ('L');
1063   out_one ('R');
1064   if (cie->signal_frame)
1065     out_one ('S');
1066   out_one (0);
1067   out_uleb128 (DWARF2_LINE_MIN_INSN_LENGTH);    /* Code alignment.  */
1068   out_sleb128 (DWARF2_CIE_DATA_ALIGNMENT);      /* Data alignment.  */
1069   if (DW_CIE_VERSION == 1)                      /* Return column.  */
1070     out_one (cie->return_column);
1071   else
1072     out_uleb128 (cie->return_column);
1073   augmentation_size = 1 + (cie->lsda_encoding != DW_EH_PE_omit);
1074   if (cie->per_encoding != DW_EH_PE_omit)
1075     augmentation_size += 1 + encoding_size (cie->per_encoding);
1076   out_uleb128 (augmentation_size);              /* Augmentation size.  */
1077   if (cie->per_encoding != DW_EH_PE_omit)
1078     {
1079       offsetT size = encoding_size (cie->per_encoding);
1080       out_one (cie->per_encoding);
1081       exp = cie->personality;
1082       if ((cie->per_encoding & 0x70) == DW_EH_PE_pcrel)
1083         {
1084 #ifdef DIFF_EXPR_OK
1085           exp.X_op = O_subtract;
1086           exp.X_op_symbol = symbol_temp_new_now ();
1087           emit_expr (&exp, size);
1088 #elif defined (tc_cfi_emit_pcrel_expr)
1089           tc_cfi_emit_pcrel_expr (&exp, size);
1090 #else
1091           abort ();
1092 #endif
1093         }
1094       else
1095         emit_expr (&exp, size);
1096     }
1097   if (cie->lsda_encoding != DW_EH_PE_omit)
1098     out_one (cie->lsda_encoding);
1099 #if defined DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
1100   out_one (DW_EH_PE_pcrel | DW_EH_PE_sdata4);
1101 #else
1102   out_one (DW_EH_PE_sdata4);
1103 #endif
1104
1105   if (cie->first)
1106     for (i = cie->first; i != cie->last; i = i->next)
1107       output_cfi_insn (i);
1108
1109   frag_align (2, DW_CFA_nop, 0);
1110   symbol_set_value_now (end_address);
1111 }
1112
1113 static void
1114 output_fde (struct fde_entry *fde, struct cie_entry *cie,
1115             struct cfi_insn_data *first, int align)
1116 {
1117   symbolS *after_size_address, *end_address;
1118   expressionS exp;
1119   offsetT augmentation_size;
1120
1121   after_size_address = symbol_temp_make ();
1122   end_address = symbol_temp_make ();
1123
1124   exp.X_op = O_subtract;
1125   exp.X_add_symbol = end_address;
1126   exp.X_op_symbol = after_size_address;
1127   exp.X_add_number = 0;
1128   emit_expr (&exp, 4);                          /* Length.  */
1129   symbol_set_value_now (after_size_address);
1130
1131   exp.X_add_symbol = after_size_address;
1132   exp.X_op_symbol = cie->start_address;
1133   emit_expr (&exp, 4);                          /* CIE offset.  */
1134
1135 #ifdef DIFF_EXPR_OK
1136   exp.X_add_symbol = fde->start_address;
1137   exp.X_op_symbol = symbol_temp_new_now ();
1138   emit_expr (&exp, 4);                          /* Code offset.  */
1139 #else
1140   exp.X_op = O_symbol;
1141   exp.X_add_symbol = fde->start_address;
1142   exp.X_op_symbol = NULL;
1143 #ifdef tc_cfi_emit_pcrel_expr
1144   tc_cfi_emit_pcrel_expr (&exp, 4);             /* Code offset.  */
1145 #else
1146   emit_expr (&exp, 4);                          /* Code offset.  */
1147 #endif
1148   exp.X_op = O_subtract;
1149 #endif
1150
1151   exp.X_add_symbol = fde->end_address;
1152   exp.X_op_symbol = fde->start_address;         /* Code length.  */
1153   emit_expr (&exp, 4);
1154
1155   augmentation_size = encoding_size (fde->lsda_encoding);
1156   out_uleb128 (augmentation_size);              /* Augmentation size.  */
1157
1158   if (fde->lsda_encoding != DW_EH_PE_omit)
1159     {
1160       exp = fde->lsda;
1161       if ((fde->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
1162         {
1163 #ifdef DIFF_EXPR_OK
1164           exp.X_op = O_subtract;
1165           exp.X_op_symbol = symbol_temp_new_now ();
1166           emit_expr (&exp, augmentation_size);
1167 #elif defined (tc_cfi_emit_pcrel_expr)
1168           tc_cfi_emit_pcrel_expr (&exp, augmentation_size);
1169 #else
1170           abort ();
1171 #endif
1172         }
1173       else
1174         emit_expr (&exp, augmentation_size);
1175     }
1176
1177   for (; first; first = first->next)
1178     output_cfi_insn (first);
1179
1180   frag_align (align, DW_CFA_nop, 0);
1181   symbol_set_value_now (end_address);
1182 }
1183
1184 static struct cie_entry *
1185 select_cie_for_fde (struct fde_entry *fde, struct cfi_insn_data **pfirst)
1186 {
1187   struct cfi_insn_data *i, *j;
1188   struct cie_entry *cie;
1189
1190   for (cie = cie_root; cie; cie = cie->next)
1191     {
1192       if (cie->return_column != fde->return_column
1193           || cie->signal_frame != fde->signal_frame
1194           || cie->per_encoding != fde->per_encoding
1195           || cie->lsda_encoding != fde->lsda_encoding)
1196         continue;
1197       if (cie->per_encoding != DW_EH_PE_omit)
1198         {
1199           if (cie->personality.X_op != fde->personality.X_op
1200               || cie->personality.X_add_number
1201                  != fde->personality.X_add_number)
1202             continue;
1203           switch (cie->personality.X_op)
1204             {
1205             case O_constant:
1206               if (cie->personality.X_unsigned != fde->personality.X_unsigned)
1207                 continue;
1208               break;
1209             case O_symbol:
1210               if (cie->personality.X_add_symbol
1211                   != fde->personality.X_add_symbol)
1212                 continue;
1213               break;
1214             default:
1215               abort ();
1216             }
1217         }
1218       for (i = cie->first, j = fde->data;
1219            i != cie->last && j != NULL;
1220            i = i->next, j = j->next)
1221         {
1222           if (i->insn != j->insn)
1223             goto fail;
1224           switch (i->insn)
1225             {
1226             case DW_CFA_advance_loc:
1227             case DW_CFA_remember_state:
1228               /* We reached the first advance/remember in the FDE,
1229                  but did not reach the end of the CIE list.  */
1230               goto fail;
1231
1232             case DW_CFA_offset:
1233             case DW_CFA_def_cfa:
1234               if (i->u.ri.reg != j->u.ri.reg)
1235                 goto fail;
1236               if (i->u.ri.offset != j->u.ri.offset)
1237                 goto fail;
1238               break;
1239
1240             case DW_CFA_register:
1241               if (i->u.rr.reg1 != j->u.rr.reg1)
1242                 goto fail;
1243               if (i->u.rr.reg2 != j->u.rr.reg2)
1244                 goto fail;
1245               break;
1246
1247             case DW_CFA_def_cfa_register:
1248             case DW_CFA_restore:
1249             case DW_CFA_undefined:
1250             case DW_CFA_same_value:
1251               if (i->u.r != j->u.r)
1252                 goto fail;
1253               break;
1254
1255             case DW_CFA_def_cfa_offset:
1256               if (i->u.i != j->u.i)
1257                 goto fail;
1258               break;
1259
1260             case CFI_escape:
1261               /* Don't bother matching these for now.  */
1262               goto fail;
1263
1264             default:
1265               abort ();
1266             }
1267         }
1268
1269       /* Success if we reached the end of the CIE list, and we've either
1270          run out of FDE entries or we've encountered an advance,
1271          remember, or escape.  */
1272       if (i == cie->last
1273           && (!j
1274               || j->insn == DW_CFA_advance_loc
1275               || j->insn == DW_CFA_remember_state
1276               || j->insn == CFI_escape))
1277         {
1278           *pfirst = j;
1279           return cie;
1280         }
1281
1282     fail:;
1283     }
1284
1285   cie = xmalloc (sizeof (struct cie_entry));
1286   cie->next = cie_root;
1287   cie_root = cie;
1288   cie->return_column = fde->return_column;
1289   cie->signal_frame = fde->signal_frame;
1290   cie->per_encoding = fde->per_encoding;
1291   cie->lsda_encoding = fde->lsda_encoding;
1292   cie->personality = fde->personality;
1293   cie->first = fde->data;
1294
1295   for (i = cie->first; i ; i = i->next)
1296     if (i->insn == DW_CFA_advance_loc
1297         || i->insn == DW_CFA_remember_state
1298         || i->insn == CFI_escape)
1299       break;
1300
1301   cie->last = i;
1302   *pfirst = i;
1303    
1304   output_cie (cie);
1305
1306   return cie;
1307 }
1308
1309 void
1310 cfi_finish (void)
1311 {
1312   segT cfi_seg;
1313   struct fde_entry *fde;
1314   int save_flag_traditional_format;
1315
1316   if (all_fde_data == 0)
1317     return;
1318
1319   /* Open .eh_frame section.  */
1320   cfi_seg = subseg_new (".eh_frame", 0);
1321   bfd_set_section_flags (stdoutput, cfi_seg,
1322                          SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY);
1323   subseg_set (cfi_seg, 0);
1324   record_alignment (cfi_seg, EH_FRAME_ALIGNMENT);
1325
1326   /* Make sure check_eh_frame doesn't do anything with our output.  */
1327   save_flag_traditional_format = flag_traditional_format;
1328   flag_traditional_format = 1;
1329
1330   for (fde = all_fde_data; fde ; fde = fde->next)
1331     {
1332       struct cfi_insn_data *first;
1333       struct cie_entry *cie;
1334
1335       if (fde->end_address == NULL)
1336         {
1337           as_bad (_("open CFI at the end of file; missing .cfi_endproc directive"));
1338           fde->end_address = fde->start_address;
1339         }
1340
1341       cie = select_cie_for_fde (fde, &first);
1342       output_fde (fde, cie, first, fde->next == NULL ? EH_FRAME_ALIGNMENT : 2);
1343     }
1344
1345   flag_traditional_format = save_flag_traditional_format;
1346 }
1347
1348 #else /* TARGET_USE_CFIPOP */
1349 void
1350 cfi_finish (void)
1351 {
1352 }
1353 #endif /* TARGET_USE_CFIPOP */