OSDN Git Service

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