OSDN Git Service

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