OSDN Git Service

PR target/45870
[pf3gnuchains/gcc-fork.git] / gcc / dwarf2out.c
1 /* Output Dwarf2 format symbol table information from GCC.
2    Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3    2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4    Free Software Foundation, Inc.
5    Contributed by Gary Funck (gary@intrepid.com).
6    Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
7    Extensively modified by Jason Merrill (jason@cygnus.com).
8
9 This file is part of GCC.
10
11 GCC is free software; you can redistribute it and/or modify it under
12 the terms of the GNU General Public License as published by the Free
13 Software Foundation; either version 3, or (at your option) any later
14 version.
15
16 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
17 WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
19 for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with GCC; see the file COPYING3.  If not see
23 <http://www.gnu.org/licenses/>.  */
24
25 /* TODO: Emit .debug_line header even when there are no functions, since
26            the file numbers are used by .debug_info.  Alternately, leave
27            out locations for types and decls.
28          Avoid talking about ctors and op= for PODs.
29          Factor out common prologue sequences into multiple CIEs.  */
30
31 /* The first part of this file deals with the DWARF 2 frame unwind
32    information, which is also used by the GCC efficient exception handling
33    mechanism.  The second part, controlled only by an #ifdef
34    DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
35    information.  */
36
37 /* DWARF2 Abbreviation Glossary:
38
39    CFA = Canonical Frame Address
40            a fixed address on the stack which identifies a call frame.
41            We define it to be the value of SP just before the call insn.
42            The CFA register and offset, which may change during the course
43            of the function, are used to calculate its value at runtime.
44
45    CFI = Call Frame Instruction
46            an instruction for the DWARF2 abstract machine
47
48    CIE = Common Information Entry
49            information describing information common to one or more FDEs
50
51    DIE = Debugging Information Entry
52
53    FDE = Frame Description Entry
54            information describing the stack call frame, in particular,
55            how to restore registers
56
57    DW_CFA_... = DWARF2 CFA call frame instruction
58    DW_TAG_... = DWARF2 DIE tag */
59
60 #include "config.h"
61 #include "system.h"
62 #include "coretypes.h"
63 #include "tm.h"
64 #include "tree.h"
65 #include "version.h"
66 #include "flags.h"
67 #include "rtl.h"
68 #include "hard-reg-set.h"
69 #include "regs.h"
70 #include "insn-config.h"
71 #include "reload.h"
72 #include "function.h"
73 #include "output.h"
74 #include "expr.h"
75 #include "libfuncs.h"
76 #include "except.h"
77 #include "dwarf2.h"
78 #include "dwarf2out.h"
79 #include "dwarf2asm.h"
80 #include "toplev.h"
81 #include "ggc.h"
82 #include "md5.h"
83 #include "tm_p.h"
84 #include "diagnostic.h"
85 #include "tree-pretty-print.h"
86 #include "debug.h"
87 #include "target.h"
88 #include "langhooks.h"
89 #include "hashtab.h"
90 #include "cgraph.h"
91 #include "input.h"
92 #include "gimple.h"
93 #include "tree-pass.h"
94 #include "tree-flow.h"
95
96 static void dwarf2out_source_line (unsigned int, const char *, int, bool);
97 static rtx last_var_location_insn;
98
99 #ifdef VMS_DEBUGGING_INFO
100 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
101
102 /* Define this macro to be a nonzero value if the directory specifications
103     which are output in the debug info should end with a separator.  */
104 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
105 /* Define this macro to evaluate to a nonzero value if GCC should refrain
106    from generating indirect strings in DWARF2 debug information, for instance
107    if your target is stuck with an old version of GDB that is unable to
108    process them properly or uses VMS Debug.  */
109 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
110 #else
111 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
112 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
113 #endif
114
115 /* ??? Poison these here until it can be done generically.  They've been
116    totally replaced in this file; make sure it stays that way.  */
117 #undef DWARF2_UNWIND_INFO
118 #undef DWARF2_FRAME_INFO
119 #if (GCC_VERSION >= 3000)
120  #pragma GCC poison DWARF2_UNWIND_INFO DWARF2_FRAME_INFO
121 #endif
122
123 #ifndef INCOMING_RETURN_ADDR_RTX
124 #define INCOMING_RETURN_ADDR_RTX  (gcc_unreachable (), NULL_RTX)
125 #endif
126
127 /* Map register numbers held in the call frame info that gcc has
128    collected using DWARF_FRAME_REGNUM to those that should be output in
129    .debug_frame and .eh_frame.  */
130 #ifndef DWARF2_FRAME_REG_OUT
131 #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
132 #endif
133
134 /* Save the result of dwarf2out_do_frame across PCH.  */
135 static GTY(()) bool saved_do_cfi_asm = 0;
136
137 /* Decide whether we want to emit frame unwind information for the current
138    translation unit.  */
139
140 int
141 dwarf2out_do_frame (void)
142 {
143   /* We want to emit correct CFA location expressions or lists, so we
144      have to return true if we're going to output debug info, even if
145      we're not going to output frame or unwind info.  */
146   if (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
147     return true;
148
149   if (saved_do_cfi_asm)
150     return true;
151
152   if (targetm.debug_unwind_info () == UI_DWARF2)
153     return true;
154
155   if ((flag_unwind_tables || flag_exceptions)
156       && targetm.except_unwind_info () == UI_DWARF2)
157     return true;
158
159   return false;
160 }
161
162 /* Decide whether to emit frame unwind via assembler directives.  */
163
164 int
165 dwarf2out_do_cfi_asm (void)
166 {
167   int enc;
168
169 #ifdef MIPS_DEBUGGING_INFO
170   return false;
171 #endif
172   if (saved_do_cfi_asm)
173     return true;
174   if (!flag_dwarf2_cfi_asm || !dwarf2out_do_frame ())
175     return false;
176   if (!HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
177     return false;
178
179   /* Make sure the personality encoding is one the assembler can support.
180      In particular, aligned addresses can't be handled.  */
181   enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,/*global=*/1);
182   if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
183     return false;
184   enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,/*global=*/0);
185   if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
186     return false;
187
188   /* If we can't get the assembler to emit only .debug_frame, and we don't need
189      dwarf2 unwind info for exceptions, then emit .debug_frame by hand.  */
190   if (!HAVE_GAS_CFI_SECTIONS_DIRECTIVE
191       && !flag_unwind_tables && !flag_exceptions
192       && targetm.except_unwind_info () != UI_DWARF2)
193     return false;
194
195   saved_do_cfi_asm = true;
196   return true;
197 }
198
199 /* The size of the target's pointer type.  */
200 #ifndef PTR_SIZE
201 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
202 #endif
203
204 /* Array of RTXes referenced by the debugging information, which therefore
205    must be kept around forever.  */
206 static GTY(()) VEC(rtx,gc) *used_rtx_array;
207
208 /* A pointer to the base of a list of incomplete types which might be
209    completed at some later time.  incomplete_types_list needs to be a
210    VEC(tree,gc) because we want to tell the garbage collector about
211    it.  */
212 static GTY(()) VEC(tree,gc) *incomplete_types;
213
214 /* A pointer to the base of a table of references to declaration
215    scopes.  This table is a display which tracks the nesting
216    of declaration scopes at the current scope and containing
217    scopes.  This table is used to find the proper place to
218    define type declaration DIE's.  */
219 static GTY(()) VEC(tree,gc) *decl_scope_table;
220
221 /* Pointers to various DWARF2 sections.  */
222 static GTY(()) section *debug_info_section;
223 static GTY(()) section *debug_abbrev_section;
224 static GTY(()) section *debug_aranges_section;
225 static GTY(()) section *debug_macinfo_section;
226 static GTY(()) section *debug_line_section;
227 static GTY(()) section *debug_loc_section;
228 static GTY(()) section *debug_pubnames_section;
229 static GTY(()) section *debug_pubtypes_section;
230 static GTY(()) section *debug_dcall_section;
231 static GTY(()) section *debug_vcall_section;
232 static GTY(()) section *debug_str_section;
233 static GTY(()) section *debug_ranges_section;
234 static GTY(()) section *debug_frame_section;
235
236 /* Personality decl of current unit.  Used only when assembler does not support
237    personality CFI.  */
238 static GTY(()) rtx current_unit_personality;
239
240 /* How to start an assembler comment.  */
241 #ifndef ASM_COMMENT_START
242 #define ASM_COMMENT_START ";#"
243 #endif
244
245 typedef struct dw_cfi_struct *dw_cfi_ref;
246 typedef struct dw_fde_struct *dw_fde_ref;
247 typedef union  dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
248
249 /* Call frames are described using a sequence of Call Frame
250    Information instructions.  The register number, offset
251    and address fields are provided as possible operands;
252    their use is selected by the opcode field.  */
253
254 enum dw_cfi_oprnd_type {
255   dw_cfi_oprnd_unused,
256   dw_cfi_oprnd_reg_num,
257   dw_cfi_oprnd_offset,
258   dw_cfi_oprnd_addr,
259   dw_cfi_oprnd_loc
260 };
261
262 typedef union GTY(()) dw_cfi_oprnd_struct {
263   unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
264   HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
265   const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
266   struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
267 }
268 dw_cfi_oprnd;
269
270 typedef struct GTY(()) dw_cfi_struct {
271   dw_cfi_ref dw_cfi_next;
272   enum dwarf_call_frame_info dw_cfi_opc;
273   dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
274     dw_cfi_oprnd1;
275   dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
276     dw_cfi_oprnd2;
277 }
278 dw_cfi_node;
279
280 /* This is how we define the location of the CFA. We use to handle it
281    as REG + OFFSET all the time,  but now it can be more complex.
282    It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
283    Instead of passing around REG and OFFSET, we pass a copy
284    of this structure.  */
285 typedef struct GTY(()) cfa_loc {
286   HOST_WIDE_INT offset;
287   HOST_WIDE_INT base_offset;
288   unsigned int reg;
289   BOOL_BITFIELD indirect : 1;  /* 1 if CFA is accessed via a dereference.  */
290   BOOL_BITFIELD in_use : 1;    /* 1 if a saved cfa is stored here.  */
291 } dw_cfa_location;
292
293 /* All call frame descriptions (FDE's) in the GCC generated DWARF
294    refer to a single Common Information Entry (CIE), defined at
295    the beginning of the .debug_frame section.  This use of a single
296    CIE obviates the need to keep track of multiple CIE's
297    in the DWARF generation routines below.  */
298
299 typedef struct GTY(()) dw_fde_struct {
300   tree decl;
301   const char *dw_fde_begin;
302   const char *dw_fde_current_label;
303   const char *dw_fde_end;
304   const char *dw_fde_vms_end_prologue;
305   const char *dw_fde_vms_begin_epilogue;
306   const char *dw_fde_hot_section_label;
307   const char *dw_fde_hot_section_end_label;
308   const char *dw_fde_unlikely_section_label;
309   const char *dw_fde_unlikely_section_end_label;
310   dw_cfi_ref dw_fde_cfi;
311   dw_cfi_ref dw_fde_switch_cfi; /* Last CFI before switching sections.  */
312   HOST_WIDE_INT stack_realignment;
313   unsigned funcdef_number;
314   /* Dynamic realign argument pointer register.  */
315   unsigned int drap_reg;
316   /* Virtual dynamic realign argument pointer register.  */
317   unsigned int vdrap_reg;
318   /* These 3 flags are copied from rtl_data in function.h.  */
319   unsigned all_throwers_are_sibcalls : 1;
320   unsigned uses_eh_lsda : 1;
321   unsigned nothrow : 1;
322   /* Whether we did stack realign in this call frame.  */
323   unsigned stack_realign : 1;
324   /* Whether dynamic realign argument pointer register has been saved.  */
325   unsigned drap_reg_saved: 1;
326   /* True iff dw_fde_begin label is in text_section or cold_text_section.  */
327   unsigned in_std_section : 1;
328   /* True iff dw_fde_unlikely_section_label is in text_section or
329      cold_text_section.  */
330   unsigned cold_in_std_section : 1;
331   /* True iff switched sections.  */
332   unsigned dw_fde_switched_sections : 1;
333   /* True iff switching from cold to hot section.  */
334   unsigned dw_fde_switched_cold_to_hot : 1;
335 }
336 dw_fde_node;
337
338 /* Maximum size (in bytes) of an artificially generated label.  */
339 #define MAX_ARTIFICIAL_LABEL_BYTES      30
340
341 /* The size of addresses as they appear in the Dwarf 2 data.
342    Some architectures use word addresses to refer to code locations,
343    but Dwarf 2 info always uses byte addresses.  On such machines,
344    Dwarf 2 addresses need to be larger than the architecture's
345    pointers.  */
346 #ifndef DWARF2_ADDR_SIZE
347 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
348 #endif
349
350 /* The size in bytes of a DWARF field indicating an offset or length
351    relative to a debug info section, specified to be 4 bytes in the
352    DWARF-2 specification.  The SGI/MIPS ABI defines it to be the same
353    as PTR_SIZE.  */
354
355 #ifndef DWARF_OFFSET_SIZE
356 #define DWARF_OFFSET_SIZE 4
357 #endif
358
359 /* The size in bytes of a DWARF 4 type signature.  */
360
361 #ifndef DWARF_TYPE_SIGNATURE_SIZE
362 #define DWARF_TYPE_SIGNATURE_SIZE 8
363 #endif
364
365 /* According to the (draft) DWARF 3 specification, the initial length
366    should either be 4 or 12 bytes.  When it's 12 bytes, the first 4
367    bytes are 0xffffffff, followed by the length stored in the next 8
368    bytes.
369
370    However, the SGI/MIPS ABI uses an initial length which is equal to
371    DWARF_OFFSET_SIZE.  It is defined (elsewhere) accordingly.  */
372
373 #ifndef DWARF_INITIAL_LENGTH_SIZE
374 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
375 #endif
376
377 /* Round SIZE up to the nearest BOUNDARY.  */
378 #define DWARF_ROUND(SIZE,BOUNDARY) \
379   ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
380
381 /* Offsets recorded in opcodes are a multiple of this alignment factor.  */
382 #ifndef DWARF_CIE_DATA_ALIGNMENT
383 #ifdef STACK_GROWS_DOWNWARD
384 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
385 #else
386 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
387 #endif
388 #endif
389
390 /* CIE identifier.  */
391 #if HOST_BITS_PER_WIDE_INT >= 64
392 #define DWARF_CIE_ID \
393   (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
394 #else
395 #define DWARF_CIE_ID DW_CIE_ID
396 #endif
397
398 /* A pointer to the base of a table that contains frame description
399    information for each routine.  */
400 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;
401
402 /* Number of elements currently allocated for fde_table.  */
403 static GTY(()) unsigned fde_table_allocated;
404
405 /* Number of elements in fde_table currently in use.  */
406 static GTY(()) unsigned fde_table_in_use;
407
408 /* Size (in elements) of increments by which we may expand the
409    fde_table.  */
410 #define FDE_TABLE_INCREMENT 256
411
412 /* Get the current fde_table entry we should use.  */
413
414 static inline dw_fde_ref
415 current_fde (void)
416 {
417   return fde_table_in_use ? &fde_table[fde_table_in_use - 1] : NULL;
418 }
419
420 /* A list of call frame insns for the CIE.  */
421 static GTY(()) dw_cfi_ref cie_cfi_head;
422
423 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
424    attribute that accelerates the lookup of the FDE associated
425    with the subprogram.  This variable holds the table index of the FDE
426    associated with the current function (body) definition.  */
427 static unsigned current_funcdef_fde;
428
429 struct GTY(()) indirect_string_node {
430   const char *str;
431   unsigned int refcount;
432   enum dwarf_form form;
433   char *label;
434 };
435
436 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
437
438 /* True if the compilation unit has location entries that reference
439    debug strings.  */
440 static GTY(()) bool debug_str_hash_forced = false;
441
442 static GTY(()) int dw2_string_counter;
443 static GTY(()) unsigned long dwarf2out_cfi_label_num;
444
445 /* True if the compilation unit places functions in more than one section.  */
446 static GTY(()) bool have_multiple_function_sections = false;
447
448 /* Whether the default text and cold text sections have been used at all.  */
449
450 static GTY(()) bool text_section_used = false;
451 static GTY(()) bool cold_text_section_used = false;
452
453 /* The default cold text section.  */
454 static GTY(()) section *cold_text_section;
455
456 /* Forward declarations for functions defined in this file.  */
457
458 static char *stripattributes (const char *);
459 static const char *dwarf_cfi_name (unsigned);
460 static dw_cfi_ref new_cfi (void);
461 static void add_cfi (dw_cfi_ref *, dw_cfi_ref);
462 static void add_fde_cfi (const char *, dw_cfi_ref);
463 static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *, dw_cfa_location *);
464 static void lookup_cfa (dw_cfa_location *);
465 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);
466 static void initial_return_save (rtx);
467 static HOST_WIDE_INT stack_adjust_offset (const_rtx, HOST_WIDE_INT,
468                                           HOST_WIDE_INT);
469 static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
470 static void output_cfi_directive (dw_cfi_ref);
471 static void output_call_frame_info (int);
472 static void dwarf2out_note_section_used (void);
473 static bool clobbers_queued_reg_save (const_rtx);
474 static void dwarf2out_frame_debug_expr (rtx, const char *);
475
476 /* Support for complex CFA locations.  */
477 static void output_cfa_loc (dw_cfi_ref);
478 static void output_cfa_loc_raw (dw_cfi_ref);
479 static void get_cfa_from_loc_descr (dw_cfa_location *,
480                                     struct dw_loc_descr_struct *);
481 static struct dw_loc_descr_struct *build_cfa_loc
482   (dw_cfa_location *, HOST_WIDE_INT);
483 static struct dw_loc_descr_struct *build_cfa_aligned_loc
484   (HOST_WIDE_INT, HOST_WIDE_INT);
485 static void def_cfa_1 (const char *, dw_cfa_location *);
486 static struct dw_loc_descr_struct *mem_loc_descriptor
487   (rtx, enum machine_mode mode, enum var_init_status);
488
489 /* How to start an assembler comment.  */
490 #ifndef ASM_COMMENT_START
491 #define ASM_COMMENT_START ";#"
492 #endif
493
494 /* Data and reference forms for relocatable data.  */
495 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
496 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
497
498 #ifndef DEBUG_FRAME_SECTION
499 #define DEBUG_FRAME_SECTION     ".debug_frame"
500 #endif
501
502 #ifndef FUNC_BEGIN_LABEL
503 #define FUNC_BEGIN_LABEL        "LFB"
504 #endif
505
506 #ifndef FUNC_END_LABEL
507 #define FUNC_END_LABEL          "LFE"
508 #endif
509
510 #ifndef PROLOGUE_END_LABEL
511 #define PROLOGUE_END_LABEL      "LPE"
512 #endif
513
514 #ifndef EPILOGUE_BEGIN_LABEL
515 #define EPILOGUE_BEGIN_LABEL    "LEB"
516 #endif
517
518 #ifndef FRAME_BEGIN_LABEL
519 #define FRAME_BEGIN_LABEL       "Lframe"
520 #endif
521 #define CIE_AFTER_SIZE_LABEL    "LSCIE"
522 #define CIE_END_LABEL           "LECIE"
523 #define FDE_LABEL               "LSFDE"
524 #define FDE_AFTER_SIZE_LABEL    "LASFDE"
525 #define FDE_END_LABEL           "LEFDE"
526 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
527 #define LINE_NUMBER_END_LABEL   "LELT"
528 #define LN_PROLOG_AS_LABEL      "LASLTP"
529 #define LN_PROLOG_END_LABEL     "LELTP"
530 #define DIE_LABEL_PREFIX        "DW"
531
532 /* The DWARF 2 CFA column which tracks the return address.  Normally this
533    is the column for PC, or the first column after all of the hard
534    registers.  */
535 #ifndef DWARF_FRAME_RETURN_COLUMN
536 #ifdef PC_REGNUM
537 #define DWARF_FRAME_RETURN_COLUMN       DWARF_FRAME_REGNUM (PC_REGNUM)
538 #else
539 #define DWARF_FRAME_RETURN_COLUMN       DWARF_FRAME_REGISTERS
540 #endif
541 #endif
542
543 /* The mapping from gcc register number to DWARF 2 CFA column number.  By
544    default, we just provide columns for all registers.  */
545 #ifndef DWARF_FRAME_REGNUM
546 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
547 #endif
548 \f
549 /* Hook used by __throw.  */
550
551 rtx
552 expand_builtin_dwarf_sp_column (void)
553 {
554   unsigned int dwarf_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM);
555   return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum, 1));
556 }
557
558 /* Return a pointer to a copy of the section string name S with all
559    attributes stripped off, and an asterisk prepended (for assemble_name).  */
560
561 static inline char *
562 stripattributes (const char *s)
563 {
564   char *stripped = XNEWVEC (char, strlen (s) + 2);
565   char *p = stripped;
566
567   *p++ = '*';
568
569   while (*s && *s != ',')
570     *p++ = *s++;
571
572   *p = '\0';
573   return stripped;
574 }
575
576 /* MEM is a memory reference for the register size table, each element of
577    which has mode MODE.  Initialize column C as a return address column.  */
578
579 static void
580 init_return_column_size (enum machine_mode mode, rtx mem, unsigned int c)
581 {
582   HOST_WIDE_INT offset = c * GET_MODE_SIZE (mode);
583   HOST_WIDE_INT size = GET_MODE_SIZE (Pmode);
584   emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
585 }
586
587 /* Divide OFF by DWARF_CIE_DATA_ALIGNMENT, asserting no remainder.  */
588
589 static inline HOST_WIDE_INT
590 div_data_align (HOST_WIDE_INT off)
591 {
592   HOST_WIDE_INT r = off / DWARF_CIE_DATA_ALIGNMENT;
593   gcc_assert (r * DWARF_CIE_DATA_ALIGNMENT == off);
594   return r;
595 }
596
597 /* Return true if we need a signed version of a given opcode
598    (e.g. DW_CFA_offset_extended_sf vs DW_CFA_offset_extended).  */
599
600 static inline bool
601 need_data_align_sf_opcode (HOST_WIDE_INT off)
602 {
603   return DWARF_CIE_DATA_ALIGNMENT < 0 ? off > 0 : off < 0;
604 }
605
606 /* Generate code to initialize the register size table.  */
607
608 void
609 expand_builtin_init_dwarf_reg_sizes (tree address)
610 {
611   unsigned int i;
612   enum machine_mode mode = TYPE_MODE (char_type_node);
613   rtx addr = expand_normal (address);
614   rtx mem = gen_rtx_MEM (BLKmode, addr);
615   bool wrote_return_column = false;
616
617   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
618     {
619       int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1);
620
621       if (rnum < DWARF_FRAME_REGISTERS)
622         {
623           HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode);
624           enum machine_mode save_mode = reg_raw_mode[i];
625           HOST_WIDE_INT size;
626
627           if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
628             save_mode = choose_hard_reg_mode (i, 1, true);
629           if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
630             {
631               if (save_mode == VOIDmode)
632                 continue;
633               wrote_return_column = true;
634             }
635           size = GET_MODE_SIZE (save_mode);
636           if (offset < 0)
637             continue;
638
639           emit_move_insn (adjust_address (mem, mode, offset),
640                           gen_int_mode (size, mode));
641         }
642     }
643
644   if (!wrote_return_column)
645     init_return_column_size (mode, mem, DWARF_FRAME_RETURN_COLUMN);
646
647 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
648   init_return_column_size (mode, mem, DWARF_ALT_FRAME_RETURN_COLUMN);
649 #endif
650
651   targetm.init_dwarf_reg_sizes_extra (address);
652 }
653
654 /* Convert a DWARF call frame info. operation to its string name */
655
656 static const char *
657 dwarf_cfi_name (unsigned int cfi_opc)
658 {
659   switch (cfi_opc)
660     {
661     case DW_CFA_advance_loc:
662       return "DW_CFA_advance_loc";
663     case DW_CFA_offset:
664       return "DW_CFA_offset";
665     case DW_CFA_restore:
666       return "DW_CFA_restore";
667     case DW_CFA_nop:
668       return "DW_CFA_nop";
669     case DW_CFA_set_loc:
670       return "DW_CFA_set_loc";
671     case DW_CFA_advance_loc1:
672       return "DW_CFA_advance_loc1";
673     case DW_CFA_advance_loc2:
674       return "DW_CFA_advance_loc2";
675     case DW_CFA_advance_loc4:
676       return "DW_CFA_advance_loc4";
677     case DW_CFA_offset_extended:
678       return "DW_CFA_offset_extended";
679     case DW_CFA_restore_extended:
680       return "DW_CFA_restore_extended";
681     case DW_CFA_undefined:
682       return "DW_CFA_undefined";
683     case DW_CFA_same_value:
684       return "DW_CFA_same_value";
685     case DW_CFA_register:
686       return "DW_CFA_register";
687     case DW_CFA_remember_state:
688       return "DW_CFA_remember_state";
689     case DW_CFA_restore_state:
690       return "DW_CFA_restore_state";
691     case DW_CFA_def_cfa:
692       return "DW_CFA_def_cfa";
693     case DW_CFA_def_cfa_register:
694       return "DW_CFA_def_cfa_register";
695     case DW_CFA_def_cfa_offset:
696       return "DW_CFA_def_cfa_offset";
697
698     /* DWARF 3 */
699     case DW_CFA_def_cfa_expression:
700       return "DW_CFA_def_cfa_expression";
701     case DW_CFA_expression:
702       return "DW_CFA_expression";
703     case DW_CFA_offset_extended_sf:
704       return "DW_CFA_offset_extended_sf";
705     case DW_CFA_def_cfa_sf:
706       return "DW_CFA_def_cfa_sf";
707     case DW_CFA_def_cfa_offset_sf:
708       return "DW_CFA_def_cfa_offset_sf";
709
710     /* SGI/MIPS specific */
711     case DW_CFA_MIPS_advance_loc8:
712       return "DW_CFA_MIPS_advance_loc8";
713
714     /* GNU extensions */
715     case DW_CFA_GNU_window_save:
716       return "DW_CFA_GNU_window_save";
717     case DW_CFA_GNU_args_size:
718       return "DW_CFA_GNU_args_size";
719     case DW_CFA_GNU_negative_offset_extended:
720       return "DW_CFA_GNU_negative_offset_extended";
721
722     default:
723       return "DW_CFA_<unknown>";
724     }
725 }
726
727 /* Return a pointer to a newly allocated Call Frame Instruction.  */
728
729 static inline dw_cfi_ref
730 new_cfi (void)
731 {
732   dw_cfi_ref cfi = ggc_alloc_dw_cfi_node ();
733
734   cfi->dw_cfi_next = NULL;
735   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
736   cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
737
738   return cfi;
739 }
740
741 /* Add a Call Frame Instruction to list of instructions.  */
742
743 static inline void
744 add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi)
745 {
746   dw_cfi_ref *p;
747   dw_fde_ref fde = current_fde ();
748
749   /* When DRAP is used, CFA is defined with an expression.  Redefine
750      CFA may lead to a different CFA value.   */
751   /* ??? Of course, this heuristic fails when we're annotating epilogues,
752      because of course we'll always want to redefine the CFA back to the
753      stack pointer on the way out.  Where should we move this check?  */
754   if (0 && fde && fde->drap_reg != INVALID_REGNUM)
755     switch (cfi->dw_cfi_opc)
756       {
757         case DW_CFA_def_cfa_register:
758         case DW_CFA_def_cfa_offset:
759         case DW_CFA_def_cfa_offset_sf:
760         case DW_CFA_def_cfa:
761         case DW_CFA_def_cfa_sf:
762           gcc_unreachable ();
763
764         default:
765           break;
766       }
767
768   /* Find the end of the chain.  */
769   for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
770     ;
771
772   *p = cfi;
773 }
774
775 /* Generate a new label for the CFI info to refer to.  FORCE is true
776    if a label needs to be output even when using .cfi_* directives.  */
777
778 char *
779 dwarf2out_cfi_label (bool force)
780 {
781   static char label[20];
782
783   if (!force && dwarf2out_do_cfi_asm ())
784     {
785       /* In this case, we will be emitting the asm directive instead of
786          the label, so just return a placeholder to keep the rest of the
787          interfaces happy.  */
788       strcpy (label, "<do not output>");
789     }
790   else
791     {
792       int num = dwarf2out_cfi_label_num++;
793       ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", num);
794       ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LCFI", num);
795     }
796
797   return label;
798 }
799
800 /* True if remember_state should be emitted before following CFI directive.  */
801 static bool emit_cfa_remember;
802
803 /* True if any CFI directives were emitted at the current insn.  */
804 static bool any_cfis_emitted;
805
806 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
807    or to the CIE if LABEL is NULL.  */
808
809 static void
810 add_fde_cfi (const char *label, dw_cfi_ref cfi)
811 {
812   dw_cfi_ref *list_head;
813
814   if (emit_cfa_remember)
815     {
816       dw_cfi_ref cfi_remember;
817
818       /* Emit the state save.  */
819       emit_cfa_remember = false;
820       cfi_remember = new_cfi ();
821       cfi_remember->dw_cfi_opc = DW_CFA_remember_state;
822       add_fde_cfi (label, cfi_remember);
823     }
824
825   list_head = &cie_cfi_head;
826
827   if (dwarf2out_do_cfi_asm ())
828     {
829       if (label)
830         {
831           dw_fde_ref fde = current_fde ();
832
833           gcc_assert (fde != NULL);
834
835           /* We still have to add the cfi to the list so that lookup_cfa
836              works later on.  When -g2 and above we even need to force
837              emitting of CFI labels and add to list a DW_CFA_set_loc for
838              convert_cfa_to_fb_loc_list purposes.  If we're generating
839              DWARF3 output we use DW_OP_call_frame_cfa and so don't use
840              convert_cfa_to_fb_loc_list.  */
841           if (dwarf_version == 2
842               && debug_info_level > DINFO_LEVEL_TERSE
843               && (write_symbols == DWARF2_DEBUG
844                   || write_symbols == VMS_AND_DWARF2_DEBUG))
845             {
846               switch (cfi->dw_cfi_opc)
847                 {
848                 case DW_CFA_def_cfa_offset:
849                 case DW_CFA_def_cfa_offset_sf:
850                 case DW_CFA_def_cfa_register:
851                 case DW_CFA_def_cfa:
852                 case DW_CFA_def_cfa_sf:
853                 case DW_CFA_def_cfa_expression:
854                 case DW_CFA_restore_state:
855                   if (*label == 0 || strcmp (label, "<do not output>") == 0)
856                     label = dwarf2out_cfi_label (true);
857
858                   if (fde->dw_fde_current_label == NULL
859                       || strcmp (label, fde->dw_fde_current_label) != 0)
860                     {
861                       dw_cfi_ref xcfi;
862
863                       label = xstrdup (label);
864
865                       /* Set the location counter to the new label.  */
866                       xcfi = new_cfi ();
867                       /* It doesn't metter whether DW_CFA_set_loc
868                          or DW_CFA_advance_loc4 is added here, those aren't
869                          emitted into assembly, only looked up by
870                          convert_cfa_to_fb_loc_list.  */
871                       xcfi->dw_cfi_opc = DW_CFA_set_loc;
872                       xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
873                       add_cfi (&fde->dw_fde_cfi, xcfi);
874                       fde->dw_fde_current_label = label;
875                     }
876                   break;
877                 default:
878                   break;
879                 }
880             }
881
882           output_cfi_directive (cfi);
883
884           list_head = &fde->dw_fde_cfi;
885           any_cfis_emitted = true;
886         }
887       /* ??? If this is a CFI for the CIE, we don't emit.  This
888          assumes that the standard CIE contents that the assembler
889          uses matches the standard CIE contents that the compiler
890          uses.  This is probably a bad assumption.  I'm not quite
891          sure how to address this for now.  */
892     }
893   else if (label)
894     {
895       dw_fde_ref fde = current_fde ();
896
897       gcc_assert (fde != NULL);
898
899       if (*label == 0)
900         label = dwarf2out_cfi_label (false);
901
902       if (fde->dw_fde_current_label == NULL
903           || strcmp (label, fde->dw_fde_current_label) != 0)
904         {
905           dw_cfi_ref xcfi;
906
907           label = xstrdup (label);
908
909           /* Set the location counter to the new label.  */
910           xcfi = new_cfi ();
911           /* If we have a current label, advance from there, otherwise
912              set the location directly using set_loc.  */
913           xcfi->dw_cfi_opc = fde->dw_fde_current_label
914                              ? DW_CFA_advance_loc4
915                              : DW_CFA_set_loc;
916           xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
917           add_cfi (&fde->dw_fde_cfi, xcfi);
918
919           fde->dw_fde_current_label = label;
920         }
921
922       list_head = &fde->dw_fde_cfi;
923       any_cfis_emitted = true;
924     }
925
926   add_cfi (list_head, cfi);
927 }
928
929 /* Subroutine of lookup_cfa.  */
930
931 static void
932 lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc, dw_cfa_location *remember)
933 {
934   switch (cfi->dw_cfi_opc)
935     {
936     case DW_CFA_def_cfa_offset:
937     case DW_CFA_def_cfa_offset_sf:
938       loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
939       break;
940     case DW_CFA_def_cfa_register:
941       loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
942       break;
943     case DW_CFA_def_cfa:
944     case DW_CFA_def_cfa_sf:
945       loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
946       loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
947       break;
948     case DW_CFA_def_cfa_expression:
949       get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);
950       break;
951
952     case DW_CFA_remember_state:
953       gcc_assert (!remember->in_use);
954       *remember = *loc;
955       remember->in_use = 1;
956       break;
957     case DW_CFA_restore_state:
958       gcc_assert (remember->in_use);
959       *loc = *remember;
960       remember->in_use = 0;
961       break;
962
963     default:
964       break;
965     }
966 }
967
968 /* Find the previous value for the CFA.  */
969
970 static void
971 lookup_cfa (dw_cfa_location *loc)
972 {
973   dw_cfi_ref cfi;
974   dw_fde_ref fde;
975   dw_cfa_location remember;
976
977   memset (loc, 0, sizeof (*loc));
978   loc->reg = INVALID_REGNUM;
979   remember = *loc;
980
981   for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
982     lookup_cfa_1 (cfi, loc, &remember);
983
984   fde = current_fde ();
985   if (fde)
986     for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
987       lookup_cfa_1 (cfi, loc, &remember);
988 }
989
990 /* The current rule for calculating the DWARF2 canonical frame address.  */
991 static dw_cfa_location cfa;
992
993 /* The register used for saving registers to the stack, and its offset
994    from the CFA.  */
995 static dw_cfa_location cfa_store;
996
997 /* The current save location around an epilogue.  */
998 static dw_cfa_location cfa_remember;
999
1000 /* The running total of the size of arguments pushed onto the stack.  */
1001 static HOST_WIDE_INT args_size;
1002
1003 /* The last args_size we actually output.  */
1004 static HOST_WIDE_INT old_args_size;
1005
1006 /* Entry point to update the canonical frame address (CFA).
1007    LABEL is passed to add_fde_cfi.  The value of CFA is now to be
1008    calculated from REG+OFFSET.  */
1009
1010 void
1011 dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)
1012 {
1013   dw_cfa_location loc;
1014   loc.indirect = 0;
1015   loc.base_offset = 0;
1016   loc.reg = reg;
1017   loc.offset = offset;
1018   def_cfa_1 (label, &loc);
1019 }
1020
1021 /* Determine if two dw_cfa_location structures define the same data.  */
1022
1023 static bool
1024 cfa_equal_p (const dw_cfa_location *loc1, const dw_cfa_location *loc2)
1025 {
1026   return (loc1->reg == loc2->reg
1027           && loc1->offset == loc2->offset
1028           && loc1->indirect == loc2->indirect
1029           && (loc1->indirect == 0
1030               || loc1->base_offset == loc2->base_offset));
1031 }
1032
1033 /* This routine does the actual work.  The CFA is now calculated from
1034    the dw_cfa_location structure.  */
1035
1036 static void
1037 def_cfa_1 (const char *label, dw_cfa_location *loc_p)
1038 {
1039   dw_cfi_ref cfi;
1040   dw_cfa_location old_cfa, loc;
1041
1042   cfa = *loc_p;
1043   loc = *loc_p;
1044
1045   if (cfa_store.reg == loc.reg && loc.indirect == 0)
1046     cfa_store.offset = loc.offset;
1047
1048   loc.reg = DWARF_FRAME_REGNUM (loc.reg);
1049   lookup_cfa (&old_cfa);
1050
1051   /* If nothing changed, no need to issue any call frame instructions.  */
1052   if (cfa_equal_p (&loc, &old_cfa))
1053     return;
1054
1055   cfi = new_cfi ();
1056
1057   if (loc.reg == old_cfa.reg && !loc.indirect && !old_cfa.indirect)
1058     {
1059       /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating
1060          the CFA register did not change but the offset did.  The data
1061          factoring for DW_CFA_def_cfa_offset_sf happens in output_cfi, or
1062          in the assembler via the .cfi_def_cfa_offset directive.  */
1063       if (loc.offset < 0)
1064         cfi->dw_cfi_opc = DW_CFA_def_cfa_offset_sf;
1065       else
1066         cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
1067       cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
1068     }
1069
1070 #ifndef MIPS_DEBUGGING_INFO  /* SGI dbx thinks this means no offset.  */
1071   else if (loc.offset == old_cfa.offset
1072            && old_cfa.reg != INVALID_REGNUM
1073            && !loc.indirect
1074            && !old_cfa.indirect)
1075     {
1076       /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
1077          indicating the CFA register has changed to <register> but the
1078          offset has not changed.  */
1079       cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
1080       cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
1081     }
1082 #endif
1083
1084   else if (loc.indirect == 0)
1085     {
1086       /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
1087          indicating the CFA register has changed to <register> with
1088          the specified offset.  The data factoring for DW_CFA_def_cfa_sf
1089          happens in output_cfi, or in the assembler via the .cfi_def_cfa
1090          directive.  */
1091       if (loc.offset < 0)
1092         cfi->dw_cfi_opc = DW_CFA_def_cfa_sf;
1093       else
1094         cfi->dw_cfi_opc = DW_CFA_def_cfa;
1095       cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
1096       cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset;
1097     }
1098   else
1099     {
1100       /* Construct a DW_CFA_def_cfa_expression instruction to
1101          calculate the CFA using a full location expression since no
1102          register-offset pair is available.  */
1103       struct dw_loc_descr_struct *loc_list;
1104
1105       cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
1106       loc_list = build_cfa_loc (&loc, 0);
1107       cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list;
1108     }
1109
1110   add_fde_cfi (label, cfi);
1111 }
1112
1113 /* Add the CFI for saving a register.  REG is the CFA column number.
1114    LABEL is passed to add_fde_cfi.
1115    If SREG is -1, the register is saved at OFFSET from the CFA;
1116    otherwise it is saved in SREG.  */
1117
1118 static void
1119 reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset)
1120 {
1121   dw_cfi_ref cfi = new_cfi ();
1122   dw_fde_ref fde = current_fde ();
1123
1124   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
1125
1126   /* When stack is aligned, store REG using DW_CFA_expression with
1127      FP.  */
1128   if (fde
1129       && fde->stack_realign
1130       && sreg == INVALID_REGNUM)
1131     {
1132       cfi->dw_cfi_opc = DW_CFA_expression;
1133       cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
1134       cfi->dw_cfi_oprnd2.dw_cfi_loc
1135         = build_cfa_aligned_loc (offset, fde->stack_realignment);
1136     }
1137   else if (sreg == INVALID_REGNUM)
1138     {
1139       if (need_data_align_sf_opcode (offset))
1140         cfi->dw_cfi_opc = DW_CFA_offset_extended_sf;
1141       else if (reg & ~0x3f)
1142         cfi->dw_cfi_opc = DW_CFA_offset_extended;
1143       else
1144         cfi->dw_cfi_opc = DW_CFA_offset;
1145       cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
1146     }
1147   else if (sreg == reg)
1148     cfi->dw_cfi_opc = DW_CFA_same_value;
1149   else
1150     {
1151       cfi->dw_cfi_opc = DW_CFA_register;
1152       cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
1153     }
1154
1155   add_fde_cfi (label, cfi);
1156 }
1157
1158 /* Add the CFI for saving a register window.  LABEL is passed to reg_save.
1159    This CFI tells the unwinder that it needs to restore the window registers
1160    from the previous frame's window save area.
1161
1162    ??? Perhaps we should note in the CIE where windows are saved (instead of
1163    assuming 0(cfa)) and what registers are in the window.  */
1164
1165 void
1166 dwarf2out_window_save (const char *label)
1167 {
1168   dw_cfi_ref cfi = new_cfi ();
1169
1170   cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
1171   add_fde_cfi (label, cfi);
1172 }
1173
1174 /* Entry point for saving a register to the stack.  REG is the GCC register
1175    number.  LABEL and OFFSET are passed to reg_save.  */
1176
1177 void
1178 dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset)
1179 {
1180   reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset);
1181 }
1182
1183 /* Entry point for saving the return address in the stack.
1184    LABEL and OFFSET are passed to reg_save.  */
1185
1186 void
1187 dwarf2out_return_save (const char *label, HOST_WIDE_INT offset)
1188 {
1189   reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset);
1190 }
1191
1192 /* Entry point for saving the return address in a register.
1193    LABEL and SREG are passed to reg_save.  */
1194
1195 void
1196 dwarf2out_return_reg (const char *label, unsigned int sreg)
1197 {
1198   reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0);
1199 }
1200
1201 /* Record the initial position of the return address.  RTL is
1202    INCOMING_RETURN_ADDR_RTX.  */
1203
1204 static void
1205 initial_return_save (rtx rtl)
1206 {
1207   unsigned int reg = INVALID_REGNUM;
1208   HOST_WIDE_INT offset = 0;
1209
1210   switch (GET_CODE (rtl))
1211     {
1212     case REG:
1213       /* RA is in a register.  */
1214       reg = DWARF_FRAME_REGNUM (REGNO (rtl));
1215       break;
1216
1217     case MEM:
1218       /* RA is on the stack.  */
1219       rtl = XEXP (rtl, 0);
1220       switch (GET_CODE (rtl))
1221         {
1222         case REG:
1223           gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM);
1224           offset = 0;
1225           break;
1226
1227         case PLUS:
1228           gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1229           offset = INTVAL (XEXP (rtl, 1));
1230           break;
1231
1232         case MINUS:
1233           gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1234           offset = -INTVAL (XEXP (rtl, 1));
1235           break;
1236
1237         default:
1238           gcc_unreachable ();
1239         }
1240
1241       break;
1242
1243     case PLUS:
1244       /* The return address is at some offset from any value we can
1245          actually load.  For instance, on the SPARC it is in %i7+8. Just
1246          ignore the offset for now; it doesn't matter for unwinding frames.  */
1247       gcc_assert (CONST_INT_P (XEXP (rtl, 1)));
1248       initial_return_save (XEXP (rtl, 0));
1249       return;
1250
1251     default:
1252       gcc_unreachable ();
1253     }
1254
1255   if (reg != DWARF_FRAME_RETURN_COLUMN)
1256     reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
1257 }
1258
1259 /* Given a SET, calculate the amount of stack adjustment it
1260    contains.  */
1261
1262 static HOST_WIDE_INT
1263 stack_adjust_offset (const_rtx pattern, HOST_WIDE_INT cur_args_size,
1264                      HOST_WIDE_INT cur_offset)
1265 {
1266   const_rtx src = SET_SRC (pattern);
1267   const_rtx dest = SET_DEST (pattern);
1268   HOST_WIDE_INT offset = 0;
1269   enum rtx_code code;
1270
1271   if (dest == stack_pointer_rtx)
1272     {
1273       code = GET_CODE (src);
1274
1275       /* Assume (set (reg sp) (reg whatever)) sets args_size
1276          level to 0.  */
1277       if (code == REG && src != stack_pointer_rtx)
1278         {
1279           offset = -cur_args_size;
1280 #ifndef STACK_GROWS_DOWNWARD
1281           offset = -offset;
1282 #endif
1283           return offset - cur_offset;
1284         }
1285
1286       if (! (code == PLUS || code == MINUS)
1287           || XEXP (src, 0) != stack_pointer_rtx
1288           || !CONST_INT_P (XEXP (src, 1)))
1289         return 0;
1290
1291       /* (set (reg sp) (plus (reg sp) (const_int))) */
1292       offset = INTVAL (XEXP (src, 1));
1293       if (code == PLUS)
1294         offset = -offset;
1295       return offset;
1296     }
1297
1298   if (MEM_P (src) && !MEM_P (dest))
1299     dest = src;
1300   if (MEM_P (dest))
1301     {
1302       /* (set (mem (pre_dec (reg sp))) (foo)) */
1303       src = XEXP (dest, 0);
1304       code = GET_CODE (src);
1305
1306       switch (code)
1307         {
1308         case PRE_MODIFY:
1309         case POST_MODIFY:
1310           if (XEXP (src, 0) == stack_pointer_rtx)
1311             {
1312               rtx val = XEXP (XEXP (src, 1), 1);
1313               /* We handle only adjustments by constant amount.  */
1314               gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS
1315                           && CONST_INT_P (val));
1316               offset = -INTVAL (val);
1317               break;
1318             }
1319           return 0;
1320
1321         case PRE_DEC:
1322         case POST_DEC:
1323           if (XEXP (src, 0) == stack_pointer_rtx)
1324             {
1325               offset = GET_MODE_SIZE (GET_MODE (dest));
1326               break;
1327             }
1328           return 0;
1329
1330         case PRE_INC:
1331         case POST_INC:
1332           if (XEXP (src, 0) == stack_pointer_rtx)
1333             {
1334               offset = -GET_MODE_SIZE (GET_MODE (dest));
1335               break;
1336             }
1337           return 0;
1338
1339         default:
1340           return 0;
1341         }
1342     }
1343   else
1344     return 0;
1345
1346   return offset;
1347 }
1348
1349 /* Precomputed args_size for CODE_LABELs and BARRIERs preceeding them,
1350    indexed by INSN_UID.  */
1351
1352 static HOST_WIDE_INT *barrier_args_size;
1353
1354 /* Helper function for compute_barrier_args_size.  Handle one insn.  */
1355
1356 static HOST_WIDE_INT
1357 compute_barrier_args_size_1 (rtx insn, HOST_WIDE_INT cur_args_size,
1358                              VEC (rtx, heap) **next)
1359 {
1360   HOST_WIDE_INT offset = 0;
1361   int i;
1362
1363   if (! RTX_FRAME_RELATED_P (insn))
1364     {
1365       if (prologue_epilogue_contains (insn))
1366         /* Nothing */;
1367       else if (GET_CODE (PATTERN (insn)) == SET)
1368         offset = stack_adjust_offset (PATTERN (insn), cur_args_size, 0);
1369       else if (GET_CODE (PATTERN (insn)) == PARALLEL
1370                || GET_CODE (PATTERN (insn)) == SEQUENCE)
1371         {
1372           /* There may be stack adjustments inside compound insns.  Search
1373              for them.  */
1374           for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1375             if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1376               offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i),
1377                                              cur_args_size, offset);
1378         }
1379     }
1380   else
1381     {
1382       rtx expr = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1383
1384       if (expr)
1385         {
1386           expr = XEXP (expr, 0);
1387           if (GET_CODE (expr) == PARALLEL
1388               || GET_CODE (expr) == SEQUENCE)
1389             for (i = 1; i < XVECLEN (expr, 0); i++)
1390               {
1391                 rtx elem = XVECEXP (expr, 0, i);
1392
1393                 if (GET_CODE (elem) == SET && !RTX_FRAME_RELATED_P (elem))
1394                   offset += stack_adjust_offset (elem, cur_args_size, offset);
1395               }
1396         }
1397     }
1398
1399 #ifndef STACK_GROWS_DOWNWARD
1400   offset = -offset;
1401 #endif
1402
1403   cur_args_size += offset;
1404   if (cur_args_size < 0)
1405     cur_args_size = 0;
1406
1407   if (JUMP_P (insn))
1408     {
1409       rtx dest = JUMP_LABEL (insn);
1410
1411       if (dest)
1412         {
1413           if (barrier_args_size [INSN_UID (dest)] < 0)
1414             {
1415               barrier_args_size [INSN_UID (dest)] = cur_args_size;
1416               VEC_safe_push (rtx, heap, *next, dest);
1417             }
1418         }
1419     }
1420
1421   return cur_args_size;
1422 }
1423
1424 /* Walk the whole function and compute args_size on BARRIERs.  */
1425
1426 static void
1427 compute_barrier_args_size (void)
1428 {
1429   int max_uid = get_max_uid (), i;
1430   rtx insn;
1431   VEC (rtx, heap) *worklist, *next, *tmp;
1432
1433   barrier_args_size = XNEWVEC (HOST_WIDE_INT, max_uid);
1434   for (i = 0; i < max_uid; i++)
1435     barrier_args_size[i] = -1;
1436
1437   worklist = VEC_alloc (rtx, heap, 20);
1438   next = VEC_alloc (rtx, heap, 20);
1439   insn = get_insns ();
1440   barrier_args_size[INSN_UID (insn)] = 0;
1441   VEC_quick_push (rtx, worklist, insn);
1442   for (;;)
1443     {
1444       while (!VEC_empty (rtx, worklist))
1445         {
1446           rtx prev, body, first_insn;
1447           HOST_WIDE_INT cur_args_size;
1448
1449           first_insn = insn = VEC_pop (rtx, worklist);
1450           cur_args_size = barrier_args_size[INSN_UID (insn)];
1451           prev = prev_nonnote_insn (insn);
1452           if (prev && BARRIER_P (prev))
1453             barrier_args_size[INSN_UID (prev)] = cur_args_size;
1454
1455           for (; insn; insn = NEXT_INSN (insn))
1456             {
1457               if (INSN_DELETED_P (insn) || NOTE_P (insn))
1458                 continue;
1459               if (BARRIER_P (insn))
1460                 break;
1461
1462               if (LABEL_P (insn))
1463                 {
1464                   if (insn == first_insn)
1465                     continue;
1466                   else if (barrier_args_size[INSN_UID (insn)] < 0)
1467                     {
1468                       barrier_args_size[INSN_UID (insn)] = cur_args_size;
1469                       continue;
1470                     }
1471                   else
1472                     {
1473                       /* The insns starting with this label have been
1474                          already scanned or are in the worklist.  */
1475                       break;
1476                     }
1477                 }
1478
1479               body = PATTERN (insn);
1480               if (GET_CODE (body) == SEQUENCE)
1481                 {
1482                   HOST_WIDE_INT dest_args_size = cur_args_size;
1483                   for (i = 1; i < XVECLEN (body, 0); i++)
1484                     if (INSN_ANNULLED_BRANCH_P (XVECEXP (body, 0, 0))
1485                         && INSN_FROM_TARGET_P (XVECEXP (body, 0, i)))
1486                       dest_args_size
1487                         = compute_barrier_args_size_1 (XVECEXP (body, 0, i),
1488                                                        dest_args_size, &next);
1489                     else
1490                       cur_args_size
1491                         = compute_barrier_args_size_1 (XVECEXP (body, 0, i),
1492                                                        cur_args_size, &next);
1493
1494                   if (INSN_ANNULLED_BRANCH_P (XVECEXP (body, 0, 0)))
1495                     compute_barrier_args_size_1 (XVECEXP (body, 0, 0),
1496                                                  dest_args_size, &next);
1497                   else
1498                     cur_args_size
1499                       = compute_barrier_args_size_1 (XVECEXP (body, 0, 0),
1500                                                      cur_args_size, &next);
1501                 }
1502               else
1503                 cur_args_size
1504                   = compute_barrier_args_size_1 (insn, cur_args_size, &next);
1505             }
1506         }
1507
1508       if (VEC_empty (rtx, next))
1509         break;
1510
1511       /* Swap WORKLIST with NEXT and truncate NEXT for next iteration.  */
1512       tmp = next;
1513       next = worklist;
1514       worklist = tmp;
1515       VEC_truncate (rtx, next, 0);
1516     }
1517
1518   VEC_free (rtx, heap, worklist);
1519   VEC_free (rtx, heap, next);
1520 }
1521
1522 /* Add a CFI to update the running total of the size of arguments
1523    pushed onto the stack.  */
1524
1525 static void
1526 dwarf2out_args_size (const char *label, HOST_WIDE_INT size)
1527 {
1528   dw_cfi_ref cfi;
1529
1530   if (size == old_args_size)
1531     return;
1532
1533   old_args_size = size;
1534
1535   cfi = new_cfi ();
1536   cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
1537   cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
1538   add_fde_cfi (label, cfi);
1539 }
1540
1541 /* Record a stack adjustment of OFFSET bytes.  */
1542
1543 static void
1544 dwarf2out_stack_adjust (HOST_WIDE_INT offset, const char *label)
1545 {
1546   if (cfa.reg == STACK_POINTER_REGNUM)
1547     cfa.offset += offset;
1548
1549   if (cfa_store.reg == STACK_POINTER_REGNUM)
1550     cfa_store.offset += offset;
1551
1552   if (ACCUMULATE_OUTGOING_ARGS)
1553     return;
1554
1555 #ifndef STACK_GROWS_DOWNWARD
1556   offset = -offset;
1557 #endif
1558
1559   args_size += offset;
1560   if (args_size < 0)
1561     args_size = 0;
1562
1563   def_cfa_1 (label, &cfa);
1564   if (flag_asynchronous_unwind_tables)
1565     dwarf2out_args_size (label, args_size);
1566 }
1567
1568 /* Check INSN to see if it looks like a push or a stack adjustment, and
1569    make a note of it if it does.  EH uses this information to find out
1570    how much extra space it needs to pop off the stack.  */
1571
1572 static void
1573 dwarf2out_notice_stack_adjust (rtx insn, bool after_p)
1574 {
1575   HOST_WIDE_INT offset;
1576   const char *label;
1577   int i;
1578
1579   /* Don't handle epilogues at all.  Certainly it would be wrong to do so
1580      with this function.  Proper support would require all frame-related
1581      insns to be marked, and to be able to handle saving state around
1582      epilogues textually in the middle of the function.  */
1583   if (prologue_epilogue_contains (insn))
1584     return;
1585
1586   /* If INSN is an instruction from target of an annulled branch, the
1587      effects are for the target only and so current argument size
1588      shouldn't change at all.  */
1589   if (final_sequence
1590       && INSN_ANNULLED_BRANCH_P (XVECEXP (final_sequence, 0, 0))
1591       && INSN_FROM_TARGET_P (insn))
1592     return;
1593
1594   /* If only calls can throw, and we have a frame pointer,
1595      save up adjustments until we see the CALL_INSN.  */
1596   if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM)
1597     {
1598       if (CALL_P (insn) && !after_p)
1599         {
1600           /* Extract the size of the args from the CALL rtx itself.  */
1601           insn = PATTERN (insn);
1602           if (GET_CODE (insn) == PARALLEL)
1603             insn = XVECEXP (insn, 0, 0);
1604           if (GET_CODE (insn) == SET)
1605             insn = SET_SRC (insn);
1606           gcc_assert (GET_CODE (insn) == CALL);
1607           dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1608         }
1609       return;
1610     }
1611
1612   if (CALL_P (insn) && !after_p)
1613     {
1614       if (!flag_asynchronous_unwind_tables)
1615         dwarf2out_args_size ("", args_size);
1616       return;
1617     }
1618   else if (BARRIER_P (insn))
1619     {
1620       /* Don't call compute_barrier_args_size () if the only
1621          BARRIER is at the end of function.  */
1622       if (barrier_args_size == NULL && next_nonnote_insn (insn))
1623         compute_barrier_args_size ();
1624       if (barrier_args_size == NULL)
1625         offset = 0;
1626       else
1627         {
1628           offset = barrier_args_size[INSN_UID (insn)];
1629           if (offset < 0)
1630             offset = 0;
1631         }
1632
1633       offset -= args_size;
1634 #ifndef STACK_GROWS_DOWNWARD
1635       offset = -offset;
1636 #endif
1637     }
1638   else if (GET_CODE (PATTERN (insn)) == SET)
1639     offset = stack_adjust_offset (PATTERN (insn), args_size, 0);
1640   else if (GET_CODE (PATTERN (insn)) == PARALLEL
1641            || GET_CODE (PATTERN (insn)) == SEQUENCE)
1642     {
1643       /* There may be stack adjustments inside compound insns.  Search
1644          for them.  */
1645       for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1646         if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1647           offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i),
1648                                          args_size, offset);
1649     }
1650   else
1651     return;
1652
1653   if (offset == 0)
1654     return;
1655
1656   label = dwarf2out_cfi_label (false);
1657   dwarf2out_stack_adjust (offset, label);
1658 }
1659
1660 /* We delay emitting a register save until either (a) we reach the end
1661    of the prologue or (b) the register is clobbered.  This clusters
1662    register saves so that there are fewer pc advances.  */
1663
1664 struct GTY(()) queued_reg_save {
1665   struct queued_reg_save *next;
1666   rtx reg;
1667   HOST_WIDE_INT cfa_offset;
1668   rtx saved_reg;
1669 };
1670
1671 static GTY(()) struct queued_reg_save *queued_reg_saves;
1672
1673 /* The caller's ORIG_REG is saved in SAVED_IN_REG.  */
1674 struct GTY(()) reg_saved_in_data {
1675   rtx orig_reg;
1676   rtx saved_in_reg;
1677 };
1678
1679 /* A list of registers saved in other registers.
1680    The list intentionally has a small maximum capacity of 4; if your
1681    port needs more than that, you might consider implementing a
1682    more efficient data structure.  */
1683 static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4];
1684 static GTY(()) size_t num_regs_saved_in_regs;
1685
1686 static const char *last_reg_save_label;
1687
1688 /* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
1689    SREG, or if SREG is NULL then it is saved at OFFSET to the CFA.  */
1690
1691 static void
1692 queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset)
1693 {
1694   struct queued_reg_save *q;
1695
1696   /* Duplicates waste space, but it's also necessary to remove them
1697      for correctness, since the queue gets output in reverse
1698      order.  */
1699   for (q = queued_reg_saves; q != NULL; q = q->next)
1700     if (REGNO (q->reg) == REGNO (reg))
1701       break;
1702
1703   if (q == NULL)
1704     {
1705       q = ggc_alloc_queued_reg_save ();
1706       q->next = queued_reg_saves;
1707       queued_reg_saves = q;
1708     }
1709
1710   q->reg = reg;
1711   q->cfa_offset = offset;
1712   q->saved_reg = sreg;
1713
1714   last_reg_save_label = label;
1715 }
1716
1717 /* Output all the entries in QUEUED_REG_SAVES.  */
1718
1719 void
1720 dwarf2out_flush_queued_reg_saves (void)
1721 {
1722   struct queued_reg_save *q;
1723
1724   for (q = queued_reg_saves; q; q = q->next)
1725     {
1726       size_t i;
1727       unsigned int reg, sreg;
1728
1729       for (i = 0; i < num_regs_saved_in_regs; i++)
1730         if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg))
1731           break;
1732       if (q->saved_reg && i == num_regs_saved_in_regs)
1733         {
1734           gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1735           num_regs_saved_in_regs++;
1736         }
1737       if (i != num_regs_saved_in_regs)
1738         {
1739           regs_saved_in_regs[i].orig_reg = q->reg;
1740           regs_saved_in_regs[i].saved_in_reg = q->saved_reg;
1741         }
1742
1743       reg = DWARF_FRAME_REGNUM (REGNO (q->reg));
1744       if (q->saved_reg)
1745         sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg));
1746       else
1747         sreg = INVALID_REGNUM;
1748       reg_save (last_reg_save_label, reg, sreg, q->cfa_offset);
1749     }
1750
1751   queued_reg_saves = NULL;
1752   last_reg_save_label = NULL;
1753 }
1754
1755 /* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved
1756    location for?  Or, does it clobber a register which we've previously
1757    said that some other register is saved in, and for which we now
1758    have a new location for?  */
1759
1760 static bool
1761 clobbers_queued_reg_save (const_rtx insn)
1762 {
1763   struct queued_reg_save *q;
1764
1765   for (q = queued_reg_saves; q; q = q->next)
1766     {
1767       size_t i;
1768       if (modified_in_p (q->reg, insn))
1769         return true;
1770       for (i = 0; i < num_regs_saved_in_regs; i++)
1771         if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg)
1772             && modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn))
1773           return true;
1774     }
1775
1776   return false;
1777 }
1778
1779 /* Entry point for saving the first register into the second.  */
1780
1781 void
1782 dwarf2out_reg_save_reg (const char *label, rtx reg, rtx sreg)
1783 {
1784   size_t i;
1785   unsigned int regno, sregno;
1786
1787   for (i = 0; i < num_regs_saved_in_regs; i++)
1788     if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (reg))
1789       break;
1790   if (i == num_regs_saved_in_regs)
1791     {
1792       gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1793       num_regs_saved_in_regs++;
1794     }
1795   regs_saved_in_regs[i].orig_reg = reg;
1796   regs_saved_in_regs[i].saved_in_reg = sreg;
1797
1798   regno = DWARF_FRAME_REGNUM (REGNO (reg));
1799   sregno = DWARF_FRAME_REGNUM (REGNO (sreg));
1800   reg_save (label, regno, sregno, 0);
1801 }
1802
1803 /* What register, if any, is currently saved in REG?  */
1804
1805 static rtx
1806 reg_saved_in (rtx reg)
1807 {
1808   unsigned int regn = REGNO (reg);
1809   size_t i;
1810   struct queued_reg_save *q;
1811
1812   for (q = queued_reg_saves; q; q = q->next)
1813     if (q->saved_reg && regn == REGNO (q->saved_reg))
1814       return q->reg;
1815
1816   for (i = 0; i < num_regs_saved_in_regs; i++)
1817     if (regs_saved_in_regs[i].saved_in_reg
1818         && regn == REGNO (regs_saved_in_regs[i].saved_in_reg))
1819       return regs_saved_in_regs[i].orig_reg;
1820
1821   return NULL_RTX;
1822 }
1823
1824
1825 /* A temporary register holding an integral value used in adjusting SP
1826    or setting up the store_reg.  The "offset" field holds the integer
1827    value, not an offset.  */
1828 static dw_cfa_location cfa_temp;
1829
1830 /* A subroutine of dwarf2out_frame_debug, process a REG_DEF_CFA note.  */
1831
1832 static void
1833 dwarf2out_frame_debug_def_cfa (rtx pat, const char *label)
1834 {
1835   memset (&cfa, 0, sizeof (cfa));
1836
1837   switch (GET_CODE (pat))
1838     {
1839     case PLUS:
1840       cfa.reg = REGNO (XEXP (pat, 0));
1841       cfa.offset = INTVAL (XEXP (pat, 1));
1842       break;
1843
1844     case REG:
1845       cfa.reg = REGNO (pat);
1846       break;
1847
1848     case MEM:
1849       cfa.indirect = 1;
1850       pat = XEXP (pat, 0);
1851       if (GET_CODE (pat) == PLUS)
1852         {
1853           cfa.base_offset = INTVAL (XEXP (pat, 1));
1854           pat = XEXP (pat, 0);
1855         }
1856       cfa.reg = REGNO (pat);
1857       break;
1858
1859     default:
1860       /* Recurse and define an expression.  */
1861       gcc_unreachable ();
1862     }
1863
1864   def_cfa_1 (label, &cfa);
1865 }
1866
1867 /* A subroutine of dwarf2out_frame_debug, process a REG_ADJUST_CFA note.  */
1868
1869 static void
1870 dwarf2out_frame_debug_adjust_cfa (rtx pat, const char *label)
1871 {
1872   rtx src, dest;
1873
1874   gcc_assert (GET_CODE (pat) == SET);
1875   dest = XEXP (pat, 0);
1876   src = XEXP (pat, 1);
1877
1878   switch (GET_CODE (src))
1879     {
1880     case PLUS:
1881       gcc_assert (REGNO (XEXP (src, 0)) == cfa.reg);
1882       cfa.offset -= INTVAL (XEXP (src, 1));
1883       break;
1884
1885     case REG:
1886         break;
1887
1888     default:
1889         gcc_unreachable ();
1890     }
1891
1892   cfa.reg = REGNO (dest);
1893   gcc_assert (cfa.indirect == 0);
1894
1895   def_cfa_1 (label, &cfa);
1896 }
1897
1898 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_OFFSET note.  */
1899
1900 static void
1901 dwarf2out_frame_debug_cfa_offset (rtx set, const char *label)
1902 {
1903   HOST_WIDE_INT offset;
1904   rtx src, addr, span;
1905
1906   src = XEXP (set, 1);
1907   addr = XEXP (set, 0);
1908   gcc_assert (MEM_P (addr));
1909   addr = XEXP (addr, 0);
1910
1911   /* As documented, only consider extremely simple addresses.  */
1912   switch (GET_CODE (addr))
1913     {
1914     case REG:
1915       gcc_assert (REGNO (addr) == cfa.reg);
1916       offset = -cfa.offset;
1917       break;
1918     case PLUS:
1919       gcc_assert (REGNO (XEXP (addr, 0)) == cfa.reg);
1920       offset = INTVAL (XEXP (addr, 1)) - cfa.offset;
1921       break;
1922     default:
1923       gcc_unreachable ();
1924     }
1925
1926   span = targetm.dwarf_register_span (src);
1927
1928   /* ??? We'd like to use queue_reg_save, but we need to come up with
1929      a different flushing heuristic for epilogues.  */
1930   if (!span)
1931     reg_save (label, DWARF_FRAME_REGNUM (REGNO (src)), INVALID_REGNUM, offset);
1932   else
1933     {
1934       /* We have a PARALLEL describing where the contents of SRC live.
1935          Queue register saves for each piece of the PARALLEL.  */
1936       int par_index;
1937       int limit;
1938       HOST_WIDE_INT span_offset = offset;
1939
1940       gcc_assert (GET_CODE (span) == PARALLEL);
1941
1942       limit = XVECLEN (span, 0);
1943       for (par_index = 0; par_index < limit; par_index++)
1944         {
1945           rtx elem = XVECEXP (span, 0, par_index);
1946
1947           reg_save (label, DWARF_FRAME_REGNUM (REGNO (elem)),
1948                     INVALID_REGNUM, span_offset);
1949           span_offset += GET_MODE_SIZE (GET_MODE (elem));
1950         }
1951     }
1952 }
1953
1954 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_REGISTER note.  */
1955
1956 static void
1957 dwarf2out_frame_debug_cfa_register (rtx set, const char *label)
1958 {
1959   rtx src, dest;
1960   unsigned sregno, dregno;
1961
1962   src = XEXP (set, 1);
1963   dest = XEXP (set, 0);
1964
1965   if (src == pc_rtx)
1966     sregno = DWARF_FRAME_RETURN_COLUMN;
1967   else
1968     sregno = DWARF_FRAME_REGNUM (REGNO (src));
1969
1970   dregno = DWARF_FRAME_REGNUM (REGNO (dest));
1971
1972   /* ??? We'd like to use queue_reg_save, but we need to come up with
1973      a different flushing heuristic for epilogues.  */
1974   reg_save (label, sregno, dregno, 0);
1975 }
1976
1977 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_EXPRESSION note. */
1978
1979 static void
1980 dwarf2out_frame_debug_cfa_expression (rtx set, const char *label)
1981 {
1982   rtx src, dest, span;
1983   dw_cfi_ref cfi = new_cfi ();
1984
1985   dest = SET_DEST (set);
1986   src = SET_SRC (set);
1987
1988   gcc_assert (REG_P (src));
1989   gcc_assert (MEM_P (dest));
1990
1991   span = targetm.dwarf_register_span (src);
1992   gcc_assert (!span);
1993
1994   cfi->dw_cfi_opc = DW_CFA_expression;
1995   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = DWARF_FRAME_REGNUM (REGNO (src));
1996   cfi->dw_cfi_oprnd2.dw_cfi_loc
1997     = mem_loc_descriptor (XEXP (dest, 0), GET_MODE (dest),
1998                           VAR_INIT_STATUS_INITIALIZED);
1999
2000   /* ??? We'd like to use queue_reg_save, were the interface different,
2001      and, as above, we could manage flushing for epilogues.  */
2002   add_fde_cfi (label, cfi);
2003 }
2004
2005 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_RESTORE note.  */
2006
2007 static void
2008 dwarf2out_frame_debug_cfa_restore (rtx reg, const char *label)
2009 {
2010   dw_cfi_ref cfi = new_cfi ();
2011   unsigned int regno = DWARF_FRAME_REGNUM (REGNO (reg));
2012
2013   cfi->dw_cfi_opc = (regno & ~0x3f ? DW_CFA_restore_extended : DW_CFA_restore);
2014   cfi->dw_cfi_oprnd1.dw_cfi_reg_num = regno;
2015
2016   add_fde_cfi (label, cfi);
2017 }
2018
2019 /* Record call frame debugging information for an expression EXPR,
2020    which either sets SP or FP (adjusting how we calculate the frame
2021    address) or saves a register to the stack or another register.
2022    LABEL indicates the address of EXPR.
2023
2024    This function encodes a state machine mapping rtxes to actions on
2025    cfa, cfa_store, and cfa_temp.reg.  We describe these rules so
2026    users need not read the source code.
2027
2028   The High-Level Picture
2029
2030   Changes in the register we use to calculate the CFA: Currently we
2031   assume that if you copy the CFA register into another register, we
2032   should take the other one as the new CFA register; this seems to
2033   work pretty well.  If it's wrong for some target, it's simple
2034   enough not to set RTX_FRAME_RELATED_P on the insn in question.
2035
2036   Changes in the register we use for saving registers to the stack:
2037   This is usually SP, but not always.  Again, we deduce that if you
2038   copy SP into another register (and SP is not the CFA register),
2039   then the new register is the one we will be using for register
2040   saves.  This also seems to work.
2041
2042   Register saves: There's not much guesswork about this one; if
2043   RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
2044   register save, and the register used to calculate the destination
2045   had better be the one we think we're using for this purpose.
2046   It's also assumed that a copy from a call-saved register to another
2047   register is saving that register if RTX_FRAME_RELATED_P is set on
2048   that instruction.  If the copy is from a call-saved register to
2049   the *same* register, that means that the register is now the same
2050   value as in the caller.
2051
2052   Except: If the register being saved is the CFA register, and the
2053   offset is nonzero, we are saving the CFA, so we assume we have to
2054   use DW_CFA_def_cfa_expression.  If the offset is 0, we assume that
2055   the intent is to save the value of SP from the previous frame.
2056
2057   In addition, if a register has previously been saved to a different
2058   register,
2059
2060   Invariants / Summaries of Rules
2061
2062   cfa          current rule for calculating the CFA.  It usually
2063                consists of a register and an offset.
2064   cfa_store    register used by prologue code to save things to the stack
2065                cfa_store.offset is the offset from the value of
2066                cfa_store.reg to the actual CFA
2067   cfa_temp     register holding an integral value.  cfa_temp.offset
2068                stores the value, which will be used to adjust the
2069                stack pointer.  cfa_temp is also used like cfa_store,
2070                to track stores to the stack via fp or a temp reg.
2071
2072   Rules  1- 4: Setting a register's value to cfa.reg or an expression
2073                with cfa.reg as the first operand changes the cfa.reg and its
2074                cfa.offset.  Rule 1 and 4 also set cfa_temp.reg and
2075                cfa_temp.offset.
2076
2077   Rules  6- 9: Set a non-cfa.reg register value to a constant or an
2078                expression yielding a constant.  This sets cfa_temp.reg
2079                and cfa_temp.offset.
2080
2081   Rule 5:      Create a new register cfa_store used to save items to the
2082                stack.
2083
2084   Rules 10-14: Save a register to the stack.  Define offset as the
2085                difference of the original location and cfa_store's
2086                location (or cfa_temp's location if cfa_temp is used).
2087
2088   Rules 16-20: If AND operation happens on sp in prologue, we assume
2089                stack is realigned.  We will use a group of DW_OP_XXX
2090                expressions to represent the location of the stored
2091                register instead of CFA+offset.
2092
2093   The Rules
2094
2095   "{a,b}" indicates a choice of a xor b.
2096   "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
2097
2098   Rule 1:
2099   (set <reg1> <reg2>:cfa.reg)
2100   effects: cfa.reg = <reg1>
2101            cfa.offset unchanged
2102            cfa_temp.reg = <reg1>
2103            cfa_temp.offset = cfa.offset
2104
2105   Rule 2:
2106   (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
2107                               {<const_int>,<reg>:cfa_temp.reg}))
2108   effects: cfa.reg = sp if fp used
2109            cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
2110            cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
2111              if cfa_store.reg==sp
2112
2113   Rule 3:
2114   (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
2115   effects: cfa.reg = fp
2116            cfa_offset += +/- <const_int>
2117
2118   Rule 4:
2119   (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
2120   constraints: <reg1> != fp
2121                <reg1> != sp
2122   effects: cfa.reg = <reg1>
2123            cfa_temp.reg = <reg1>
2124            cfa_temp.offset = cfa.offset
2125
2126   Rule 5:
2127   (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
2128   constraints: <reg1> != fp
2129                <reg1> != sp
2130   effects: cfa_store.reg = <reg1>
2131            cfa_store.offset = cfa.offset - cfa_temp.offset
2132
2133   Rule 6:
2134   (set <reg> <const_int>)
2135   effects: cfa_temp.reg = <reg>
2136            cfa_temp.offset = <const_int>
2137
2138   Rule 7:
2139   (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
2140   effects: cfa_temp.reg = <reg1>
2141            cfa_temp.offset |= <const_int>
2142
2143   Rule 8:
2144   (set <reg> (high <exp>))
2145   effects: none
2146
2147   Rule 9:
2148   (set <reg> (lo_sum <exp> <const_int>))
2149   effects: cfa_temp.reg = <reg>
2150            cfa_temp.offset = <const_int>
2151
2152   Rule 10:
2153   (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
2154   effects: cfa_store.offset -= <const_int>
2155            cfa.offset = cfa_store.offset if cfa.reg == sp
2156            cfa.reg = sp
2157            cfa.base_offset = -cfa_store.offset
2158
2159   Rule 11:
2160   (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
2161   effects: cfa_store.offset += -/+ mode_size(mem)
2162            cfa.offset = cfa_store.offset if cfa.reg == sp
2163            cfa.reg = sp
2164            cfa.base_offset = -cfa_store.offset
2165
2166   Rule 12:
2167   (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
2168
2169        <reg2>)
2170   effects: cfa.reg = <reg1>
2171            cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
2172
2173   Rule 13:
2174   (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
2175   effects: cfa.reg = <reg1>
2176            cfa.base_offset = -{cfa_store,cfa_temp}.offset
2177
2178   Rule 14:
2179   (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
2180   effects: cfa.reg = <reg1>
2181            cfa.base_offset = -cfa_temp.offset
2182            cfa_temp.offset -= mode_size(mem)
2183
2184   Rule 15:
2185   (set <reg> {unspec, unspec_volatile})
2186   effects: target-dependent
2187
2188   Rule 16:
2189   (set sp (and: sp <const_int>))
2190   constraints: cfa_store.reg == sp
2191   effects: current_fde.stack_realign = 1
2192            cfa_store.offset = 0
2193            fde->drap_reg = cfa.reg if cfa.reg != sp and cfa.reg != fp
2194
2195   Rule 17:
2196   (set (mem ({pre_inc, pre_dec} sp)) (mem (plus (cfa.reg) (const_int))))
2197   effects: cfa_store.offset += -/+ mode_size(mem)
2198
2199   Rule 18:
2200   (set (mem ({pre_inc, pre_dec} sp)) fp)
2201   constraints: fde->stack_realign == 1
2202   effects: cfa_store.offset = 0
2203            cfa.reg != HARD_FRAME_POINTER_REGNUM
2204
2205   Rule 19:
2206   (set (mem ({pre_inc, pre_dec} sp)) cfa.reg)
2207   constraints: fde->stack_realign == 1
2208                && cfa.offset == 0
2209                && cfa.indirect == 0
2210                && cfa.reg != HARD_FRAME_POINTER_REGNUM
2211   effects: Use DW_CFA_def_cfa_expression to define cfa
2212            cfa.reg == fde->drap_reg  */
2213
2214 static void
2215 dwarf2out_frame_debug_expr (rtx expr, const char *label)
2216 {
2217   rtx src, dest, span;
2218   HOST_WIDE_INT offset;
2219   dw_fde_ref fde;
2220
2221   /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
2222      the PARALLEL independently. The first element is always processed if
2223      it is a SET. This is for backward compatibility.   Other elements
2224      are processed only if they are SETs and the RTX_FRAME_RELATED_P
2225      flag is set in them.  */
2226   if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE)
2227     {
2228       int par_index;
2229       int limit = XVECLEN (expr, 0);
2230       rtx elem;
2231
2232       /* PARALLELs have strict read-modify-write semantics, so we
2233          ought to evaluate every rvalue before changing any lvalue.
2234          It's cumbersome to do that in general, but there's an
2235          easy approximation that is enough for all current users:
2236          handle register saves before register assignments.  */
2237       if (GET_CODE (expr) == PARALLEL)
2238         for (par_index = 0; par_index < limit; par_index++)
2239           {
2240             elem = XVECEXP (expr, 0, par_index);
2241             if (GET_CODE (elem) == SET
2242                 && MEM_P (SET_DEST (elem))
2243                 && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
2244               dwarf2out_frame_debug_expr (elem, label);
2245           }
2246
2247       for (par_index = 0; par_index < limit; par_index++)
2248         {
2249           elem = XVECEXP (expr, 0, par_index);
2250           if (GET_CODE (elem) == SET
2251               && (!MEM_P (SET_DEST (elem)) || GET_CODE (expr) == SEQUENCE)
2252               && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
2253             dwarf2out_frame_debug_expr (elem, label);
2254           else if (GET_CODE (elem) == SET
2255                    && par_index != 0
2256                    && !RTX_FRAME_RELATED_P (elem))
2257             {
2258               /* Stack adjustment combining might combine some post-prologue
2259                  stack adjustment into a prologue stack adjustment.  */
2260               HOST_WIDE_INT offset = stack_adjust_offset (elem, args_size, 0);
2261
2262               if (offset != 0)
2263                 dwarf2out_stack_adjust (offset, label);
2264             }
2265         }
2266       return;
2267     }
2268
2269   gcc_assert (GET_CODE (expr) == SET);
2270
2271   src = SET_SRC (expr);
2272   dest = SET_DEST (expr);
2273
2274   if (REG_P (src))
2275     {
2276       rtx rsi = reg_saved_in (src);
2277       if (rsi)
2278         src = rsi;
2279     }
2280
2281   fde = current_fde ();
2282
2283   switch (GET_CODE (dest))
2284     {
2285     case REG:
2286       switch (GET_CODE (src))
2287         {
2288           /* Setting FP from SP.  */
2289         case REG:
2290           if (cfa.reg == (unsigned) REGNO (src))
2291             {
2292               /* Rule 1 */
2293               /* Update the CFA rule wrt SP or FP.  Make sure src is
2294                  relative to the current CFA register.
2295
2296                  We used to require that dest be either SP or FP, but the
2297                  ARM copies SP to a temporary register, and from there to
2298                  FP.  So we just rely on the backends to only set
2299                  RTX_FRAME_RELATED_P on appropriate insns.  */
2300               cfa.reg = REGNO (dest);
2301               cfa_temp.reg = cfa.reg;
2302               cfa_temp.offset = cfa.offset;
2303             }
2304           else
2305             {
2306               /* Saving a register in a register.  */
2307               gcc_assert (!fixed_regs [REGNO (dest)]
2308                           /* For the SPARC and its register window.  */
2309                           || (DWARF_FRAME_REGNUM (REGNO (src))
2310                               == DWARF_FRAME_RETURN_COLUMN));
2311
2312               /* After stack is aligned, we can only save SP in FP
2313                  if drap register is used.  In this case, we have
2314                  to restore stack pointer with the CFA value and we
2315                  don't generate this DWARF information.  */
2316               if (fde
2317                   && fde->stack_realign
2318                   && REGNO (src) == STACK_POINTER_REGNUM)
2319                 gcc_assert (REGNO (dest) == HARD_FRAME_POINTER_REGNUM
2320                             && fde->drap_reg != INVALID_REGNUM
2321                             && cfa.reg != REGNO (src));
2322               else
2323                 queue_reg_save (label, src, dest, 0);
2324             }
2325           break;
2326
2327         case PLUS:
2328         case MINUS:
2329         case LO_SUM:
2330           if (dest == stack_pointer_rtx)
2331             {
2332               /* Rule 2 */
2333               /* Adjusting SP.  */
2334               switch (GET_CODE (XEXP (src, 1)))
2335                 {
2336                 case CONST_INT:
2337                   offset = INTVAL (XEXP (src, 1));
2338                   break;
2339                 case REG:
2340                   gcc_assert ((unsigned) REGNO (XEXP (src, 1))
2341                               == cfa_temp.reg);
2342                   offset = cfa_temp.offset;
2343                   break;
2344                 default:
2345                   gcc_unreachable ();
2346                 }
2347
2348               if (XEXP (src, 0) == hard_frame_pointer_rtx)
2349                 {
2350                   /* Restoring SP from FP in the epilogue.  */
2351                   gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM);
2352                   cfa.reg = STACK_POINTER_REGNUM;
2353                 }
2354               else if (GET_CODE (src) == LO_SUM)
2355                 /* Assume we've set the source reg of the LO_SUM from sp.  */
2356                 ;
2357               else
2358                 gcc_assert (XEXP (src, 0) == stack_pointer_rtx);
2359
2360               if (GET_CODE (src) != MINUS)
2361                 offset = -offset;
2362               if (cfa.reg == STACK_POINTER_REGNUM)
2363                 cfa.offset += offset;
2364               if (cfa_store.reg == STACK_POINTER_REGNUM)
2365                 cfa_store.offset += offset;
2366             }
2367           else if (dest == hard_frame_pointer_rtx)
2368             {
2369               /* Rule 3 */
2370               /* Either setting the FP from an offset of the SP,
2371                  or adjusting the FP */
2372               gcc_assert (frame_pointer_needed);
2373
2374               gcc_assert (REG_P (XEXP (src, 0))
2375                           && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
2376                           && CONST_INT_P (XEXP (src, 1)));
2377               offset = INTVAL (XEXP (src, 1));
2378               if (GET_CODE (src) != MINUS)
2379                 offset = -offset;
2380               cfa.offset += offset;
2381               cfa.reg = HARD_FRAME_POINTER_REGNUM;
2382             }
2383           else
2384             {
2385               gcc_assert (GET_CODE (src) != MINUS);
2386
2387               /* Rule 4 */
2388               if (REG_P (XEXP (src, 0))
2389                   && REGNO (XEXP (src, 0)) == cfa.reg
2390                   && CONST_INT_P (XEXP (src, 1)))
2391                 {
2392                   /* Setting a temporary CFA register that will be copied
2393                      into the FP later on.  */
2394                   offset = - INTVAL (XEXP (src, 1));
2395                   cfa.offset += offset;
2396                   cfa.reg = REGNO (dest);
2397                   /* Or used to save regs to the stack.  */
2398                   cfa_temp.reg = cfa.reg;
2399                   cfa_temp.offset = cfa.offset;
2400                 }
2401
2402               /* Rule 5 */
2403               else if (REG_P (XEXP (src, 0))
2404                        && REGNO (XEXP (src, 0)) == cfa_temp.reg
2405                        && XEXP (src, 1) == stack_pointer_rtx)
2406                 {
2407                   /* Setting a scratch register that we will use instead
2408                      of SP for saving registers to the stack.  */
2409                   gcc_assert (cfa.reg == STACK_POINTER_REGNUM);
2410                   cfa_store.reg = REGNO (dest);
2411                   cfa_store.offset = cfa.offset - cfa_temp.offset;
2412                 }
2413
2414               /* Rule 9 */
2415               else if (GET_CODE (src) == LO_SUM
2416                        && CONST_INT_P (XEXP (src, 1)))
2417                 {
2418                   cfa_temp.reg = REGNO (dest);
2419                   cfa_temp.offset = INTVAL (XEXP (src, 1));
2420                 }
2421               else
2422                 gcc_unreachable ();
2423             }
2424           break;
2425
2426           /* Rule 6 */
2427         case CONST_INT:
2428           cfa_temp.reg = REGNO (dest);
2429           cfa_temp.offset = INTVAL (src);
2430           break;
2431
2432           /* Rule 7 */
2433         case IOR:
2434           gcc_assert (REG_P (XEXP (src, 0))
2435                       && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg
2436                       && CONST_INT_P (XEXP (src, 1)));
2437
2438           if ((unsigned) REGNO (dest) != cfa_temp.reg)
2439             cfa_temp.reg = REGNO (dest);
2440           cfa_temp.offset |= INTVAL (XEXP (src, 1));
2441           break;
2442
2443           /* Skip over HIGH, assuming it will be followed by a LO_SUM,
2444              which will fill in all of the bits.  */
2445           /* Rule 8 */
2446         case HIGH:
2447           break;
2448
2449           /* Rule 15 */
2450         case UNSPEC:
2451         case UNSPEC_VOLATILE:
2452           gcc_assert (targetm.dwarf_handle_frame_unspec);
2453           targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1));
2454           return;
2455
2456           /* Rule 16 */
2457         case AND:
2458           /* If this AND operation happens on stack pointer in prologue,
2459              we assume the stack is realigned and we extract the
2460              alignment.  */
2461           if (fde && XEXP (src, 0) == stack_pointer_rtx)
2462             {
2463               /* We interpret reg_save differently with stack_realign set.
2464                  Thus we must flush whatever we have queued first.  */
2465               dwarf2out_flush_queued_reg_saves ();
2466
2467               gcc_assert (cfa_store.reg == REGNO (XEXP (src, 0)));
2468               fde->stack_realign = 1;
2469               fde->stack_realignment = INTVAL (XEXP (src, 1));
2470               cfa_store.offset = 0;
2471
2472               if (cfa.reg != STACK_POINTER_REGNUM
2473                   && cfa.reg != HARD_FRAME_POINTER_REGNUM)
2474                 fde->drap_reg = cfa.reg;
2475             }
2476           return;
2477
2478         default:
2479           gcc_unreachable ();
2480         }
2481
2482       def_cfa_1 (label, &cfa);
2483       break;
2484
2485     case MEM:
2486
2487       /* Saving a register to the stack.  Make sure dest is relative to the
2488          CFA register.  */
2489       switch (GET_CODE (XEXP (dest, 0)))
2490         {
2491           /* Rule 10 */
2492           /* With a push.  */
2493         case PRE_MODIFY:
2494           /* We can't handle variable size modifications.  */
2495           gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
2496                       == CONST_INT);
2497           offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
2498
2499           gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
2500                       && cfa_store.reg == STACK_POINTER_REGNUM);
2501
2502           cfa_store.offset += offset;
2503           if (cfa.reg == STACK_POINTER_REGNUM)
2504             cfa.offset = cfa_store.offset;
2505
2506           offset = -cfa_store.offset;
2507           break;
2508
2509           /* Rule 11 */
2510         case PRE_INC:
2511         case PRE_DEC:
2512           offset = GET_MODE_SIZE (GET_MODE (dest));
2513           if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
2514             offset = -offset;
2515
2516           gcc_assert ((REGNO (XEXP (XEXP (dest, 0), 0))
2517                        == STACK_POINTER_REGNUM)
2518                       && cfa_store.reg == STACK_POINTER_REGNUM);
2519
2520           cfa_store.offset += offset;
2521
2522           /* Rule 18: If stack is aligned, we will use FP as a
2523              reference to represent the address of the stored
2524              regiser.  */
2525           if (fde
2526               && fde->stack_realign
2527               && src == hard_frame_pointer_rtx)
2528             {
2529               gcc_assert (cfa.reg != HARD_FRAME_POINTER_REGNUM);
2530               cfa_store.offset = 0;
2531             }
2532
2533           if (cfa.reg == STACK_POINTER_REGNUM)
2534             cfa.offset = cfa_store.offset;
2535
2536           offset = -cfa_store.offset;
2537           break;
2538
2539           /* Rule 12 */
2540           /* With an offset.  */
2541         case PLUS:
2542         case MINUS:
2543         case LO_SUM:
2544           {
2545             int regno;
2546
2547             gcc_assert (CONST_INT_P (XEXP (XEXP (dest, 0), 1))
2548                         && REG_P (XEXP (XEXP (dest, 0), 0)));
2549             offset = INTVAL (XEXP (XEXP (dest, 0), 1));
2550             if (GET_CODE (XEXP (dest, 0)) == MINUS)
2551               offset = -offset;
2552
2553             regno = REGNO (XEXP (XEXP (dest, 0), 0));
2554
2555             if (cfa.reg == (unsigned) regno)
2556               offset -= cfa.offset;
2557             else if (cfa_store.reg == (unsigned) regno)
2558               offset -= cfa_store.offset;
2559             else
2560               {
2561                 gcc_assert (cfa_temp.reg == (unsigned) regno);
2562                 offset -= cfa_temp.offset;
2563               }
2564           }
2565           break;
2566
2567           /* Rule 13 */
2568           /* Without an offset.  */
2569         case REG:
2570           {
2571             int regno = REGNO (XEXP (dest, 0));
2572
2573             if (cfa.reg == (unsigned) regno)
2574               offset = -cfa.offset;
2575             else if (cfa_store.reg == (unsigned) regno)
2576               offset = -cfa_store.offset;
2577             else
2578               {
2579                 gcc_assert (cfa_temp.reg == (unsigned) regno);
2580                 offset = -cfa_temp.offset;
2581               }
2582           }
2583           break;
2584
2585           /* Rule 14 */
2586         case POST_INC:
2587           gcc_assert (cfa_temp.reg
2588                       == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)));
2589           offset = -cfa_temp.offset;
2590           cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
2591           break;
2592
2593         default:
2594           gcc_unreachable ();
2595         }
2596
2597         /* Rule 17 */
2598         /* If the source operand of this MEM operation is not a
2599            register, basically the source is return address.  Here
2600            we only care how much stack grew and we don't save it.  */
2601       if (!REG_P (src))
2602         break;
2603
2604       if (REGNO (src) != STACK_POINTER_REGNUM
2605           && REGNO (src) != HARD_FRAME_POINTER_REGNUM
2606           && (unsigned) REGNO (src) == cfa.reg)
2607         {
2608           /* We're storing the current CFA reg into the stack.  */
2609
2610           if (cfa.offset == 0)
2611             {
2612               /* Rule 19 */
2613               /* If stack is aligned, putting CFA reg into stack means
2614                  we can no longer use reg + offset to represent CFA.
2615                  Here we use DW_CFA_def_cfa_expression instead.  The
2616                  result of this expression equals to the original CFA
2617                  value.  */
2618               if (fde
2619                   && fde->stack_realign
2620                   && cfa.indirect == 0
2621                   && cfa.reg != HARD_FRAME_POINTER_REGNUM)
2622                 {
2623                   dw_cfa_location cfa_exp;
2624
2625                   gcc_assert (fde->drap_reg == cfa.reg);
2626
2627                   cfa_exp.indirect = 1;
2628                   cfa_exp.reg = HARD_FRAME_POINTER_REGNUM;
2629                   cfa_exp.base_offset = offset;
2630                   cfa_exp.offset = 0;
2631
2632                   fde->drap_reg_saved = 1;
2633
2634                   def_cfa_1 (label, &cfa_exp);
2635                   break;
2636                 }
2637
2638               /* If the source register is exactly the CFA, assume
2639                  we're saving SP like any other register; this happens
2640                  on the ARM.  */
2641               def_cfa_1 (label, &cfa);
2642               queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset);
2643               break;
2644             }
2645           else
2646             {
2647               /* Otherwise, we'll need to look in the stack to
2648                  calculate the CFA.  */
2649               rtx x = XEXP (dest, 0);
2650
2651               if (!REG_P (x))
2652                 x = XEXP (x, 0);
2653               gcc_assert (REG_P (x));
2654
2655               cfa.reg = REGNO (x);
2656               cfa.base_offset = offset;
2657               cfa.indirect = 1;
2658               def_cfa_1 (label, &cfa);
2659               break;
2660             }
2661         }
2662
2663       def_cfa_1 (label, &cfa);
2664       {
2665         span = targetm.dwarf_register_span (src);
2666
2667         if (!span)
2668           queue_reg_save (label, src, NULL_RTX, offset);
2669         else
2670           {
2671             /* We have a PARALLEL describing where the contents of SRC
2672                live.  Queue register saves for each piece of the
2673                PARALLEL.  */
2674             int par_index;
2675             int limit;
2676             HOST_WIDE_INT span_offset = offset;
2677
2678             gcc_assert (GET_CODE (span) == PARALLEL);
2679
2680             limit = XVECLEN (span, 0);
2681             for (par_index = 0; par_index < limit; par_index++)
2682               {
2683                 rtx elem = XVECEXP (span, 0, par_index);
2684
2685                 queue_reg_save (label, elem, NULL_RTX, span_offset);
2686                 span_offset += GET_MODE_SIZE (GET_MODE (elem));
2687               }
2688           }
2689       }
2690       break;
2691
2692     default:
2693       gcc_unreachable ();
2694     }
2695 }
2696
2697 /* Record call frame debugging information for INSN, which either
2698    sets SP or FP (adjusting how we calculate the frame address) or saves a
2699    register to the stack.  If INSN is NULL_RTX, initialize our state.
2700
2701    If AFTER_P is false, we're being called before the insn is emitted,
2702    otherwise after.  Call instructions get invoked twice.  */
2703
2704 void
2705 dwarf2out_frame_debug (rtx insn, bool after_p)
2706 {
2707   const char *label;
2708   rtx note, n;
2709   bool handled_one = false;
2710
2711   if (insn == NULL_RTX)
2712     {
2713       size_t i;
2714
2715       /* Flush any queued register saves.  */
2716       dwarf2out_flush_queued_reg_saves ();
2717
2718       /* Set up state for generating call frame debug info.  */
2719       lookup_cfa (&cfa);
2720       gcc_assert (cfa.reg
2721                   == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
2722
2723       cfa.reg = STACK_POINTER_REGNUM;
2724       cfa_store = cfa;
2725       cfa_temp.reg = -1;
2726       cfa_temp.offset = 0;
2727
2728       for (i = 0; i < num_regs_saved_in_regs; i++)
2729         {
2730           regs_saved_in_regs[i].orig_reg = NULL_RTX;
2731           regs_saved_in_regs[i].saved_in_reg = NULL_RTX;
2732         }
2733       num_regs_saved_in_regs = 0;
2734
2735       if (barrier_args_size)
2736         {
2737           XDELETEVEC (barrier_args_size);
2738           barrier_args_size = NULL;
2739         }
2740       return;
2741     }
2742
2743   if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn))
2744     dwarf2out_flush_queued_reg_saves ();
2745
2746   if (!RTX_FRAME_RELATED_P (insn))
2747     {
2748       /* ??? This should be done unconditionally since stack adjustments
2749          matter if the stack pointer is not the CFA register anymore but
2750          is still used to save registers.  */
2751       if (!ACCUMULATE_OUTGOING_ARGS)
2752         dwarf2out_notice_stack_adjust (insn, after_p);
2753       return;
2754     }
2755
2756   label = dwarf2out_cfi_label (false);
2757   any_cfis_emitted = false;
2758
2759   for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
2760     switch (REG_NOTE_KIND (note))
2761       {
2762       case REG_FRAME_RELATED_EXPR:
2763         insn = XEXP (note, 0);
2764         goto found;
2765
2766       case REG_CFA_DEF_CFA:
2767         dwarf2out_frame_debug_def_cfa (XEXP (note, 0), label);
2768         handled_one = true;
2769         break;
2770
2771       case REG_CFA_ADJUST_CFA:
2772         n = XEXP (note, 0);
2773         if (n == NULL)
2774           {
2775             n = PATTERN (insn);
2776             if (GET_CODE (n) == PARALLEL)
2777               n = XVECEXP (n, 0, 0);
2778           }
2779         dwarf2out_frame_debug_adjust_cfa (n, label);
2780         handled_one = true;
2781         break;
2782
2783       case REG_CFA_OFFSET:
2784         n = XEXP (note, 0);
2785         if (n == NULL)
2786           n = single_set (insn);
2787         dwarf2out_frame_debug_cfa_offset (n, label);
2788         handled_one = true;
2789         break;
2790
2791       case REG_CFA_REGISTER:
2792         n = XEXP (note, 0);
2793         if (n == NULL)
2794           {
2795             n = PATTERN (insn);
2796             if (GET_CODE (n) == PARALLEL)
2797               n = XVECEXP (n, 0, 0);
2798           }
2799         dwarf2out_frame_debug_cfa_register (n, label);
2800         handled_one = true;
2801         break;
2802
2803       case REG_CFA_EXPRESSION:
2804         n = XEXP (note, 0);
2805         if (n == NULL)
2806           n = single_set (insn);
2807         dwarf2out_frame_debug_cfa_expression (n, label);
2808         handled_one = true;
2809         break;
2810
2811       case REG_CFA_RESTORE:
2812         n = XEXP (note, 0);
2813         if (n == NULL)
2814           {
2815             n = PATTERN (insn);
2816             if (GET_CODE (n) == PARALLEL)
2817               n = XVECEXP (n, 0, 0);
2818             n = XEXP (n, 0);
2819           }
2820         dwarf2out_frame_debug_cfa_restore (n, label);
2821         handled_one = true;
2822         break;
2823
2824       case REG_CFA_SET_VDRAP:
2825         n = XEXP (note, 0);
2826         if (REG_P (n))
2827           {
2828             dw_fde_ref fde = current_fde ();
2829             if (fde)
2830               {
2831                 gcc_assert (fde->vdrap_reg == INVALID_REGNUM);
2832                 if (REG_P (n))
2833                   fde->vdrap_reg = REGNO (n);
2834               }
2835           }
2836         handled_one = true;
2837         break;
2838
2839       default:
2840         break;
2841       }
2842   if (handled_one)
2843     {
2844       if (any_cfis_emitted)
2845         dwarf2out_flush_queued_reg_saves ();
2846       return;
2847     }
2848
2849   insn = PATTERN (insn);
2850  found:
2851   dwarf2out_frame_debug_expr (insn, label);
2852
2853   /* Check again.  A parallel can save and update the same register.
2854      We could probably check just once, here, but this is safer than
2855      removing the check above.  */
2856   if (any_cfis_emitted || clobbers_queued_reg_save (insn))
2857     dwarf2out_flush_queued_reg_saves ();
2858 }
2859
2860 /* Determine if we need to save and restore CFI information around this
2861    epilogue.  If SIBCALL is true, then this is a sibcall epilogue.  If
2862    we do need to save/restore, then emit the save now, and insert a
2863    NOTE_INSN_CFA_RESTORE_STATE at the appropriate place in the stream.  */
2864
2865 void
2866 dwarf2out_cfi_begin_epilogue (rtx insn)
2867 {
2868   bool saw_frp = false;
2869   rtx i;
2870
2871   /* Scan forward to the return insn, noticing if there are possible
2872      frame related insns.  */
2873   for (i = NEXT_INSN (insn); i ; i = NEXT_INSN (i))
2874     {
2875       if (!INSN_P (i))
2876         continue;
2877
2878       /* Look for both regular and sibcalls to end the block.  */
2879       if (returnjump_p (i))
2880         break;
2881       if (CALL_P (i) && SIBLING_CALL_P (i))
2882         break;
2883
2884       if (GET_CODE (PATTERN (i)) == SEQUENCE)
2885         {
2886           int idx;
2887           rtx seq = PATTERN (i);
2888
2889           if (returnjump_p (XVECEXP (seq, 0, 0)))
2890             break;
2891           if (CALL_P (XVECEXP (seq, 0, 0))
2892               && SIBLING_CALL_P (XVECEXP (seq, 0, 0)))
2893             break;
2894
2895           for (idx = 0; idx < XVECLEN (seq, 0); idx++)
2896             if (RTX_FRAME_RELATED_P (XVECEXP (seq, 0, idx)))
2897               saw_frp = true;
2898         }
2899
2900       if (RTX_FRAME_RELATED_P (i))
2901         saw_frp = true;
2902     }
2903
2904   /* If the port doesn't emit epilogue unwind info, we don't need a
2905      save/restore pair.  */
2906   if (!saw_frp)
2907     return;
2908
2909   /* Otherwise, search forward to see if the return insn was the last
2910      basic block of the function.  If so, we don't need save/restore.  */
2911   gcc_assert (i != NULL);
2912   i = next_real_insn (i);
2913   if (i == NULL)
2914     return;
2915
2916   /* Insert the restore before that next real insn in the stream, and before
2917      a potential NOTE_INSN_EPILOGUE_BEG -- we do need these notes to be
2918      properly nested.  This should be after any label or alignment.  This
2919      will be pushed into the CFI stream by the function below.  */
2920   while (1)
2921     {
2922       rtx p = PREV_INSN (i);
2923       if (!NOTE_P (p))
2924         break;
2925       if (NOTE_KIND (p) == NOTE_INSN_BASIC_BLOCK)
2926         break;
2927       i = p;
2928     }
2929   emit_note_before (NOTE_INSN_CFA_RESTORE_STATE, i);
2930
2931   emit_cfa_remember = true;
2932
2933   /* And emulate the state save.  */
2934   gcc_assert (!cfa_remember.in_use);
2935   cfa_remember = cfa;
2936   cfa_remember.in_use = 1;
2937 }
2938
2939 /* A "subroutine" of dwarf2out_cfi_begin_epilogue.  Emit the restore
2940    required.  */
2941
2942 void
2943 dwarf2out_frame_debug_restore_state (void)
2944 {
2945   dw_cfi_ref cfi = new_cfi ();
2946   const char *label = dwarf2out_cfi_label (false);
2947
2948   cfi->dw_cfi_opc = DW_CFA_restore_state;
2949   add_fde_cfi (label, cfi);
2950
2951   gcc_assert (cfa_remember.in_use);
2952   cfa = cfa_remember;
2953   cfa_remember.in_use = 0;
2954 }
2955
2956 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used.  */
2957 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
2958  (enum dwarf_call_frame_info cfi);
2959
2960 static enum dw_cfi_oprnd_type
2961 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
2962 {
2963   switch (cfi)
2964     {
2965     case DW_CFA_nop:
2966     case DW_CFA_GNU_window_save:
2967     case DW_CFA_remember_state:
2968     case DW_CFA_restore_state:
2969       return dw_cfi_oprnd_unused;
2970
2971     case DW_CFA_set_loc:
2972     case DW_CFA_advance_loc1:
2973     case DW_CFA_advance_loc2:
2974     case DW_CFA_advance_loc4:
2975     case DW_CFA_MIPS_advance_loc8:
2976       return dw_cfi_oprnd_addr;
2977
2978     case DW_CFA_offset:
2979     case DW_CFA_offset_extended:
2980     case DW_CFA_def_cfa:
2981     case DW_CFA_offset_extended_sf:
2982     case DW_CFA_def_cfa_sf:
2983     case DW_CFA_restore:
2984     case DW_CFA_restore_extended:
2985     case DW_CFA_undefined:
2986     case DW_CFA_same_value:
2987     case DW_CFA_def_cfa_register:
2988     case DW_CFA_register:
2989     case DW_CFA_expression:
2990       return dw_cfi_oprnd_reg_num;
2991
2992     case DW_CFA_def_cfa_offset:
2993     case DW_CFA_GNU_args_size:
2994     case DW_CFA_def_cfa_offset_sf:
2995       return dw_cfi_oprnd_offset;
2996
2997     case DW_CFA_def_cfa_expression:
2998       return dw_cfi_oprnd_loc;
2999
3000     default:
3001       gcc_unreachable ();
3002     }
3003 }
3004
3005 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used.  */
3006 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
3007  (enum dwarf_call_frame_info cfi);
3008
3009 static enum dw_cfi_oprnd_type
3010 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
3011 {
3012   switch (cfi)
3013     {
3014     case DW_CFA_def_cfa:
3015     case DW_CFA_def_cfa_sf:
3016     case DW_CFA_offset:
3017     case DW_CFA_offset_extended_sf:
3018     case DW_CFA_offset_extended:
3019       return dw_cfi_oprnd_offset;
3020
3021     case DW_CFA_register:
3022       return dw_cfi_oprnd_reg_num;
3023
3024     case DW_CFA_expression:
3025       return dw_cfi_oprnd_loc;
3026
3027     default:
3028       return dw_cfi_oprnd_unused;
3029     }
3030 }
3031
3032 /* Switch [BACK] to eh_frame_section.  If we don't have an eh_frame_section,
3033    switch to the data section instead, and write out a synthetic start label
3034    for collect2 the first time around.  */
3035
3036 static void
3037 switch_to_eh_frame_section (bool back)
3038 {
3039   tree label;
3040
3041 #ifdef EH_FRAME_SECTION_NAME
3042   if (eh_frame_section == 0)
3043     {
3044       int flags;
3045
3046       if (EH_TABLES_CAN_BE_READ_ONLY)
3047         {
3048           int fde_encoding;
3049           int per_encoding;
3050           int lsda_encoding;
3051
3052           fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
3053                                                        /*global=*/0);
3054           per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
3055                                                        /*global=*/1);
3056           lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
3057                                                         /*global=*/0);
3058           flags = ((! flag_pic
3059                     || ((fde_encoding & 0x70) != DW_EH_PE_absptr
3060                         && (fde_encoding & 0x70) != DW_EH_PE_aligned
3061                         && (per_encoding & 0x70) != DW_EH_PE_absptr
3062                         && (per_encoding & 0x70) != DW_EH_PE_aligned
3063                         && (lsda_encoding & 0x70) != DW_EH_PE_absptr
3064                         && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
3065                    ? 0 : SECTION_WRITE);
3066         }
3067       else
3068         flags = SECTION_WRITE;
3069       eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
3070     }
3071 #endif /* EH_FRAME_SECTION_NAME */
3072
3073   if (eh_frame_section)
3074     switch_to_section (eh_frame_section);
3075   else
3076     {
3077       /* We have no special eh_frame section.  Put the information in
3078          the data section and emit special labels to guide collect2.  */
3079       switch_to_section (data_section);
3080
3081       if (!back)
3082         {
3083           label = get_file_function_name ("F");
3084           ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
3085           targetm.asm_out.globalize_label (asm_out_file,
3086                                            IDENTIFIER_POINTER (label));
3087           ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
3088         }
3089     }
3090 }
3091
3092 /* Switch [BACK] to the eh or debug frame table section, depending on
3093    FOR_EH.  */
3094
3095 static void
3096 switch_to_frame_table_section (int for_eh, bool back)
3097 {
3098   if (for_eh)
3099     switch_to_eh_frame_section (back);
3100   else
3101     {
3102       if (!debug_frame_section)
3103         debug_frame_section = get_section (DEBUG_FRAME_SECTION,
3104                                            SECTION_DEBUG, NULL);
3105       switch_to_section (debug_frame_section);
3106     }
3107 }
3108
3109 /* Output a Call Frame Information opcode and its operand(s).  */
3110
3111 static void
3112 output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh)
3113 {
3114   unsigned long r;
3115   HOST_WIDE_INT off;
3116
3117   if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
3118     dw2_asm_output_data (1, (cfi->dw_cfi_opc
3119                              | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)),
3120                          "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX,
3121                          ((unsigned HOST_WIDE_INT)
3122                           cfi->dw_cfi_oprnd1.dw_cfi_offset));
3123   else if (cfi->dw_cfi_opc == DW_CFA_offset)
3124     {
3125       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3126       dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
3127                            "DW_CFA_offset, column %#lx", r);
3128       off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3129       dw2_asm_output_data_uleb128 (off, NULL);
3130     }
3131   else if (cfi->dw_cfi_opc == DW_CFA_restore)
3132     {
3133       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3134       dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
3135                            "DW_CFA_restore, column %#lx", r);
3136     }
3137   else
3138     {
3139       dw2_asm_output_data (1, cfi->dw_cfi_opc,
3140                            "%s", dwarf_cfi_name (cfi->dw_cfi_opc));
3141
3142       switch (cfi->dw_cfi_opc)
3143         {
3144         case DW_CFA_set_loc:
3145           if (for_eh)
3146             dw2_asm_output_encoded_addr_rtx (
3147                 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
3148                 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr),
3149                 false, NULL);
3150           else
3151             dw2_asm_output_addr (DWARF2_ADDR_SIZE,
3152                                  cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL);
3153           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3154           break;
3155
3156         case DW_CFA_advance_loc1:
3157           dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3158                                 fde->dw_fde_current_label, NULL);
3159           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3160           break;
3161
3162         case DW_CFA_advance_loc2:
3163           dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3164                                 fde->dw_fde_current_label, NULL);
3165           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3166           break;
3167
3168         case DW_CFA_advance_loc4:
3169           dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3170                                 fde->dw_fde_current_label, NULL);
3171           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3172           break;
3173
3174         case DW_CFA_MIPS_advance_loc8:
3175           dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3176                                 fde->dw_fde_current_label, NULL);
3177           fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3178           break;
3179
3180         case DW_CFA_offset_extended:
3181           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3182           dw2_asm_output_data_uleb128 (r, NULL);
3183           off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3184           dw2_asm_output_data_uleb128 (off, NULL);
3185           break;
3186
3187         case DW_CFA_def_cfa:
3188           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3189           dw2_asm_output_data_uleb128 (r, NULL);
3190           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
3191           break;
3192
3193         case DW_CFA_offset_extended_sf:
3194           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3195           dw2_asm_output_data_uleb128 (r, NULL);
3196           off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3197           dw2_asm_output_data_sleb128 (off, NULL);
3198           break;
3199
3200         case DW_CFA_def_cfa_sf:
3201           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3202           dw2_asm_output_data_uleb128 (r, NULL);
3203           off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3204           dw2_asm_output_data_sleb128 (off, NULL);
3205           break;
3206
3207         case DW_CFA_restore_extended:
3208         case DW_CFA_undefined:
3209         case DW_CFA_same_value:
3210         case DW_CFA_def_cfa_register:
3211           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3212           dw2_asm_output_data_uleb128 (r, NULL);
3213           break;
3214
3215         case DW_CFA_register:
3216           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3217           dw2_asm_output_data_uleb128 (r, NULL);
3218           r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh);
3219           dw2_asm_output_data_uleb128 (r, NULL);
3220           break;
3221
3222         case DW_CFA_def_cfa_offset:
3223         case DW_CFA_GNU_args_size:
3224           dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
3225           break;
3226
3227         case DW_CFA_def_cfa_offset_sf:
3228           off = div_data_align (cfi->dw_cfi_oprnd1.dw_cfi_offset);
3229           dw2_asm_output_data_sleb128 (off, NULL);
3230           break;
3231
3232         case DW_CFA_GNU_window_save:
3233           break;
3234
3235         case DW_CFA_def_cfa_expression:
3236         case DW_CFA_expression:
3237           output_cfa_loc (cfi);
3238           break;
3239
3240         case DW_CFA_GNU_negative_offset_extended:
3241           /* Obsoleted by DW_CFA_offset_extended_sf.  */
3242           gcc_unreachable ();
3243
3244         default:
3245           break;
3246         }
3247     }
3248 }
3249
3250 /* Similar, but do it via assembler directives instead.  */
3251
3252 static void
3253 output_cfi_directive (dw_cfi_ref cfi)
3254 {
3255   unsigned long r, r2;
3256
3257   switch (cfi->dw_cfi_opc)
3258     {
3259     case DW_CFA_advance_loc:
3260     case DW_CFA_advance_loc1:
3261     case DW_CFA_advance_loc2:
3262     case DW_CFA_advance_loc4:
3263     case DW_CFA_MIPS_advance_loc8:
3264     case DW_CFA_set_loc:
3265       /* Should only be created by add_fde_cfi in a code path not
3266          followed when emitting via directives.  The assembler is
3267          going to take care of this for us.  */
3268       gcc_unreachable ();
3269
3270     case DW_CFA_offset:
3271     case DW_CFA_offset_extended:
3272     case DW_CFA_offset_extended_sf:
3273       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3274       fprintf (asm_out_file, "\t.cfi_offset %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
3275                r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
3276       break;
3277
3278     case DW_CFA_restore:
3279     case DW_CFA_restore_extended:
3280       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3281       fprintf (asm_out_file, "\t.cfi_restore %lu\n", r);
3282       break;
3283
3284     case DW_CFA_undefined:
3285       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3286       fprintf (asm_out_file, "\t.cfi_undefined %lu\n", r);
3287       break;
3288
3289     case DW_CFA_same_value:
3290       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3291       fprintf (asm_out_file, "\t.cfi_same_value %lu\n", r);
3292       break;
3293
3294     case DW_CFA_def_cfa:
3295     case DW_CFA_def_cfa_sf:
3296       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3297       fprintf (asm_out_file, "\t.cfi_def_cfa %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
3298                r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
3299       break;
3300
3301     case DW_CFA_def_cfa_register:
3302       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3303       fprintf (asm_out_file, "\t.cfi_def_cfa_register %lu\n", r);
3304       break;
3305
3306     case DW_CFA_register:
3307       r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3308       r2 = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, 1);
3309       fprintf (asm_out_file, "\t.cfi_register %lu, %lu\n", r, r2);
3310       break;
3311
3312     case DW_CFA_def_cfa_offset:
3313     case DW_CFA_def_cfa_offset_sf:
3314       fprintf (asm_out_file, "\t.cfi_def_cfa_offset "
3315                HOST_WIDE_INT_PRINT_DEC"\n",
3316                cfi->dw_cfi_oprnd1.dw_cfi_offset);
3317       break;
3318
3319     case DW_CFA_remember_state:
3320       fprintf (asm_out_file, "\t.cfi_remember_state\n");
3321       break;
3322     case DW_CFA_restore_state:
3323       fprintf (asm_out_file, "\t.cfi_restore_state\n");
3324       break;
3325
3326     case DW_CFA_GNU_args_size:
3327       fprintf (asm_out_file, "\t.cfi_escape %#x,", DW_CFA_GNU_args_size);
3328       dw2_asm_output_data_uleb128_raw (cfi->dw_cfi_oprnd1.dw_cfi_offset);
3329       if (flag_debug_asm)
3330         fprintf (asm_out_file, "\t%s args_size "HOST_WIDE_INT_PRINT_DEC,
3331                  ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset);
3332       fputc ('\n', asm_out_file);
3333       break;
3334
3335     case DW_CFA_GNU_window_save:
3336       fprintf (asm_out_file, "\t.cfi_window_save\n");
3337       break;
3338
3339     case DW_CFA_def_cfa_expression:
3340     case DW_CFA_expression:
3341       fprintf (asm_out_file, "\t.cfi_escape %#x,", cfi->dw_cfi_opc);
3342       output_cfa_loc_raw (cfi);
3343       fputc ('\n', asm_out_file);
3344       break;
3345
3346     default:
3347       gcc_unreachable ();
3348     }
3349 }
3350
3351 DEF_VEC_P (dw_cfi_ref);
3352 DEF_VEC_ALLOC_P (dw_cfi_ref, heap);
3353
3354 /* Output CFIs to bring current FDE to the same state as after executing
3355    CFIs in CFI chain.  DO_CFI_ASM is true if .cfi_* directives shall
3356    be emitted, false otherwise.  If it is false, FDE and FOR_EH are the
3357    other arguments to pass to output_cfi.  */
3358
3359 static void
3360 output_cfis (dw_cfi_ref cfi, bool do_cfi_asm, dw_fde_ref fde, bool for_eh)
3361 {
3362   struct dw_cfi_struct cfi_buf;
3363   dw_cfi_ref cfi2;
3364   dw_cfi_ref cfi_args_size = NULL, cfi_cfa = NULL, cfi_cfa_offset = NULL;
3365   VEC (dw_cfi_ref, heap) *regs = VEC_alloc (dw_cfi_ref, heap, 32);
3366   unsigned int len, idx;
3367
3368   for (;; cfi = cfi->dw_cfi_next)
3369     switch (cfi ? cfi->dw_cfi_opc : DW_CFA_nop)
3370       {
3371       case DW_CFA_advance_loc:
3372       case DW_CFA_advance_loc1:
3373       case DW_CFA_advance_loc2:
3374       case DW_CFA_advance_loc4:
3375       case DW_CFA_MIPS_advance_loc8:
3376       case DW_CFA_set_loc:
3377         /* All advances should be ignored.  */
3378         break;
3379       case DW_CFA_remember_state:
3380         {
3381           dw_cfi_ref args_size = cfi_args_size;
3382
3383           /* Skip everything between .cfi_remember_state and
3384              .cfi_restore_state.  */
3385           for (cfi2 = cfi->dw_cfi_next; cfi2; cfi2 = cfi2->dw_cfi_next)
3386             if (cfi2->dw_cfi_opc == DW_CFA_restore_state)
3387               break;
3388             else if (cfi2->dw_cfi_opc == DW_CFA_GNU_args_size)
3389               args_size = cfi2;
3390             else
3391               gcc_assert (cfi2->dw_cfi_opc != DW_CFA_remember_state);
3392
3393           if (cfi2 == NULL)
3394             goto flush_all;
3395           else
3396             {
3397               cfi = cfi2;
3398               cfi_args_size = args_size;
3399             }
3400           break;
3401         }
3402       case DW_CFA_GNU_args_size:
3403         cfi_args_size = cfi;
3404         break;
3405       case DW_CFA_GNU_window_save:
3406         goto flush_all;
3407       case DW_CFA_offset:
3408       case DW_CFA_offset_extended:
3409       case DW_CFA_offset_extended_sf:
3410       case DW_CFA_restore:
3411       case DW_CFA_restore_extended:
3412       case DW_CFA_undefined:
3413       case DW_CFA_same_value:
3414       case DW_CFA_register:
3415       case DW_CFA_val_offset:
3416       case DW_CFA_val_offset_sf:
3417       case DW_CFA_expression:
3418       case DW_CFA_val_expression:
3419       case DW_CFA_GNU_negative_offset_extended:
3420         if (VEC_length (dw_cfi_ref, regs) <= cfi->dw_cfi_oprnd1.dw_cfi_reg_num)
3421           VEC_safe_grow_cleared (dw_cfi_ref, heap, regs,
3422                                  cfi->dw_cfi_oprnd1.dw_cfi_reg_num + 1);
3423         VEC_replace (dw_cfi_ref, regs, cfi->dw_cfi_oprnd1.dw_cfi_reg_num, cfi);
3424         break;
3425       case DW_CFA_def_cfa:
3426       case DW_CFA_def_cfa_sf:
3427       case DW_CFA_def_cfa_expression:
3428         cfi_cfa = cfi;
3429         cfi_cfa_offset = cfi;
3430         break;
3431       case DW_CFA_def_cfa_register:
3432         cfi_cfa = cfi;
3433         break;
3434       case DW_CFA_def_cfa_offset:
3435       case DW_CFA_def_cfa_offset_sf:
3436         cfi_cfa_offset = cfi;
3437         break;
3438       case DW_CFA_nop:
3439         gcc_assert (cfi == NULL);
3440       flush_all:
3441         len = VEC_length (dw_cfi_ref, regs);
3442         for (idx = 0; idx < len; idx++)
3443           {
3444             cfi2 = VEC_replace (dw_cfi_ref, regs, idx, NULL);
3445             if (cfi2 != NULL
3446                 && cfi2->dw_cfi_opc != DW_CFA_restore
3447                 && cfi2->dw_cfi_opc != DW_CFA_restore_extended)
3448               {
3449                 if (do_cfi_asm)
3450                   output_cfi_directive (cfi2);
3451                 else
3452                   output_cfi (cfi2, fde, for_eh);
3453               }
3454           }
3455         if (cfi_cfa && cfi_cfa_offset && cfi_cfa_offset != cfi_cfa)
3456           {
3457             gcc_assert (cfi_cfa->dw_cfi_opc != DW_CFA_def_cfa_expression);
3458             cfi_buf = *cfi_cfa;
3459             switch (cfi_cfa_offset->dw_cfi_opc)
3460               {
3461               case DW_CFA_def_cfa_offset:
3462                 cfi_buf.dw_cfi_opc = DW_CFA_def_cfa;
3463                 cfi_buf.dw_cfi_oprnd2 = cfi_cfa_offset->dw_cfi_oprnd1;
3464                 break;
3465               case DW_CFA_def_cfa_offset_sf:
3466                 cfi_buf.dw_cfi_opc = DW_CFA_def_cfa_sf;
3467                 cfi_buf.dw_cfi_oprnd2 = cfi_cfa_offset->dw_cfi_oprnd1;
3468                 break;
3469               case DW_CFA_def_cfa:
3470               case DW_CFA_def_cfa_sf:
3471                 cfi_buf.dw_cfi_opc = cfi_cfa_offset->dw_cfi_opc;
3472                 cfi_buf.dw_cfi_oprnd2 = cfi_cfa_offset->dw_cfi_oprnd2;
3473                 break;
3474               default:
3475                 gcc_unreachable ();
3476               }
3477             cfi_cfa = &cfi_buf;
3478           }
3479         else if (cfi_cfa_offset)
3480           cfi_cfa = cfi_cfa_offset;
3481         if (cfi_cfa)
3482           {
3483             if (do_cfi_asm)
3484               output_cfi_directive (cfi_cfa);
3485             else
3486               output_cfi (cfi_cfa, fde, for_eh);
3487           }
3488         cfi_cfa = NULL;
3489         cfi_cfa_offset = NULL;
3490         if (cfi_args_size
3491             && cfi_args_size->dw_cfi_oprnd1.dw_cfi_offset)
3492           {
3493             if (do_cfi_asm)
3494               output_cfi_directive (cfi_args_size);
3495             else
3496               output_cfi (cfi_args_size, fde, for_eh);
3497           }
3498         cfi_args_size = NULL;
3499         if (cfi == NULL)
3500           {
3501             VEC_free (dw_cfi_ref, heap, regs);
3502             return;
3503           }
3504         else if (do_cfi_asm)
3505           output_cfi_directive (cfi);
3506         else
3507           output_cfi (cfi, fde, for_eh);
3508         break;
3509       default:
3510         gcc_unreachable ();
3511     }
3512 }
3513
3514 /* Output one FDE.  */
3515
3516 static void
3517 output_fde (dw_fde_ref fde, bool for_eh, bool second,
3518             char *section_start_label, int fde_encoding, char *augmentation,
3519             bool any_lsda_needed, int lsda_encoding)
3520 {
3521   const char *begin, *end;
3522   static unsigned int j;
3523   char l1[20], l2[20];
3524   dw_cfi_ref cfi;
3525
3526   targetm.asm_out.emit_unwind_label (asm_out_file, fde->decl, for_eh,
3527                                      /* empty */ 0);
3528   targetm.asm_out.internal_label (asm_out_file, FDE_LABEL,
3529                                   for_eh + j);
3530   ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + j);
3531   ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + j);
3532   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
3533     dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
3534                          " indicating 64-bit DWARF extension");
3535   dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
3536                         "FDE Length");
3537   ASM_OUTPUT_LABEL (asm_out_file, l1);
3538
3539   if (for_eh)
3540     dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
3541   else
3542     dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
3543                            debug_frame_section, "FDE CIE offset");
3544
3545   if (!fde->dw_fde_switched_sections)
3546     {
3547       begin = fde->dw_fde_begin;
3548       end = fde->dw_fde_end;
3549     }
3550   else
3551     {
3552       /* For the first section, prefer dw_fde_begin over
3553          dw_fde_{hot,cold}_section_label, as the latter
3554          might be separated from the real start of the
3555          function by alignment padding.  */
3556       if (!second)
3557         begin = fde->dw_fde_begin;
3558       else if (fde->dw_fde_switched_cold_to_hot)
3559         begin = fde->dw_fde_hot_section_label;
3560       else
3561         begin = fde->dw_fde_unlikely_section_label;
3562       if (second ^ fde->dw_fde_switched_cold_to_hot)
3563         end = fde->dw_fde_unlikely_section_end_label;
3564       else
3565         end = fde->dw_fde_hot_section_end_label;
3566     }
3567
3568   if (for_eh)