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