OSDN Git Service

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