OSDN Git Service

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