Update copyright years
[external/binutils.git] / gas / dw2gencfi.c
1 /* dw2gencfi.c - Support for generating Dwarf2 CFI information.
2    Copyright (C) 2003-2014 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 #ifndef DWARF2_FORMAT
79 #define DWARF2_FORMAT(SEC) dwarf2_format_32bit
80 #endif
81
82 #ifndef DWARF2_ADDR_SIZE
83 #define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
84 #endif
85
86 #if SUPPORT_FRAME_LINKONCE
87 #define CUR_SEG(structp) structp->cur_seg
88 #define SET_CUR_SEG(structp, seg) structp->cur_seg = seg
89 #define HANDLED(structp) structp->handled
90 #define SET_HANDLED(structp, val) structp->handled = val
91 #else
92 #define CUR_SEG(structp) NULL
93 #define SET_CUR_SEG(structp, seg) (void) (0 && seg)
94 #define HANDLED(structp) 0
95 #define SET_HANDLED(structp, val) (void) (0 && val)
96 #endif
97
98 /* Private segment collection list.  */
99 struct dwcfi_seg_list
100 {
101   segT   seg;
102   int    subseg;
103   char * seg_name;
104 };
105
106 #define FRAME_NAME ".eh_frame"
107
108 static struct hash_control *dwcfi_hash;
109
110 /* Build based on segment the derived .debug_...
111    segment name containing origin segment's postfix name part.  */
112
113 static char *
114 get_debugseg_name (segT seg, const char *base_name)
115 {
116   const char *name;
117
118   if (!seg)
119     name = "";
120   else
121     {
122       const char * dollar;
123       const char * dot;
124
125       name = bfd_get_section_name (stdoutput, seg);
126
127       dollar = strchr (name, '$');
128       dot = strchr (name + 1, '.');
129
130       if (!dollar && !dot)
131         name = "";
132       else if (!dollar)
133         name = dot;
134       else if (!dot)
135         name = dollar;
136       else if (dot < dollar)
137         name = dot;
138       else
139         name = dollar;
140     }
141
142   return concat (base_name, name, NULL);
143 }
144
145 /* Allocate a dwcfi_seg_list structure.  */
146
147 static struct dwcfi_seg_list *
148 alloc_debugseg_item (segT seg, int subseg, char *name)
149 {
150   struct dwcfi_seg_list *r;
151
152   r = (struct dwcfi_seg_list *)
153     xmalloc (sizeof (struct dwcfi_seg_list) + strlen (name));
154   r->seg = seg;
155   r->subseg = subseg;
156   r->seg_name = name;
157   return r;
158 }
159
160 static segT
161 is_now_linkonce_segment (void)
162 {
163   if ((bfd_get_section_flags (stdoutput, now_seg)
164        & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD
165           | SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE
166           | SEC_LINK_DUPLICATES_SAME_CONTENTS)) != 0)
167     return now_seg;
168   return NULL;
169 }
170
171 /* Generate debug... segment with same linkonce properties
172    of based segment.  */
173
174 static segT
175 make_debug_seg (segT cseg, char *name, int sflags)
176 {
177   segT save_seg = now_seg;
178   int save_subseg = now_subseg;
179   segT r;
180   flagword flags;
181
182   r = subseg_new (name, 0);
183
184   /* Check if code segment is marked as linked once.  */
185   if (!cseg)
186     flags = 0;
187   else
188     flags = bfd_get_section_flags (stdoutput, cseg)
189       & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD
190          | SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE
191          | SEC_LINK_DUPLICATES_SAME_CONTENTS);
192
193   /* Add standard section flags.  */
194   flags |= sflags;
195
196   /* Apply possibly linked once flags to new generated segment, too.  */
197   if (!bfd_set_section_flags (stdoutput, r, flags))
198     as_bad (_("bfd_set_section_flags: %s"),
199             bfd_errmsg (bfd_get_error ()));
200
201   /* Restore to previous segment.  */
202   if (save_seg != NULL)
203     subseg_set (save_seg, save_subseg);
204   return r;
205 }
206
207 static void
208 dwcfi_hash_insert (const char *name, struct dwcfi_seg_list *item)
209 {
210   const char *error_string;
211
212   if ((error_string = hash_jam (dwcfi_hash, name, (char *) item)))
213     as_fatal (_("Inserting \"%s\" into structure table failed: %s"),
214               name, error_string);
215 }
216
217 static struct dwcfi_seg_list *
218 dwcfi_hash_find (char *name)
219 {
220   return (struct dwcfi_seg_list *) hash_find (dwcfi_hash, name);
221 }
222
223 static struct dwcfi_seg_list *
224 dwcfi_hash_find_or_make (segT cseg, const char *base_name, int flags)
225 {
226   struct dwcfi_seg_list *item;
227   char *name;
228
229   /* Initialize dwcfi_hash once.  */
230   if (!dwcfi_hash)
231     dwcfi_hash = hash_new ();
232
233   name = get_debugseg_name (cseg, base_name);
234
235   item = dwcfi_hash_find (name);
236   if (!item)
237     {
238       item = alloc_debugseg_item (make_debug_seg (cseg, name, flags), 0, name);
239
240       dwcfi_hash_insert (item->seg_name, item);
241     }
242   else
243     free (name);
244
245   return item;
246 }
247
248 /* ??? Share this with dwarf2cfg.c.  */
249 #ifndef TC_DWARF2_EMIT_OFFSET
250 #define TC_DWARF2_EMIT_OFFSET  generic_dwarf2_emit_offset
251
252 /* Create an offset to .dwarf2_*.  */
253
254 static void
255 generic_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
256 {
257   expressionS exp;
258
259   exp.X_op = O_symbol;
260   exp.X_add_symbol = symbol;
261   exp.X_add_number = 0;
262   emit_expr (&exp, size);
263 }
264 #endif
265
266 struct cfi_escape_data
267 {
268   struct cfi_escape_data *next;
269   expressionS exp;
270 };
271
272 struct cie_entry
273 {
274   struct cie_entry *next;
275 #if SUPPORT_FRAME_LINKONCE
276   segT cur_seg;
277 #endif
278   symbolS *start_address;
279   unsigned int return_column;
280   unsigned int signal_frame;
281   unsigned char per_encoding;
282   unsigned char lsda_encoding;
283   expressionS personality;
284   struct cfi_insn_data *first, *last;
285 };
286
287 /* List of FDE entries.  */
288
289 struct fde_entry *all_fde_data;
290 static struct fde_entry **last_fde_data = &all_fde_data;
291
292 /* List of CIEs so that they could be reused.  */
293 static struct cie_entry *cie_root;
294
295 /* Stack of old CFI data, for save/restore.  */
296 struct cfa_save_data
297 {
298   struct cfa_save_data *next;
299   offsetT cfa_offset;
300 };
301
302 /* Current open FDE entry.  */
303 struct frch_cfi_data
304 {
305   struct fde_entry *cur_fde_data;
306   symbolS *last_address;
307   offsetT cur_cfa_offset;
308   struct cfa_save_data *cfa_save_stack;
309 };
310 \f
311 /* Construct a new FDE structure and add it to the end of the fde list.  */
312
313 static struct fde_entry *
314 alloc_fde_entry (void)
315 {
316   struct fde_entry *fde = (struct fde_entry *)
317       xcalloc (1, sizeof (struct fde_entry));
318
319   frchain_now->frch_cfi_data = (struct frch_cfi_data *)
320       xcalloc (1, sizeof (struct frch_cfi_data));
321   frchain_now->frch_cfi_data->cur_fde_data = fde;
322   *last_fde_data = fde;
323   last_fde_data = &fde->next;
324   SET_CUR_SEG (fde, is_now_linkonce_segment ());
325   SET_HANDLED (fde, 0);
326   fde->last = &fde->data;
327   fde->return_column = DWARF2_DEFAULT_RETURN_COLUMN;
328   fde->per_encoding = DW_EH_PE_omit;
329   fde->lsda_encoding = DW_EH_PE_omit;
330
331   return fde;
332 }
333
334 /* The following functions are available for a backend to construct its
335    own unwind information, usually from legacy unwind directives.  */
336
337 /* Construct a new INSN structure and add it to the end of the insn list
338    for the currently active FDE.  */
339
340 static struct cfi_insn_data *
341 alloc_cfi_insn_data (void)
342 {
343   struct cfi_insn_data *insn = (struct cfi_insn_data *)
344       xcalloc (1, sizeof (struct cfi_insn_data));
345   struct fde_entry *cur_fde_data = frchain_now->frch_cfi_data->cur_fde_data;
346
347   *cur_fde_data->last = insn;
348   cur_fde_data->last = &insn->next;
349   SET_CUR_SEG (insn, is_now_linkonce_segment ());
350   return insn;
351 }
352
353 /* Construct a new FDE structure that begins at LABEL.  */
354
355 void
356 cfi_new_fde (symbolS *label)
357 {
358   struct fde_entry *fde = alloc_fde_entry ();
359   fde->start_address = label;
360   frchain_now->frch_cfi_data->last_address = label;
361 }
362
363 /* End the currently open FDE.  */
364
365 void
366 cfi_end_fde (symbolS *label)
367 {
368   frchain_now->frch_cfi_data->cur_fde_data->end_address = label;
369   free (frchain_now->frch_cfi_data);
370   frchain_now->frch_cfi_data = NULL;
371 }
372
373 /* Set the return column for the current FDE.  */
374
375 void
376 cfi_set_return_column (unsigned regno)
377 {
378   frchain_now->frch_cfi_data->cur_fde_data->return_column = regno;
379 }
380
381 /* Universal functions to store new instructions.  */
382
383 static void
384 cfi_add_CFA_insn (int insn)
385 {
386   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
387
388   insn_ptr->insn = insn;
389 }
390
391 static void
392 cfi_add_CFA_insn_reg (int insn, unsigned regno)
393 {
394   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
395
396   insn_ptr->insn = insn;
397   insn_ptr->u.r = regno;
398 }
399
400 static void
401 cfi_add_CFA_insn_offset (int insn, offsetT offset)
402 {
403   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
404
405   insn_ptr->insn = insn;
406   insn_ptr->u.i = offset;
407 }
408
409 static void
410 cfi_add_CFA_insn_reg_reg (int insn, unsigned reg1, unsigned reg2)
411 {
412   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
413
414   insn_ptr->insn = insn;
415   insn_ptr->u.rr.reg1 = reg1;
416   insn_ptr->u.rr.reg2 = reg2;
417 }
418
419 static void
420 cfi_add_CFA_insn_reg_offset (int insn, unsigned regno, offsetT offset)
421 {
422   struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
423
424   insn_ptr->insn = insn;
425   insn_ptr->u.ri.reg = regno;
426   insn_ptr->u.ri.offset = offset;
427 }
428
429 /* Add a CFI insn to advance the PC from the last address to LABEL.  */
430
431 void
432 cfi_add_advance_loc (symbolS *label)
433 {
434   struct cfi_insn_data *insn = alloc_cfi_insn_data ();
435
436   insn->insn = DW_CFA_advance_loc;
437   insn->u.ll.lab1 = frchain_now->frch_cfi_data->last_address;
438   insn->u.ll.lab2 = label;
439
440   frchain_now->frch_cfi_data->last_address = label;
441 }
442
443 /* Add a DW_CFA_offset record to the CFI data.  */
444
445 void
446 cfi_add_CFA_offset (unsigned regno, offsetT offset)
447 {
448   unsigned int abs_data_align;
449
450   gas_assert (DWARF2_CIE_DATA_ALIGNMENT != 0);
451   cfi_add_CFA_insn_reg_offset (DW_CFA_offset, regno, offset);
452
453   abs_data_align = (DWARF2_CIE_DATA_ALIGNMENT < 0
454                     ? -DWARF2_CIE_DATA_ALIGNMENT : DWARF2_CIE_DATA_ALIGNMENT);
455   if (offset % abs_data_align)
456     as_bad (_("register save offset not a multiple of %u"), abs_data_align);
457 }
458
459 /* Add a DW_CFA_def_cfa record to the CFI data.  */
460
461 void
462 cfi_add_CFA_def_cfa (unsigned regno, offsetT offset)
463 {
464   cfi_add_CFA_insn_reg_offset (DW_CFA_def_cfa, regno, offset);
465   frchain_now->frch_cfi_data->cur_cfa_offset = offset;
466 }
467
468 /* Add a DW_CFA_register record to the CFI data.  */
469
470 void
471 cfi_add_CFA_register (unsigned reg1, unsigned reg2)
472 {
473   cfi_add_CFA_insn_reg_reg (DW_CFA_register, reg1, reg2);
474 }
475
476 /* Add a DW_CFA_def_cfa_register record to the CFI data.  */
477
478 void
479 cfi_add_CFA_def_cfa_register (unsigned regno)
480 {
481   cfi_add_CFA_insn_reg (DW_CFA_def_cfa_register, regno);
482 }
483
484 /* Add a DW_CFA_def_cfa_offset record to the CFI data.  */
485
486 void
487 cfi_add_CFA_def_cfa_offset (offsetT offset)
488 {
489   cfi_add_CFA_insn_offset (DW_CFA_def_cfa_offset, offset);
490   frchain_now->frch_cfi_data->cur_cfa_offset = offset;
491 }
492
493 void
494 cfi_add_CFA_restore (unsigned regno)
495 {
496   cfi_add_CFA_insn_reg (DW_CFA_restore, regno);
497 }
498
499 void
500 cfi_add_CFA_undefined (unsigned regno)
501 {
502   cfi_add_CFA_insn_reg (DW_CFA_undefined, regno);
503 }
504
505 void
506 cfi_add_CFA_same_value (unsigned regno)
507 {
508   cfi_add_CFA_insn_reg (DW_CFA_same_value, regno);
509 }
510
511 void
512 cfi_add_CFA_remember_state (void)
513 {
514   struct cfa_save_data *p;
515
516   cfi_add_CFA_insn (DW_CFA_remember_state);
517
518   p = (struct cfa_save_data *) xmalloc (sizeof (*p));
519   p->cfa_offset = frchain_now->frch_cfi_data->cur_cfa_offset;
520   p->next = frchain_now->frch_cfi_data->cfa_save_stack;
521   frchain_now->frch_cfi_data->cfa_save_stack = p;
522 }
523
524 void
525 cfi_add_CFA_restore_state (void)
526 {
527   struct cfa_save_data *p;
528
529   cfi_add_CFA_insn (DW_CFA_restore_state);
530
531   p = frchain_now->frch_cfi_data->cfa_save_stack;
532   if (p)
533     {
534       frchain_now->frch_cfi_data->cur_cfa_offset = p->cfa_offset;
535       frchain_now->frch_cfi_data->cfa_save_stack = p->next;
536       free (p);
537     }
538   else
539     as_bad (_("CFI state restore without previous remember"));
540 }
541
542 \f
543 /* Parse CFI assembler directives.  */
544
545 static void dot_cfi (int);
546 static void dot_cfi_escape (int);
547 static void dot_cfi_sections (int);
548 static void dot_cfi_startproc (int);
549 static void dot_cfi_endproc (int);
550 static void dot_cfi_personality (int);
551 static void dot_cfi_lsda (int);
552 static void dot_cfi_val_encoded_addr (int);
553
554 const pseudo_typeS cfi_pseudo_table[] =
555   {
556     { "cfi_sections", dot_cfi_sections, 0 },
557     { "cfi_startproc", dot_cfi_startproc, 0 },
558     { "cfi_endproc", dot_cfi_endproc, 0 },
559     { "cfi_def_cfa", dot_cfi, DW_CFA_def_cfa },
560     { "cfi_def_cfa_register", dot_cfi, DW_CFA_def_cfa_register },
561     { "cfi_def_cfa_offset", dot_cfi, DW_CFA_def_cfa_offset },
562     { "cfi_adjust_cfa_offset", dot_cfi, CFI_adjust_cfa_offset },
563     { "cfi_offset", dot_cfi, DW_CFA_offset },
564     { "cfi_rel_offset", dot_cfi, CFI_rel_offset },
565     { "cfi_register", dot_cfi, DW_CFA_register },
566     { "cfi_return_column", dot_cfi, CFI_return_column },
567     { "cfi_restore", dot_cfi, DW_CFA_restore },
568     { "cfi_undefined", dot_cfi, DW_CFA_undefined },
569     { "cfi_same_value", dot_cfi, DW_CFA_same_value },
570     { "cfi_remember_state", dot_cfi, DW_CFA_remember_state },
571     { "cfi_restore_state", dot_cfi, DW_CFA_restore_state },
572     { "cfi_window_save", dot_cfi, DW_CFA_GNU_window_save },
573     { "cfi_escape", dot_cfi_escape, 0 },
574     { "cfi_signal_frame", dot_cfi, CFI_signal_frame },
575     { "cfi_personality", dot_cfi_personality, 0 },
576     { "cfi_lsda", dot_cfi_lsda, 0 },
577     { "cfi_val_encoded_addr", dot_cfi_val_encoded_addr, 0 },
578     { NULL, NULL, 0 }
579   };
580
581 static void
582 cfi_parse_separator (void)
583 {
584   SKIP_WHITESPACE ();
585   if (*input_line_pointer == ',')
586     input_line_pointer++;
587   else
588     as_bad (_("missing separator"));
589 }
590
591 #ifndef tc_parse_to_dw2regnum
592 static void
593 tc_parse_to_dw2regnum (expressionS *exp)
594 {
595 # ifdef tc_regname_to_dw2regnum
596   SKIP_WHITESPACE ();
597   if (is_name_beginner (*input_line_pointer)
598       || (*input_line_pointer == '%'
599           && is_name_beginner (*++input_line_pointer)))
600     {
601       char *name, c;
602
603       name = input_line_pointer;
604       c = get_symbol_end ();
605
606       exp->X_op = O_constant;
607       exp->X_add_number = tc_regname_to_dw2regnum (name);
608
609       *input_line_pointer = c;
610     }
611   else
612 # endif
613     expression_and_evaluate (exp);
614 }
615 #endif
616
617 static unsigned
618 cfi_parse_reg (void)
619 {
620   int regno;
621   expressionS exp;
622
623   tc_parse_to_dw2regnum (&exp);
624   switch (exp.X_op)
625     {
626     case O_register:
627     case O_constant:
628       regno = exp.X_add_number;
629       break;
630
631     default:
632       regno = -1;
633       break;
634     }
635
636   if (regno < 0)
637     {
638       as_bad (_("bad register expression"));
639       regno = 0;
640     }
641
642   return regno;
643 }
644
645 static offsetT
646 cfi_parse_const (void)
647 {
648   return get_absolute_expression ();
649 }
650
651 static void
652 dot_cfi (int arg)
653 {
654   offsetT offset;
655   unsigned reg1, reg2;
656
657   if (frchain_now->frch_cfi_data == NULL)
658     {
659       as_bad (_("CFI instruction used without previous .cfi_startproc"));
660       ignore_rest_of_line ();
661       return;
662     }
663
664   /* If the last address was not at the current PC, advance to current.  */
665   if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now
666       || S_GET_VALUE (frchain_now->frch_cfi_data->last_address)
667          != frag_now_fix ())
668     cfi_add_advance_loc (symbol_temp_new_now ());
669
670   switch (arg)
671     {
672     case DW_CFA_offset:
673       reg1 = cfi_parse_reg ();
674       cfi_parse_separator ();
675       offset = cfi_parse_const ();
676       cfi_add_CFA_offset (reg1, offset);
677       break;
678
679     case CFI_rel_offset:
680       reg1 = cfi_parse_reg ();
681       cfi_parse_separator ();
682       offset = cfi_parse_const ();
683       cfi_add_CFA_offset (reg1,
684                           offset - frchain_now->frch_cfi_data->cur_cfa_offset);
685       break;
686
687     case DW_CFA_def_cfa:
688       reg1 = cfi_parse_reg ();
689       cfi_parse_separator ();
690       offset = cfi_parse_const ();
691       cfi_add_CFA_def_cfa (reg1, offset);
692       break;
693
694     case DW_CFA_register:
695       reg1 = cfi_parse_reg ();
696       cfi_parse_separator ();
697       reg2 = cfi_parse_reg ();
698       cfi_add_CFA_register (reg1, reg2);
699       break;
700
701     case DW_CFA_def_cfa_register:
702       reg1 = cfi_parse_reg ();
703       cfi_add_CFA_def_cfa_register (reg1);
704       break;
705
706     case DW_CFA_def_cfa_offset:
707       offset = cfi_parse_const ();
708       cfi_add_CFA_def_cfa_offset (offset);
709       break;
710
711     case CFI_adjust_cfa_offset:
712       offset = cfi_parse_const ();
713       cfi_add_CFA_def_cfa_offset (frchain_now->frch_cfi_data->cur_cfa_offset
714                                   + offset);
715       break;
716
717     case DW_CFA_restore:
718       for (;;)
719         {
720           reg1 = cfi_parse_reg ();
721           cfi_add_CFA_restore (reg1);
722           SKIP_WHITESPACE ();
723           if (*input_line_pointer != ',')
724             break;
725           ++input_line_pointer;
726         }
727       break;
728
729     case DW_CFA_undefined:
730       for (;;)
731         {
732           reg1 = cfi_parse_reg ();
733           cfi_add_CFA_undefined (reg1);
734           SKIP_WHITESPACE ();
735           if (*input_line_pointer != ',')
736             break;
737           ++input_line_pointer;
738         }
739       break;
740
741     case DW_CFA_same_value:
742       reg1 = cfi_parse_reg ();
743       cfi_add_CFA_same_value (reg1);
744       break;
745
746     case CFI_return_column:
747       reg1 = cfi_parse_reg ();
748       cfi_set_return_column (reg1);
749       break;
750
751     case DW_CFA_remember_state:
752       cfi_add_CFA_remember_state ();
753       break;
754
755     case DW_CFA_restore_state:
756       cfi_add_CFA_restore_state ();
757       break;
758
759     case DW_CFA_GNU_window_save:
760       cfi_add_CFA_insn (DW_CFA_GNU_window_save);
761       break;
762
763     case CFI_signal_frame:
764       frchain_now->frch_cfi_data->cur_fde_data->signal_frame = 1;
765       break;
766
767     default:
768       abort ();
769     }
770
771   demand_empty_rest_of_line ();
772 }
773
774 static void
775 dot_cfi_escape (int ignored ATTRIBUTE_UNUSED)
776 {
777   struct cfi_escape_data *head, **tail, *e;
778   struct cfi_insn_data *insn;
779
780   if (frchain_now->frch_cfi_data == NULL)
781     {
782       as_bad (_("CFI instruction used without previous .cfi_startproc"));
783       ignore_rest_of_line ();
784       return;
785     }
786
787   /* If the last address was not at the current PC, advance to current.  */
788   if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now
789       || S_GET_VALUE (frchain_now->frch_cfi_data->last_address)
790          != frag_now_fix ())
791     cfi_add_advance_loc (symbol_temp_new_now ());
792
793   tail = &head;
794   do
795     {
796       e = (struct cfi_escape_data *) xmalloc (sizeof (*e));
797       do_parse_cons_expression (&e->exp, 1);
798       *tail = e;
799       tail = &e->next;
800     }
801   while (*input_line_pointer++ == ',');
802   *tail = NULL;
803
804   insn = alloc_cfi_insn_data ();
805   insn->insn = CFI_escape;
806   insn->u.esc = head;
807
808   --input_line_pointer;
809   demand_empty_rest_of_line ();
810 }
811
812 static void
813 dot_cfi_personality (int ignored ATTRIBUTE_UNUSED)
814 {
815   struct fde_entry *fde;
816   offsetT encoding;
817
818   if (frchain_now->frch_cfi_data == NULL)
819     {
820       as_bad (_("CFI instruction used without previous .cfi_startproc"));
821       ignore_rest_of_line ();
822       return;
823     }
824
825   fde = frchain_now->frch_cfi_data->cur_fde_data;
826   encoding = cfi_parse_const ();
827   if (encoding == DW_EH_PE_omit)
828     {
829       demand_empty_rest_of_line ();
830       fde->per_encoding = encoding;
831       return;
832     }
833
834   if ((encoding & 0xff) != encoding
835       || ((encoding & 0x70) != 0
836 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
837           && (encoding & 0x70) != DW_EH_PE_pcrel
838 #endif
839           )
840          /* leb128 can be handled, but does something actually need it?  */
841       || (encoding & 7) == DW_EH_PE_uleb128
842       || (encoding & 7) > DW_EH_PE_udata8)
843     {
844       as_bad (_("invalid or unsupported encoding in .cfi_personality"));
845       ignore_rest_of_line ();
846       return;
847     }
848
849   if (*input_line_pointer++ != ',')
850     {
851       as_bad (_(".cfi_personality requires encoding and symbol arguments"));
852       ignore_rest_of_line ();
853       return;
854     }
855
856   expression_and_evaluate (&fde->personality);
857   switch (fde->personality.X_op)
858     {
859     case O_symbol:
860       break;
861     case O_constant:
862       if ((encoding & 0x70) == DW_EH_PE_pcrel)
863         encoding = DW_EH_PE_omit;
864       break;
865     default:
866       encoding = DW_EH_PE_omit;
867       break;
868     }
869
870   fde->per_encoding = encoding;
871
872   if (encoding == DW_EH_PE_omit)
873     {
874       as_bad (_("wrong second argument to .cfi_personality"));
875       ignore_rest_of_line ();
876       return;
877     }
878
879   demand_empty_rest_of_line ();
880 }
881
882 static void
883 dot_cfi_lsda (int ignored ATTRIBUTE_UNUSED)
884 {
885   struct fde_entry *fde;
886   offsetT encoding;
887
888   if (frchain_now->frch_cfi_data == NULL)
889     {
890       as_bad (_("CFI instruction used without previous .cfi_startproc"));
891       ignore_rest_of_line ();
892       return;
893     }
894
895   fde = frchain_now->frch_cfi_data->cur_fde_data;
896   encoding = cfi_parse_const ();
897   if (encoding == DW_EH_PE_omit)
898     {
899       demand_empty_rest_of_line ();
900       fde->lsda_encoding = encoding;
901       return;
902     }
903
904   if ((encoding & 0xff) != encoding
905       || ((encoding & 0x70) != 0
906 #if CFI_DIFF_LSDA_OK || defined tc_cfi_emit_pcrel_expr
907           && (encoding & 0x70) != DW_EH_PE_pcrel
908 #endif
909           )
910          /* leb128 can be handled, but does something actually need it?  */
911       || (encoding & 7) == DW_EH_PE_uleb128
912       || (encoding & 7) > DW_EH_PE_udata8)
913     {
914       as_bad (_("invalid or unsupported encoding in .cfi_lsda"));
915       ignore_rest_of_line ();
916       return;
917     }
918
919   if (*input_line_pointer++ != ',')
920     {
921       as_bad (_(".cfi_lsda requires encoding and symbol arguments"));
922       ignore_rest_of_line ();
923       return;
924     }
925
926   fde->lsda_encoding = encoding;
927
928   expression_and_evaluate (&fde->lsda);
929   switch (fde->lsda.X_op)
930     {
931     case O_symbol:
932       break;
933     case O_constant:
934       if ((encoding & 0x70) == DW_EH_PE_pcrel)
935         encoding = DW_EH_PE_omit;
936       break;
937     default:
938       encoding = DW_EH_PE_omit;
939       break;
940     }
941
942   fde->lsda_encoding = encoding;
943
944   if (encoding == DW_EH_PE_omit)
945     {
946       as_bad (_("wrong second argument to .cfi_lsda"));
947       ignore_rest_of_line ();
948       return;
949     }
950
951   demand_empty_rest_of_line ();
952 }
953
954 static void
955 dot_cfi_val_encoded_addr (int ignored ATTRIBUTE_UNUSED)
956 {
957   struct cfi_insn_data *insn_ptr;
958   offsetT encoding;
959
960   if (frchain_now->frch_cfi_data == NULL)
961     {
962       as_bad (_("CFI instruction used without previous .cfi_startproc"));
963       ignore_rest_of_line ();
964       return;
965     }
966
967   /* If the last address was not at the current PC, advance to current.  */
968   if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now
969       || S_GET_VALUE (frchain_now->frch_cfi_data->last_address)
970          != frag_now_fix ())
971     cfi_add_advance_loc (symbol_temp_new_now ());
972
973   insn_ptr = alloc_cfi_insn_data ();
974   insn_ptr->insn = CFI_val_encoded_addr;
975
976   insn_ptr->u.ea.reg = cfi_parse_reg ();
977
978   cfi_parse_separator ();
979   encoding = cfi_parse_const ();
980   if ((encoding & 0xff) != encoding
981       || ((encoding & 0x70) != 0
982 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
983           && (encoding & 0x70) != DW_EH_PE_pcrel
984 #endif
985           )
986          /* leb128 can be handled, but does something actually need it?  */
987       || (encoding & 7) == DW_EH_PE_uleb128
988       || (encoding & 7) > DW_EH_PE_udata8)
989     {
990       as_bad (_("invalid or unsupported encoding in .cfi_lsda"));
991       encoding = DW_EH_PE_omit;
992     }
993
994   cfi_parse_separator ();
995   expression_and_evaluate (&insn_ptr->u.ea.exp);
996   switch (insn_ptr->u.ea.exp.X_op)
997     {
998     case O_symbol:
999       break;
1000     case O_constant:
1001       if ((encoding & 0x70) != DW_EH_PE_pcrel)
1002         break;
1003     default:
1004       encoding = DW_EH_PE_omit;
1005       break;
1006     }
1007
1008   insn_ptr->u.ea.encoding = encoding;
1009   if (encoding == DW_EH_PE_omit)
1010     {
1011       as_bad (_("wrong third argument to .cfi_val_encoded_addr"));
1012       ignore_rest_of_line ();
1013       return;
1014     }
1015
1016   demand_empty_rest_of_line ();
1017 }
1018
1019 /* By default emit .eh_frame only, not .debug_frame.  */
1020 #define CFI_EMIT_eh_frame       (1 << 0)
1021 #define CFI_EMIT_debug_frame    (1 << 1)
1022 #define CFI_EMIT_target         (1 << 2)
1023 static int cfi_sections = CFI_EMIT_eh_frame;
1024
1025 static void
1026 dot_cfi_sections (int ignored ATTRIBUTE_UNUSED)
1027 {
1028   int sections = 0;
1029
1030   SKIP_WHITESPACE ();
1031   if (is_name_beginner (*input_line_pointer))
1032     while (1)
1033       {
1034         char *name, c;
1035
1036         name = input_line_pointer;
1037         c = get_symbol_end ();
1038
1039         if (strncmp (name, ".eh_frame", sizeof ".eh_frame") == 0
1040             && name[9] != '_')
1041           sections |= CFI_EMIT_eh_frame;
1042         else if (strncmp (name, ".debug_frame", sizeof ".debug_frame") == 0)
1043           sections |= CFI_EMIT_debug_frame;
1044 #ifdef tc_cfi_section_name
1045         else if (strcmp (name, tc_cfi_section_name) == 0)
1046           sections |= CFI_EMIT_target;
1047 #endif
1048         else
1049           {
1050             *input_line_pointer = c;
1051             input_line_pointer = name;
1052             break;
1053           }
1054
1055         *input_line_pointer = c;
1056         SKIP_WHITESPACE ();
1057         if (*input_line_pointer == ',')
1058           {
1059             name = input_line_pointer++;
1060             SKIP_WHITESPACE ();
1061             if (!is_name_beginner (*input_line_pointer))
1062               {
1063                 input_line_pointer = name;
1064                 break;
1065               }
1066           }
1067         else if (is_name_beginner (*input_line_pointer))
1068           break;
1069       }
1070
1071   demand_empty_rest_of_line ();
1072   cfi_sections = sections;
1073 }
1074
1075 static void
1076 dot_cfi_startproc (int ignored ATTRIBUTE_UNUSED)
1077 {
1078   int simple = 0;
1079
1080   if (frchain_now->frch_cfi_data != NULL)
1081     {
1082       as_bad (_("previous CFI entry not closed (missing .cfi_endproc)"));
1083       ignore_rest_of_line ();
1084       return;
1085     }
1086
1087   cfi_new_fde (symbol_temp_new_now ());
1088
1089   SKIP_WHITESPACE ();
1090   if (is_name_beginner (*input_line_pointer))
1091     {
1092       char *name, c;
1093
1094       name = input_line_pointer;
1095       c = get_symbol_end ();
1096
1097       if (strcmp (name, "simple") == 0)
1098         {
1099           simple = 1;
1100           *input_line_pointer = c;
1101         }
1102       else
1103         input_line_pointer = name;
1104     }
1105   demand_empty_rest_of_line ();
1106
1107   frchain_now->frch_cfi_data->cur_cfa_offset = 0;
1108   if (!simple)
1109     tc_cfi_frame_initial_instructions ();
1110
1111   if ((cfi_sections & CFI_EMIT_target) != 0)
1112     tc_cfi_startproc ();
1113 }
1114
1115 static void
1116 dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED)
1117 {
1118   struct fde_entry *fde;
1119
1120   if (frchain_now->frch_cfi_data == NULL)
1121     {
1122       as_bad (_(".cfi_endproc without corresponding .cfi_startproc"));
1123       ignore_rest_of_line ();
1124       return;
1125     }
1126
1127   fde = frchain_now->frch_cfi_data->cur_fde_data;
1128
1129   cfi_end_fde (symbol_temp_new_now ());
1130
1131   demand_empty_rest_of_line ();
1132
1133   if ((cfi_sections & CFI_EMIT_target) != 0)
1134     tc_cfi_endproc (fde);
1135 }
1136
1137 \f
1138 /* Emit a single byte into the current segment.  */
1139
1140 static inline void
1141 out_one (int byte)
1142 {
1143   FRAG_APPEND_1_CHAR (byte);
1144 }
1145
1146 /* Emit a two-byte word into the current segment.  */
1147
1148 static inline void
1149 out_two (int data)
1150 {
1151   md_number_to_chars (frag_more (2), data, 2);
1152 }
1153
1154 /* Emit a four byte word into the current segment.  */
1155
1156 static inline void
1157 out_four (int data)
1158 {
1159   md_number_to_chars (frag_more (4), data, 4);
1160 }
1161
1162 /* Emit an unsigned "little-endian base 128" number.  */
1163
1164 static void
1165 out_uleb128 (addressT value)
1166 {
1167   output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
1168 }
1169
1170 /* Emit an unsigned "little-endian base 128" number.  */
1171
1172 static void
1173 out_sleb128 (offsetT value)
1174 {
1175   output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1);
1176 }
1177
1178 static void
1179 output_cfi_insn (struct cfi_insn_data *insn)
1180 {
1181   offsetT offset;
1182   unsigned int regno;
1183
1184   switch (insn->insn)
1185     {
1186     case DW_CFA_advance_loc:
1187       {
1188         symbolS *from = insn->u.ll.lab1;
1189         symbolS *to = insn->u.ll.lab2;
1190
1191         if (symbol_get_frag (to) == symbol_get_frag (from))
1192           {
1193             addressT delta = S_GET_VALUE (to) - S_GET_VALUE (from);
1194             addressT scaled = delta / DWARF2_LINE_MIN_INSN_LENGTH;
1195
1196             if (scaled <= 0x3F)
1197               out_one (DW_CFA_advance_loc + scaled);
1198             else if (scaled <= 0xFF)
1199               {
1200                 out_one (DW_CFA_advance_loc1);
1201                 out_one (scaled);
1202               }
1203             else if (scaled <= 0xFFFF)
1204               {
1205                 out_one (DW_CFA_advance_loc2);
1206                 out_two (scaled);
1207               }
1208             else
1209               {
1210                 out_one (DW_CFA_advance_loc4);
1211                 out_four (scaled);
1212               }
1213           }
1214         else
1215           {
1216             expressionS exp;
1217
1218             exp.X_op = O_subtract;
1219             exp.X_add_symbol = to;
1220             exp.X_op_symbol = from;
1221             exp.X_add_number = 0;
1222
1223             /* The code in ehopt.c expects that one byte of the encoding
1224                is already allocated to the frag.  This comes from the way
1225                that it scans the .eh_frame section looking first for the
1226                .byte DW_CFA_advance_loc4.  */
1227             *frag_more (1) = DW_CFA_advance_loc4;
1228
1229             frag_var (rs_cfa, 4, 0, DWARF2_LINE_MIN_INSN_LENGTH << 3,
1230                       make_expr_symbol (&exp), frag_now_fix () - 1,
1231                       (char *) frag_now);
1232           }
1233       }
1234       break;
1235
1236     case DW_CFA_def_cfa:
1237       offset = insn->u.ri.offset;
1238       if (offset < 0)
1239         {
1240           out_one (DW_CFA_def_cfa_sf);
1241           out_uleb128 (insn->u.ri.reg);
1242           out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
1243         }
1244       else
1245         {
1246           out_one (DW_CFA_def_cfa);
1247           out_uleb128 (insn->u.ri.reg);
1248           out_uleb128 (offset);
1249         }
1250       break;
1251
1252     case DW_CFA_def_cfa_register:
1253     case DW_CFA_undefined:
1254     case DW_CFA_same_value:
1255       out_one (insn->insn);
1256       out_uleb128 (insn->u.r);
1257       break;
1258
1259     case DW_CFA_def_cfa_offset:
1260       offset = insn->u.i;
1261       if (offset < 0)
1262         {
1263           out_one (DW_CFA_def_cfa_offset_sf);
1264           out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
1265         }
1266       else
1267         {
1268           out_one (DW_CFA_def_cfa_offset);
1269           out_uleb128 (offset);
1270         }
1271       break;
1272
1273     case DW_CFA_restore:
1274       regno = insn->u.r;
1275       if (regno <= 0x3F)
1276         {
1277           out_one (DW_CFA_restore + regno);
1278         }
1279       else
1280         {
1281           out_one (DW_CFA_restore_extended);
1282           out_uleb128 (regno);
1283         }
1284       break;
1285
1286     case DW_CFA_offset:
1287       regno = insn->u.ri.reg;
1288       offset = insn->u.ri.offset / DWARF2_CIE_DATA_ALIGNMENT;
1289       if (offset < 0)
1290         {
1291           out_one (DW_CFA_offset_extended_sf);
1292           out_uleb128 (regno);
1293           out_sleb128 (offset);
1294         }
1295       else if (regno <= 0x3F)
1296         {
1297           out_one (DW_CFA_offset + regno);
1298           out_uleb128 (offset);
1299         }
1300       else
1301         {
1302           out_one (DW_CFA_offset_extended);
1303           out_uleb128 (regno);
1304           out_uleb128 (offset);
1305         }
1306       break;
1307
1308     case DW_CFA_register:
1309       out_one (DW_CFA_register);
1310       out_uleb128 (insn->u.rr.reg1);
1311       out_uleb128 (insn->u.rr.reg2);
1312       break;
1313
1314     case DW_CFA_remember_state:
1315     case DW_CFA_restore_state:
1316       out_one (insn->insn);
1317       break;
1318
1319     case DW_CFA_GNU_window_save:
1320       out_one (DW_CFA_GNU_window_save);
1321       break;
1322
1323     case CFI_escape:
1324       {
1325         struct cfi_escape_data *e;
1326         for (e = insn->u.esc; e ; e = e->next)
1327           emit_expr (&e->exp, 1);
1328         break;
1329       }
1330
1331     case CFI_val_encoded_addr:
1332       {
1333         unsigned encoding = insn->u.ea.encoding;
1334         offsetT encoding_size;
1335
1336         if (encoding == DW_EH_PE_omit)
1337           break;
1338         out_one (DW_CFA_val_expression);
1339         out_uleb128 (insn->u.ea.reg);
1340
1341         switch (encoding & 0x7)
1342           {
1343           case DW_EH_PE_absptr:
1344             encoding_size = DWARF2_ADDR_SIZE (stdoutput);
1345             break;
1346           case DW_EH_PE_udata2:
1347             encoding_size = 2;
1348             break;
1349           case DW_EH_PE_udata4:
1350             encoding_size = 4;
1351             break;
1352           case DW_EH_PE_udata8:
1353             encoding_size = 8;
1354             break;
1355           default:
1356             abort ();
1357           }
1358
1359         /* If the user has requested absolute encoding,
1360            then use the smaller DW_OP_addr encoding.  */
1361         if (insn->u.ea.encoding == DW_EH_PE_absptr)
1362           {
1363             out_uleb128 (1 + encoding_size);
1364             out_one (DW_OP_addr);
1365           }
1366         else
1367           {
1368             out_uleb128 (1 + 1 + encoding_size);
1369             out_one (DW_OP_GNU_encoded_addr);
1370             out_one (encoding);
1371
1372             if ((encoding & 0x70) == DW_EH_PE_pcrel)
1373               {
1374 #if CFI_DIFF_EXPR_OK
1375                 insn->u.ea.exp.X_op = O_subtract;
1376                 insn->u.ea.exp.X_op_symbol = symbol_temp_new_now ();
1377 #elif defined (tc_cfi_emit_pcrel_expr)
1378                 tc_cfi_emit_pcrel_expr (&insn->u.ea.exp, encoding_size);
1379                 break;
1380 #else
1381                 abort ();
1382 #endif
1383               }
1384           }
1385         emit_expr (&insn->u.ea.exp, encoding_size);
1386       }
1387       break;
1388
1389     default:
1390       abort ();
1391     }
1392 }
1393
1394 static offsetT
1395 encoding_size (unsigned char encoding)
1396 {
1397   if (encoding == DW_EH_PE_omit)
1398     return 0;
1399   switch (encoding & 0x7)
1400     {
1401     case 0:
1402       return bfd_get_arch_size (stdoutput) == 64 ? 8 : 4;
1403     case DW_EH_PE_udata2:
1404       return 2;
1405     case DW_EH_PE_udata4:
1406       return 4;
1407     case DW_EH_PE_udata8:
1408       return 8;
1409     default:
1410       abort ();
1411     }
1412 }
1413
1414 static void
1415 output_cie (struct cie_entry *cie, bfd_boolean eh_frame, int align)
1416 {
1417   symbolS *after_size_address, *end_address;
1418   expressionS exp;
1419   struct cfi_insn_data *i;
1420   offsetT augmentation_size;
1421   int enc;
1422   enum dwarf2_format fmt = DWARF2_FORMAT (now_seg);
1423
1424   cie->start_address = symbol_temp_new_now ();
1425   after_size_address = symbol_temp_make ();
1426   end_address = symbol_temp_make ();
1427
1428   exp.X_op = O_subtract;
1429   exp.X_add_symbol = end_address;
1430   exp.X_op_symbol = after_size_address;
1431   exp.X_add_number = 0;
1432
1433   if (eh_frame || fmt == dwarf2_format_32bit)
1434     emit_expr (&exp, 4);                        /* Length.  */
1435   else
1436     {
1437       if (fmt == dwarf2_format_64bit)
1438         out_four (-1);
1439       emit_expr (&exp, 8);                      /* Length.  */
1440     }
1441   symbol_set_value_now (after_size_address);
1442   if (eh_frame)
1443     out_four (0);                               /* CIE id.  */
1444   else
1445     {
1446       out_four (-1);                            /* CIE id.  */
1447       if (fmt != dwarf2_format_32bit)
1448         out_four (-1);
1449     }
1450   out_one (DW_CIE_VERSION);                     /* Version.  */
1451   if (eh_frame)
1452     {
1453       out_one ('z');                            /* Augmentation.  */
1454       if (cie->per_encoding != DW_EH_PE_omit)
1455         out_one ('P');
1456       if (cie->lsda_encoding != DW_EH_PE_omit)
1457         out_one ('L');
1458       out_one ('R');
1459     }
1460   if (cie->signal_frame)
1461     out_one ('S');
1462   out_one (0);
1463   out_uleb128 (DWARF2_LINE_MIN_INSN_LENGTH);    /* Code alignment.  */
1464   out_sleb128 (DWARF2_CIE_DATA_ALIGNMENT);      /* Data alignment.  */
1465   if (DW_CIE_VERSION == 1)                      /* Return column.  */
1466     out_one (cie->return_column);
1467   else
1468     out_uleb128 (cie->return_column);
1469   if (eh_frame)
1470     {
1471       augmentation_size = 1 + (cie->lsda_encoding != DW_EH_PE_omit);
1472       if (cie->per_encoding != DW_EH_PE_omit)
1473         augmentation_size += 1 + encoding_size (cie->per_encoding);
1474       out_uleb128 (augmentation_size);          /* Augmentation size.  */
1475
1476       if (cie->per_encoding != DW_EH_PE_omit)
1477         {
1478           offsetT size = encoding_size (cie->per_encoding);
1479           out_one (cie->per_encoding);
1480           exp = cie->personality;
1481           if ((cie->per_encoding & 0x70) == DW_EH_PE_pcrel)
1482             {
1483 #if CFI_DIFF_EXPR_OK
1484               exp.X_op = O_subtract;
1485               exp.X_op_symbol = symbol_temp_new_now ();
1486               emit_expr (&exp, size);
1487 #elif defined (tc_cfi_emit_pcrel_expr)
1488               tc_cfi_emit_pcrel_expr (&exp, size);
1489 #else
1490               abort ();
1491 #endif
1492             }
1493           else
1494             emit_expr (&exp, size);
1495         }
1496
1497       if (cie->lsda_encoding != DW_EH_PE_omit)
1498         out_one (cie->lsda_encoding);
1499     }
1500
1501   switch (DWARF2_FDE_RELOC_SIZE)
1502     {
1503     case 2:
1504       enc = DW_EH_PE_sdata2;
1505       break;
1506     case 4:
1507       enc = DW_EH_PE_sdata4;
1508       break;
1509     case 8:
1510       enc = DW_EH_PE_sdata8;
1511       break;
1512     default:
1513       abort ();
1514     }
1515 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
1516   enc |= DW_EH_PE_pcrel;
1517 #endif
1518   if (eh_frame)
1519     out_one (enc);
1520
1521   if (cie->first)
1522     {
1523       for (i = cie->first; i != cie->last; i = i->next)
1524         {
1525           if (CUR_SEG (i) != CUR_SEG (cie))
1526             continue;
1527           output_cfi_insn (i);
1528         }
1529     }
1530
1531   frag_align (align, DW_CFA_nop, 0);
1532   symbol_set_value_now (end_address);
1533 }
1534
1535 static void
1536 output_fde (struct fde_entry *fde, struct cie_entry *cie,
1537             bfd_boolean eh_frame, struct cfi_insn_data *first,
1538             int align)
1539 {
1540   symbolS *after_size_address, *end_address;
1541   expressionS exp;
1542   offsetT augmentation_size;
1543   enum dwarf2_format fmt = DWARF2_FORMAT (now_seg);
1544   int offset_size;
1545   int addr_size;
1546
1547   after_size_address = symbol_temp_make ();
1548   end_address = symbol_temp_make ();
1549
1550   exp.X_op = O_subtract;
1551   exp.X_add_symbol = end_address;
1552   exp.X_op_symbol = after_size_address;
1553   exp.X_add_number = 0;
1554   if (eh_frame || fmt == dwarf2_format_32bit)
1555     offset_size = 4;
1556   else
1557     {
1558       if (fmt == dwarf2_format_64bit)
1559         out_four (-1);
1560       offset_size = 8;
1561     }
1562   emit_expr (&exp, offset_size);                /* Length.  */
1563   symbol_set_value_now (after_size_address);
1564
1565   if (eh_frame)
1566     {
1567       exp.X_op = O_subtract;
1568       exp.X_add_symbol = after_size_address;
1569       exp.X_op_symbol = cie->start_address;
1570       exp.X_add_number = 0;
1571       emit_expr (&exp, offset_size);            /* CIE offset.  */
1572     }
1573   else
1574     {
1575       TC_DWARF2_EMIT_OFFSET (cie->start_address, offset_size);
1576     }
1577
1578   if (eh_frame)
1579     {
1580       exp.X_op = O_subtract;
1581       exp.X_add_number = 0;
1582 #if CFI_DIFF_EXPR_OK
1583       exp.X_add_symbol = fde->start_address;
1584       exp.X_op_symbol = symbol_temp_new_now ();
1585       emit_expr (&exp, DWARF2_FDE_RELOC_SIZE);  /* Code offset.  */
1586 #else
1587       exp.X_op = O_symbol;
1588       exp.X_add_symbol = fde->start_address;
1589 #ifdef tc_cfi_emit_pcrel_expr
1590       tc_cfi_emit_pcrel_expr (&exp, DWARF2_FDE_RELOC_SIZE);      /* Code offset.  */
1591 #else
1592       emit_expr (&exp, DWARF2_FDE_RELOC_SIZE);  /* Code offset.  */
1593 #endif
1594 #endif
1595       addr_size = DWARF2_FDE_RELOC_SIZE;
1596     }
1597   else
1598     {
1599       exp.X_op = O_symbol;
1600       exp.X_add_symbol = fde->start_address;
1601       exp.X_add_number = 0;
1602       addr_size = DWARF2_ADDR_SIZE (stdoutput);
1603       emit_expr (&exp, addr_size);
1604     }
1605
1606   exp.X_op = O_subtract;
1607   exp.X_add_symbol = fde->end_address;
1608   exp.X_op_symbol = fde->start_address;         /* Code length.  */
1609   exp.X_add_number = 0;
1610   emit_expr (&exp, addr_size);
1611
1612   augmentation_size = encoding_size (fde->lsda_encoding);
1613   if (eh_frame)
1614     out_uleb128 (augmentation_size);            /* Augmentation size.  */
1615
1616   if (fde->lsda_encoding != DW_EH_PE_omit)
1617     {
1618       exp = fde->lsda;
1619       if ((fde->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
1620         {
1621 #if CFI_DIFF_LSDA_OK
1622           exp.X_op = O_subtract;
1623           exp.X_op_symbol = symbol_temp_new_now ();
1624           emit_expr (&exp, augmentation_size);
1625 #elif defined (tc_cfi_emit_pcrel_expr)
1626           tc_cfi_emit_pcrel_expr (&exp, augmentation_size);
1627 #else
1628           abort ();
1629 #endif
1630         }
1631       else
1632         emit_expr (&exp, augmentation_size);
1633     }
1634
1635   for (; first; first = first->next)
1636     if (CUR_SEG (first) == CUR_SEG (fde))
1637       output_cfi_insn (first);
1638
1639   frag_align (align, DW_CFA_nop, 0);
1640   symbol_set_value_now (end_address);
1641 }
1642
1643 static struct cie_entry *
1644 select_cie_for_fde (struct fde_entry *fde, bfd_boolean eh_frame,
1645                     struct cfi_insn_data **pfirst, int align)
1646 {
1647   struct cfi_insn_data *i, *j;
1648   struct cie_entry *cie;
1649
1650   for (cie = cie_root; cie; cie = cie->next)
1651     {
1652       if (CUR_SEG (cie) != CUR_SEG (fde))
1653         continue;
1654       if (cie->return_column != fde->return_column
1655           || cie->signal_frame != fde->signal_frame
1656           || cie->per_encoding != fde->per_encoding
1657           || cie->lsda_encoding != fde->lsda_encoding)
1658         continue;
1659       if (cie->per_encoding != DW_EH_PE_omit)
1660         {
1661           if (cie->personality.X_op != fde->personality.X_op
1662               || cie->personality.X_add_number
1663                  != fde->personality.X_add_number)
1664             continue;
1665           switch (cie->personality.X_op)
1666             {
1667             case O_constant:
1668               if (cie->personality.X_unsigned != fde->personality.X_unsigned)
1669                 continue;
1670               break;
1671             case O_symbol:
1672               if (cie->personality.X_add_symbol
1673                   != fde->personality.X_add_symbol)
1674                 continue;
1675               break;
1676             default:
1677               abort ();
1678             }
1679         }
1680       for (i = cie->first, j = fde->data;
1681            i != cie->last && j != NULL;
1682            i = i->next, j = j->next)
1683         {
1684           if (i->insn != j->insn)
1685             goto fail;
1686           switch (i->insn)
1687             {
1688             case DW_CFA_advance_loc:
1689             case DW_CFA_remember_state:
1690               /* We reached the first advance/remember in the FDE,
1691                  but did not reach the end of the CIE list.  */
1692               goto fail;
1693
1694             case DW_CFA_offset:
1695             case DW_CFA_def_cfa:
1696               if (i->u.ri.reg != j->u.ri.reg)
1697                 goto fail;
1698               if (i->u.ri.offset != j->u.ri.offset)
1699                 goto fail;
1700               break;
1701
1702             case DW_CFA_register:
1703               if (i->u.rr.reg1 != j->u.rr.reg1)
1704                 goto fail;
1705               if (i->u.rr.reg2 != j->u.rr.reg2)
1706                 goto fail;
1707               break;
1708
1709             case DW_CFA_def_cfa_register:
1710             case DW_CFA_restore:
1711             case DW_CFA_undefined:
1712             case DW_CFA_same_value:
1713               if (i->u.r != j->u.r)
1714                 goto fail;
1715               break;
1716
1717             case DW_CFA_def_cfa_offset:
1718               if (i->u.i != j->u.i)
1719                 goto fail;
1720               break;
1721
1722             case CFI_escape:
1723             case CFI_val_encoded_addr:
1724               /* Don't bother matching these for now.  */
1725               goto fail;
1726
1727             default:
1728               abort ();
1729             }
1730         }
1731
1732       /* Success if we reached the end of the CIE list, and we've either
1733          run out of FDE entries or we've encountered an advance,
1734          remember, or escape.  */
1735       if (i == cie->last
1736           && (!j
1737               || j->insn == DW_CFA_advance_loc
1738               || j->insn == DW_CFA_remember_state
1739               || j->insn == CFI_escape
1740               || j->insn == CFI_val_encoded_addr))
1741         {
1742           *pfirst = j;
1743           return cie;
1744         }
1745
1746     fail:;
1747     }
1748
1749   cie = (struct cie_entry *) xmalloc (sizeof (struct cie_entry));
1750   cie->next = cie_root;
1751   cie_root = cie;
1752   SET_CUR_SEG (cie, CUR_SEG (fde));
1753   cie->return_column = fde->return_column;
1754   cie->signal_frame = fde->signal_frame;
1755   cie->per_encoding = fde->per_encoding;
1756   cie->lsda_encoding = fde->lsda_encoding;
1757   cie->personality = fde->personality;
1758   cie->first = fde->data;
1759
1760   for (i = cie->first; i ; i = i->next)
1761     if (i->insn == DW_CFA_advance_loc
1762         || i->insn == DW_CFA_remember_state
1763         || i->insn == CFI_escape
1764         || i->insn == CFI_val_encoded_addr)
1765       break;
1766
1767   cie->last = i;
1768   *pfirst = i;
1769
1770   output_cie (cie, eh_frame, align);
1771
1772   return cie;
1773 }
1774
1775 #ifdef md_reg_eh_frame_to_debug_frame
1776 static void
1777 cfi_change_reg_numbers (struct cfi_insn_data *insn, segT ccseg)
1778 {
1779   for (; insn; insn = insn->next)
1780     {
1781       if (CUR_SEG (insn) != ccseg)
1782         continue;
1783       switch (insn->insn)
1784         {
1785         case DW_CFA_advance_loc:
1786         case DW_CFA_def_cfa_offset:
1787         case DW_CFA_remember_state:
1788         case DW_CFA_restore_state:
1789         case DW_CFA_GNU_window_save:
1790         case CFI_escape:
1791           break;
1792
1793         case DW_CFA_def_cfa:
1794         case DW_CFA_offset:
1795           insn->u.ri.reg = md_reg_eh_frame_to_debug_frame (insn->u.ri.reg);
1796           break;
1797
1798         case DW_CFA_def_cfa_register:
1799         case DW_CFA_undefined:
1800         case DW_CFA_same_value:
1801         case DW_CFA_restore:
1802           insn->u.r = md_reg_eh_frame_to_debug_frame (insn->u.r);
1803           break;
1804
1805         case DW_CFA_register:
1806           insn->u.rr.reg1 = md_reg_eh_frame_to_debug_frame (insn->u.rr.reg1);
1807           insn->u.rr.reg2 = md_reg_eh_frame_to_debug_frame (insn->u.rr.reg2);
1808           break;
1809
1810         case CFI_val_encoded_addr:
1811           insn->u.ea.reg = md_reg_eh_frame_to_debug_frame (insn->u.ea.reg);
1812           break;
1813
1814         default:
1815           abort ();
1816         }
1817     }
1818 }
1819 #else
1820 #define cfi_change_reg_numbers(insn, cseg) do { } while (0)
1821 #endif
1822
1823 static segT
1824 get_cfi_seg (segT cseg, const char *base, flagword flags, int align)
1825 {
1826   if (SUPPORT_FRAME_LINKONCE)
1827     {
1828       struct dwcfi_seg_list *l;
1829
1830       l = dwcfi_hash_find_or_make (cseg, base, flags);
1831
1832       cseg = l->seg;
1833       subseg_set (cseg, l->subseg);
1834     }
1835   else
1836     {
1837       cseg = subseg_new (base, 0);
1838       bfd_set_section_flags (stdoutput, cseg, flags);
1839     }
1840   record_alignment (cseg, align);
1841   return cseg;
1842 }
1843
1844 void
1845 cfi_finish (void)
1846 {
1847   struct cie_entry *cie, *cie_next;
1848   segT cfi_seg, ccseg;
1849   struct fde_entry *fde;
1850   struct cfi_insn_data *first;
1851   int save_flag_traditional_format, seek_next_seg;
1852
1853   if (all_fde_data == 0)
1854     return;
1855
1856   if ((cfi_sections & CFI_EMIT_eh_frame) != 0)
1857     {
1858       /* Make sure check_eh_frame doesn't do anything with our output.  */
1859       save_flag_traditional_format = flag_traditional_format;
1860       flag_traditional_format = 1;
1861
1862       if (!SUPPORT_FRAME_LINKONCE)
1863         {
1864           /* Open .eh_frame section.  */
1865           cfi_seg = get_cfi_seg (NULL, ".eh_frame",
1866                                  (SEC_ALLOC | SEC_LOAD | SEC_DATA
1867                                   | DWARF2_EH_FRAME_READ_ONLY),
1868                                  EH_FRAME_ALIGNMENT);
1869 #ifdef md_fix_up_eh_frame
1870           md_fix_up_eh_frame (cfi_seg);
1871 #else
1872           (void) cfi_seg;
1873 #endif
1874         }
1875
1876       do
1877         {
1878           ccseg = NULL;
1879           seek_next_seg = 0;
1880
1881           for (cie = cie_root; cie; cie = cie_next)
1882             {
1883               cie_next = cie->next;
1884               free ((void *) cie);
1885             }
1886           cie_root = NULL;
1887
1888           for (fde = all_fde_data; fde ; fde = fde->next)
1889             {
1890               if (SUPPORT_FRAME_LINKONCE)
1891                 {
1892                   if (HANDLED (fde))
1893                     continue;
1894                   if (seek_next_seg && CUR_SEG (fde) != ccseg)
1895                     {
1896                       seek_next_seg = 2;
1897                       continue;
1898                     }
1899                   if (!seek_next_seg)
1900                     {
1901                       ccseg = CUR_SEG (fde);
1902                       /* Open .eh_frame section.  */
1903                       cfi_seg = get_cfi_seg (ccseg, ".eh_frame",
1904                                              (SEC_ALLOC | SEC_LOAD | SEC_DATA
1905                                               | DWARF2_EH_FRAME_READ_ONLY),
1906                                              EH_FRAME_ALIGNMENT);
1907 #ifdef md_fix_up_eh_frame
1908                       md_fix_up_eh_frame (cfi_seg);
1909 #else
1910                       (void) cfi_seg;
1911 #endif
1912                       seek_next_seg = 1;
1913                     }
1914                   SET_HANDLED (fde, 1);
1915                 }
1916
1917               if (fde->end_address == NULL)
1918                 {
1919                   as_bad (_("open CFI at the end of file; missing .cfi_endproc directive"));
1920                   fde->end_address = fde->start_address;
1921                 }
1922
1923               cie = select_cie_for_fde (fde, TRUE, &first, 2);
1924               output_fde (fde, cie, TRUE, first,
1925                           fde->next == NULL ? EH_FRAME_ALIGNMENT : 2);
1926             }
1927         }
1928       while (SUPPORT_FRAME_LINKONCE && seek_next_seg == 2);
1929
1930       if (SUPPORT_FRAME_LINKONCE)
1931         for (fde = all_fde_data; fde ; fde = fde->next)
1932           SET_HANDLED (fde, 0);
1933
1934       flag_traditional_format = save_flag_traditional_format;
1935     }
1936
1937   if ((cfi_sections & CFI_EMIT_debug_frame) != 0)
1938     {
1939       int alignment = ffs (DWARF2_ADDR_SIZE (stdoutput)) - 1;
1940
1941       if (!SUPPORT_FRAME_LINKONCE)
1942         get_cfi_seg (NULL, ".debug_frame",
1943                      SEC_READONLY | SEC_DEBUGGING,
1944                      alignment);
1945
1946       do
1947         {
1948           ccseg = NULL;
1949           seek_next_seg = 0;
1950
1951           for (cie = cie_root; cie; cie = cie_next)
1952             {
1953               cie_next = cie->next;
1954               free ((void *) cie);
1955             }
1956           cie_root = NULL;
1957
1958           for (fde = all_fde_data; fde ; fde = fde->next)
1959             {
1960               if (SUPPORT_FRAME_LINKONCE)
1961                 {
1962                   if (HANDLED (fde))
1963                     continue;
1964                   if (seek_next_seg && CUR_SEG (fde) != ccseg)
1965                     {
1966                       seek_next_seg = 2;
1967                       continue;
1968                     }
1969                   if (!seek_next_seg)
1970                     {
1971                       ccseg = CUR_SEG (fde);
1972                       /* Open .debug_frame section.  */
1973                       get_cfi_seg (ccseg, ".debug_frame",
1974                                    SEC_READONLY | SEC_DEBUGGING,
1975                                    alignment);
1976                       seek_next_seg = 1;
1977                     }
1978                   SET_HANDLED (fde, 1);
1979                 }
1980               if (fde->end_address == NULL)
1981                 {
1982                   as_bad (_("open CFI at the end of file; missing .cfi_endproc directive"));
1983                   fde->end_address = fde->start_address;
1984                 }
1985
1986               fde->per_encoding = DW_EH_PE_omit;
1987               fde->lsda_encoding = DW_EH_PE_omit;
1988               cfi_change_reg_numbers (fde->data, ccseg);
1989               cie = select_cie_for_fde (fde, FALSE, &first, alignment);
1990               output_fde (fde, cie, FALSE, first, alignment);
1991             }
1992         }
1993       while (SUPPORT_FRAME_LINKONCE && seek_next_seg == 2);
1994
1995       if (SUPPORT_FRAME_LINKONCE)
1996         for (fde = all_fde_data; fde ; fde = fde->next)
1997           SET_HANDLED (fde, 0);
1998     }
1999 }
2000
2001 #else /* TARGET_USE_CFIPOP */
2002
2003 /* Emit an intelligible error message for missing support.  */
2004
2005 static void
2006 dot_cfi_dummy (int ignored ATTRIBUTE_UNUSED)
2007 {
2008   as_bad (_("CFI is not supported for this target"));
2009   ignore_rest_of_line ();
2010 }
2011
2012 const pseudo_typeS cfi_pseudo_table[] =
2013   {
2014     { "cfi_sections", dot_cfi_dummy, 0 },
2015     { "cfi_startproc", dot_cfi_dummy, 0 },
2016     { "cfi_endproc", dot_cfi_dummy, 0 },
2017     { "cfi_def_cfa", dot_cfi_dummy, 0 },
2018     { "cfi_def_cfa_register", dot_cfi_dummy, 0 },
2019     { "cfi_def_cfa_offset", dot_cfi_dummy, 0 },
2020     { "cfi_adjust_cfa_offset", dot_cfi_dummy, 0 },
2021     { "cfi_offset", dot_cfi_dummy, 0 },
2022     { "cfi_rel_offset", dot_cfi_dummy, 0 },
2023     { "cfi_register", dot_cfi_dummy, 0 },
2024     { "cfi_return_column", dot_cfi_dummy, 0 },
2025     { "cfi_restore", dot_cfi_dummy, 0 },
2026     { "cfi_undefined", dot_cfi_dummy, 0 },
2027     { "cfi_same_value", dot_cfi_dummy, 0 },
2028     { "cfi_remember_state", dot_cfi_dummy, 0 },
2029     { "cfi_restore_state", dot_cfi_dummy, 0 },
2030     { "cfi_window_save", dot_cfi_dummy, 0 },
2031     { "cfi_escape", dot_cfi_dummy, 0 },
2032     { "cfi_signal_frame", dot_cfi_dummy, 0 },
2033     { "cfi_personality", dot_cfi_dummy, 0 },
2034     { "cfi_lsda", dot_cfi_dummy, 0 },
2035     { "cfi_val_encoded_addr", dot_cfi_dummy, 0 },
2036     { NULL, NULL, 0 }
2037   };
2038
2039 void
2040 cfi_finish (void)
2041 {
2042 }
2043 #endif /* TARGET_USE_CFIPOP */