OSDN Git Service

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