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