OSDN Git Service

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