OSDN Git Service

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