OSDN Git Service

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