OSDN Git Service

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