OSDN Git Service

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