OSDN Git Service

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