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