OSDN Git Service

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