OSDN Git Service

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