1 /* dw2gencfi.c - Support for generating Dwarf2 CFI information.
2 Copyright (C) 2003-2022 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 #include "dwarf2dbg.h"
26
27 #ifdef TARGET_USE_CFIPOP
28
29 /* By default, use difference expressions if DIFF_EXPR_OK is defined. */
30 #ifndef CFI_DIFF_EXPR_OK
31 # ifdef DIFF_EXPR_OK
32 # define CFI_DIFF_EXPR_OK 1
33 # else
34 # define CFI_DIFF_EXPR_OK 0
35 # endif
36 #endif
37
38 #ifndef CFI_DIFF_LSDA_OK
39 #define CFI_DIFF_LSDA_OK CFI_DIFF_EXPR_OK
40 #endif
41
42 #if CFI_DIFF_EXPR_OK == 1 && CFI_DIFF_LSDA_OK == 0
43 # error "CFI_DIFF_EXPR_OK should imply CFI_DIFF_LSDA_OK"
44 #endif
45
46 /* We re-use DWARF2_LINE_MIN_INSN_LENGTH for the code alignment field
47 of the CIE. Default to 1 if not otherwise specified. */
48 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
49 #define DWARF2_LINE_MIN_INSN_LENGTH 1
50 #endif
51
52 /* By default, use 32-bit relocations from .eh_frame into .text. */
53 #ifndef DWARF2_FDE_RELOC_SIZE
54 #define DWARF2_FDE_RELOC_SIZE 4
55 #endif
56
57 /* By default, use a read-only .eh_frame section. */
58 #ifndef DWARF2_EH_FRAME_READ_ONLY
59 #define DWARF2_EH_FRAME_READ_ONLY SEC_READONLY
60 #endif
61
62 #ifndef EH_FRAME_ALIGNMENT
63 #define EH_FRAME_ALIGNMENT (bfd_get_arch_size (stdoutput) == 64 ? 3 : 2)
64 #endif
65
66 #ifndef tc_cfi_frame_initial_instructions
67 #define tc_cfi_frame_initial_instructions() ((void)0)
68 #endif
69
70 #ifndef tc_cfi_startproc
71 # define tc_cfi_startproc() ((void)0)
72 #endif
73
74 #ifndef tc_cfi_endproc
75 # define tc_cfi_endproc(fde) ((void) (fde))
76 #endif
77
78 #define EH_FRAME_LINKONCE (SUPPORT_FRAME_LINKONCE || compact_eh)
79
80 #ifndef DWARF2_FORMAT
81 #define DWARF2_FORMAT(SEC) dwarf2_format_32bit
82 #endif
83
84 #ifndef DWARF2_ADDR_SIZE
85 #define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
86 #endif
87
88 #if MULTIPLE_FRAME_SECTIONS
89 #define CUR_SEG(structp) structp->cur_seg
90 #define SET_CUR_SEG(structp, seg) structp->cur_seg = seg
91 #define HANDLED(structp) structp->handled
92 #define SET_HANDLED(structp, val) structp->handled = val
93 #else
94 #define CUR_SEG(structp) NULL
95 #define SET_CUR_SEG(structp, seg) (void) (0 && seg)
96 #define HANDLED(structp) 0
97 #define SET_HANDLED(structp, val) (void) (0 && val)
98 #endif
99
100 #ifndef tc_cfi_reloc_for_encoding
101 #define tc_cfi_reloc_for_encoding(e) BFD_RELOC_NONE
102 #endif
103
104 /* Private segment collection list. */
105 struct dwcfi_seg_list
106 {
107 segT seg;
108 int subseg;
109 char * seg_name;
110 };
111
112 #ifdef SUPPORT_COMPACT_EH
113 static bool compact_eh;
114 #else
115 #define compact_eh 0
116 #endif
117
118 static htab_t dwcfi_hash;
119
120 /* Emit a single byte into the current segment. */
121
122 static inline void
out_one(int byte)123 out_one (int byte)
124 {
125 FRAG_APPEND_1_CHAR (byte);
126 }
127
128 /* Emit a two-byte word into the current segment. */
129
130 static inline void
out_two(int data)131 out_two (int data)
132 {
133 md_number_to_chars (frag_more (2), data, 2);
134 }
135
136 /* Emit a four byte word into the current segment. */
137
138 static inline void
out_four(int data)139 out_four (int data)
140 {
141 md_number_to_chars (frag_more (4), data, 4);
142 }
143
144 /* Emit an unsigned "little-endian base 128" number. */
145
146 static void
out_uleb128(addressT value)147 out_uleb128 (addressT value)
148 {
149 output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
150 }
151
152 /* Emit an unsigned "little-endian base 128" number. */
153
154 static void
out_sleb128(offsetT value)155 out_sleb128 (offsetT value)
156 {
157 output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1);
158 }
159
160 static unsigned int
encoding_size(unsigned char encoding)161 encoding_size (unsigned char encoding)
162 {
163 if (encoding == DW_EH_PE_omit)
164 return 0;
165 switch (encoding & 0x7)
166 {
167 case 0:
168 return bfd_get_arch_size (stdoutput) == 64 ? 8 : 4;
169 case DW_EH_PE_udata2:
170 return 2;
171 case DW_EH_PE_udata4:
172 return 4;
173 case DW_EH_PE_udata8:
174 return 8;
175 default:
176 abort ();
177 }
178 }
179
180 /* Emit expression EXP in ENCODING. If EMIT_ENCODING is true, first
181 emit a byte containing ENCODING. */
182
183 static void
emit_expr_encoded(expressionS * exp,int encoding,bool emit_encoding)184 emit_expr_encoded (expressionS *exp, int encoding, bool emit_encoding)
185 {
186 unsigned int size = encoding_size (encoding);
187 bfd_reloc_code_real_type code;
188
189 if (encoding == DW_EH_PE_omit)
190 return;
191
192 if (emit_encoding)
193 out_one (encoding);
194
195 code = tc_cfi_reloc_for_encoding (encoding);
196 if (code != BFD_RELOC_NONE)
197 {
198 reloc_howto_type *howto = bfd_reloc_type_lookup (stdoutput, code);
199 char *p = frag_more (size);
200 gas_assert (size == (unsigned) howto->bitsize / 8);
201 md_number_to_chars (p, 0, size);
202 fix_new (frag_now, p - frag_now->fr_literal, size, exp->X_add_symbol,
203 exp->X_add_number, howto->pc_relative, code);
204 }
205 else if ((encoding & 0x70) == DW_EH_PE_pcrel)
206 {
207 #if CFI_DIFF_EXPR_OK
208 expressionS tmp = *exp;
209 tmp.X_op = O_subtract;
210 tmp.X_op_symbol = symbol_temp_new_now ();
211 emit_expr (&tmp, size);
212 #elif defined (tc_cfi_emit_pcrel_expr)
213 tc_cfi_emit_pcrel_expr (exp, size);
214 #else
215 abort ();
216 #endif
217 }
218 else
219 emit_expr (exp, size);
220 }
221
222 /* Build based on segment the derived .debug_...
223 segment name containing origin segment's postfix name part. */
224
225 static char *
get_debugseg_name(segT seg,const char * base_name)226 get_debugseg_name (segT seg, const char *base_name)
227 {
228 const char * name;
229 const char * dollar;
230 const char * dot;
231
232 if (!seg)
233 return concat (base_name, NULL);
234
235 name = bfd_section_name (seg);
236
237 if (name == NULL || *name == 0)
238 return concat (base_name, NULL);
239
240 dollar = strchr (name, '$');
241 dot = strchr (name + 1, '.');
242
243 if (!dollar && !dot)
244 {
245 if (!strcmp (base_name, ".eh_frame_entry")
246 && strcmp (name, ".text") != 0)
247 return concat (base_name, ".", name, NULL);
248
249 name = "";
250 }
251 else if (!dollar)
252 name = dot;
253 else if (!dot)
254 name = dollar;
255 else if (dot < dollar)
256 name = dot;
257 else
258 name = dollar;
259
260 return concat (base_name, name, NULL);
261 }
262
263 /* Allocate a dwcfi_seg_list structure. */
264
265 static struct dwcfi_seg_list *
alloc_debugseg_item(segT seg,int subseg,char * name)266 alloc_debugseg_item (segT seg, int subseg, char *name)
267 {
268 struct dwcfi_seg_list *r;
269
270 r = (struct dwcfi_seg_list *)
271 xmalloc (sizeof (struct dwcfi_seg_list) + strlen (name));
272 r->seg = seg;
273 r->subseg = subseg;
274 r->seg_name = name;
275 return r;
276 }
277
278 static segT
is_now_linkonce_segment(void)279 is_now_linkonce_segment (void)
280 {
281 if (compact_eh)
282 return now_seg;
283
284 if ((bfd_section_flags (now_seg)
285 & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD
286 | SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE
287 | SEC_LINK_DUPLICATES_SAME_CONTENTS)) != 0)
288 return now_seg;
289 return NULL;
290 }
291
292 /* Generate debug... segment with same linkonce properties
293 of based segment. */
294
295 static segT
make_debug_seg(segT cseg,char * name,int sflags)296 make_debug_seg (segT cseg, char *name, int sflags)
297 {
298 segT save_seg = now_seg;
299 int save_subseg = now_subseg;
300 segT r;
301 flagword flags;
302
303 r = subseg_new (name, 0);
304
305 /* Check if code segment is marked as linked once. */
306 if (!cseg)
307 flags = 0;
308 else
309 flags = (bfd_section_flags (cseg)
310 & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD
311 | SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE
312 | SEC_LINK_DUPLICATES_SAME_CONTENTS));
313
314 /* Add standard section flags. */
315 flags |= sflags;
316
317 /* Apply possibly linked once flags to new generated segment, too. */
318 if (!bfd_set_section_flags (r, flags))
319 as_bad (_("bfd_set_section_flags: %s"),
320 bfd_errmsg (bfd_get_error ()));
321
322 /* Restore to previous segment. */
323 if (save_seg != NULL)
324 subseg_set (save_seg, save_subseg);
325 return r;
326 }
327
328 static struct dwcfi_seg_list *
dwcfi_hash_find(char * name)329 dwcfi_hash_find (char *name)
330 {
331 return (struct dwcfi_seg_list *) str_hash_find (dwcfi_hash, name);
332 }
333
334 static struct dwcfi_seg_list *
dwcfi_hash_find_or_make(segT cseg,const char * base_name,int flags)335 dwcfi_hash_find_or_make (segT cseg, const char *base_name, int flags)
336 {
337 struct dwcfi_seg_list *item;
338 char *name;
339
340 /* Initialize dwcfi_hash once. */
341 if (!dwcfi_hash)
342 dwcfi_hash = str_htab_create ();
343
344 name = get_debugseg_name (cseg, base_name);
345
346 item = dwcfi_hash_find (name);
347 if (!item)
348 {
349 item = alloc_debugseg_item (make_debug_seg (cseg, name, flags), 0, name);
350
351 str_hash_insert (dwcfi_hash, item->seg_name, item, 0);
352 }
353 else
354 free (name);
355
356 return item;
357 }
358
359 /* ??? Share this with dwarf2cfg.c. */
360 #ifndef TC_DWARF2_EMIT_OFFSET
361 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
362
363 /* Create an offset to .dwarf2_*. */
364
365 static void
generic_dwarf2_emit_offset(symbolS * symbol,unsigned int size)366 generic_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
367 {
368 expressionS exp;
369
370 exp.X_op = O_symbol;
371 exp.X_add_symbol = symbol;
372 exp.X_add_number = 0;
373 emit_expr (&exp, size);
374 }
375 #endif
376
377 struct cfi_escape_data
378 {
379 struct cfi_escape_data *next;
380 expressionS exp;
381 };
382
383 struct cie_entry
384 {
385 struct cie_entry *next;
386 #if MULTIPLE_FRAME_SECTIONS
387 segT cur_seg;
388 #endif
389 symbolS *start_address;
390 unsigned int return_column;
391 unsigned int signal_frame;
392 unsigned char fde_encoding;
393 unsigned char per_encoding;
394 unsigned char lsda_encoding;
395 expressionS personality;
396 #ifdef tc_cie_entry_extras
397 tc_cie_entry_extras
398 #endif
399 struct cfi_insn_data *first, *last;
400 };
401
402 /* List of FDE entries. */
403
404 struct fde_entry *all_fde_data;
405 static struct fde_entry **last_fde_data = &all_fde_data;
406
407 /* List of CIEs so that they could be reused. */
408 static struct cie_entry *cie_root;
409
410 /* Construct a new FDE structure and add it to the end of the fde list. */
411
412 static struct fde_entry *
alloc_fde_entry(void)413 alloc_fde_entry (void)
414 {
415 struct fde_entry *fde = XCNEW (struct fde_entry);
416
417 frchain_now->frch_cfi_data = XCNEW (struct frch_cfi_data);
418 frchain_now->frch_cfi_data->cur_fde_data = fde;
419 *last_fde_data = fde;
420 last_fde_data = &fde->next;
421 SET_CUR_SEG (fde, is_now_linkonce_segment ());
422 SET_HANDLED (fde, 0);
423 fde->last = &fde->data;
424 fde->return_column = DWARF2_DEFAULT_RETURN_COLUMN;
425 fde->per_encoding = DW_EH_PE_omit;
426 fde->lsda_encoding = DW_EH_PE_omit;
427 fde->eh_header_type = EH_COMPACT_UNKNOWN;
428 #ifdef tc_fde_entry_init_extra
429 tc_fde_entry_init_extra (fde)
430 #endif
431
432 return fde;
433 }
434
435 /* The following functions are available for a backend to construct its
436 own unwind information, usually from legacy unwind directives. */
437
438 /* Construct a new INSN structure and add it to the end of the insn list
439 for the currently active FDE. */
440
441 static bool cfi_sections_set = false;
442 static int cfi_sections = CFI_EMIT_eh_frame;
443 int all_cfi_sections = 0;
444 static struct fde_entry *last_fde;
445
446 static struct cfi_insn_data *
alloc_cfi_insn_data(void)447 alloc_cfi_insn_data (void)
448 {
449 struct cfi_insn_data *insn = XCNEW (struct cfi_insn_data);
450 struct fde_entry *cur_fde_data = frchain_now->frch_cfi_data->cur_fde_data;
451
452 *cur_fde_data->last = insn;
453 cur_fde_data->last = &insn->next;
454 SET_CUR_SEG (insn, is_now_linkonce_segment ());
455 return insn;
456 }
457
458 /* Construct a new FDE structure that begins at LABEL. */
459
460 void
cfi_new_fde(symbolS * label)461 cfi_new_fde (symbolS *label)
462 {
463 struct fde_entry *fde = alloc_fde_entry ();
464 fde->start_address = label;
465 frchain_now->frch_cfi_data->last_address = label;
466 }
467
468 /* End the currently open FDE. */
469
470 void
cfi_end_fde(symbolS * label)471 cfi_end_fde (symbolS *label)
472 {
473 frchain_now->frch_cfi_data->cur_fde_data->end_address = label;
474 free (frchain_now->frch_cfi_data);
475 frchain_now->frch_cfi_data = NULL;
476 }
477
478 /* Set the return column for the current FDE. */
479
480 void
cfi_set_return_column(unsigned regno)481 cfi_set_return_column (unsigned regno)
482 {
483 frchain_now->frch_cfi_data->cur_fde_data->return_column = regno;
484 }
485
486 void
cfi_set_sections(void)487 cfi_set_sections (void)
488 {
489 frchain_now->frch_cfi_data->cur_fde_data->sections = all_cfi_sections;
490 cfi_sections_set = true;
491 }
492
493 /* Universal functions to store new instructions. */
494
495 static void
cfi_add_CFA_insn(int insn)496 cfi_add_CFA_insn (int insn)
497 {
498 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
499
500 insn_ptr->insn = insn;
501 }
502
503 static void
cfi_add_CFA_insn_reg(int insn,unsigned regno)504 cfi_add_CFA_insn_reg (int insn, unsigned regno)
505 {
506 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
507
508 insn_ptr->insn = insn;
509 insn_ptr->u.r = regno;
510 }
511
512 static void
cfi_add_CFA_insn_offset(int insn,offsetT offset)513 cfi_add_CFA_insn_offset (int insn, offsetT offset)
514 {
515 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
516
517 insn_ptr->insn = insn;
518 insn_ptr->u.i = offset;
519 }
520
521 static void
cfi_add_CFA_insn_reg_reg(int insn,unsigned reg1,unsigned reg2)522 cfi_add_CFA_insn_reg_reg (int insn, unsigned reg1, unsigned reg2)
523 {
524 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
525
526 insn_ptr->insn = insn;
527 insn_ptr->u.rr.reg1 = reg1;
528 insn_ptr->u.rr.reg2 = reg2;
529 }
530
531 static void
cfi_add_CFA_insn_reg_offset(int insn,unsigned regno,offsetT offset)532 cfi_add_CFA_insn_reg_offset (int insn, unsigned regno, offsetT offset)
533 {
534 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
535
536 insn_ptr->insn = insn;
537 insn_ptr->u.ri.reg = regno;
538 insn_ptr->u.ri.offset = offset;
539 }
540
541 /* Add a CFI insn to advance the PC from the last address to LABEL. */
542
543 void
cfi_add_advance_loc(symbolS * label)544 cfi_add_advance_loc (symbolS *label)
545 {
546 struct cfi_insn_data *insn = alloc_cfi_insn_data ();
547
548 insn->insn = DW_CFA_advance_loc;
549 insn->u.ll.lab1 = frchain_now->frch_cfi_data->last_address;
550 insn->u.ll.lab2 = label;
551
552 frchain_now->frch_cfi_data->last_address = label;
553 }
554
555 /* Add a CFI insn to label the current position in the CFI segment. */
556
557 void
cfi_add_label(const char * name)558 cfi_add_label (const char *name)
559 {
560 unsigned int len = strlen (name) + 1;
561 struct cfi_insn_data *insn = alloc_cfi_insn_data ();
562
563 insn->insn = CFI_label;
564 obstack_grow (¬es, name, len);
565 insn->u.sym_name = (char *) obstack_finish (¬es);
566 }
567
568 /* Add a DW_CFA_offset record to the CFI data. */
569
570 void
cfi_add_CFA_offset(unsigned regno,offsetT offset)571 cfi_add_CFA_offset (unsigned regno, offsetT offset)
572 {
573 unsigned int abs_data_align;
574
575 gas_assert (DWARF2_CIE_DATA_ALIGNMENT != 0);
576 cfi_add_CFA_insn_reg_offset (DW_CFA_offset, regno, offset);
577
578 abs_data_align = (DWARF2_CIE_DATA_ALIGNMENT < 0
579 ? -DWARF2_CIE_DATA_ALIGNMENT : DWARF2_CIE_DATA_ALIGNMENT);
580 if (offset % abs_data_align)
581 as_bad (_("register save offset not a multiple of %u"), abs_data_align);
582 }
583
584 /* Add a DW_CFA_val_offset record to the CFI data. */
585
586 void
cfi_add_CFA_val_offset(unsigned regno,offsetT offset)587 cfi_add_CFA_val_offset (unsigned regno, offsetT offset)
588 {
589 unsigned int abs_data_align;
590
591 gas_assert (DWARF2_CIE_DATA_ALIGNMENT != 0);
592 cfi_add_CFA_insn_reg_offset (DW_CFA_val_offset, regno, offset);
593
594 abs_data_align = (DWARF2_CIE_DATA_ALIGNMENT < 0
595 ? -DWARF2_CIE_DATA_ALIGNMENT : DWARF2_CIE_DATA_ALIGNMENT);
596 if (offset % abs_data_align)
597 as_bad (_("register save offset not a multiple of %u"), abs_data_align);
598 }
599
600 /* Add a DW_CFA_def_cfa record to the CFI data. */
601
602 void
cfi_add_CFA_def_cfa(unsigned regno,offsetT offset)603 cfi_add_CFA_def_cfa (unsigned regno, offsetT offset)
604 {
605 cfi_add_CFA_insn_reg_offset (DW_CFA_def_cfa, regno, offset);
606 frchain_now->frch_cfi_data->cur_cfa_offset = offset;
607 }
608
609 /* Add a DW_CFA_register record to the CFI data. */
610
611 void
cfi_add_CFA_register(unsigned reg1,unsigned reg2)612 cfi_add_CFA_register (unsigned reg1, unsigned reg2)
613 {
614 cfi_add_CFA_insn_reg_reg (DW_CFA_register, reg1, reg2);
615 }
616
617 /* Add a DW_CFA_def_cfa_register record to the CFI data. */
618
619 void
cfi_add_CFA_def_cfa_register(unsigned regno)620 cfi_add_CFA_def_cfa_register (unsigned regno)
621 {
622 cfi_add_CFA_insn_reg (DW_CFA_def_cfa_register, regno);
623 }
624
625 /* Add a DW_CFA_def_cfa_offset record to the CFI data. */
626
627 void
cfi_add_CFA_def_cfa_offset(offsetT offset)628 cfi_add_CFA_def_cfa_offset (offsetT offset)
629 {
630 cfi_add_CFA_insn_offset (DW_CFA_def_cfa_offset, offset);
631 frchain_now->frch_cfi_data->cur_cfa_offset = offset;
632 }
633
634 void
cfi_add_CFA_restore(unsigned regno)635 cfi_add_CFA_restore (unsigned regno)
636 {
637 cfi_add_CFA_insn_reg (DW_CFA_restore, regno);
638 }
639
640 void
cfi_add_CFA_undefined(unsigned regno)641 cfi_add_CFA_undefined (unsigned regno)
642 {
643 cfi_add_CFA_insn_reg (DW_CFA_undefined, regno);
644 }
645
646 void
cfi_add_CFA_same_value(unsigned regno)647 cfi_add_CFA_same_value (unsigned regno)
648 {
649 cfi_add_CFA_insn_reg (DW_CFA_same_value, regno);
650 }
651
652 void
cfi_add_CFA_remember_state(void)653 cfi_add_CFA_remember_state (void)
654 {
655 struct cfa_save_data *p;
656
657 cfi_add_CFA_insn (DW_CFA_remember_state);
658
659 p = XNEW (struct cfa_save_data);
660 p->cfa_offset = frchain_now->frch_cfi_data->cur_cfa_offset;
661 p->next = frchain_now->frch_cfi_data->cfa_save_stack;
662 frchain_now->frch_cfi_data->cfa_save_stack = p;
663 }
664
665 void
cfi_add_CFA_restore_state(void)666 cfi_add_CFA_restore_state (void)
667 {
668 struct cfa_save_data *p;
669
670 cfi_add_CFA_insn (DW_CFA_restore_state);
671
672 p = frchain_now->frch_cfi_data->cfa_save_stack;
673 if (p)
674 {
675 frchain_now->frch_cfi_data->cur_cfa_offset = p->cfa_offset;
676 frchain_now->frch_cfi_data->cfa_save_stack = p->next;
677 free (p);
678 }
679 else
680 as_bad (_("CFI state restore without previous remember"));
681 }
682
683
684 /* Parse CFI assembler directives. */
685
686 static void dot_cfi (int);
687 static void dot_cfi_escape (int);
688 static void dot_cfi_sections (int);
689 static void dot_cfi_startproc (int);
690 static void dot_cfi_endproc (int);
691 static void dot_cfi_fde_data (int);
692 static void dot_cfi_personality (int);
693 static void dot_cfi_personality_id (int);
694 static void dot_cfi_lsda (int);
695 static void dot_cfi_val_encoded_addr (int);
696 static void dot_cfi_inline_lsda (int);
697 static void dot_cfi_label (int);
698
699 const pseudo_typeS cfi_pseudo_table[] =
700 {
701 { "cfi_sections", dot_cfi_sections, 0 },
702 { "cfi_startproc", dot_cfi_startproc, 0 },
703 { "cfi_endproc", dot_cfi_endproc, 0 },
704 { "cfi_fde_data", dot_cfi_fde_data, 0 },
705 { "cfi_def_cfa", dot_cfi, DW_CFA_def_cfa },
706 { "cfi_def_cfa_register", dot_cfi, DW_CFA_def_cfa_register },
707 { "cfi_def_cfa_offset", dot_cfi, DW_CFA_def_cfa_offset },
708 { "cfi_adjust_cfa_offset", dot_cfi, CFI_adjust_cfa_offset },
709 { "cfi_offset", dot_cfi, DW_CFA_offset },
710 { "cfi_rel_offset", dot_cfi, CFI_rel_offset },
711 { "cfi_register", dot_cfi, DW_CFA_register },
712 { "cfi_return_column", dot_cfi, CFI_return_column },
713 { "cfi_restore", dot_cfi, DW_CFA_restore },
714 { "cfi_undefined", dot_cfi, DW_CFA_undefined },
715 { "cfi_same_value", dot_cfi, DW_CFA_same_value },
716 { "cfi_remember_state", dot_cfi, DW_CFA_remember_state },
717 { "cfi_restore_state", dot_cfi, DW_CFA_restore_state },
718 { "cfi_window_save", dot_cfi, DW_CFA_GNU_window_save },
719 { "cfi_negate_ra_state", dot_cfi, DW_CFA_AARCH64_negate_ra_state },
720 { "cfi_escape", dot_cfi_escape, 0 },
721 { "cfi_signal_frame", dot_cfi, CFI_signal_frame },
722 { "cfi_personality", dot_cfi_personality, 0 },
723 { "cfi_personality_id", dot_cfi_personality_id, 0 },
724 { "cfi_lsda", dot_cfi_lsda, 0 },
725 { "cfi_val_encoded_addr", dot_cfi_val_encoded_addr, 0 },
726 { "cfi_inline_lsda", dot_cfi_inline_lsda, 0 },
727 { "cfi_label", dot_cfi_label, 0 },
728 { "cfi_val_offset", dot_cfi, DW_CFA_val_offset },
729 { NULL, NULL, 0 }
730 };
731
732 static void
cfi_parse_separator(void)733 cfi_parse_separator (void)
734 {
735 SKIP_WHITESPACE ();
736 if (*input_line_pointer == ',')
737 input_line_pointer++;
738 else
739 as_bad (_("missing separator"));
740 }
741
742 #ifndef tc_parse_to_dw2regnum
743 static void
tc_parse_to_dw2regnum(expressionS * exp)744 tc_parse_to_dw2regnum (expressionS *exp)
745 {
746 # ifdef tc_regname_to_dw2regnum
747 SKIP_WHITESPACE ();
748 if (is_name_beginner (*input_line_pointer)
749 || (*input_line_pointer == '%'
750 && is_name_beginner (*++input_line_pointer)))
751 {
752 char *name, c;
753
754 c = get_symbol_name (& name);
755
756 exp->X_op = O_constant;
757 exp->X_add_number = tc_regname_to_dw2regnum (name);
758
759 restore_line_pointer (c);
760 }
761 else
762 # endif
763 expression_and_evaluate (exp);
764 }
765 #endif
766
767 static unsigned
cfi_parse_reg(void)768 cfi_parse_reg (void)
769 {
770 int regno;
771 expressionS exp;
772
773 tc_parse_to_dw2regnum (&exp);
774 switch (exp.X_op)
775 {
776 case O_register:
777 case O_constant:
778 regno = exp.X_add_number;
779 break;
780
781 default:
782 regno = -1;
783 break;
784 }
785
786 if (regno < 0)
787 {
788 as_bad (_("bad register expression"));
789 regno = 0;
790 }
791
792 return regno;
793 }
794
795 static offsetT
cfi_parse_const(void)796 cfi_parse_const (void)
797 {
798 return get_absolute_expression ();
799 }
800
801 static void
dot_cfi(int arg)802 dot_cfi (int arg)
803 {
804 offsetT offset;
805 unsigned reg1, reg2;
806
807 if (frchain_now->frch_cfi_data == NULL)
808 {
809 as_bad (_("CFI instruction used without previous .cfi_startproc"));
810 ignore_rest_of_line ();
811 return;
812 }
813
814 /* If the last address was not at the current PC, advance to current. */
815 if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now
816 || (S_GET_VALUE (frchain_now->frch_cfi_data->last_address)
817 != frag_now_fix ()))
818 cfi_add_advance_loc (symbol_temp_new_now ());
819
820 switch (arg)
821 {
822 case DW_CFA_offset:
823 reg1 = cfi_parse_reg ();
824 cfi_parse_separator ();
825 offset = cfi_parse_const ();
826 cfi_add_CFA_offset (reg1, offset);
827 break;
828
829 case DW_CFA_val_offset:
830 reg1 = cfi_parse_reg ();
831 cfi_parse_separator ();
832 offset = cfi_parse_const ();
833 cfi_add_CFA_val_offset (reg1, offset);
834 break;
835
836 case CFI_rel_offset:
837 reg1 = cfi_parse_reg ();
838 cfi_parse_separator ();
839 offset = cfi_parse_const ();
840 cfi_add_CFA_offset (reg1,
841 offset - frchain_now->frch_cfi_data->cur_cfa_offset);
842 break;
843
844 case DW_CFA_def_cfa:
845 reg1 = cfi_parse_reg ();
846 cfi_parse_separator ();
847 offset = cfi_parse_const ();
848 cfi_add_CFA_def_cfa (reg1, offset);
849 break;
850
851 case DW_CFA_register:
852 reg1 = cfi_parse_reg ();
853 cfi_parse_separator ();
854 reg2 = cfi_parse_reg ();
855 cfi_add_CFA_register (reg1, reg2);
856 break;
857
858 case DW_CFA_def_cfa_register:
859 reg1 = cfi_parse_reg ();
860 cfi_add_CFA_def_cfa_register (reg1);
861 break;
862
863 case DW_CFA_def_cfa_offset:
864 offset = cfi_parse_const ();
865 cfi_add_CFA_def_cfa_offset (offset);
866 break;
867
868 case CFI_adjust_cfa_offset:
869 offset = cfi_parse_const ();
870 cfi_add_CFA_def_cfa_offset (frchain_now->frch_cfi_data->cur_cfa_offset
871 + offset);
872 break;
873
874 case DW_CFA_restore:
875 for (;;)
876 {
877 reg1 = cfi_parse_reg ();
878 cfi_add_CFA_restore (reg1);
879 SKIP_WHITESPACE ();
880 if (*input_line_pointer != ',')
881 break;
882 ++input_line_pointer;
883 }
884 break;
885
886 case DW_CFA_undefined:
887 for (;;)
888 {
889 reg1 = cfi_parse_reg ();
890 cfi_add_CFA_undefined (reg1);
891 SKIP_WHITESPACE ();
892 if (*input_line_pointer != ',')
893 break;
894 ++input_line_pointer;
895 }
896 break;
897
898 case DW_CFA_same_value:
899 reg1 = cfi_parse_reg ();
900 cfi_add_CFA_same_value (reg1);
901 break;
902
903 case CFI_return_column:
904 reg1 = cfi_parse_reg ();
905 cfi_set_return_column (reg1);
906 break;
907
908 case DW_CFA_remember_state:
909 cfi_add_CFA_remember_state ();
910 break;
911
912 case DW_CFA_restore_state:
913 cfi_add_CFA_restore_state ();
914 break;
915
916 case DW_CFA_GNU_window_save:
917 cfi_add_CFA_insn (DW_CFA_GNU_window_save);
918 break;
919
920 case CFI_signal_frame:
921 frchain_now->frch_cfi_data->cur_fde_data->signal_frame = 1;
922 break;
923
924 default:
925 abort ();
926 }
927
928 demand_empty_rest_of_line ();
929 }
930
931 static void
dot_cfi_escape(int ignored ATTRIBUTE_UNUSED)932 dot_cfi_escape (int ignored ATTRIBUTE_UNUSED)
933 {
934 struct cfi_escape_data *head, **tail, *e;
935 struct cfi_insn_data *insn;
936
937 if (frchain_now->frch_cfi_data == NULL)
938 {
939 as_bad (_("CFI instruction used without previous .cfi_startproc"));
940 ignore_rest_of_line ();
941 return;
942 }
943
944 /* If the last address was not at the current PC, advance to current. */
945 if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now
946 || (S_GET_VALUE (frchain_now->frch_cfi_data->last_address)
947 != frag_now_fix ()))
948 cfi_add_advance_loc (symbol_temp_new_now ());
949
950 tail = &head;
951 do
952 {
953 e = XNEW (struct cfi_escape_data);
954 do_parse_cons_expression (&e->exp, 1);
955 *tail = e;
956 tail = &e->next;
957 }
958 while (*input_line_pointer++ == ',');
959 *tail = NULL;
960
961 insn = alloc_cfi_insn_data ();
962 insn->insn = CFI_escape;
963 insn->u.esc = head;
964
965 --input_line_pointer;
966 demand_empty_rest_of_line ();
967 }
968
969 static void
dot_cfi_personality(int ignored ATTRIBUTE_UNUSED)970 dot_cfi_personality (int ignored ATTRIBUTE_UNUSED)
971 {
972 struct fde_entry *fde;
973 offsetT encoding;
974
975 if (frchain_now->frch_cfi_data == NULL)
976 {
977 as_bad (_("CFI instruction used without previous .cfi_startproc"));
978 ignore_rest_of_line ();
979 return;
980 }
981
982 fde = frchain_now->frch_cfi_data->cur_fde_data;
983 encoding = cfi_parse_const ();
984 if (encoding == DW_EH_PE_omit)
985 {
986 demand_empty_rest_of_line ();
987 fde->per_encoding = encoding;
988 return;
989 }
990
991 if ((encoding & 0xff) != encoding
992 || ((((encoding & 0x70) != 0
993 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
994 && (encoding & 0x70) != DW_EH_PE_pcrel
995 #endif
996 )
997 /* leb128 can be handled, but does something actually need it? */
998 || (encoding & 7) == DW_EH_PE_uleb128
999 || (encoding & 7) > DW_EH_PE_udata8)
1000 && tc_cfi_reloc_for_encoding (encoding) == BFD_RELOC_NONE))
1001 {
1002 as_bad (_("invalid or unsupported encoding in .cfi_personality"));
1003 ignore_rest_of_line ();
1004 return;
1005 }
1006
1007 if (*input_line_pointer++ != ',')
1008 {
1009 as_bad (_(".cfi_personality requires encoding and symbol arguments"));
1010 ignore_rest_of_line ();
1011 return;
1012 }
1013
1014 expression_and_evaluate (&fde->personality);
1015 switch (fde->personality.X_op)
1016 {
1017 case O_symbol:
1018 break;
1019 case O_constant:
1020 if ((encoding & 0x70) == DW_EH_PE_pcrel)
1021 encoding = DW_EH_PE_omit;
1022 break;
1023 default:
1024 encoding = DW_EH_PE_omit;
1025 break;
1026 }
1027
1028 fde->per_encoding = encoding;
1029
1030 if (encoding == DW_EH_PE_omit)
1031 {
1032 as_bad (_("wrong second argument to .cfi_personality"));
1033 ignore_rest_of_line ();
1034 return;
1035 }
1036
1037 demand_empty_rest_of_line ();
1038 }
1039
1040 static void
dot_cfi_lsda(int ignored ATTRIBUTE_UNUSED)1041 dot_cfi_lsda (int ignored ATTRIBUTE_UNUSED)
1042 {
1043 struct fde_entry *fde;
1044 offsetT encoding;
1045
1046 if (frchain_now->frch_cfi_data == NULL)
1047 {
1048 as_bad (_("CFI instruction used without previous .cfi_startproc"));
1049 ignore_rest_of_line ();
1050 return;
1051 }
1052
1053 fde = frchain_now->frch_cfi_data->cur_fde_data;
1054 encoding = cfi_parse_const ();
1055 if (encoding == DW_EH_PE_omit)
1056 {
1057 demand_empty_rest_of_line ();
1058 fde->lsda_encoding = encoding;
1059 return;
1060 }
1061
1062 if ((encoding & 0xff) != encoding
1063 || ((((encoding & 0x70) != 0
1064 #if CFI_DIFF_LSDA_OK || defined tc_cfi_emit_pcrel_expr
1065 && (encoding & 0x70) != DW_EH_PE_pcrel
1066 #endif
1067 )
1068 /* leb128 can be handled, but does something actually need it? */
1069 || (encoding & 7) == DW_EH_PE_uleb128
1070 || (encoding & 7) > DW_EH_PE_udata8)
1071 && tc_cfi_reloc_for_encoding (encoding) == BFD_RELOC_NONE))
1072 {
1073 as_bad (_("invalid or unsupported encoding in .cfi_lsda"));
1074 ignore_rest_of_line ();
1075 return;
1076 }
1077
1078 if (*input_line_pointer++ != ',')
1079 {
1080 as_bad (_(".cfi_lsda requires encoding and symbol arguments"));
1081 ignore_rest_of_line ();
1082 return;
1083 }
1084
1085 fde->lsda_encoding = encoding;
1086
1087 expression_and_evaluate (&fde->lsda);
1088 switch (fde->lsda.X_op)
1089 {
1090 case O_symbol:
1091 break;
1092 case O_constant:
1093 if ((encoding & 0x70) == DW_EH_PE_pcrel)
1094 encoding = DW_EH_PE_omit;
1095 break;
1096 default:
1097 encoding = DW_EH_PE_omit;
1098 break;
1099 }
1100
1101 fde->lsda_encoding = encoding;
1102
1103 if (encoding == DW_EH_PE_omit)
1104 {
1105 as_bad (_("wrong second argument to .cfi_lsda"));
1106 ignore_rest_of_line ();
1107 return;
1108 }
1109
1110 demand_empty_rest_of_line ();
1111 }
1112
1113 static void
dot_cfi_val_encoded_addr(int ignored ATTRIBUTE_UNUSED)1114 dot_cfi_val_encoded_addr (int ignored ATTRIBUTE_UNUSED)
1115 {
1116 struct cfi_insn_data *insn_ptr;
1117 offsetT encoding;
1118
1119 if (frchain_now->frch_cfi_data == NULL)
1120 {
1121 as_bad (_("CFI instruction used without previous .cfi_startproc"));
1122 ignore_rest_of_line ();
1123 return;
1124 }
1125
1126 /* If the last address was not at the current PC, advance to current. */
1127 if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now
1128 || (S_GET_VALUE (frchain_now->frch_cfi_data->last_address)
1129 != frag_now_fix ()))
1130 cfi_add_advance_loc (symbol_temp_new_now ());
1131
1132 insn_ptr = alloc_cfi_insn_data ();
1133 insn_ptr->insn = CFI_val_encoded_addr;
1134
1135 insn_ptr->u.ea.reg = cfi_parse_reg ();
1136
1137 cfi_parse_separator ();
1138 encoding = cfi_parse_const ();
1139 if ((encoding & 0xff) != encoding
1140 || ((encoding & 0x70) != 0
1141 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
1142 && (encoding & 0x70) != DW_EH_PE_pcrel
1143 #endif
1144 )
1145 /* leb128 can be handled, but does something actually need it? */
1146 || (encoding & 7) == DW_EH_PE_uleb128
1147 || (encoding & 7) > DW_EH_PE_udata8)
1148 {
1149 as_bad (_("invalid or unsupported encoding in .cfi_lsda"));
1150 encoding = DW_EH_PE_omit;
1151 }
1152
1153 cfi_parse_separator ();
1154 expression_and_evaluate (&insn_ptr->u.ea.exp);
1155 switch (insn_ptr->u.ea.exp.X_op)
1156 {
1157 case O_symbol:
1158 break;
1159 case O_constant:
1160 if ((encoding & 0x70) != DW_EH_PE_pcrel)
1161 break;
1162 /* Fall through. */
1163 default:
1164 encoding = DW_EH_PE_omit;
1165 break;
1166 }
1167
1168 insn_ptr->u.ea.encoding = encoding;
1169 if (encoding == DW_EH_PE_omit)
1170 {
1171 as_bad (_("wrong third argument to .cfi_val_encoded_addr"));
1172 ignore_rest_of_line ();
1173 return;
1174 }
1175
1176 demand_empty_rest_of_line ();
1177 }
1178
1179 static void
dot_cfi_label(int ignored ATTRIBUTE_UNUSED)1180 dot_cfi_label (int ignored ATTRIBUTE_UNUSED)
1181 {
1182 char *name;
1183
1184 if (frchain_now->frch_cfi_data == NULL)
1185 {
1186 as_bad (_("CFI instruction used without previous .cfi_startproc"));
1187 ignore_rest_of_line ();
1188 return;
1189 }
1190
1191 name = read_symbol_name ();
1192 if (name == NULL)
1193 return;
1194
1195 /* If the last address was not at the current PC, advance to current. */
1196 if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now
1197 || (S_GET_VALUE (frchain_now->frch_cfi_data->last_address)
1198 != frag_now_fix ()))
1199 cfi_add_advance_loc (symbol_temp_new_now ());
1200
1201 cfi_add_label (name);
1202 free (name);
1203
1204 demand_empty_rest_of_line ();
1205 }
1206
1207 static void
dot_cfi_sections(int ignored ATTRIBUTE_UNUSED)1208 dot_cfi_sections (int ignored ATTRIBUTE_UNUSED)
1209 {
1210 int sections = 0;
1211
1212 SKIP_WHITESPACE ();
1213 if (is_name_beginner (*input_line_pointer) || *input_line_pointer == '"')
1214 while (1)
1215 {
1216 char * saved_ilp;
1217 char *name, c;
1218
1219 saved_ilp = input_line_pointer;
1220 c = get_symbol_name (& name);
1221
1222 if (startswith (name, ".eh_frame")
1223 && name[9] != '_')
1224 sections |= CFI_EMIT_eh_frame;
1225 else if (startswith (name, ".debug_frame"))
1226 sections |= CFI_EMIT_debug_frame;
1227 #if SUPPORT_COMPACT_EH
1228 else if (startswith (name, ".eh_frame_entry"))
1229 {
1230 compact_eh = true;
1231 sections |= CFI_EMIT_eh_frame_compact;
1232 }
1233 #endif
1234 #ifdef tc_cfi_section_name
1235 else if (strcmp (name, tc_cfi_section_name) == 0)
1236 sections |= CFI_EMIT_target;
1237 #endif
1238 else
1239 {
1240 *input_line_pointer = c;
1241 input_line_pointer = saved_ilp;
1242 break;
1243 }
1244
1245 *input_line_pointer = c;
1246 SKIP_WHITESPACE_AFTER_NAME ();
1247 if (*input_line_pointer == ',')
1248 {
1249 name = input_line_pointer++;
1250 SKIP_WHITESPACE ();
1251 if (!is_name_beginner (*input_line_pointer)
1252 && *input_line_pointer != '"')
1253 {
1254 input_line_pointer = name;
1255 break;
1256 }
1257 }
1258 else if (is_name_beginner (*input_line_pointer)
1259 || *input_line_pointer == '"')
1260 break;
1261 }
1262
1263 demand_empty_rest_of_line ();
1264 if (cfi_sections_set
1265 && (sections & (CFI_EMIT_eh_frame | CFI_EMIT_eh_frame_compact))
1266 && ((cfi_sections & (CFI_EMIT_eh_frame | CFI_EMIT_eh_frame_compact))
1267 != (sections & (CFI_EMIT_eh_frame | CFI_EMIT_eh_frame_compact))))
1268 as_bad (_("inconsistent uses of .cfi_sections"));
1269 cfi_sections = sections;
1270 }
1271
1272 static void
dot_cfi_startproc(int ignored ATTRIBUTE_UNUSED)1273 dot_cfi_startproc (int ignored ATTRIBUTE_UNUSED)
1274 {
1275 int simple = 0;
1276
1277 if (frchain_now->frch_cfi_data != NULL)
1278 {
1279 as_bad (_("previous CFI entry not closed (missing .cfi_endproc)"));
1280 ignore_rest_of_line ();
1281 return;
1282 }
1283
1284 cfi_new_fde (symbol_temp_new_now ());
1285
1286 SKIP_WHITESPACE ();
1287 if (is_name_beginner (*input_line_pointer) || *input_line_pointer == '"')
1288 {
1289 char * saved_ilp = input_line_pointer;
1290 char *name, c;
1291
1292 c = get_symbol_name (& name);
1293
1294 if (strcmp (name, "simple") == 0)
1295 {
1296 simple = 1;
1297 restore_line_pointer (c);
1298 }
1299 else
1300 input_line_pointer = saved_ilp;
1301 }
1302 demand_empty_rest_of_line ();
1303
1304 cfi_sections_set = true;
1305 all_cfi_sections |= cfi_sections;
1306 cfi_set_sections ();
1307 frchain_now->frch_cfi_data->cur_cfa_offset = 0;
1308 if (!simple)
1309 tc_cfi_frame_initial_instructions ();
1310
1311 if ((cfi_sections & CFI_EMIT_target) != 0)
1312 tc_cfi_startproc ();
1313 }
1314
1315 static void
dot_cfi_endproc(int ignored ATTRIBUTE_UNUSED)1316 dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED)
1317 {
1318 if (frchain_now->frch_cfi_data == NULL)
1319 {
1320 as_bad (_(".cfi_endproc without corresponding .cfi_startproc"));
1321 ignore_rest_of_line ();
1322 return;
1323 }
1324
1325 last_fde = frchain_now->frch_cfi_data->cur_fde_data;
1326
1327 cfi_end_fde (symbol_temp_new_now ());
1328
1329 demand_empty_rest_of_line ();
1330
1331 cfi_sections_set = true;
1332 if ((cfi_sections & CFI_EMIT_target) != 0)
1333 tc_cfi_endproc (last_fde);
1334 }
1335
1336 static segT
get_cfi_seg(segT cseg,const char * base,flagword flags,int align)1337 get_cfi_seg (segT cseg, const char *base, flagword flags, int align)
1338 {
1339 /* Exclude .debug_frame sections for Compact EH. */
1340 if (SUPPORT_FRAME_LINKONCE || ((flags & SEC_DEBUGGING) == 0 && compact_eh))
1341 {
1342 struct dwcfi_seg_list *l;
1343
1344 l = dwcfi_hash_find_or_make (cseg, base, flags);
1345
1346 cseg = l->seg;
1347 subseg_set (cseg, l->subseg);
1348 }
1349 else
1350 {
1351 cseg = subseg_new (base, 0);
1352 bfd_set_section_flags (cseg, flags);
1353 }
1354 record_alignment (cseg, align);
1355 return cseg;
1356 }
1357
1358 #if SUPPORT_COMPACT_EH
1359 static void
dot_cfi_personality_id(int ignored ATTRIBUTE_UNUSED)1360 dot_cfi_personality_id (int ignored ATTRIBUTE_UNUSED)
1361 {
1362 struct fde_entry *fde;
1363
1364 if (frchain_now->frch_cfi_data == NULL)
1365 {
1366 as_bad (_("CFI instruction used without previous .cfi_startproc"));
1367 ignore_rest_of_line ();
1368 return;
1369 }
1370
1371 fde = frchain_now->frch_cfi_data->cur_fde_data;
1372 fde->personality_id = cfi_parse_const ();
1373 demand_empty_rest_of_line ();
1374
1375 if (fde->personality_id == 0 || fde->personality_id > 3)
1376 {
1377 as_bad (_("wrong argument to .cfi_personality_id"));
1378 return;
1379 }
1380 }
1381
1382 static void
dot_cfi_fde_data(int ignored ATTRIBUTE_UNUSED)1383 dot_cfi_fde_data (int ignored ATTRIBUTE_UNUSED)
1384 {
1385 if (frchain_now->frch_cfi_data == NULL)
1386 {
1387 as_bad (_(".cfi_fde_data without corresponding .cfi_startproc"));
1388 ignore_rest_of_line ();
1389 return;
1390 }
1391
1392 last_fde = frchain_now->frch_cfi_data->cur_fde_data;
1393
1394 cfi_sections_set = true;
1395 if ((cfi_sections & CFI_EMIT_target) != 0
1396 || (cfi_sections & CFI_EMIT_eh_frame_compact) != 0)
1397 {
1398 struct cfi_escape_data *head, **tail, *e;
1399 int num_ops = 0;
1400
1401 tail = &head;
1402 if (!is_it_end_of_statement ())
1403 {
1404 num_ops = 0;
1405 do
1406 {
1407 e = XNEW (struct cfi_escape_data);
1408 do_parse_cons_expression (&e->exp, 1);
1409 *tail = e;
1410 tail = &e->next;
1411 num_ops++;
1412 }
1413 while (*input_line_pointer++ == ',');
1414 --input_line_pointer;
1415 }
1416 *tail = NULL;
1417
1418 if (last_fde->lsda_encoding != DW_EH_PE_omit)
1419 last_fde->eh_header_type = EH_COMPACT_HAS_LSDA;
1420 else if (num_ops <= 3 && last_fde->per_encoding == DW_EH_PE_omit)
1421 last_fde->eh_header_type = EH_COMPACT_INLINE;
1422 else
1423 last_fde->eh_header_type = EH_COMPACT_OUTLINE;
1424
1425 if (last_fde->eh_header_type == EH_COMPACT_INLINE)
1426 num_ops = 3;
1427
1428 last_fde->eh_data_size = num_ops;
1429 last_fde->eh_data = XNEWVEC (bfd_byte, num_ops);
1430 num_ops = 0;
1431 while (head)
1432 {
1433 e = head;
1434 head = e->next;
1435 last_fde->eh_data[num_ops++] = e->exp.X_add_number;
1436 free (e);
1437 }
1438 if (last_fde->eh_header_type == EH_COMPACT_INLINE)
1439 while (num_ops < 3)
1440 last_fde->eh_data[num_ops++] = tc_compact_eh_opcode_stop;
1441 }
1442
1443 demand_empty_rest_of_line ();
1444 }
1445
1446 /* Function to emit the compact unwinding opcodes stored in the
1447 fde's eh_data field. The end of the opcode data will be
1448 padded to the value in align. */
1449
1450 static void
output_compact_unwind_data(struct fde_entry * fde,int align)1451 output_compact_unwind_data (struct fde_entry *fde, int align)
1452 {
1453 int data_size = fde->eh_data_size + 2;
1454 int align_padding;
1455 int amask;
1456 char *p;
1457
1458 fde->eh_loc = symbol_temp_new_now ();
1459
1460 p = frag_more (1);
1461 if (fde->personality_id != 0)
1462 *p = fde->personality_id;
1463 else if (fde->per_encoding != DW_EH_PE_omit)
1464 {
1465 *p = 0;
1466 emit_expr_encoded (&fde->personality, fde->per_encoding, false);
1467 data_size += encoding_size (fde->per_encoding);
1468 }
1469 else
1470 *p = 1;
1471
1472 amask = (1 << align) - 1;
1473 align_padding = ((data_size + amask) & ~amask) - data_size;
1474
1475 p = frag_more (fde->eh_data_size + 1 + align_padding);
1476 memcpy (p, fde->eh_data, fde->eh_data_size);
1477 p += fde->eh_data_size;
1478
1479 while (align_padding-- > 0)
1480 *(p++) = tc_compact_eh_opcode_pad;
1481
1482 *(p++) = tc_compact_eh_opcode_stop;
1483 fde->eh_header_type = EH_COMPACT_OUTLINE_DONE;
1484 }
1485
1486 /* Handle the .cfi_inline_lsda directive. */
1487 static void
dot_cfi_inline_lsda(int ignored ATTRIBUTE_UNUSED)1488 dot_cfi_inline_lsda (int ignored ATTRIBUTE_UNUSED)
1489 {
1490 segT ccseg;
1491 int align;
1492 long max_alignment = 28;
1493
1494 if (!last_fde)
1495 {
1496 as_bad (_("unexpected .cfi_inline_lsda"));
1497 ignore_rest_of_line ();
1498 return;
1499 }
1500
1501 if ((last_fde->sections & CFI_EMIT_eh_frame_compact) == 0)
1502 {
1503 as_bad (_(".cfi_inline_lsda not valid for this frame"));
1504 ignore_rest_of_line ();
1505 return;
1506 }
1507
1508 if (last_fde->eh_header_type != EH_COMPACT_UNKNOWN
1509 && last_fde->eh_header_type != EH_COMPACT_HAS_LSDA)
1510 {
1511 as_bad (_(".cfi_inline_lsda seen for frame without .cfi_lsda"));
1512 ignore_rest_of_line ();
1513 return;
1514 }
1515
1516 #ifdef md_flush_pending_output
1517 md_flush_pending_output ();
1518 #endif
1519
1520 align = get_absolute_expression ();
1521 if (align > max_alignment)
1522 {
1523 align = max_alignment;
1524 as_bad (_("Alignment too large: %d. assumed."), align);
1525 }
1526 else if (align < 0)
1527 {
1528 as_warn (_("Alignment negative: 0 assumed."));
1529 align = 0;
1530 }
1531
1532 demand_empty_rest_of_line ();
1533 ccseg = CUR_SEG (last_fde);
1534
1535 /* Open .gnu_extab section. */
1536 get_cfi_seg (ccseg, ".gnu_extab",
1537 (SEC_ALLOC | SEC_LOAD | SEC_DATA
1538 | DWARF2_EH_FRAME_READ_ONLY),
1539 1);
1540
1541 frag_align (align, 0, 0);
1542 record_alignment (now_seg, align);
1543 if (last_fde->eh_header_type == EH_COMPACT_HAS_LSDA)
1544 output_compact_unwind_data (last_fde, align);
1545
1546 last_fde = NULL;
1547
1548 return;
1549 }
1550 #else /* !SUPPORT_COMPACT_EH */
1551 static void
dot_cfi_inline_lsda(int ignored ATTRIBUTE_UNUSED)1552 dot_cfi_inline_lsda (int ignored ATTRIBUTE_UNUSED)
1553 {
1554 as_bad (_(".cfi_inline_lsda is not supported for this target"));
1555 ignore_rest_of_line ();
1556 }
1557
1558 static void
dot_cfi_fde_data(int ignored ATTRIBUTE_UNUSED)1559 dot_cfi_fde_data (int ignored ATTRIBUTE_UNUSED)
1560 {
1561 as_bad (_(".cfi_fde_data is not supported for this target"));
1562 ignore_rest_of_line ();
1563 }
1564
1565 static void
dot_cfi_personality_id(int ignored ATTRIBUTE_UNUSED)1566 dot_cfi_personality_id (int ignored ATTRIBUTE_UNUSED)
1567 {
1568 as_bad (_(".cfi_personality_id is not supported for this target"));
1569 ignore_rest_of_line ();
1570 }
1571 #endif
1572
1573 static void
output_cfi_insn(struct cfi_insn_data * insn)1574 output_cfi_insn (struct cfi_insn_data *insn)
1575 {
1576 offsetT offset;
1577 unsigned int regno;
1578
1579 switch (insn->insn)
1580 {
1581 case DW_CFA_advance_loc:
1582 {
1583 symbolS *from = insn->u.ll.lab1;
1584 symbolS *to = insn->u.ll.lab2;
1585
1586 if (symbol_get_frag (to) == symbol_get_frag (from))
1587 {
1588 addressT delta = S_GET_VALUE (to) - S_GET_VALUE (from);
1589 addressT scaled = delta / DWARF2_LINE_MIN_INSN_LENGTH;
1590
1591 if (scaled == 0)
1592 ;
1593 else if (scaled <= 0x3F)
1594 out_one (DW_CFA_advance_loc + scaled);
1595 else if (scaled <= 0xFF)
1596 {
1597 out_one (DW_CFA_advance_loc1);
1598 out_one (scaled);
1599 }
1600 else if (scaled <= 0xFFFF)
1601 {
1602 out_one (DW_CFA_advance_loc2);
1603 out_two (scaled);
1604 }
1605 else
1606 {
1607 out_one (DW_CFA_advance_loc4);
1608 out_four (scaled);
1609 }
1610 }
1611 else
1612 {
1613 expressionS exp;
1614
1615 exp.X_op = O_subtract;
1616 exp.X_add_symbol = to;
1617 exp.X_op_symbol = from;
1618 exp.X_add_number = 0;
1619
1620 /* The code in ehopt.c expects that one byte of the encoding
1621 is already allocated to the frag. This comes from the way
1622 that it scans the .eh_frame section looking first for the
1623 .byte DW_CFA_advance_loc4. Call frag_grow with the sum of
1624 room needed by frag_more and frag_var to preallocate space
1625 ensuring that the DW_CFA_advance_loc4 is in the fixed part
1626 of the rs_cfa frag, so that the relax machinery can remove
1627 the advance_loc should it advance by zero. */
1628 frag_grow (5);
1629 *frag_more (1) = DW_CFA_advance_loc4;
1630
1631 frag_var (rs_cfa, 4, 0, DWARF2_LINE_MIN_INSN_LENGTH << 3,
1632 make_expr_symbol (&exp), frag_now_fix () - 1,
1633 (char *) frag_now);
1634 }
1635 }
1636 break;
1637
1638 case DW_CFA_def_cfa:
1639 offset = insn->u.ri.offset;
1640 if (offset < 0)
1641 {
1642 out_one (DW_CFA_def_cfa_sf);
1643 out_uleb128 (insn->u.ri.reg);
1644 out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
1645 }
1646 else
1647 {
1648 out_one (DW_CFA_def_cfa);
1649 out_uleb128 (insn->u.ri.reg);
1650 out_uleb128 (offset);
1651 }
1652 break;
1653
1654 case DW_CFA_def_cfa_register:
1655 case DW_CFA_undefined:
1656 case DW_CFA_same_value:
1657 out_one (insn->insn);
1658 out_uleb128 (insn->u.r);
1659 break;
1660
1661 case DW_CFA_def_cfa_offset:
1662 offset = insn->u.i;
1663 if (offset < 0)
1664 {
1665 out_one (DW_CFA_def_cfa_offset_sf);
1666 out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
1667 }
1668 else
1669 {
1670 out_one (DW_CFA_def_cfa_offset);
1671 out_uleb128 (offset);
1672 }
1673 break;
1674
1675 case DW_CFA_restore:
1676 regno = insn->u.r;
1677 if (regno <= 0x3F)
1678 {
1679 out_one (DW_CFA_restore + regno);
1680 }
1681 else
1682 {
1683 out_one (DW_CFA_restore_extended);
1684 out_uleb128 (regno);
1685 }
1686 break;
1687
1688 case DW_CFA_offset:
1689 regno = insn->u.ri.reg;
1690 offset = insn->u.ri.offset / DWARF2_CIE_DATA_ALIGNMENT;
1691 if (offset < 0)
1692 {
1693 out_one (DW_CFA_offset_extended_sf);
1694 out_uleb128 (regno);
1695 out_sleb128 (offset);
1696 }
1697 else if (regno <= 0x3F)
1698 {
1699 out_one (DW_CFA_offset + regno);
1700 out_uleb128 (offset);
1701 }
1702 else
1703 {
1704 out_one (DW_CFA_offset_extended);
1705 out_uleb128 (regno);
1706 out_uleb128 (offset);
1707 }
1708 break;
1709
1710 case DW_CFA_val_offset:
1711 regno = insn->u.ri.reg;
1712 offset = insn->u.ri.offset / DWARF2_CIE_DATA_ALIGNMENT;
1713 if (offset < 0)
1714 {
1715 out_one (DW_CFA_val_offset_sf);
1716 out_uleb128 (regno);
1717 out_sleb128 (offset);
1718 }
1719 else
1720 {
1721 out_one (DW_CFA_val_offset);
1722 out_uleb128 (regno);
1723 out_uleb128 (offset);
1724 }
1725 break;
1726
1727 case DW_CFA_register:
1728 out_one (DW_CFA_register);
1729 out_uleb128 (insn->u.rr.reg1);
1730 out_uleb128 (insn->u.rr.reg2);
1731 break;
1732
1733 case DW_CFA_remember_state:
1734 case DW_CFA_restore_state:
1735 out_one (insn->insn);
1736 break;
1737
1738 case DW_CFA_GNU_window_save:
1739 out_one (DW_CFA_GNU_window_save);
1740 break;
1741
1742 case CFI_escape:
1743 {
1744 struct cfi_escape_data *e;
1745 for (e = insn->u.esc; e ; e = e->next)
1746 emit_expr (&e->exp, 1);
1747 break;
1748 }
1749
1750 case CFI_val_encoded_addr:
1751 {
1752 unsigned encoding = insn->u.ea.encoding;
1753 offsetT enc_size;
1754
1755 if (encoding == DW_EH_PE_omit)
1756 break;
1757 out_one (DW_CFA_val_expression);
1758 out_uleb128 (insn->u.ea.reg);
1759
1760 switch (encoding & 0x7)
1761 {
1762 case DW_EH_PE_absptr:
1763 enc_size = DWARF2_ADDR_SIZE (stdoutput);
1764 break;
1765 case DW_EH_PE_udata2:
1766 enc_size = 2;
1767 break;
1768 case DW_EH_PE_udata4:
1769 enc_size = 4;
1770 break;
1771 case DW_EH_PE_udata8:
1772 enc_size = 8;
1773 break;
1774 default:
1775 abort ();
1776 }
1777
1778 /* If the user has requested absolute encoding,
1779 then use the smaller DW_OP_addr encoding. */
1780 if (insn->u.ea.encoding == DW_EH_PE_absptr)
1781 {
1782 out_uleb128 (1 + enc_size);
1783 out_one (DW_OP_addr);
1784 }
1785 else
1786 {
1787 out_uleb128 (1 + 1 + enc_size);
1788 out_one (DW_OP_GNU_encoded_addr);
1789 out_one (encoding);
1790
1791 if ((encoding & 0x70) == DW_EH_PE_pcrel)
1792 {
1793 #if CFI_DIFF_EXPR_OK
1794 insn->u.ea.exp.X_op = O_subtract;
1795 insn->u.ea.exp.X_op_symbol = symbol_temp_new_now ();
1796 #elif defined (tc_cfi_emit_pcrel_expr)
1797 tc_cfi_emit_pcrel_expr (&insn->u.ea.exp, enc_size);
1798 break;
1799 #else
1800 abort ();
1801 #endif
1802 }
1803 }
1804 emit_expr (&insn->u.ea.exp, enc_size);
1805 }
1806 break;
1807
1808 case CFI_label:
1809 colon (insn->u.sym_name);
1810 break;
1811
1812 default:
1813 abort ();
1814 }
1815 }
1816
1817 static void
output_cie(struct cie_entry * cie,bool eh_frame,int align)1818 output_cie (struct cie_entry *cie, bool eh_frame, int align)
1819 {
1820 symbolS *after_size_address, *end_address;
1821 expressionS exp;
1822 struct cfi_insn_data *i;
1823 offsetT augmentation_size;
1824 int enc;
1825 enum dwarf2_format fmt = DWARF2_FORMAT (now_seg);
1826
1827 cie->start_address = symbol_temp_new_now ();
1828 after_size_address = symbol_temp_make ();
1829 end_address = symbol_temp_make ();
1830
1831 exp.X_op = O_subtract;
1832 exp.X_add_symbol = end_address;
1833 exp.X_op_symbol = after_size_address;
1834 exp.X_add_number = 0;
1835
1836 if (eh_frame || fmt == dwarf2_format_32bit)
1837 emit_expr (&exp, 4); /* Length. */
1838 else
1839 {
1840 if (fmt == dwarf2_format_64bit)
1841 out_four (-1);
1842 emit_expr (&exp, 8); /* Length. */
1843 }
1844 symbol_set_value_now (after_size_address);
1845 if (eh_frame)
1846 out_four (0); /* CIE id. */
1847 else
1848 {
1849 out_four (-1); /* CIE id. */
1850 if (fmt != dwarf2_format_32bit)
1851 out_four (-1);
1852 }
1853 out_one (flag_dwarf_cie_version); /* Version. */
1854 if (eh_frame)
1855 {
1856 out_one ('z'); /* Augmentation. */
1857 if (cie->per_encoding != DW_EH_PE_omit)
1858 out_one ('P');
1859 if (cie->lsda_encoding != DW_EH_PE_omit)
1860 out_one ('L');
1861 out_one ('R');
1862 #ifdef tc_output_cie_extra
1863 tc_output_cie_extra (cie);
1864 #endif
1865 }
1866 if (cie->signal_frame)
1867 out_one ('S');
1868 out_one (0);
1869 if (flag_dwarf_cie_version >= 4)
1870 {
1871 /* For now we are assuming a flat address space with 4 or 8 byte
1872 addresses. */
1873 int address_size = dwarf2_format_32bit ? 4 : 8;
1874 out_one (address_size); /* Address size. */
1875 out_one (0); /* Segment size. */
1876 }
1877 out_uleb128 (DWARF2_LINE_MIN_INSN_LENGTH); /* Code alignment. */
1878 out_sleb128 (DWARF2_CIE_DATA_ALIGNMENT); /* Data alignment. */
1879 if (flag_dwarf_cie_version == 1) /* Return column. */
1880 {
1881 if ((cie->return_column & 0xff) != cie->return_column)
1882 as_bad (_("return column number %d overflows in CIE version 1"),
1883 cie->return_column);
1884 out_one (cie->return_column);
1885 }
1886 else
1887 out_uleb128 (cie->return_column);
1888 if (eh_frame)
1889 {
1890 augmentation_size = 1 + (cie->lsda_encoding != DW_EH_PE_omit);
1891 if (cie->per_encoding != DW_EH_PE_omit)
1892 augmentation_size += 1 + encoding_size (cie->per_encoding);
1893 out_uleb128 (augmentation_size); /* Augmentation size. */
1894
1895 emit_expr_encoded (&cie->personality, cie->per_encoding, true);
1896
1897 if (cie->lsda_encoding != DW_EH_PE_omit)
1898 out_one (cie->lsda_encoding);
1899 }
1900
1901 switch (DWARF2_FDE_RELOC_SIZE)
1902 {
1903 case 2:
1904 enc = DW_EH_PE_sdata2;
1905 break;
1906 case 4:
1907 enc = DW_EH_PE_sdata4;
1908 break;
1909 case 8:
1910 enc = DW_EH_PE_sdata8;
1911 break;
1912 default:
1913 abort ();
1914 }
1915 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
1916 enc |= DW_EH_PE_pcrel;
1917 #endif
1918 #ifdef DWARF2_FDE_RELOC_ENCODING
1919 /* Allow target to override encoding. */
1920 enc = DWARF2_FDE_RELOC_ENCODING (enc);
1921 #endif
1922 cie->fde_encoding = enc;
1923 if (eh_frame)
1924 out_one (enc);
1925
1926 if (cie->first)
1927 {
1928 for (i = cie->first; i != cie->last; i = i->next)
1929 {
1930 if (CUR_SEG (i) != CUR_SEG (cie))
1931 continue;
1932 output_cfi_insn (i);
1933 }
1934 }
1935
1936 frag_align (align, DW_CFA_nop, 0);
1937 symbol_set_value_now (end_address);
1938 }
1939
1940 static void
output_fde(struct fde_entry * fde,struct cie_entry * cie,bool eh_frame,struct cfi_insn_data * first,int align)1941 output_fde (struct fde_entry *fde, struct cie_entry *cie,
1942 bool eh_frame, struct cfi_insn_data *first,
1943 int align)
1944 {
1945 symbolS *after_size_address, *end_address;
1946 expressionS exp;
1947 offsetT augmentation_size;
1948 enum dwarf2_format fmt = DWARF2_FORMAT (now_seg);
1949 unsigned int offset_size;
1950 unsigned int addr_size;
1951
1952 after_size_address = symbol_temp_make ();
1953 end_address = symbol_temp_make ();
1954
1955 exp.X_op = O_subtract;
1956 exp.X_add_symbol = end_address;
1957 exp.X_op_symbol = after_size_address;
1958 exp.X_add_number = 0;
1959 if (eh_frame || fmt == dwarf2_format_32bit)
1960 offset_size = 4;
1961 else
1962 {
1963 if (fmt == dwarf2_format_64bit)
1964 out_four (-1);
1965 offset_size = 8;
1966 }
1967 emit_expr (&exp, offset_size); /* Length. */
1968 symbol_set_value_now (after_size_address);
1969
1970 if (eh_frame)
1971 {
1972 exp.X_op = O_subtract;
1973 exp.X_add_symbol = after_size_address;
1974 exp.X_op_symbol = cie->start_address;
1975 exp.X_add_number = 0;
1976 emit_expr (&exp, offset_size); /* CIE offset. */
1977 }
1978 else
1979 {
1980 TC_DWARF2_EMIT_OFFSET (cie->start_address, offset_size);
1981 }
1982
1983 exp.X_op = O_symbol;
1984 if (eh_frame)
1985 {
1986 bfd_reloc_code_real_type code
1987 = tc_cfi_reloc_for_encoding (cie->fde_encoding);
1988 addr_size = DWARF2_FDE_RELOC_SIZE;
1989 if (code != BFD_RELOC_NONE)
1990 {
1991 reloc_howto_type *howto = bfd_reloc_type_lookup (stdoutput, code);
1992 char *p = frag_more (addr_size);
1993 gas_assert (addr_size == (unsigned) howto->bitsize / 8);
1994 md_number_to_chars (p, 0, addr_size);
1995 fix_new (frag_now, p - frag_now->fr_literal, addr_size,
1996 fde->start_address, 0, howto->pc_relative, code);
1997 }
1998 else
1999 {
2000 exp.X_op = O_subtract;
2001 exp.X_add_number = 0;
2002 #if CFI_DIFF_EXPR_OK
2003 exp.X_add_symbol = fde->start_address;
2004 exp.X_op_symbol = symbol_temp_new_now ();
2005 emit_expr (&exp, addr_size); /* Code offset. */
2006 #else
2007 exp.X_op = O_symbol;
2008 exp.X_add_symbol = fde->start_address;
2009
2010 #if defined(tc_cfi_emit_pcrel_expr)
2011 tc_cfi_emit_pcrel_expr (&exp, addr_size); /* Code offset. */
2012 #else
2013 emit_expr (&exp, addr_size); /* Code offset. */
2014 #endif
2015 #endif
2016 }
2017 }
2018 else
2019 {
2020 exp.X_add_number = 0;
2021 exp.X_add_symbol = fde->start_address;
2022 addr_size = DWARF2_ADDR_SIZE (stdoutput);
2023 emit_expr (&exp, addr_size);
2024 }
2025
2026 exp.X_op = O_subtract;
2027 exp.X_add_symbol = fde->end_address;
2028 exp.X_op_symbol = fde->start_address; /* Code length. */
2029 exp.X_add_number = 0;
2030 emit_expr (&exp, addr_size);
2031
2032 augmentation_size = encoding_size (fde->lsda_encoding);
2033 if (eh_frame)
2034 out_uleb128 (augmentation_size); /* Augmentation size. */
2035
2036 emit_expr_encoded (&fde->lsda, cie->lsda_encoding, false);
2037
2038 for (; first; first = first->next)
2039 if (CUR_SEG (first) == CUR_SEG (fde))
2040 output_cfi_insn (first);
2041
2042 frag_align (align, DW_CFA_nop, 0);
2043 symbol_set_value_now (end_address);
2044 }
2045
2046 /* Allow these insns to be put in the initial sequence of a CIE.
2047 If J is non-NULL, then compare I and J insns for a match. */
2048
2049 static inline bool
initial_cie_insn(const struct cfi_insn_data * i,const struct cfi_insn_data * j)2050 initial_cie_insn (const struct cfi_insn_data *i, const struct cfi_insn_data *j)
2051 {
2052 if (j && i->insn != j->insn)
2053 return false;
2054 switch (i->insn)
2055 {
2056 case DW_CFA_offset:
2057 case DW_CFA_def_cfa:
2058 case DW_CFA_val_offset:
2059 if (j)
2060 {
2061 if (i->u.ri.reg != j->u.ri.reg)
2062 return false;
2063 if (i->u.ri.offset != j->u.ri.offset)
2064 return false;
2065 }
2066 break;
2067
2068 case DW_CFA_register:
2069 if (j)
2070 {
2071 if (i->u.rr.reg1 != j->u.rr.reg1)
2072 return false;
2073 if (i->u.rr.reg2 != j->u.rr.reg2)
2074 return false;
2075 }
2076 break;
2077
2078 case DW_CFA_def_cfa_register:
2079 case DW_CFA_restore:
2080 case DW_CFA_undefined:
2081 case DW_CFA_same_value:
2082 if (j)
2083 {
2084 if (i->u.r != j->u.r)
2085 return false;
2086 }
2087 break;
2088
2089 case DW_CFA_def_cfa_offset:
2090 if (j)
2091 {
2092 if (i->u.i != j->u.i)
2093 return false;
2094 }
2095 break;
2096
2097 default:
2098 return false;
2099 }
2100 return true;
2101 }
2102
2103 static struct cie_entry *
select_cie_for_fde(struct fde_entry * fde,bool eh_frame,struct cfi_insn_data ** pfirst,int align)2104 select_cie_for_fde (struct fde_entry *fde, bool eh_frame,
2105 struct cfi_insn_data **pfirst, int align)
2106 {
2107 struct cfi_insn_data *i, *j;
2108 struct cie_entry *cie;
2109
2110 for (cie = cie_root; cie; cie = cie->next)
2111 {
2112 if (CUR_SEG (cie) != CUR_SEG (fde))
2113 continue;
2114 #ifdef tc_cie_fde_equivalent_extra
2115 if (!tc_cie_fde_equivalent_extra (cie, fde))
2116 continue;
2117 #endif
2118 if (cie->return_column != fde->return_column
2119 || cie->signal_frame != fde->signal_frame
2120 || cie->per_encoding != fde->per_encoding
2121 || cie->lsda_encoding != fde->lsda_encoding)
2122 continue;
2123 if (cie->per_encoding != DW_EH_PE_omit)
2124 {
2125 if (cie->personality.X_op != fde->personality.X_op
2126 || (cie->personality.X_add_number
2127 != fde->personality.X_add_number))
2128 continue;
2129 switch (cie->personality.X_op)
2130 {
2131 case O_constant:
2132 if (cie->personality.X_unsigned != fde->personality.X_unsigned)
2133 continue;
2134 break;
2135 case O_symbol:
2136 if (cie->personality.X_add_symbol
2137 != fde->personality.X_add_symbol)
2138 continue;
2139 break;
2140 default:
2141 abort ();
2142 }
2143 }
2144 for (i = cie->first, j = fde->data;
2145 i != cie->last && j != NULL;
2146 i = i->next, j = j->next)
2147 {
2148 if (!initial_cie_insn (i, j))
2149 break;
2150 }
2151
2152 if (i == cie->last)
2153 {
2154 *pfirst = j;
2155 return cie;
2156 }
2157 }
2158
2159 cie = XNEW (struct cie_entry);
2160 cie->next = cie_root;
2161 cie_root = cie;
2162 SET_CUR_SEG (cie, CUR_SEG (fde));
2163 cie->return_column = fde->return_column;
2164 cie->signal_frame = fde->signal_frame;
2165 cie->per_encoding = fde->per_encoding;
2166 cie->lsda_encoding = fde->lsda_encoding;
2167 cie->personality = fde->personality;
2168 cie->first = fde->data;
2169 #ifdef tc_cie_entry_init_extra
2170 tc_cie_entry_init_extra (cie, fde)
2171 #endif
2172
2173 for (i = cie->first; i ; i = i->next)
2174 if (!initial_cie_insn (i, NULL))
2175 break;
2176
2177 cie->last = i;
2178 *pfirst = i;
2179
2180 output_cie (cie, eh_frame, align);
2181
2182 return cie;
2183 }
2184
2185 #ifdef md_reg_eh_frame_to_debug_frame
2186 static void
cfi_change_reg_numbers(struct cfi_insn_data * insn,segT ccseg)2187 cfi_change_reg_numbers (struct cfi_insn_data *insn, segT ccseg)
2188 {
2189 for (; insn; insn = insn->next)
2190 {
2191 if (CUR_SEG (insn) != ccseg)
2192 continue;
2193 switch (insn->insn)
2194 {
2195 case DW_CFA_advance_loc:
2196 case DW_CFA_def_cfa_offset:
2197 case DW_CFA_remember_state:
2198 case DW_CFA_restore_state:
2199 case DW_CFA_GNU_window_save:
2200 case CFI_escape:
2201 case CFI_label:
2202 break;
2203
2204 case DW_CFA_def_cfa:
2205 case DW_CFA_offset:
2206 insn->u.ri.reg = md_reg_eh_frame_to_debug_frame (insn->u.ri.reg);
2207 break;
2208
2209 case DW_CFA_def_cfa_register:
2210 case DW_CFA_undefined:
2211 case DW_CFA_same_value:
2212 case DW_CFA_restore:
2213 insn->u.r = md_reg_eh_frame_to_debug_frame (insn->u.r);
2214 break;
2215
2216 case DW_CFA_register:
2217 insn->u.rr.reg1 = md_reg_eh_frame_to_debug_frame (insn->u.rr.reg1);
2218 insn->u.rr.reg2 = md_reg_eh_frame_to_debug_frame (insn->u.rr.reg2);
2219 break;
2220
2221 case CFI_val_encoded_addr:
2222 insn->u.ea.reg = md_reg_eh_frame_to_debug_frame (insn->u.ea.reg);
2223 break;
2224
2225 default:
2226 abort ();
2227 }
2228 }
2229 }
2230 #else
2231 #define cfi_change_reg_numbers(insn, cseg) do { } while (0)
2232 #endif
2233
2234 #if SUPPORT_COMPACT_EH
2235 static void
cfi_emit_eh_header(symbolS * sym,bfd_vma addend)2236 cfi_emit_eh_header (symbolS *sym, bfd_vma addend)
2237 {
2238 expressionS exp;
2239
2240 exp.X_add_number = addend;
2241 exp.X_add_symbol = sym;
2242 emit_expr_encoded (&exp, DW_EH_PE_sdata4 | DW_EH_PE_pcrel, false);
2243 }
2244
2245 static void
output_eh_header(struct fde_entry * fde)2246 output_eh_header (struct fde_entry *fde)
2247 {
2248 char *p;
2249 bfd_vma addend;
2250
2251 if (fde->eh_header_type == EH_COMPACT_INLINE)
2252 addend = 0;
2253 else
2254 addend = 1;
2255
2256 cfi_emit_eh_header (fde->start_address, addend);
2257
2258 if (fde->eh_header_type == EH_COMPACT_INLINE)
2259 {
2260 p = frag_more (4);
2261 /* Inline entries always use PR1. */
2262 *(p++) = 1;
2263 memcpy(p, fde->eh_data, 3);
2264 }
2265 else
2266 {
2267 if (fde->eh_header_type == EH_COMPACT_LEGACY)
2268 addend = 1;
2269 else if (fde->eh_header_type == EH_COMPACT_OUTLINE
2270 || fde->eh_header_type == EH_COMPACT_OUTLINE_DONE)
2271 addend = 0;
2272 else
2273 abort ();
2274 cfi_emit_eh_header (fde->eh_loc, addend);
2275 }
2276 }
2277 #endif
2278
2279 void
cfi_finish(void)2280 cfi_finish (void)
2281 {
2282 struct cie_entry *cie, *cie_next;
2283 segT cfi_seg, ccseg;
2284 struct fde_entry *fde;
2285 struct cfi_insn_data *first;
2286 int save_flag_traditional_format, seek_next_seg;
2287
2288 if (all_fde_data == 0)
2289 return;
2290
2291 cfi_sections_set = true;
2292 if ((all_cfi_sections & CFI_EMIT_eh_frame) != 0
2293 || (all_cfi_sections & CFI_EMIT_eh_frame_compact) != 0)
2294 {
2295 /* Make sure check_eh_frame doesn't do anything with our output. */
2296 save_flag_traditional_format = flag_traditional_format;
2297 flag_traditional_format = 1;
2298
2299 if (!EH_FRAME_LINKONCE)
2300 {
2301 /* Open .eh_frame section. */
2302 cfi_seg = get_cfi_seg (NULL, ".eh_frame",
2303 (SEC_ALLOC | SEC_LOAD | SEC_DATA
2304 | DWARF2_EH_FRAME_READ_ONLY),
2305 EH_FRAME_ALIGNMENT);
2306 #ifdef md_fix_up_eh_frame
2307 md_fix_up_eh_frame (cfi_seg);
2308 #else
2309 (void) cfi_seg;
2310 #endif
2311 }
2312
2313 do
2314 {
2315 ccseg = NULL;
2316 seek_next_seg = 0;
2317
2318 for (cie = cie_root; cie; cie = cie_next)
2319 {
2320 cie_next = cie->next;
2321 free ((void *) cie);
2322 }
2323 cie_root = NULL;
2324
2325 for (fde = all_fde_data; fde ; fde = fde->next)
2326 {
2327 if ((fde->sections & CFI_EMIT_eh_frame) == 0
2328 && (fde->sections & CFI_EMIT_eh_frame_compact) == 0)
2329 continue;
2330
2331 #if SUPPORT_COMPACT_EH
2332 /* Emit a LEGACY format header if we have processed all
2333 of the .cfi directives without encountering either inline or
2334 out-of-line compact unwinding opcodes. */
2335 if (fde->eh_header_type == EH_COMPACT_HAS_LSDA
2336 || fde->eh_header_type == EH_COMPACT_UNKNOWN)
2337 fde->eh_header_type = EH_COMPACT_LEGACY;
2338
2339 if (fde->eh_header_type != EH_COMPACT_LEGACY)
2340 continue;
2341 #endif
2342 if (EH_FRAME_LINKONCE)
2343 {
2344 if (HANDLED (fde))
2345 continue;
2346 if (seek_next_seg && CUR_SEG (fde) != ccseg)
2347 {
2348 seek_next_seg = 2;
2349 continue;
2350 }
2351 if (!seek_next_seg)
2352 {
2353 ccseg = CUR_SEG (fde);
2354 /* Open .eh_frame section. */
2355 cfi_seg = get_cfi_seg (ccseg, ".eh_frame",
2356 (SEC_ALLOC | SEC_LOAD | SEC_DATA
2357 | DWARF2_EH_FRAME_READ_ONLY),
2358 EH_FRAME_ALIGNMENT);
2359 #ifdef md_fix_up_eh_frame
2360 md_fix_up_eh_frame (cfi_seg);
2361 #else
2362 (void) cfi_seg;
2363 #endif
2364 seek_next_seg = 1;
2365 }
2366 SET_HANDLED (fde, 1);
2367 }
2368
2369 if (fde->end_address == NULL)
2370 {
2371 as_bad (_("open CFI at the end of file; "
2372 "missing .cfi_endproc directive"));
2373 fde->end_address = fde->start_address;
2374 }
2375
2376 cie = select_cie_for_fde (fde, true, &first, 2);
2377 fde->eh_loc = symbol_temp_new_now ();
2378 output_fde (fde, cie, true, first,
2379 fde->next == NULL ? EH_FRAME_ALIGNMENT : 2);
2380 }
2381 }
2382 while (EH_FRAME_LINKONCE && seek_next_seg == 2);
2383
2384 if (EH_FRAME_LINKONCE)
2385 for (fde = all_fde_data; fde ; fde = fde->next)
2386 SET_HANDLED (fde, 0);
2387
2388 #if SUPPORT_COMPACT_EH
2389 if (compact_eh)
2390 {
2391 /* Create remaining out of line table entries. */
2392 do
2393 {
2394 ccseg = NULL;
2395 seek_next_seg = 0;
2396
2397 for (fde = all_fde_data; fde ; fde = fde->next)
2398 {
2399 if ((fde->sections & CFI_EMIT_eh_frame) == 0
2400 && (fde->sections & CFI_EMIT_eh_frame_compact) == 0)
2401 continue;
2402
2403 if (fde->eh_header_type != EH_COMPACT_OUTLINE)
2404 continue;
2405 if (HANDLED (fde))
2406 continue;
2407 if (seek_next_seg && CUR_SEG (fde) != ccseg)
2408 {
2409 seek_next_seg = 2;
2410 continue;
2411 }
2412 if (!seek_next_seg)
2413 {
2414 ccseg = CUR_SEG (fde);
2415 /* Open .gnu_extab section. */
2416 get_cfi_seg (ccseg, ".gnu_extab",
2417 (SEC_ALLOC | SEC_LOAD | SEC_DATA
2418 | DWARF2_EH_FRAME_READ_ONLY),
2419 1);
2420 seek_next_seg = 1;
2421 }
2422 SET_HANDLED (fde, 1);
2423
2424 frag_align (1, 0, 0);
2425 record_alignment (now_seg, 1);
2426 output_compact_unwind_data (fde, 1);
2427 }
2428 }
2429 while (EH_FRAME_LINKONCE && seek_next_seg == 2);
2430
2431 for (fde = all_fde_data; fde ; fde = fde->next)
2432 SET_HANDLED (fde, 0);
2433
2434 /* Create index table fragments. */
2435 do
2436 {
2437 ccseg = NULL;
2438 seek_next_seg = 0;
2439
2440 for (fde = all_fde_data; fde ; fde = fde->next)
2441 {
2442 if ((fde->sections & CFI_EMIT_eh_frame) == 0
2443 && (fde->sections & CFI_EMIT_eh_frame_compact) == 0)
2444 continue;
2445
2446 if (HANDLED (fde))
2447 continue;
2448 if (seek_next_seg && CUR_SEG (fde) != ccseg)
2449 {
2450 seek_next_seg = 2;
2451 continue;
2452 }
2453 if (!seek_next_seg)
2454 {
2455 ccseg = CUR_SEG (fde);
2456 /* Open .eh_frame_entry section. */
2457 cfi_seg = get_cfi_seg (ccseg, ".eh_frame_entry",
2458 (SEC_ALLOC | SEC_LOAD | SEC_DATA
2459 | DWARF2_EH_FRAME_READ_ONLY),
2460 2);
2461 seek_next_seg = 1;
2462 }
2463 SET_HANDLED (fde, 1);
2464
2465 output_eh_header (fde);
2466 }
2467 }
2468 while (seek_next_seg == 2);
2469
2470 for (fde = all_fde_data; fde ; fde = fde->next)
2471 SET_HANDLED (fde, 0);
2472 }
2473 #endif /* SUPPORT_COMPACT_EH */
2474
2475 flag_traditional_format = save_flag_traditional_format;
2476 }
2477
2478 cfi_sections_set = true;
2479 if ((all_cfi_sections & CFI_EMIT_debug_frame) != 0)
2480 {
2481 int alignment = ffs (DWARF2_ADDR_SIZE (stdoutput)) - 1;
2482
2483 if (!SUPPORT_FRAME_LINKONCE)
2484 get_cfi_seg (NULL, ".debug_frame",
2485 SEC_READONLY | SEC_DEBUGGING,
2486 alignment);
2487
2488 do
2489 {
2490 ccseg = NULL;
2491 seek_next_seg = 0;
2492
2493 for (cie = cie_root; cie; cie = cie_next)
2494 {
2495 cie_next = cie->next;
2496 free ((void *) cie);
2497 }
2498 cie_root = NULL;
2499
2500 for (fde = all_fde_data; fde ; fde = fde->next)
2501 {
2502 if ((fde->sections & CFI_EMIT_debug_frame) == 0)
2503 continue;
2504
2505 if (SUPPORT_FRAME_LINKONCE)
2506 {
2507 if (HANDLED (fde))
2508 continue;
2509 if (seek_next_seg && CUR_SEG (fde) != ccseg)
2510 {
2511 seek_next_seg = 2;
2512 continue;
2513 }
2514 if (!seek_next_seg)
2515 {
2516 ccseg = CUR_SEG (fde);
2517 /* Open .debug_frame section. */
2518 get_cfi_seg (ccseg, ".debug_frame",
2519 SEC_READONLY | SEC_DEBUGGING,
2520 alignment);
2521 seek_next_seg = 1;
2522 }
2523 SET_HANDLED (fde, 1);
2524 }
2525 if (fde->end_address == NULL)
2526 {
2527 as_bad (_("open CFI at the end of file; "
2528 "missing .cfi_endproc directive"));
2529 fde->end_address = fde->start_address;
2530 }
2531
2532 fde->per_encoding = DW_EH_PE_omit;
2533 fde->lsda_encoding = DW_EH_PE_omit;
2534 cfi_change_reg_numbers (fde->data, ccseg);
2535 cie = select_cie_for_fde (fde, false, &first, alignment);
2536 output_fde (fde, cie, false, first, alignment);
2537 }
2538 }
2539 while (SUPPORT_FRAME_LINKONCE && seek_next_seg == 2);
2540
2541 if (SUPPORT_FRAME_LINKONCE)
2542 for (fde = all_fde_data; fde ; fde = fde->next)
2543 SET_HANDLED (fde, 0);
2544 }
2545 }
2546
2547 #else /* TARGET_USE_CFIPOP */
2548
2549 /* Emit an intelligible error message for missing support. */
2550
2551 static void
dot_cfi_dummy(int ignored ATTRIBUTE_UNUSED)2552 dot_cfi_dummy (int ignored ATTRIBUTE_UNUSED)
2553 {
2554 as_bad (_("CFI is not supported for this target"));
2555 ignore_rest_of_line ();
2556 }
2557
2558 const pseudo_typeS cfi_pseudo_table[] =
2559 {
2560 { "cfi_sections", dot_cfi_dummy, 0 },
2561 { "cfi_startproc", dot_cfi_dummy, 0 },
2562 { "cfi_endproc", dot_cfi_dummy, 0 },
2563 { "cfi_fde_data", dot_cfi_dummy, 0 },
2564 { "cfi_def_cfa", dot_cfi_dummy, 0 },
2565 { "cfi_def_cfa_register", dot_cfi_dummy, 0 },
2566 { "cfi_def_cfa_offset", dot_cfi_dummy, 0 },
2567 { "cfi_adjust_cfa_offset", dot_cfi_dummy, 0 },
2568 { "cfi_offset", dot_cfi_dummy, 0 },
2569 { "cfi_rel_offset", dot_cfi_dummy, 0 },
2570 { "cfi_register", dot_cfi_dummy, 0 },
2571 { "cfi_return_column", dot_cfi_dummy, 0 },
2572 { "cfi_restore", dot_cfi_dummy, 0 },
2573 { "cfi_undefined", dot_cfi_dummy, 0 },
2574 { "cfi_same_value", dot_cfi_dummy, 0 },
2575 { "cfi_remember_state", dot_cfi_dummy, 0 },
2576 { "cfi_restore_state", dot_cfi_dummy, 0 },
2577 { "cfi_window_save", dot_cfi_dummy, 0 },
2578 { "cfi_escape", dot_cfi_dummy, 0 },
2579 { "cfi_signal_frame", dot_cfi_dummy, 0 },
2580 { "cfi_personality", dot_cfi_dummy, 0 },
2581 { "cfi_personality_id", dot_cfi_dummy, 0 },
2582 { "cfi_lsda", dot_cfi_dummy, 0 },
2583 { "cfi_val_encoded_addr", dot_cfi_dummy, 0 },
2584 { "cfi_label", dot_cfi_dummy, 0 },
2585 { "cfi_inline_lsda", dot_cfi_dummy, 0 },
2586 { "cfi_val_offset", dot_cfi_dummy, 0 },
2587 { NULL, NULL, 0 }
2588 };
2589
2590 void
cfi_finish(void)2591 cfi_finish (void)
2592 {
2593 }
2594 #endif /* TARGET_USE_CFIPOP */
2595