OSDN Git Service

dwarf2: Move CFI output routines to dwarf2cfi.c.
[pf3gnuchains/gcc-fork.git] / gcc / dwarf2out.c
1 /* Output Dwarf2 format symbol table information from GCC.
2    Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3    2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4    Free Software Foundation, Inc.
5    Contributed by Gary Funck (gary@intrepid.com).
6    Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
7    Extensively modified by Jason Merrill (jason@cygnus.com).
8
9 This file is part of GCC.
10
11 GCC is free software; you can redistribute it and/or modify it under
12 the terms of the GNU General Public License as published by the Free
13 Software Foundation; either version 3, or (at your option) any later
14 version.
15
16 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
17 WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
19 for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with GCC; see the file COPYING3.  If not see
23 <http://www.gnu.org/licenses/>.  */
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 /* DWARF2 Abbreviation Glossary:
38
39    CFA = Canonical Frame Address
40            a fixed address on the stack which identifies a call frame.
41            We define it to be the value of SP just before the call insn.
42            The CFA register and offset, which may change during the course
43            of the function, are used to calculate its value at runtime.
44
45    CFI = Call Frame Instruction
46            an instruction for the DWARF2 abstract machine
47
48    CIE = Common Information Entry
49            information describing information common to one or more FDEs
50
51    DIE = Debugging Information Entry
52
53    FDE = Frame Description Entry
54            information describing the stack call frame, in particular,
55            how to restore registers
56
57    DW_CFA_... = DWARF2 CFA call frame instruction
58    DW_TAG_... = DWARF2 DIE tag */
59
60 #include "config.h"
61 #include "system.h"
62 #include "coretypes.h"
63 #include "tm.h"
64 #include "tree.h"
65 #include "version.h"
66 #include "flags.h"
67 #include "rtl.h"
68 #include "hard-reg-set.h"
69 #include "regs.h"
70 #include "insn-config.h"
71 #include "reload.h"
72 #include "function.h"
73 #include "output.h"
74 #include "expr.h"
75 #include "libfuncs.h"
76 #include "except.h"
77 #include "dwarf2.h"
78 #include "dwarf2out.h"
79 #include "dwarf2asm.h"
80 #include "toplev.h"
81 #include "ggc.h"
82 #include "md5.h"
83 #include "tm_p.h"
84 #include "diagnostic.h"
85 #include "tree-pretty-print.h"
86 #include "debug.h"
87 #include "target.h"
88 #include "common/common-target.h"
89 #include "langhooks.h"
90 #include "hashtab.h"
91 #include "cgraph.h"
92 #include "input.h"
93 #include "gimple.h"
94 #include "tree-pass.h"
95 #include "tree-flow.h"
96 #include "cfglayout.h"
97
98 static void dwarf2out_source_line (unsigned int, const char *, int, bool);
99 static rtx last_var_location_insn;
100
101 #ifdef VMS_DEBUGGING_INFO
102 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
103
104 /* Define this macro to be a nonzero value if the directory specifications
105     which are output in the debug info should end with a separator.  */
106 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
107 /* Define this macro to evaluate to a nonzero value if GCC should refrain
108    from generating indirect strings in DWARF2 debug information, for instance
109    if your target is stuck with an old version of GDB that is unable to
110    process them properly or uses VMS Debug.  */
111 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
112 #else
113 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
114 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
115 #endif
116
117 /* ??? Poison these here until it can be done generically.  They've been
118    totally replaced in this file; make sure it stays that way.  */
119 #undef DWARF2_UNWIND_INFO
120 #undef DWARF2_FRAME_INFO
121 #if (GCC_VERSION >= 3000)
122  #pragma GCC poison DWARF2_UNWIND_INFO DWARF2_FRAME_INFO
123 #endif
124
125 /* The size of the target's pointer type.  */
126 #ifndef PTR_SIZE
127 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
128 #endif
129
130 /* Array of RTXes referenced by the debugging information, which therefore
131    must be kept around forever.  */
132 static GTY(()) VEC(rtx,gc) *used_rtx_array;
133
134 /* A pointer to the base of a list of incomplete types which might be
135    completed at some later time.  incomplete_types_list needs to be a
136    VEC(tree,gc) because we want to tell the garbage collector about
137    it.  */
138 static GTY(()) VEC(tree,gc) *incomplete_types;
139
140 /* A pointer to the base of a table of references to declaration
141    scopes.  This table is a display which tracks the nesting
142    of declaration scopes at the current scope and containing
143    scopes.  This table is used to find the proper place to
144    define type declaration DIE's.  */
145 static GTY(()) VEC(tree,gc) *decl_scope_table;
146
147 /* Pointers to various DWARF2 sections.  */
148 static GTY(()) section *debug_info_section;
149 static GTY(()) section *debug_abbrev_section;
150 static GTY(()) section *debug_aranges_section;
151 static GTY(()) section *debug_macinfo_section;
152 static GTY(()) section *debug_line_section;
153 static GTY(()) section *debug_loc_section;
154 static GTY(()) section *debug_pubnames_section;
155 static GTY(()) section *debug_pubtypes_section;
156 static GTY(()) section *debug_str_section;
157 static GTY(()) section *debug_ranges_section;
158 static GTY(()) section *debug_frame_section;
159
160 /* Maximum size (in bytes) of an artificially generated label.  */
161 #define MAX_ARTIFICIAL_LABEL_BYTES      30
162
163 /* According to the (draft) DWARF 3 specification, the initial length
164    should either be 4 or 12 bytes.  When it's 12 bytes, the first 4
165    bytes are 0xffffffff, followed by the length stored in the next 8
166    bytes.
167
168    However, the SGI/MIPS ABI uses an initial length which is equal to
169    DWARF_OFFSET_SIZE.  It is defined (elsewhere) accordingly.  */
170
171 #ifndef DWARF_INITIAL_LENGTH_SIZE
172 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
173 #endif
174
175 /* Round SIZE up to the nearest BOUNDARY.  */
176 #define DWARF_ROUND(SIZE,BOUNDARY) \
177   ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
178
179 /* CIE identifier.  */
180 #if HOST_BITS_PER_WIDE_INT >= 64
181 #define DWARF_CIE_ID \
182   (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
183 #else
184 #define DWARF_CIE_ID DW_CIE_ID
185 #endif
186
187 DEF_VEC_P (dw_fde_ref);
188 DEF_VEC_ALLOC_P (dw_fde_ref, gc);
189
190 /* A vector for a table that contains frame description
191    information for each routine.  */
192 static GTY(()) VEC(dw_fde_ref, gc) *fde_vec;
193
194 struct GTY(()) indirect_string_node {
195   const char *str;
196   unsigned int refcount;
197   enum dwarf_form form;
198   char *label;
199 };
200
201 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
202
203 static GTY(()) int dw2_string_counter;
204
205 /* True if the compilation unit places functions in more than one section.  */
206 static GTY(()) bool have_multiple_function_sections = false;
207
208 /* Whether the default text and cold text sections have been used at all.  */
209
210 static GTY(()) bool text_section_used = false;
211 static GTY(()) bool cold_text_section_used = false;
212
213 /* The default cold text section.  */
214 static GTY(()) section *cold_text_section;
215
216 /* Forward declarations for functions defined in this file.  */
217
218 static char *stripattributes (const char *);
219 static void output_call_frame_info (int);
220 static void dwarf2out_note_section_used (void);
221
222 /* Personality decl of current unit.  Used only when assembler does not support
223    personality CFI.  */
224 static GTY(()) rtx current_unit_personality;
225
226 /* Data and reference forms for relocatable data.  */
227 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
228 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
229
230 #ifndef DEBUG_FRAME_SECTION
231 #define DEBUG_FRAME_SECTION     ".debug_frame"
232 #endif
233
234 #ifndef FUNC_BEGIN_LABEL
235 #define FUNC_BEGIN_LABEL        "LFB"
236 #endif
237
238 #ifndef FUNC_END_LABEL
239 #define FUNC_END_LABEL          "LFE"
240 #endif
241
242 #ifndef PROLOGUE_END_LABEL
243 #define PROLOGUE_END_LABEL      "LPE"
244 #endif
245
246 #ifndef EPILOGUE_BEGIN_LABEL
247 #define EPILOGUE_BEGIN_LABEL    "LEB"
248 #endif
249
250 #ifndef FRAME_BEGIN_LABEL
251 #define FRAME_BEGIN_LABEL       "Lframe"
252 #endif
253 #define CIE_AFTER_SIZE_LABEL    "LSCIE"
254 #define CIE_END_LABEL           "LECIE"
255 #define FDE_LABEL               "LSFDE"
256 #define FDE_AFTER_SIZE_LABEL    "LASFDE"
257 #define FDE_END_LABEL           "LEFDE"
258 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
259 #define LINE_NUMBER_END_LABEL   "LELT"
260 #define LN_PROLOG_AS_LABEL      "LASLTP"
261 #define LN_PROLOG_END_LABEL     "LELTP"
262 #define DIE_LABEL_PREFIX        "DW"
263 \f
264 /* Match the base name of a file to the base name of a compilation unit. */
265
266 static int
267 matches_main_base (const char *path)
268 {
269   /* Cache the last query. */
270   static const char *last_path = NULL;
271   static int last_match = 0;
272   if (path != last_path)
273     {
274       const char *base;
275       int length = base_of_path (path, &base);
276       last_path = path;
277       last_match = (length == main_input_baselength
278                     && memcmp (base, main_input_basename, length) == 0);
279     }
280   return last_match;
281 }
282
283 #ifdef DEBUG_DEBUG_STRUCT
284
285 static int
286 dump_struct_debug (tree type, enum debug_info_usage usage,
287                    enum debug_struct_file criterion, int generic,
288                    int matches, int result)
289 {
290   /* Find the type name. */
291   tree type_decl = TYPE_STUB_DECL (type);
292   tree t = type_decl;
293   const char *name = 0;
294   if (TREE_CODE (t) == TYPE_DECL)
295     t = DECL_NAME (t);
296   if (t)
297     name = IDENTIFIER_POINTER (t);
298
299   fprintf (stderr, "    struct %d %s %s %s %s %d %p %s\n",
300            criterion,
301            DECL_IN_SYSTEM_HEADER (type_decl) ? "sys" : "usr",
302            matches ? "bas" : "hdr",
303            generic ? "gen" : "ord",
304            usage == DINFO_USAGE_DFN ? ";" :
305              usage == DINFO_USAGE_DIR_USE ? "." : "*",
306            result,
307            (void*) type_decl, name);
308   return result;
309 }
310 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
311   dump_struct_debug (type, usage, criterion, generic, matches, result)
312
313 #else
314
315 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
316   (result)
317
318 #endif
319
320 static bool
321 should_emit_struct_debug (tree type, enum debug_info_usage usage)
322 {
323   enum debug_struct_file criterion;
324   tree type_decl;
325   bool generic = lang_hooks.types.generic_p (type);
326
327   if (generic)
328     criterion = debug_struct_generic[usage];
329   else
330     criterion = debug_struct_ordinary[usage];
331
332   if (criterion == DINFO_STRUCT_FILE_NONE)
333     return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
334   if (criterion == DINFO_STRUCT_FILE_ANY)
335     return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
336
337   type_decl = TYPE_STUB_DECL (TYPE_MAIN_VARIANT (type));
338
339   if (criterion == DINFO_STRUCT_FILE_SYS && DECL_IN_SYSTEM_HEADER (type_decl))
340     return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
341
342   if (matches_main_base (DECL_SOURCE_FILE (type_decl)))
343     return DUMP_GSTRUCT (type, usage, criterion, generic, true, true);
344   return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
345 }
346 \f
347 /* Return a pointer to a copy of the section string name S with all
348    attributes stripped off, and an asterisk prepended (for assemble_name).  */
349
350 static inline char *
351 stripattributes (const char *s)
352 {
353   char *stripped = XNEWVEC (char, strlen (s) + 2);
354   char *p = stripped;
355
356   *p++ = '*';
357
358   while (*s && *s != ',')
359     *p++ = *s++;
360
361   *p = '\0';
362   return stripped;
363 }
364
365 /* Switch [BACK] to eh_frame_section.  If we don't have an eh_frame_section,
366    switch to the data section instead, and write out a synthetic start label
367    for collect2 the first time around.  */
368
369 static void
370 switch_to_eh_frame_section (bool back)
371 {
372   tree label;
373
374 #ifdef EH_FRAME_SECTION_NAME
375   if (eh_frame_section == 0)
376     {
377       int flags;
378
379       if (EH_TABLES_CAN_BE_READ_ONLY)
380         {
381           int fde_encoding;
382           int per_encoding;
383           int lsda_encoding;
384
385           fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
386                                                        /*global=*/0);
387           per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
388                                                        /*global=*/1);
389           lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
390                                                         /*global=*/0);
391           flags = ((! flag_pic
392                     || ((fde_encoding & 0x70) != DW_EH_PE_absptr
393                         && (fde_encoding & 0x70) != DW_EH_PE_aligned
394                         && (per_encoding & 0x70) != DW_EH_PE_absptr
395                         && (per_encoding & 0x70) != DW_EH_PE_aligned
396                         && (lsda_encoding & 0x70) != DW_EH_PE_absptr
397                         && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
398                    ? 0 : SECTION_WRITE);
399         }
400       else
401         flags = SECTION_WRITE;
402       eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
403     }
404 #endif /* EH_FRAME_SECTION_NAME */
405
406   if (eh_frame_section)
407     switch_to_section (eh_frame_section);
408   else
409     {
410       /* We have no special eh_frame section.  Put the information in
411          the data section and emit special labels to guide collect2.  */
412       switch_to_section (data_section);
413
414       if (!back)
415         {
416           label = get_file_function_name ("F");
417           ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
418           targetm.asm_out.globalize_label (asm_out_file,
419                                            IDENTIFIER_POINTER (label));
420           ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
421         }
422     }
423 }
424
425 /* Switch [BACK] to the eh or debug frame table section, depending on
426    FOR_EH.  */
427
428 static void
429 switch_to_frame_table_section (int for_eh, bool back)
430 {
431   if (for_eh)
432     switch_to_eh_frame_section (back);
433   else
434     {
435       if (!debug_frame_section)
436         debug_frame_section = get_section (DEBUG_FRAME_SECTION,
437                                            SECTION_DEBUG, NULL);
438       switch_to_section (debug_frame_section);
439     }
440 }
441
442 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used.  */
443
444 enum dw_cfi_oprnd_type
445 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
446 {
447   switch (cfi)
448     {
449     case DW_CFA_nop:
450     case DW_CFA_GNU_window_save:
451     case DW_CFA_remember_state:
452     case DW_CFA_restore_state:
453       return dw_cfi_oprnd_unused;
454
455     case DW_CFA_set_loc:
456     case DW_CFA_advance_loc1:
457     case DW_CFA_advance_loc2:
458     case DW_CFA_advance_loc4:
459     case DW_CFA_MIPS_advance_loc8:
460       return dw_cfi_oprnd_addr;
461
462     case DW_CFA_offset:
463     case DW_CFA_offset_extended:
464     case DW_CFA_def_cfa:
465     case DW_CFA_offset_extended_sf:
466     case DW_CFA_def_cfa_sf:
467     case DW_CFA_restore:
468     case DW_CFA_restore_extended:
469     case DW_CFA_undefined:
470     case DW_CFA_same_value:
471     case DW_CFA_def_cfa_register:
472     case DW_CFA_register:
473     case DW_CFA_expression:
474       return dw_cfi_oprnd_reg_num;
475
476     case DW_CFA_def_cfa_offset:
477     case DW_CFA_GNU_args_size:
478     case DW_CFA_def_cfa_offset_sf:
479       return dw_cfi_oprnd_offset;
480
481     case DW_CFA_def_cfa_expression:
482       return dw_cfi_oprnd_loc;
483
484     default:
485       gcc_unreachable ();
486     }
487 }
488
489 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used.  */
490
491 enum dw_cfi_oprnd_type
492 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
493 {
494   switch (cfi)
495     {
496     case DW_CFA_def_cfa:
497     case DW_CFA_def_cfa_sf:
498     case DW_CFA_offset:
499     case DW_CFA_offset_extended_sf:
500     case DW_CFA_offset_extended:
501       return dw_cfi_oprnd_offset;
502
503     case DW_CFA_register:
504       return dw_cfi_oprnd_reg_num;
505
506     case DW_CFA_expression:
507       return dw_cfi_oprnd_loc;
508
509     default:
510       return dw_cfi_oprnd_unused;
511     }
512 }
513
514 /* Output one FDE.  */
515
516 static void
517 output_fde (dw_fde_ref fde, bool for_eh, bool second,
518             char *section_start_label, int fde_encoding, char *augmentation,
519             bool any_lsda_needed, int lsda_encoding)
520 {
521   int ix;
522   const char *begin, *end;
523   static unsigned int j;
524   char l1[20], l2[20];
525   dw_cfi_ref cfi;
526
527   targetm.asm_out.emit_unwind_label (asm_out_file, fde->decl, for_eh,
528                                      /* empty */ 0);
529   targetm.asm_out.internal_label (asm_out_file, FDE_LABEL,
530                                   for_eh + j);
531   ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + j);
532   ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + j);
533   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
534     dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
535                          " indicating 64-bit DWARF extension");
536   dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
537                         "FDE Length");
538   ASM_OUTPUT_LABEL (asm_out_file, l1);
539
540   if (for_eh)
541     dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
542   else
543     dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
544                            debug_frame_section, "FDE CIE offset");
545
546   begin = second ? fde->dw_fde_second_begin : fde->dw_fde_begin;
547   end = second ? fde->dw_fde_second_end : fde->dw_fde_end;
548
549   if (for_eh)
550     {
551       rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, begin);
552       SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
553       dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref, false,
554                                        "FDE initial location");
555       dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
556                             end, begin, "FDE address range");
557     }
558   else
559     {
560       dw2_asm_output_addr (DWARF2_ADDR_SIZE, begin, "FDE initial location");
561       dw2_asm_output_delta (DWARF2_ADDR_SIZE, end, begin, "FDE address range");
562     }
563
564   if (augmentation[0])
565     {
566       if (any_lsda_needed)
567         {
568           int size = size_of_encoded_value (lsda_encoding);
569
570           if (lsda_encoding == DW_EH_PE_aligned)
571             {
572               int offset = (  4         /* Length */
573                             + 4         /* CIE offset */
574                             + 2 * size_of_encoded_value (fde_encoding)
575                             + 1         /* Augmentation size */ );
576               int pad = -offset & (PTR_SIZE - 1);
577
578               size += pad;
579               gcc_assert (size_of_uleb128 (size) == 1);
580             }
581
582           dw2_asm_output_data_uleb128 (size, "Augmentation size");
583
584           if (fde->uses_eh_lsda)
585             {
586               ASM_GENERATE_INTERNAL_LABEL (l1, second ? "LLSDAC" : "LLSDA",
587                                            fde->funcdef_number);
588               dw2_asm_output_encoded_addr_rtx (lsda_encoding,
589                                                gen_rtx_SYMBOL_REF (Pmode, l1),
590                                                false,
591                                                "Language Specific Data Area");
592             }
593           else
594             {
595               if (lsda_encoding == DW_EH_PE_aligned)
596                 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
597               dw2_asm_output_data (size_of_encoded_value (lsda_encoding), 0,
598                                    "Language Specific Data Area (none)");
599             }
600         }
601       else
602         dw2_asm_output_data_uleb128 (0, "Augmentation size");
603     }
604
605   /* Loop through the Call Frame Instructions associated with
606      this FDE.  */
607   fde->dw_fde_current_label = begin;
608   if (fde->dw_fde_second_begin == NULL)
609     FOR_EACH_VEC_ELT (dw_cfi_ref, fde->dw_fde_cfi, ix, cfi)
610       output_cfi (cfi, fde, for_eh);
611   else if (!second)
612     {
613       if (fde->dw_fde_switch_cfi_index > 0)
614         FOR_EACH_VEC_ELT (dw_cfi_ref, fde->dw_fde_cfi, ix, cfi)
615           {
616             if (ix == fde->dw_fde_switch_cfi_index)
617               break;
618             output_cfi (cfi, fde, for_eh);
619           }
620     }
621   else
622     {
623       int i, from = 0;
624       int until = VEC_length (dw_cfi_ref, fde->dw_fde_cfi);
625
626       if (fde->dw_fde_switch_cfi_index > 0)
627         {
628           from = fde->dw_fde_switch_cfi_index;
629           output_cfis (fde->dw_fde_cfi, from, false, fde, for_eh);
630         }
631       for (i = from; i < until; i++)
632         output_cfi (VEC_index (dw_cfi_ref, fde->dw_fde_cfi, i),
633                     fde, for_eh);
634     }
635
636   /* If we are to emit a ref/link from function bodies to their frame tables,
637      do it now.  This is typically performed to make sure that tables
638      associated with functions are dragged with them and not discarded in
639      garbage collecting links. We need to do this on a per function basis to
640      cope with -ffunction-sections.  */
641
642 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
643   /* Switch to the function section, emit the ref to the tables, and
644      switch *back* into the table section.  */
645   switch_to_section (function_section (fde->decl));
646   ASM_OUTPUT_DWARF_TABLE_REF (section_start_label);
647   switch_to_frame_table_section (for_eh, true);
648 #endif
649
650   /* Pad the FDE out to an address sized boundary.  */
651   ASM_OUTPUT_ALIGN (asm_out_file,
652                     floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
653   ASM_OUTPUT_LABEL (asm_out_file, l2);
654
655   j += 2;
656 }
657
658 /* Return true if frame description entry FDE is needed for EH.  */
659
660 static bool
661 fde_needed_for_eh_p (dw_fde_ref fde)
662 {
663   if (flag_asynchronous_unwind_tables)
664     return true;
665
666   if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde->decl))
667     return true;
668
669   if (fde->uses_eh_lsda)
670     return true;
671
672   /* If exceptions are enabled, we have collected nothrow info.  */
673   if (flag_exceptions && (fde->all_throwers_are_sibcalls || fde->nothrow))
674     return false;
675
676   return true;
677 }
678
679 /* Output the call frame information used to record information
680    that relates to calculating the frame pointer, and records the
681    location of saved registers.  */
682
683 static void
684 output_call_frame_info (int for_eh)
685 {
686   unsigned int i;
687   dw_fde_ref fde;
688   dw_cfi_ref cfi;
689   char l1[20], l2[20], section_start_label[20];
690   bool any_lsda_needed = false;
691   char augmentation[6];
692   int augmentation_size;
693   int fde_encoding = DW_EH_PE_absptr;
694   int per_encoding = DW_EH_PE_absptr;
695   int lsda_encoding = DW_EH_PE_absptr;
696   int return_reg;
697   rtx personality = NULL;
698   int dw_cie_version;
699
700   /* Don't emit a CIE if there won't be any FDEs.  */
701   if (fde_vec == NULL)
702     return;
703
704   /* Nothing to do if the assembler's doing it all.  */
705   if (dwarf2out_do_cfi_asm ())
706     return;
707
708   /* If we don't have any functions we'll want to unwind out of, don't emit
709      any EH unwind information.  If we make FDEs linkonce, we may have to
710      emit an empty label for an FDE that wouldn't otherwise be emitted.  We
711      want to avoid having an FDE kept around when the function it refers to
712      is discarded.  Example where this matters: a primary function template
713      in C++ requires EH information, an explicit specialization doesn't.  */
714   if (for_eh)
715     {
716       bool any_eh_needed = false;
717
718       FOR_EACH_VEC_ELT (dw_fde_ref, fde_vec, i, fde)
719         {
720           if (fde->uses_eh_lsda)
721             any_eh_needed = any_lsda_needed = true;
722           else if (fde_needed_for_eh_p (fde))
723             any_eh_needed = true;
724           else if (TARGET_USES_WEAK_UNWIND_INFO)
725             targetm.asm_out.emit_unwind_label (asm_out_file, fde->decl, 1, 1);
726         }
727
728       if (!any_eh_needed)
729         return;
730     }
731
732   /* We're going to be generating comments, so turn on app.  */
733   if (flag_debug_asm)
734     app_enable ();
735
736   /* Switch to the proper frame section, first time.  */
737   switch_to_frame_table_section (for_eh, false);
738
739   ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
740   ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
741
742   /* Output the CIE.  */
743   ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
744   ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
745   if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
746     dw2_asm_output_data (4, 0xffffffff,
747       "Initial length escape value indicating 64-bit DWARF extension");
748   dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
749                         "Length of Common Information Entry");
750   ASM_OUTPUT_LABEL (asm_out_file, l1);
751
752   /* Now that the CIE pointer is PC-relative for EH,
753      use 0 to identify the CIE.  */
754   dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
755                        (for_eh ? 0 : DWARF_CIE_ID),
756                        "CIE Identifier Tag");
757
758   /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
759      use CIE version 1, unless that would produce incorrect results
760      due to overflowing the return register column.  */
761   return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
762   dw_cie_version = 1;
763   if (return_reg >= 256 || dwarf_version > 2)
764     dw_cie_version = 3;
765   dw2_asm_output_data (1, dw_cie_version, "CIE Version");
766
767   augmentation[0] = 0;
768   augmentation_size = 0;
769
770   personality = current_unit_personality;
771   if (for_eh)
772     {
773       char *p;
774
775       /* Augmentation:
776          z      Indicates that a uleb128 is present to size the
777                 augmentation section.
778          L      Indicates the encoding (and thus presence) of
779                 an LSDA pointer in the FDE augmentation.
780          R      Indicates a non-default pointer encoding for
781                 FDE code pointers.
782          P      Indicates the presence of an encoding + language
783                 personality routine in the CIE augmentation.  */
784
785       fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
786       per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
787       lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
788
789       p = augmentation + 1;
790       if (personality)
791         {
792           *p++ = 'P';
793           augmentation_size += 1 + size_of_encoded_value (per_encoding);
794           assemble_external_libcall (personality);
795         }
796       if (any_lsda_needed)
797         {
798           *p++ = 'L';
799           augmentation_size += 1;
800         }
801       if (fde_encoding != DW_EH_PE_absptr)
802         {
803           *p++ = 'R';
804           augmentation_size += 1;
805         }
806       if (p > augmentation + 1)
807         {
808           augmentation[0] = 'z';
809           *p = '\0';
810         }
811
812       /* Ug.  Some platforms can't do unaligned dynamic relocations at all.  */
813       if (personality && per_encoding == DW_EH_PE_aligned)
814         {
815           int offset = (  4             /* Length */
816                         + 4             /* CIE Id */
817                         + 1             /* CIE version */
818                         + strlen (augmentation) + 1     /* Augmentation */
819                         + size_of_uleb128 (1)           /* Code alignment */
820                         + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
821                         + 1             /* RA column */
822                         + 1             /* Augmentation size */
823                         + 1             /* Personality encoding */ );
824           int pad = -offset & (PTR_SIZE - 1);
825
826           augmentation_size += pad;
827
828           /* Augmentations should be small, so there's scarce need to
829              iterate for a solution.  Die if we exceed one uleb128 byte.  */
830           gcc_assert (size_of_uleb128 (augmentation_size) == 1);
831         }
832     }
833
834   dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
835   if (dw_cie_version >= 4)
836     {
837       dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "CIE Address Size");
838       dw2_asm_output_data (1, 0, "CIE Segment Size");
839     }
840   dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
841   dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
842                                "CIE Data Alignment Factor");
843
844   if (dw_cie_version == 1)
845     dw2_asm_output_data (1, return_reg, "CIE RA Column");
846   else
847     dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
848
849   if (augmentation[0])
850     {
851       dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
852       if (personality)
853         {
854           dw2_asm_output_data (1, per_encoding, "Personality (%s)",
855                                eh_data_format_name (per_encoding));
856           dw2_asm_output_encoded_addr_rtx (per_encoding,
857                                            personality,
858                                            true, NULL);
859         }
860
861       if (any_lsda_needed)
862         dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
863                              eh_data_format_name (lsda_encoding));
864
865       if (fde_encoding != DW_EH_PE_absptr)
866         dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
867                              eh_data_format_name (fde_encoding));
868     }
869
870   FOR_EACH_VEC_ELT (dw_cfi_ref, cie_cfi_vec, i, cfi)
871     output_cfi (cfi, NULL, for_eh);
872
873   /* Pad the CIE out to an address sized boundary.  */
874   ASM_OUTPUT_ALIGN (asm_out_file,
875                     floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
876   ASM_OUTPUT_LABEL (asm_out_file, l2);
877
878   /* Loop through all of the FDE's.  */
879   FOR_EACH_VEC_ELT (dw_fde_ref, fde_vec, i, fde)
880     {
881       unsigned int k;
882
883       /* Don't emit EH unwind info for leaf functions that don't need it.  */
884       if (for_eh && !fde_needed_for_eh_p (fde))
885         continue;
886
887       for (k = 0; k < (fde->dw_fde_second_begin ? 2 : 1); k++)
888         output_fde (fde, for_eh, k, section_start_label, fde_encoding,
889                     augmentation, any_lsda_needed, lsda_encoding);
890     }
891
892   if (for_eh && targetm.terminate_dw2_eh_frame_info)
893     dw2_asm_output_data (4, 0, "End of Table");
894 #ifdef MIPS_DEBUGGING_INFO
895   /* Work around Irix 6 assembler bug whereby labels at the end of a section
896      get a value of 0.  Putting .align 0 after the label fixes it.  */
897   ASM_OUTPUT_ALIGN (asm_out_file, 0);
898 #endif
899
900   /* Turn off app to make assembly quicker.  */
901   if (flag_debug_asm)
902     app_disable ();
903 }
904
905 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed.  */
906
907 static void
908 dwarf2out_do_cfi_startproc (bool second)
909 {
910   int enc;
911   rtx ref;
912   rtx personality = get_personality_function (current_function_decl);
913
914   fprintf (asm_out_file, "\t.cfi_startproc\n");
915
916   if (personality)
917     {
918       enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
919       ref = personality;
920
921       /* ??? The GAS support isn't entirely consistent.  We have to
922          handle indirect support ourselves, but PC-relative is done
923          in the assembler.  Further, the assembler can't handle any
924          of the weirder relocation types.  */
925       if (enc & DW_EH_PE_indirect)
926         ref = dw2_force_const_mem (ref, true);
927
928       fprintf (asm_out_file, "\t.cfi_personality %#x,", enc);
929       output_addr_const (asm_out_file, ref);
930       fputc ('\n', asm_out_file);
931     }
932
933   if (crtl->uses_eh_lsda)
934     {
935       char lab[20];
936
937       enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
938       ASM_GENERATE_INTERNAL_LABEL (lab, second ? "LLSDAC" : "LLSDA",
939                                    current_function_funcdef_no);
940       ref = gen_rtx_SYMBOL_REF (Pmode, lab);
941       SYMBOL_REF_FLAGS (ref) = SYMBOL_FLAG_LOCAL;
942
943       if (enc & DW_EH_PE_indirect)
944         ref = dw2_force_const_mem (ref, true);
945
946       fprintf (asm_out_file, "\t.cfi_lsda %#x,", enc);
947       output_addr_const (asm_out_file, ref);
948       fputc ('\n', asm_out_file);
949     }
950 }
951
952 /* Allocate CURRENT_FDE.  Immediately initialize all we can, noting that
953    this allocation may be done before pass_final.  */
954
955 dw_fde_ref
956 dwarf2out_alloc_current_fde (void)
957 {
958   dw_fde_ref fde;
959
960   fde = ggc_alloc_cleared_dw_fde_node ();
961   fde->decl = current_function_decl;
962   fde->funcdef_number = current_function_funcdef_no;
963   fde->fde_index = VEC_length (dw_fde_ref, fde_vec);
964   fde->all_throwers_are_sibcalls = crtl->all_throwers_are_sibcalls;
965   fde->uses_eh_lsda = crtl->uses_eh_lsda;
966   fde->nothrow = crtl->nothrow;
967   fde->drap_reg = INVALID_REGNUM;
968   fde->vdrap_reg = INVALID_REGNUM;
969
970   /* Record the FDE associated with this function.  */
971   cfun->fde = fde;
972   VEC_safe_push (dw_fde_ref, gc, fde_vec, fde);
973
974   return fde;
975 }
976
977 /* Output a marker (i.e. a label) for the beginning of a function, before
978    the prologue.  */
979
980 void
981 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
982                           const char *file ATTRIBUTE_UNUSED)
983 {
984   char label[MAX_ARTIFICIAL_LABEL_BYTES];
985   char * dup_label;
986   dw_fde_ref fde;
987   section *fnsec;
988   bool do_frame;
989
990   current_function_func_begin_label = NULL;
991
992   do_frame = dwarf2out_do_frame ();
993
994   /* ??? current_function_func_begin_label is also used by except.c for
995      call-site information.  We must emit this label if it might be used.  */
996   if (!do_frame
997       && (!flag_exceptions
998           || targetm_common.except_unwind_info (&global_options) != UI_TARGET))
999     return;
1000
1001   fnsec = function_section (current_function_decl);
1002   switch_to_section (fnsec);
1003   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
1004                                current_function_funcdef_no);
1005   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
1006                           current_function_funcdef_no);
1007   dup_label = xstrdup (label);
1008   current_function_func_begin_label = dup_label;
1009
1010   /* We can elide the fde allocation if we're not emitting debug info.  */
1011   if (!do_frame)
1012     return;
1013
1014   /* Cater to the various TARGET_ASM_OUTPUT_MI_THUNK implementations that
1015      emit insns as rtx but bypass the bulk of rest_of_compilation, which
1016      would include pass_dwarf2_frame.  If we've not created the FDE yet,
1017      do so now.  */
1018   fde = cfun->fde;
1019   if (fde == NULL)
1020     fde = dwarf2out_alloc_current_fde ();
1021
1022   /* Initialize the bits of CURRENT_FDE that were not available earlier.  */
1023   fde->dw_fde_begin = dup_label;
1024   fde->dw_fde_current_label = dup_label;
1025   fde->in_std_section = (fnsec == text_section
1026                          || (cold_text_section && fnsec == cold_text_section));
1027
1028   /* We only want to output line number information for the genuine dwarf2
1029      prologue case, not the eh frame case.  */
1030 #ifdef DWARF2_DEBUGGING_INFO
1031   if (file)
1032     dwarf2out_source_line (line, file, 0, true);
1033 #endif
1034
1035   if (dwarf2out_do_cfi_asm ())
1036     dwarf2out_do_cfi_startproc (false);
1037   else
1038     {
1039       rtx personality = get_personality_function (current_function_decl);
1040       if (!current_unit_personality)
1041         current_unit_personality = personality;
1042
1043       /* We cannot keep a current personality per function as without CFI
1044          asm, at the point where we emit the CFI data, there is no current
1045          function anymore.  */
1046       if (personality && current_unit_personality != personality)
1047         sorry ("multiple EH personalities are supported only with assemblers "
1048                "supporting .cfi_personality directive");
1049     }
1050 }
1051
1052 /* Output a marker (i.e. a label) for the end of the generated code
1053    for a function prologue.  This gets called *after* the prologue code has
1054    been generated.  */
1055
1056 void
1057 dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED,
1058                         const char *file ATTRIBUTE_UNUSED)
1059 {
1060   char label[MAX_ARTIFICIAL_LABEL_BYTES];
1061
1062   /* Output a label to mark the endpoint of the code generated for this
1063      function.  */
1064   ASM_GENERATE_INTERNAL_LABEL (label, PROLOGUE_END_LABEL,
1065                                current_function_funcdef_no);
1066   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, PROLOGUE_END_LABEL,
1067                           current_function_funcdef_no);
1068   cfun->fde->dw_fde_vms_end_prologue = xstrdup (label);
1069 }
1070
1071 /* Output a marker (i.e. a label) for the beginning of the generated code
1072    for a function epilogue.  This gets called *before* the prologue code has
1073    been generated.  */
1074
1075 void
1076 dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED,
1077                           const char *file ATTRIBUTE_UNUSED)
1078 {
1079   dw_fde_ref fde = cfun->fde;
1080   char label[MAX_ARTIFICIAL_LABEL_BYTES];
1081
1082   if (fde->dw_fde_vms_begin_epilogue)
1083     return;
1084
1085   /* Output a label to mark the endpoint of the code generated for this
1086      function.  */
1087   ASM_GENERATE_INTERNAL_LABEL (label, EPILOGUE_BEGIN_LABEL,
1088                                current_function_funcdef_no);
1089   ASM_OUTPUT_DEBUG_LABEL (asm_out_file, EPILOGUE_BEGIN_LABEL,
1090                           current_function_funcdef_no);
1091   fde->dw_fde_vms_begin_epilogue = xstrdup (label);
1092 }
1093
1094 /* Output a marker (i.e. a label) for the absolute end of the generated code
1095    for a function definition.  This gets called *after* the epilogue code has
1096    been generated.  */
1097
1098 void
1099 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
1100                         const char *file ATTRIBUTE_UNUSED)
1101 {
1102   dw_fde_ref fde;
1103   char label[MAX_ARTIFICIAL_LABEL_BYTES];
1104
1105   last_var_location_insn = NULL_RTX;
1106
1107   if (dwarf2out_do_cfi_asm ())
1108     fprintf (asm_out_file, "\t.cfi_endproc\n");
1109
1110   /* Output a label to mark the endpoint of the code generated for this
1111      function.  */
1112   ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
1113                                current_function_funcdef_no);
1114   ASM_OUTPUT_LABEL (asm_out_file, label);
1115   fde = cfun->fde;
1116   gcc_assert (fde != NULL);
1117   if (fde->dw_fde_second_begin == NULL)
1118     fde->dw_fde_end = xstrdup (label);
1119 }
1120
1121 void
1122 dwarf2out_frame_finish (void)
1123 {
1124   /* Output call frame information.  */
1125   if (targetm.debug_unwind_info () == UI_DWARF2)
1126     output_call_frame_info (0);
1127
1128   /* Output another copy for the unwinder.  */
1129   if ((flag_unwind_tables || flag_exceptions)
1130       && targetm_common.except_unwind_info (&global_options) == UI_DWARF2)
1131     output_call_frame_info (1);
1132 }
1133
1134 /* Note that the current function section is being used for code.  */
1135
1136 static void
1137 dwarf2out_note_section_used (void)
1138 {
1139   section *sec = current_function_section ();
1140   if (sec == text_section)
1141     text_section_used = true;
1142   else if (sec == cold_text_section)
1143     cold_text_section_used = true;
1144 }
1145
1146 static void var_location_switch_text_section (void);
1147 static void set_cur_line_info_table (section *);
1148
1149 void
1150 dwarf2out_switch_text_section (void)
1151 {
1152   section *sect;
1153   dw_fde_ref fde = cfun->fde;
1154
1155   gcc_assert (cfun && fde && fde->dw_fde_second_begin == NULL);
1156
1157   if (!in_cold_section_p)
1158     {
1159       fde->dw_fde_end = crtl->subsections.cold_section_end_label;
1160       fde->dw_fde_second_begin = crtl->subsections.hot_section_label;
1161       fde->dw_fde_second_end = crtl->subsections.hot_section_end_label;
1162     }
1163   else
1164     {
1165       fde->dw_fde_end = crtl->subsections.hot_section_end_label;
1166       fde->dw_fde_second_begin = crtl->subsections.cold_section_label;
1167       fde->dw_fde_second_end = crtl->subsections.cold_section_end_label;
1168     }
1169   have_multiple_function_sections = true;
1170
1171   /* There is no need to mark used sections when not debugging.  */
1172   if (cold_text_section != NULL)
1173     dwarf2out_note_section_used ();
1174
1175   if (dwarf2out_do_cfi_asm ())
1176     fprintf (asm_out_file, "\t.cfi_endproc\n");
1177
1178   /* Now do the real section switch.  */
1179   sect = current_function_section ();
1180   switch_to_section (sect);
1181
1182   fde->second_in_std_section
1183     = (sect == text_section
1184        || (cold_text_section && sect == cold_text_section));
1185
1186   fde->dw_fde_switch_cfi_index = VEC_length (dw_cfi_ref, fde->dw_fde_cfi);
1187
1188   if (dwarf2out_do_cfi_asm ())
1189     {
1190       dwarf2out_do_cfi_startproc (true);
1191       /* As this is a different FDE, insert all current CFI instructions
1192          again.  */
1193       output_cfis (fde->dw_fde_cfi, fde->dw_fde_switch_cfi_index,
1194                    true, fde, true);
1195     }
1196
1197   var_location_switch_text_section ();
1198
1199   set_cur_line_info_table (sect);
1200 }
1201 \f
1202 /* And now, the subset of the debugging information support code necessary
1203    for emitting location expressions.  */
1204
1205 /* Data about a single source file.  */
1206 struct GTY(()) dwarf_file_data {
1207   const char * filename;
1208   int emitted_number;
1209 };
1210
1211 typedef struct GTY(()) deferred_locations_struct
1212 {
1213   tree variable;
1214   dw_die_ref die;
1215 } deferred_locations;
1216
1217 DEF_VEC_O(deferred_locations);
1218 DEF_VEC_ALLOC_O(deferred_locations,gc);
1219
1220 static GTY(()) VEC(deferred_locations, gc) *deferred_locations_list;
1221
1222 DEF_VEC_P(dw_die_ref);
1223 DEF_VEC_ALLOC_P(dw_die_ref,heap);
1224
1225 /* Location lists are ranges + location descriptions for that range,
1226    so you can track variables that are in different places over
1227    their entire life.  */
1228 typedef struct GTY(()) dw_loc_list_struct {
1229   dw_loc_list_ref dw_loc_next;
1230   const char *begin; /* Label for begin address of range */
1231   const char *end;  /* Label for end address of range */
1232   char *ll_symbol; /* Label for beginning of location list.
1233                       Only on head of list */
1234   const char *section; /* Section this loclist is relative to */
1235   dw_loc_descr_ref expr;
1236   hashval_t hash;
1237   /* True if all addresses in this and subsequent lists are known to be
1238      resolved.  */
1239   bool resolved_addr;
1240   /* True if this list has been replaced by dw_loc_next.  */
1241   bool replaced;
1242   bool emitted;
1243   /* True if the range should be emitted even if begin and end
1244      are the same.  */
1245   bool force;
1246 } dw_loc_list_node;
1247
1248 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
1249
1250 /* Convert a DWARF stack opcode into its string name.  */
1251
1252 static const char *
1253 dwarf_stack_op_name (unsigned int op)
1254 {
1255   switch (op)
1256     {
1257     case DW_OP_addr:
1258       return "DW_OP_addr";
1259     case DW_OP_deref:
1260       return "DW_OP_deref";
1261     case DW_OP_const1u:
1262       return "DW_OP_const1u";
1263     case DW_OP_const1s:
1264       return "DW_OP_const1s";
1265     case DW_OP_const2u:
1266       return "DW_OP_const2u";
1267     case DW_OP_const2s:
1268       return "DW_OP_const2s";
1269     case DW_OP_const4u:
1270       return "DW_OP_const4u";
1271     case DW_OP_const4s:
1272       return "DW_OP_const4s";
1273     case DW_OP_const8u:
1274       return "DW_OP_const8u";
1275     case DW_OP_const8s:
1276       return "DW_OP_const8s";
1277     case DW_OP_constu:
1278       return "DW_OP_constu";
1279     case DW_OP_consts:
1280       return "DW_OP_consts";
1281     case DW_OP_dup:
1282       return "DW_OP_dup";
1283     case DW_OP_drop:
1284       return "DW_OP_drop";
1285     case DW_OP_over:
1286       return "DW_OP_over";
1287     case DW_OP_pick:
1288       return "DW_OP_pick";
1289     case DW_OP_swap:
1290       return "DW_OP_swap";
1291     case DW_OP_rot:
1292       return "DW_OP_rot";
1293     case DW_OP_xderef:
1294       return "DW_OP_xderef";
1295     case DW_OP_abs:
1296       return "DW_OP_abs";
1297     case DW_OP_and:
1298       return "DW_OP_and";
1299     case DW_OP_div:
1300       return "DW_OP_div";
1301     case DW_OP_minus:
1302       return "DW_OP_minus";
1303     case DW_OP_mod:
1304       return "DW_OP_mod";
1305     case DW_OP_mul:
1306       return "DW_OP_mul";
1307     case DW_OP_neg:
1308       return "DW_OP_neg";
1309     case DW_OP_not:
1310       return "DW_OP_not";
1311     case DW_OP_or:
1312       return "DW_OP_or";
1313     case DW_OP_plus:
1314       return "DW_OP_plus";
1315     case DW_OP_plus_uconst:
1316       return "DW_OP_plus_uconst";
1317     case DW_OP_shl:
1318       return "DW_OP_shl";
1319     case DW_OP_shr:
1320       return "DW_OP_shr";
1321     case DW_OP_shra:
1322       return "DW_OP_shra";
1323     case DW_OP_xor:
1324       return "DW_OP_xor";
1325     case DW_OP_bra:
1326       return "DW_OP_bra";
1327     case DW_OP_eq:
1328       return "DW_OP_eq";
1329     case DW_OP_ge:
1330       return "DW_OP_ge";
1331     case DW_OP_gt:
1332       return "DW_OP_gt";
1333     case DW_OP_le:
1334       return "DW_OP_le";
1335     case DW_OP_lt:
1336       return "DW_OP_lt";
1337     case DW_OP_ne:
1338       return "DW_OP_ne";
1339     case DW_OP_skip:
1340       return "DW_OP_skip";
1341     case DW_OP_lit0:
1342       return "DW_OP_lit0";
1343     case DW_OP_lit1:
1344       return "DW_OP_lit1";
1345     case DW_OP_lit2:
1346       return "DW_OP_lit2";
1347     case DW_OP_lit3:
1348       return "DW_OP_lit3";
1349     case DW_OP_lit4:
1350       return "DW_OP_lit4";
1351     case DW_OP_lit5:
1352       return "DW_OP_lit5";
1353     case DW_OP_lit6:
1354       return "DW_OP_lit6";
1355     case DW_OP_lit7:
1356       return "DW_OP_lit7";
1357     case DW_OP_lit8:
1358       return "DW_OP_lit8";
1359     case DW_OP_lit9:
1360       return "DW_OP_lit9";
1361     case DW_OP_lit10:
1362       return "DW_OP_lit10";
1363     case DW_OP_lit11:
1364       return "DW_OP_lit11";
1365     case DW_OP_lit12:
1366       return "DW_OP_lit12";
1367     case DW_OP_lit13:
1368       return "DW_OP_lit13";
1369     case DW_OP_lit14:
1370       return "DW_OP_lit14";
1371     case DW_OP_lit15:
1372       return "DW_OP_lit15";
1373     case DW_OP_lit16:
1374       return "DW_OP_lit16";
1375     case DW_OP_lit17:
1376       return "DW_OP_lit17";
1377     case DW_OP_lit18:
1378       return "DW_OP_lit18";
1379     case DW_OP_lit19:
1380       return "DW_OP_lit19";
1381     case DW_OP_lit20:
1382       return "DW_OP_lit20";
1383     case DW_OP_lit21:
1384       return "DW_OP_lit21";
1385     case DW_OP_lit22:
1386       return "DW_OP_lit22";
1387     case DW_OP_lit23:
1388       return "DW_OP_lit23";
1389     case DW_OP_lit24:
1390       return "DW_OP_lit24";
1391     case DW_OP_lit25:
1392       return "DW_OP_lit25";
1393     case DW_OP_lit26:
1394       return "DW_OP_lit26";
1395     case DW_OP_lit27:
1396       return "DW_OP_lit27";
1397     case DW_OP_lit28:
1398       return "DW_OP_lit28";
1399     case DW_OP_lit29:
1400       return "DW_OP_lit29";
1401     case DW_OP_lit30:
1402       return "DW_OP_lit30";
1403     case DW_OP_lit31:
1404       return "DW_OP_lit31";
1405     case DW_OP_reg0:
1406       return "DW_OP_reg0";
1407     case DW_OP_reg1:
1408       return "DW_OP_reg1";
1409     case DW_OP_reg2:
1410       return "DW_OP_reg2";
1411     case DW_OP_reg3:
1412       return "DW_OP_reg3";
1413     case DW_OP_reg4:
1414       return "DW_OP_reg4";
1415     case DW_OP_reg5:
1416       return "DW_OP_reg5";
1417     case DW_OP_reg6:
1418       return "DW_OP_reg6";
1419     case DW_OP_reg7:
1420       return "DW_OP_reg7";
1421     case DW_OP_reg8:
1422       return "DW_OP_reg8";
1423     case DW_OP_reg9:
1424       return "DW_OP_reg9";
1425     case DW_OP_reg10:
1426       return "DW_OP_reg10";
1427     case DW_OP_reg11:
1428       return "DW_OP_reg11";
1429     case DW_OP_reg12:
1430       return "DW_OP_reg12";
1431     case DW_OP_reg13:
1432       return "DW_OP_reg13";
1433     case DW_OP_reg14:
1434       return "DW_OP_reg14";
1435     case DW_OP_reg15:
1436       return "DW_OP_reg15";
1437     case DW_OP_reg16:
1438       return "DW_OP_reg16";
1439     case DW_OP_reg17:
1440       return "DW_OP_reg17";
1441     case DW_OP_reg18:
1442       return "DW_OP_reg18";
1443     case DW_OP_reg19:
1444       return "DW_OP_reg19";
1445     case DW_OP_reg20:
1446       return "DW_OP_reg20";
1447     case DW_OP_reg21:
1448       return "DW_OP_reg21";
1449     case DW_OP_reg22:
1450       return "DW_OP_reg22";
1451     case DW_OP_reg23:
1452       return "DW_OP_reg23";
1453     case DW_OP_reg24:
1454       return "DW_OP_reg24";
1455     case DW_OP_reg25:
1456       return "DW_OP_reg25";
1457     case DW_OP_reg26:
1458       return "DW_OP_reg26";
1459     case DW_OP_reg27:
1460       return "DW_OP_reg27";
1461     case DW_OP_reg28:
1462       return "DW_OP_reg28";
1463     case DW_OP_reg29:
1464       return "DW_OP_reg29";
1465     case DW_OP_reg30:
1466       return "DW_OP_reg30";
1467     case DW_OP_reg31:
1468       return "DW_OP_reg31";
1469     case DW_OP_breg0:
1470       return "DW_OP_breg0";
1471     case DW_OP_breg1:
1472       return "DW_OP_breg1";
1473     case DW_OP_breg2:
1474       return "DW_OP_breg2";
1475     case DW_OP_breg3:
1476       return "DW_OP_breg3";
1477     case DW_OP_breg4:
1478       return "DW_OP_breg4";
1479     case DW_OP_breg5:
1480       return "DW_OP_breg5";
1481     case DW_OP_breg6:
1482       return "DW_OP_breg6";
1483     case DW_OP_breg7:
1484       return "DW_OP_breg7";
1485     case DW_OP_breg8:
1486       return "DW_OP_breg8";
1487     case DW_OP_breg9:
1488       return "DW_OP_breg9";
1489     case DW_OP_breg10:
1490       return "DW_OP_breg10";
1491     case DW_OP_breg11:
1492       return "DW_OP_breg11";
1493     case DW_OP_breg12:
1494       return "DW_OP_breg12";
1495     case DW_OP_breg13:
1496       return "DW_OP_breg13";
1497     case DW_OP_breg14:
1498       return "DW_OP_breg14";
1499     case DW_OP_breg15:
1500       return "DW_OP_breg15";
1501     case DW_OP_breg16:
1502       return "DW_OP_breg16";
1503     case DW_OP_breg17:
1504       return "DW_OP_breg17";
1505     case DW_OP_breg18:
1506       return "DW_OP_breg18";
1507     case DW_OP_breg19:
1508       return "DW_OP_breg19";
1509     case DW_OP_breg20:
1510       return "DW_OP_breg20";
1511     case DW_OP_breg21:
1512       return "DW_OP_breg21";
1513     case DW_OP_breg22:
1514       return "DW_OP_breg22";
1515     case DW_OP_breg23:
1516       return "DW_OP_breg23";
1517     case DW_OP_breg24:
1518       return "DW_OP_breg24";
1519     case DW_OP_breg25:
1520       return "DW_OP_breg25";
1521     case DW_OP_breg26:
1522       return "DW_OP_breg26";
1523     case DW_OP_breg27:
1524       return "DW_OP_breg27";
1525     case DW_OP_breg28:
1526       return "DW_OP_breg28";
1527     case DW_OP_breg29:
1528       return "DW_OP_breg29";
1529     case DW_OP_breg30:
1530       return "DW_OP_breg30";
1531     case DW_OP_breg31:
1532       return "DW_OP_breg31";
1533     case DW_OP_regx:
1534       return "DW_OP_regx";
1535     case DW_OP_fbreg:
1536       return "DW_OP_fbreg";
1537     case DW_OP_bregx:
1538       return "DW_OP_bregx";
1539     case DW_OP_piece:
1540       return "DW_OP_piece";
1541     case DW_OP_deref_size:
1542       return "DW_OP_deref_size";
1543     case DW_OP_xderef_size:
1544       return "DW_OP_xderef_size";
1545     case DW_OP_nop:
1546       return "DW_OP_nop";
1547
1548     case DW_OP_push_object_address:
1549       return "DW_OP_push_object_address";
1550     case DW_OP_call2:
1551       return "DW_OP_call2";
1552     case DW_OP_call4:
1553       return "DW_OP_call4";
1554     case DW_OP_call_ref:
1555       return "DW_OP_call_ref";
1556     case DW_OP_implicit_value:
1557       return "DW_OP_implicit_value";
1558     case DW_OP_stack_value:
1559       return "DW_OP_stack_value";
1560     case DW_OP_form_tls_address:
1561       return "DW_OP_form_tls_address";
1562     case DW_OP_call_frame_cfa:
1563       return "DW_OP_call_frame_cfa";
1564     case DW_OP_bit_piece:
1565       return "DW_OP_bit_piece";
1566
1567     case DW_OP_GNU_push_tls_address:
1568       return "DW_OP_GNU_push_tls_address";
1569     case DW_OP_GNU_uninit:
1570       return "DW_OP_GNU_uninit";
1571     case DW_OP_GNU_encoded_addr:
1572       return "DW_OP_GNU_encoded_addr";
1573     case DW_OP_GNU_implicit_pointer:
1574       return "DW_OP_GNU_implicit_pointer";
1575     case DW_OP_GNU_entry_value:
1576       return "DW_OP_GNU_entry_value";
1577     case DW_OP_GNU_const_type:
1578       return "DW_OP_GNU_const_type";
1579     case DW_OP_GNU_regval_type:
1580       return "DW_OP_GNU_regval_type";
1581     case DW_OP_GNU_deref_type:
1582       return "DW_OP_GNU_deref_type";
1583     case DW_OP_GNU_convert:
1584       return "DW_OP_GNU_convert";
1585     case DW_OP_GNU_reinterpret:
1586       return "DW_OP_GNU_reinterpret";
1587     case DW_OP_GNU_parameter_ref:
1588       return "DW_OP_GNU_parameter_ref";
1589
1590     default:
1591       return "OP_<unknown>";
1592     }
1593 }
1594
1595 /* Return a pointer to a newly allocated location description.  Location
1596    descriptions are simple expression terms that can be strung
1597    together to form more complicated location (address) descriptions.  */
1598
1599 static inline dw_loc_descr_ref
1600 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
1601                unsigned HOST_WIDE_INT oprnd2)
1602 {
1603   dw_loc_descr_ref descr = ggc_alloc_cleared_dw_loc_descr_node ();
1604
1605   descr->dw_loc_opc = op;
1606   descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
1607   descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
1608   descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
1609   descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
1610
1611   return descr;
1612 }
1613
1614 /* Return a pointer to a newly allocated location description for
1615    REG and OFFSET.  */
1616
1617 static inline dw_loc_descr_ref
1618 new_reg_loc_descr (unsigned int reg,  unsigned HOST_WIDE_INT offset)
1619 {
1620   if (reg <= 31)
1621     return new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + reg),
1622                           offset, 0);
1623   else
1624     return new_loc_descr (DW_OP_bregx, reg, offset);
1625 }
1626
1627 /* Add a location description term to a location description expression.  */
1628
1629 static inline void
1630 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
1631 {
1632   dw_loc_descr_ref *d;
1633
1634   /* Find the end of the chain.  */
1635   for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
1636     ;
1637
1638   *d = descr;
1639 }
1640
1641 /* Add a constant OFFSET to a location expression.  */
1642
1643 static void
1644 loc_descr_plus_const (dw_loc_descr_ref *list_head, HOST_WIDE_INT offset)
1645 {
1646   dw_loc_descr_ref loc;
1647   HOST_WIDE_INT *p;
1648
1649   gcc_assert (*list_head != NULL);
1650
1651   if (!offset)
1652     return;
1653
1654   /* Find the end of the chain.  */
1655   for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
1656     ;
1657
1658   p = NULL;
1659   if (loc->dw_loc_opc == DW_OP_fbreg
1660       || (loc->dw_loc_opc >= DW_OP_breg0 && loc->dw_loc_opc <= DW_OP_breg31))
1661     p = &loc->dw_loc_oprnd1.v.val_int;
1662   else if (loc->dw_loc_opc == DW_OP_bregx)
1663     p = &loc->dw_loc_oprnd2.v.val_int;
1664
1665   /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
1666      offset.  Don't optimize if an signed integer overflow would happen.  */
1667   if (p != NULL
1668       && ((offset > 0 && *p <= INTTYPE_MAXIMUM (HOST_WIDE_INT) - offset)
1669           || (offset < 0 && *p >= INTTYPE_MINIMUM (HOST_WIDE_INT) - offset)))
1670     *p += offset;
1671
1672   else if (offset > 0)
1673     loc->dw_loc_next = new_loc_descr (DW_OP_plus_uconst, offset, 0);
1674
1675   else
1676     {
1677       loc->dw_loc_next = int_loc_descriptor (-offset);
1678       add_loc_descr (&loc->dw_loc_next, new_loc_descr (DW_OP_minus, 0, 0));
1679     }
1680 }
1681
1682 /* Add a constant OFFSET to a location list.  */
1683
1684 static void
1685 loc_list_plus_const (dw_loc_list_ref list_head, HOST_WIDE_INT offset)
1686 {
1687   dw_loc_list_ref d;
1688   for (d = list_head; d != NULL; d = d->dw_loc_next)
1689     loc_descr_plus_const (&d->expr, offset);
1690 }
1691
1692 #define DWARF_REF_SIZE  \
1693   (dwarf_version == 2 ? DWARF2_ADDR_SIZE : DWARF_OFFSET_SIZE)
1694
1695 static unsigned long int get_base_type_offset (dw_die_ref);
1696
1697 /* Return the size of a location descriptor.  */
1698
1699 static unsigned long
1700 size_of_loc_descr (dw_loc_descr_ref loc)
1701 {
1702   unsigned long size = 1;
1703
1704   switch (loc->dw_loc_opc)
1705     {
1706     case DW_OP_addr:
1707       size += DWARF2_ADDR_SIZE;
1708       break;
1709     case DW_OP_const1u:
1710     case DW_OP_const1s:
1711       size += 1;
1712       break;
1713     case DW_OP_const2u:
1714     case DW_OP_const2s:
1715       size += 2;
1716       break;
1717     case DW_OP_const4u:
1718     case DW_OP_const4s:
1719       size += 4;
1720       break;
1721     case DW_OP_const8u:
1722     case DW_OP_const8s:
1723       size += 8;
1724       break;
1725     case DW_OP_constu:
1726       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1727       break;
1728     case DW_OP_consts:
1729       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
1730       break;
1731     case DW_OP_pick:
1732       size += 1;
1733       break;
1734     case DW_OP_plus_uconst:
1735       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1736       break;
1737     case DW_OP_skip:
1738     case DW_OP_bra:
1739       size += 2;
1740       break;
1741     case DW_OP_breg0:
1742     case DW_OP_breg1:
1743     case DW_OP_breg2:
1744     case DW_OP_breg3:
1745     case DW_OP_breg4:
1746     case DW_OP_breg5:
1747     case DW_OP_breg6:
1748     case DW_OP_breg7:
1749     case DW_OP_breg8:
1750     case DW_OP_breg9:
1751     case DW_OP_breg10:
1752     case DW_OP_breg11:
1753     case DW_OP_breg12:
1754     case DW_OP_breg13:
1755     case DW_OP_breg14:
1756     case DW_OP_breg15:
1757     case DW_OP_breg16:
1758     case DW_OP_breg17:
1759     case DW_OP_breg18:
1760     case DW_OP_breg19:
1761     case DW_OP_breg20:
1762     case DW_OP_breg21:
1763     case DW_OP_breg22:
1764     case DW_OP_breg23:
1765     case DW_OP_breg24:
1766     case DW_OP_breg25:
1767     case DW_OP_breg26:
1768     case DW_OP_breg27:
1769     case DW_OP_breg28:
1770     case DW_OP_breg29:
1771     case DW_OP_breg30:
1772     case DW_OP_breg31:
1773       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
1774       break;
1775     case DW_OP_regx:
1776       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1777       break;
1778     case DW_OP_fbreg:
1779       size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
1780       break;
1781     case DW_OP_bregx:
1782       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1783       size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
1784       break;
1785     case DW_OP_piece:
1786       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1787       break;
1788     case DW_OP_bit_piece:
1789       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1790       size += size_of_uleb128 (loc->dw_loc_oprnd2.v.val_unsigned);
1791       break;
1792     case DW_OP_deref_size:
1793     case DW_OP_xderef_size:
1794       size += 1;
1795       break;
1796     case DW_OP_call2:
1797       size += 2;
1798       break;
1799     case DW_OP_call4:
1800       size += 4;
1801       break;
1802     case DW_OP_call_ref:
1803       size += DWARF_REF_SIZE;
1804       break;
1805     case DW_OP_implicit_value:
1806       size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned)
1807               + loc->dw_loc_oprnd1.v.val_unsigned;
1808       break;
1809     case DW_OP_GNU_implicit_pointer:
1810       size += DWARF_REF_SIZE + size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
1811       break;
1812     case DW_OP_GNU_entry_value:
1813       {
1814         unsigned long op_size = size_of_locs (loc->dw_loc_oprnd1.v.val_loc);
1815         size += size_of_uleb128 (op_size) + op_size;
1816         break;
1817       }
1818     case DW_OP_GNU_const_type:
1819       {
1820         unsigned long o
1821           = get_base_type_offset (loc->dw_loc_oprnd1.v.val_die_ref.die);
1822         size += size_of_uleb128 (o) + 1;
1823         switch (loc->dw_loc_oprnd2.val_class)
1824           {
1825           case dw_val_class_vec:
1826             size += loc->dw_loc_oprnd2.v.val_vec.length
1827                     * loc->dw_loc_oprnd2.v.val_vec.elt_size;
1828             break;
1829           case dw_val_class_const:
1830             size += HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT;
1831             break;
1832           case dw_val_class_const_double:
1833             size += 2 * HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT;
1834             break;
1835           default:
1836             gcc_unreachable ();
1837           }
1838         break;
1839       }
1840     case DW_OP_GNU_regval_type:
1841       {
1842         unsigned long o
1843           = get_base_type_offset (loc->dw_loc_oprnd2.v.val_die_ref.die);
1844         size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned)
1845                 + size_of_uleb128 (o);
1846       }
1847       break;
1848     case DW_OP_GNU_deref_type:
1849       {
1850         unsigned long o
1851           = get_base_type_offset (loc->dw_loc_oprnd2.v.val_die_ref.die);
1852         size += 1 + size_of_uleb128 (o);
1853       }
1854       break;
1855     case DW_OP_GNU_convert:
1856     case DW_OP_GNU_reinterpret:
1857       if (loc->dw_loc_oprnd1.val_class == dw_val_class_unsigned_const)
1858         size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1859       else
1860         {
1861           unsigned long o
1862             = get_base_type_offset (loc->dw_loc_oprnd1.v.val_die_ref.die);
1863           size += size_of_uleb128 (o);
1864         }
1865       break;
1866     case DW_OP_GNU_parameter_ref:
1867       size += 4;
1868       break;
1869     default:
1870       break;
1871     }
1872
1873   return size;
1874 }
1875
1876 /* Return the size of a series of location descriptors.  */
1877
1878 unsigned long
1879 size_of_locs (dw_loc_descr_ref loc)
1880 {
1881   dw_loc_descr_ref l;
1882   unsigned long size;
1883
1884   /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
1885      field, to avoid writing to a PCH file.  */
1886   for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
1887     {
1888       if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra)
1889         break;
1890       size += size_of_loc_descr (l);
1891     }
1892   if (! l)
1893     return size;
1894
1895   for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
1896     {
1897       l->dw_loc_addr = size;
1898       size += size_of_loc_descr (l);
1899     }
1900
1901   return size;
1902 }
1903
1904 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
1905 static void get_ref_die_offset_label (char *, dw_die_ref);
1906 static unsigned long int get_ref_die_offset (dw_die_ref);
1907
1908 /* Output location description stack opcode's operands (if any).
1909    The for_eh_or_skip parameter controls whether register numbers are
1910    converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
1911    hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
1912    info).  This should be suppressed for the cases that have not been converted
1913    (i.e. symbolic debug info), by setting the parameter < 0.  See PR47324.  */
1914
1915 static void
1916 output_loc_operands (dw_loc_descr_ref loc, int for_eh_or_skip)
1917 {
1918   dw_val_ref val1 = &loc->dw_loc_oprnd1;
1919   dw_val_ref val2 = &loc->dw_loc_oprnd2;
1920
1921   switch (loc->dw_loc_opc)
1922     {
1923 #ifdef DWARF2_DEBUGGING_INFO
1924     case DW_OP_const2u:
1925     case DW_OP_const2s:
1926       dw2_asm_output_data (2, val1->v.val_int, NULL);
1927       break;
1928     case DW_OP_const4u:
1929       if (loc->dtprel)
1930         {
1931           gcc_assert (targetm.asm_out.output_dwarf_dtprel);
1932           targetm.asm_out.output_dwarf_dtprel (asm_out_file, 4,
1933                                                val1->v.val_addr);
1934           fputc ('\n', asm_out_file);
1935           break;
1936         }
1937       /* FALLTHRU */
1938     case DW_OP_const4s:
1939       dw2_asm_output_data (4, val1->v.val_int, NULL);
1940       break;
1941     case DW_OP_const8u:
1942       if (loc->dtprel)
1943         {
1944           gcc_assert (targetm.asm_out.output_dwarf_dtprel);
1945           targetm.asm_out.output_dwarf_dtprel (asm_out_file, 8,
1946                                                val1->v.val_addr);
1947           fputc ('\n', asm_out_file);
1948           break;
1949         }
1950       /* FALLTHRU */
1951     case DW_OP_const8s:
1952       gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
1953       dw2_asm_output_data (8, val1->v.val_int, NULL);
1954       break;
1955     case DW_OP_skip:
1956     case DW_OP_bra:
1957       {
1958         int offset;
1959
1960         gcc_assert (val1->val_class == dw_val_class_loc);
1961         offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
1962
1963         dw2_asm_output_data (2, offset, NULL);
1964       }
1965       break;
1966     case DW_OP_implicit_value:
1967       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
1968       switch (val2->val_class)
1969         {
1970         case dw_val_class_const:
1971           dw2_asm_output_data (val1->v.val_unsigned, val2->v.val_int, NULL);
1972           break;
1973         case dw_val_class_vec:
1974           {
1975             unsigned int elt_size = val2->v.val_vec.elt_size;
1976             unsigned int len = val2->v.val_vec.length;
1977             unsigned int i;
1978             unsigned char *p;
1979
1980             if (elt_size > sizeof (HOST_WIDE_INT))
1981               {
1982                 elt_size /= 2;
1983                 len *= 2;
1984               }
1985             for (i = 0, p = val2->v.val_vec.array;
1986                  i < len;
1987                  i++, p += elt_size)
1988               dw2_asm_output_data (elt_size, extract_int (p, elt_size),
1989                                    "fp or vector constant word %u", i);
1990           }
1991           break;
1992         case dw_val_class_const_double:
1993           {
1994             unsigned HOST_WIDE_INT first, second;
1995
1996             if (WORDS_BIG_ENDIAN)
1997               {
1998                 first = val2->v.val_double.high;
1999                 second = val2->v.val_double.low;
2000               }
2001             else
2002               {
2003                 first = val2->v.val_double.low;
2004                 second = val2->v.val_double.high;
2005               }
2006             dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
2007                                  first, NULL);
2008             dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
2009                                  second, NULL);
2010           }
2011           break;
2012         case dw_val_class_addr:
2013           gcc_assert (val1->v.val_unsigned == DWARF2_ADDR_SIZE);
2014           dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val2->v.val_addr, NULL);
2015           break;
2016         default:
2017           gcc_unreachable ();
2018         }
2019       break;
2020 #else
2021     case DW_OP_const2u:
2022     case DW_OP_const2s:
2023     case DW_OP_const4u:
2024     case DW_OP_const4s:
2025     case DW_OP_const8u:
2026     case DW_OP_const8s:
2027     case DW_OP_skip:
2028     case DW_OP_bra:
2029     case DW_OP_implicit_value:
2030       /* We currently don't make any attempt to make sure these are
2031          aligned properly like we do for the main unwind info, so
2032          don't support emitting things larger than a byte if we're
2033          only doing unwinding.  */
2034       gcc_unreachable ();
2035 #endif
2036     case DW_OP_const1u:
2037     case DW_OP_const1s:
2038       dw2_asm_output_data (1, val1->v.val_int, NULL);
2039       break;
2040     case DW_OP_constu:
2041       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2042       break;
2043     case DW_OP_consts:
2044       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
2045       break;
2046     case DW_OP_pick:
2047       dw2_asm_output_data (1, val1->v.val_int, NULL);
2048       break;
2049     case DW_OP_plus_uconst:
2050       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2051       break;
2052     case DW_OP_breg0:
2053     case DW_OP_breg1:
2054     case DW_OP_breg2:
2055     case DW_OP_breg3:
2056     case DW_OP_breg4:
2057     case DW_OP_breg5:
2058     case DW_OP_breg6:
2059     case DW_OP_breg7:
2060     case DW_OP_breg8:
2061     case DW_OP_breg9:
2062     case DW_OP_breg10:
2063     case DW_OP_breg11:
2064     case DW_OP_breg12:
2065     case DW_OP_breg13:
2066     case DW_OP_breg14:
2067     case DW_OP_breg15:
2068     case DW_OP_breg16:
2069     case DW_OP_breg17:
2070     case DW_OP_breg18:
2071     case DW_OP_breg19:
2072     case DW_OP_breg20:
2073     case DW_OP_breg21:
2074     case DW_OP_breg22:
2075     case DW_OP_breg23:
2076     case DW_OP_breg24:
2077     case DW_OP_breg25:
2078     case DW_OP_breg26:
2079     case DW_OP_breg27:
2080     case DW_OP_breg28:
2081     case DW_OP_breg29:
2082     case DW_OP_breg30:
2083     case DW_OP_breg31:
2084       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
2085       break;
2086     case DW_OP_regx:
2087       {
2088         unsigned r = val1->v.val_unsigned;
2089         if (for_eh_or_skip >= 0)
2090           r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2091         gcc_assert (size_of_uleb128 (r) 
2092                     == size_of_uleb128 (val1->v.val_unsigned));
2093         dw2_asm_output_data_uleb128 (r, NULL);  
2094       }
2095       break;
2096     case DW_OP_fbreg:
2097       dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
2098       break;
2099     case DW_OP_bregx:
2100       {
2101         unsigned r = val1->v.val_unsigned;
2102         if (for_eh_or_skip >= 0)
2103           r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2104         gcc_assert (size_of_uleb128 (r) 
2105                     == size_of_uleb128 (val1->v.val_unsigned));
2106         dw2_asm_output_data_uleb128 (r, NULL);  
2107         dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
2108       }
2109       break;
2110     case DW_OP_piece:
2111       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2112       break;
2113     case DW_OP_bit_piece:
2114       dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2115       dw2_asm_output_data_uleb128 (val2->v.val_unsigned, NULL);
2116       break;
2117     case DW_OP_deref_size:
2118     case DW_OP_xderef_size:
2119       dw2_asm_output_data (1, val1->v.val_int, NULL);
2120       break;
2121
2122     case DW_OP_addr:
2123       if (loc->dtprel)
2124         {
2125           if (targetm.asm_out.output_dwarf_dtprel)
2126             {
2127               targetm.asm_out.output_dwarf_dtprel (asm_out_file,
2128                                                    DWARF2_ADDR_SIZE,
2129                                                    val1->v.val_addr);
2130               fputc ('\n', asm_out_file);
2131             }
2132           else
2133             gcc_unreachable ();
2134         }
2135       else
2136         {
2137 #ifdef DWARF2_DEBUGGING_INFO
2138           dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
2139 #else
2140           gcc_unreachable ();
2141 #endif
2142         }
2143       break;
2144
2145     case DW_OP_GNU_implicit_pointer:
2146       {
2147         char label[MAX_ARTIFICIAL_LABEL_BYTES
2148                    + HOST_BITS_PER_WIDE_INT / 2 + 2];
2149         gcc_assert (val1->val_class == dw_val_class_die_ref);
2150         get_ref_die_offset_label (label, val1->v.val_die_ref.die);
2151         dw2_asm_output_offset (DWARF_REF_SIZE, label, debug_info_section, NULL);
2152         dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
2153       }
2154       break;
2155
2156     case DW_OP_GNU_entry_value:
2157       dw2_asm_output_data_uleb128 (size_of_locs (val1->v.val_loc), NULL);
2158       output_loc_sequence (val1->v.val_loc, for_eh_or_skip);
2159       break;
2160
2161     case DW_OP_GNU_const_type:
2162       {
2163         unsigned long o = get_base_type_offset (val1->v.val_die_ref.die), l;
2164         gcc_assert (o);
2165         dw2_asm_output_data_uleb128 (o, NULL);
2166         switch (val2->val_class)
2167           {
2168           case dw_val_class_const:
2169             l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
2170             dw2_asm_output_data (1, l, NULL);
2171             dw2_asm_output_data (l, val2->v.val_int, NULL);
2172             break;
2173           case dw_val_class_vec:
2174             {
2175               unsigned int elt_size = val2->v.val_vec.elt_size;
2176               unsigned int len = val2->v.val_vec.length;
2177               unsigned int i;
2178               unsigned char *p;
2179
2180               l = len * elt_size;
2181               dw2_asm_output_data (1, l, NULL);
2182               if (elt_size > sizeof (HOST_WIDE_INT))
2183                 {
2184                   elt_size /= 2;
2185                   len *= 2;
2186                 }
2187               for (i = 0, p = val2->v.val_vec.array;
2188                    i < len;
2189                    i++, p += elt_size)
2190                 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
2191                                      "fp or vector constant word %u", i);
2192             }
2193             break;
2194           case dw_val_class_const_double:
2195             {
2196               unsigned HOST_WIDE_INT first, second;
2197               l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
2198
2199               dw2_asm_output_data (1, 2 * l, NULL);
2200               if (WORDS_BIG_ENDIAN)
2201                 {
2202                   first = val2->v.val_double.high;
2203                   second = val2->v.val_double.low;
2204                 }
2205               else
2206                 {
2207                   first = val2->v.val_double.low;
2208                   second = val2->v.val_double.high;
2209                 }
2210               dw2_asm_output_data (l, first, NULL);
2211               dw2_asm_output_data (l, second, NULL);
2212             }
2213             break;
2214           default:
2215             gcc_unreachable ();
2216           }
2217       }
2218       break;
2219     case DW_OP_GNU_regval_type:
2220       {
2221         unsigned r = val1->v.val_unsigned;
2222         unsigned long o = get_base_type_offset (val2->v.val_die_ref.die);
2223         gcc_assert (o);
2224         if (for_eh_or_skip >= 0)
2225           {
2226             r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2227             gcc_assert (size_of_uleb128 (r)
2228                         == size_of_uleb128 (val1->v.val_unsigned));
2229           }
2230         dw2_asm_output_data_uleb128 (r, NULL);
2231         dw2_asm_output_data_uleb128 (o, NULL);
2232       }
2233       break;
2234     case DW_OP_GNU_deref_type:
2235       {
2236         unsigned long o = get_base_type_offset (val2->v.val_die_ref.die);
2237         gcc_assert (o);
2238         dw2_asm_output_data (1, val1->v.val_int, NULL);
2239         dw2_asm_output_data_uleb128 (o, NULL);
2240       }
2241       break;
2242     case DW_OP_GNU_convert:
2243     case DW_OP_GNU_reinterpret:
2244       if (loc->dw_loc_oprnd1.val_class == dw_val_class_unsigned_const)
2245         dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2246       else
2247         {
2248           unsigned long o = get_base_type_offset (val1->v.val_die_ref.die);
2249           gcc_assert (o);
2250           dw2_asm_output_data_uleb128 (o, NULL);
2251         }
2252       break;
2253
2254     case DW_OP_GNU_parameter_ref:
2255       {
2256         unsigned long o;
2257         gcc_assert (val1->val_class == dw_val_class_die_ref);
2258         o = get_ref_die_offset (val1->v.val_die_ref.die);
2259         dw2_asm_output_data (4, o, NULL);
2260       }
2261       break;
2262
2263     default:
2264       /* Other codes have no operands.  */
2265       break;
2266     }
2267 }
2268
2269 /* Output a sequence of location operations.  
2270    The for_eh_or_skip parameter controls whether register numbers are
2271    converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2272    hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2273    info).  This should be suppressed for the cases that have not been converted
2274    (i.e. symbolic debug info), by setting the parameter < 0.  See PR47324.  */
2275
2276 void
2277 output_loc_sequence (dw_loc_descr_ref loc, int for_eh_or_skip)
2278 {
2279   for (; loc != NULL; loc = loc->dw_loc_next)
2280     {
2281       enum dwarf_location_atom opc = loc->dw_loc_opc;
2282       /* Output the opcode.  */
2283       if (for_eh_or_skip >= 0 
2284           && opc >= DW_OP_breg0 && opc <= DW_OP_breg31)
2285         {
2286           unsigned r = (opc - DW_OP_breg0);
2287           r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2288           gcc_assert (r <= 31);
2289           opc = (enum dwarf_location_atom) (DW_OP_breg0 + r);
2290         }
2291       else if (for_eh_or_skip >= 0 
2292                && opc >= DW_OP_reg0 && opc <= DW_OP_reg31)
2293         {
2294           unsigned r = (opc - DW_OP_reg0);
2295           r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2296           gcc_assert (r <= 31);
2297           opc = (enum dwarf_location_atom) (DW_OP_reg0 + r);
2298         }
2299
2300       dw2_asm_output_data (1, opc,
2301                              "%s", dwarf_stack_op_name (opc));
2302
2303       /* Output the operand(s) (if any).  */
2304       output_loc_operands (loc, for_eh_or_skip);
2305     }
2306 }
2307
2308 /* Output location description stack opcode's operands (if any).
2309    The output is single bytes on a line, suitable for .cfi_escape.  */
2310
2311 static void
2312 output_loc_operands_raw (dw_loc_descr_ref loc)
2313 {
2314   dw_val_ref val1 = &loc->dw_loc_oprnd1;
2315   dw_val_ref val2 = &loc->dw_loc_oprnd2;
2316
2317   switch (loc->dw_loc_opc)
2318     {
2319     case DW_OP_addr:
2320     case DW_OP_implicit_value:
2321       /* We cannot output addresses in .cfi_escape, only bytes.  */
2322       gcc_unreachable ();
2323
2324     case DW_OP_const1u:
2325     case DW_OP_const1s:
2326     case DW_OP_pick:
2327     case DW_OP_deref_size:
2328     case DW_OP_xderef_size:
2329       fputc (',', asm_out_file);
2330       dw2_asm_output_data_raw (1, val1->v.val_int);
2331       break;
2332
2333     case DW_OP_const2u:
2334     case DW_OP_const2s:
2335       fputc (',', asm_out_file);
2336       dw2_asm_output_data_raw (2, val1->v.val_int);
2337       break;
2338
2339     case DW_OP_const4u:
2340     case DW_OP_const4s:
2341       fputc (',', asm_out_file);
2342       dw2_asm_output_data_raw (4, val1->v.val_int);
2343       break;
2344
2345     case DW_OP_const8u:
2346     case DW_OP_const8s:
2347       gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
2348       fputc (',', asm_out_file);
2349       dw2_asm_output_data_raw (8, val1->v.val_int);
2350       break;
2351
2352     case DW_OP_skip:
2353     case DW_OP_bra:
2354       {
2355         int offset;
2356
2357         gcc_assert (val1->val_class == dw_val_class_loc);
2358         offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
2359
2360         fputc (',', asm_out_file);
2361         dw2_asm_output_data_raw (2, offset);
2362       }
2363       break;
2364
2365     case DW_OP_regx:
2366       {
2367         unsigned r = DWARF2_FRAME_REG_OUT (val1->v.val_unsigned, 1);
2368         gcc_assert (size_of_uleb128 (r) 
2369                     == size_of_uleb128 (val1->v.val_unsigned));
2370         fputc (',', asm_out_file);
2371         dw2_asm_output_data_uleb128_raw (r);
2372       }
2373       break;
2374       
2375     case DW_OP_constu:
2376     case DW_OP_plus_uconst:
2377     case DW_OP_piece:
2378       fputc (',', asm_out_file);
2379       dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
2380       break;
2381
2382     case DW_OP_bit_piece:
2383       fputc (',', asm_out_file);
2384       dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
2385       dw2_asm_output_data_uleb128_raw (val2->v.val_unsigned);
2386       break;
2387
2388     case DW_OP_consts:
2389     case DW_OP_breg0:
2390     case DW_OP_breg1:
2391     case DW_OP_breg2:
2392     case DW_OP_breg3:
2393     case DW_OP_breg4:
2394     case DW_OP_breg5:
2395     case DW_OP_breg6:
2396     case DW_OP_breg7:
2397     case DW_OP_breg8:
2398     case DW_OP_breg9:
2399     case DW_OP_breg10:
2400     case DW_OP_breg11:
2401     case DW_OP_breg12:
2402     case DW_OP_breg13:
2403     case DW_OP_breg14:
2404     case DW_OP_breg15:
2405     case DW_OP_breg16:
2406     case DW_OP_breg17:
2407     case DW_OP_breg18:
2408     case DW_OP_breg19:
2409     case DW_OP_breg20:
2410     case DW_OP_breg21:
2411     case DW_OP_breg22:
2412     case DW_OP_breg23:
2413     case DW_OP_breg24:
2414     case DW_OP_breg25:
2415     case DW_OP_breg26:
2416     case DW_OP_breg27:
2417     case DW_OP_breg28:
2418     case DW_OP_breg29:
2419     case DW_OP_breg30:
2420     case DW_OP_breg31:
2421     case DW_OP_fbreg:
2422       fputc (',', asm_out_file);
2423       dw2_asm_output_data_sleb128_raw (val1->v.val_int);
2424       break;
2425
2426     case DW_OP_bregx:
2427       {
2428         unsigned r = DWARF2_FRAME_REG_OUT (val1->v.val_unsigned, 1);
2429         gcc_assert (size_of_uleb128 (r) 
2430                     == size_of_uleb128 (val1->v.val_unsigned));
2431         fputc (',', asm_out_file);
2432         dw2_asm_output_data_uleb128_raw (r);
2433         fputc (',', asm_out_file);
2434         dw2_asm_output_data_sleb128_raw (val2->v.val_int);
2435       }
2436       break;
2437
2438     case DW_OP_GNU_implicit_pointer:
2439     case DW_OP_GNU_entry_value:
2440     case DW_OP_GNU_const_type:
2441     case DW_OP_GNU_regval_type:
2442     case DW_OP_GNU_deref_type:
2443     case DW_OP_GNU_convert:
2444     case DW_OP_GNU_reinterpret:
2445     case DW_OP_GNU_parameter_ref:
2446       gcc_unreachable ();
2447       break;
2448
2449     default:
2450       /* Other codes have no operands.  */
2451       break;
2452     }
2453 }
2454
2455 void
2456 output_loc_sequence_raw (dw_loc_descr_ref loc)
2457 {
2458   while (1)
2459     {
2460       enum dwarf_location_atom opc = loc->dw_loc_opc;
2461       /* Output the opcode.  */
2462       if (opc >= DW_OP_breg0 && opc <= DW_OP_breg31)
2463         {
2464           unsigned r = (opc - DW_OP_breg0);
2465           r = DWARF2_FRAME_REG_OUT (r, 1);
2466           gcc_assert (r <= 31);
2467           opc = (enum dwarf_location_atom) (DW_OP_breg0 + r);
2468         }
2469       else if (opc >= DW_OP_reg0 && opc <= DW_OP_reg31)
2470         {
2471           unsigned r = (opc - DW_OP_reg0);
2472           r = DWARF2_FRAME_REG_OUT (r, 1);
2473           gcc_assert (r <= 31);
2474           opc = (enum dwarf_location_atom) (DW_OP_reg0 + r);
2475         }
2476       /* Output the opcode.  */
2477       fprintf (asm_out_file, "%#x", opc);
2478       output_loc_operands_raw (loc);
2479
2480       if (!loc->dw_loc_next)
2481         break;
2482       loc = loc->dw_loc_next;
2483
2484       fputc (',', asm_out_file);
2485     }
2486 }
2487
2488 /* This function builds a dwarf location descriptor sequence from a
2489    dw_cfa_location, adding the given OFFSET to the result of the
2490    expression.  */
2491
2492 struct dw_loc_descr_struct *
2493 build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset)
2494 {
2495   struct dw_loc_descr_struct *head, *tmp;
2496
2497   offset += cfa->offset;
2498
2499   if (cfa->indirect)
2500     {
2501       head = new_reg_loc_descr (cfa->reg, cfa->base_offset);
2502       head->dw_loc_oprnd1.val_class = dw_val_class_const;
2503       tmp = new_loc_descr (DW_OP_deref, 0, 0);
2504       add_loc_descr (&head, tmp);
2505       if (offset != 0)
2506         {
2507           tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0);
2508           add_loc_descr (&head, tmp);
2509         }
2510     }
2511   else
2512     head = new_reg_loc_descr (cfa->reg, offset);
2513
2514   return head;
2515 }
2516
2517 /* This function builds a dwarf location descriptor sequence for
2518    the address at OFFSET from the CFA when stack is aligned to
2519    ALIGNMENT byte.  */
2520
2521 struct dw_loc_descr_struct *
2522 build_cfa_aligned_loc (dw_cfa_location *cfa,
2523                        HOST_WIDE_INT offset, HOST_WIDE_INT alignment)
2524 {
2525   struct dw_loc_descr_struct *head;
2526   unsigned int dwarf_fp
2527     = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM);
2528
2529   /* When CFA is defined as FP+OFFSET, emulate stack alignment.  */
2530   if (cfa->reg == HARD_FRAME_POINTER_REGNUM && cfa->indirect == 0)
2531     {
2532       head = new_reg_loc_descr (dwarf_fp, 0);
2533       add_loc_descr (&head, int_loc_descriptor (alignment));
2534       add_loc_descr (&head, new_loc_descr (DW_OP_and, 0, 0));
2535       loc_descr_plus_const (&head, offset);
2536     }
2537   else
2538     head = new_reg_loc_descr (dwarf_fp, offset);
2539   return head;
2540 }
2541 \f
2542 /* And now, the support for symbolic debugging information.  */
2543
2544 /* .debug_str support.  */
2545 static int output_indirect_string (void **, void *);
2546
2547 static void dwarf2out_init (const char *);
2548 static void dwarf2out_finish (const char *);
2549 static void dwarf2out_assembly_start (void);
2550 static void dwarf2out_define (unsigned int, const char *);
2551 static void dwarf2out_undef (unsigned int, const char *);
2552 static void dwarf2out_start_source_file (unsigned, const char *);
2553 static void dwarf2out_end_source_file (unsigned);
2554 static void dwarf2out_function_decl (tree);
2555 static void dwarf2out_begin_block (unsigned, unsigned);
2556 static void dwarf2out_end_block (unsigned, unsigned);
2557 static bool dwarf2out_ignore_block (const_tree);
2558 static void dwarf2out_global_decl (tree);
2559 static void dwarf2out_type_decl (tree, int);
2560 static void dwarf2out_imported_module_or_decl (tree, tree, tree, bool);
2561 static void dwarf2out_imported_module_or_decl_1 (tree, tree, tree,
2562                                                  dw_die_ref);
2563 static void dwarf2out_abstract_function (tree);
2564 static void dwarf2out_var_location (rtx);
2565 static void dwarf2out_begin_function (tree);
2566 static void dwarf2out_set_name (tree, tree);
2567
2568 /* The debug hooks structure.  */
2569
2570 const struct gcc_debug_hooks dwarf2_debug_hooks =
2571 {
2572   dwarf2out_init,
2573   dwarf2out_finish,
2574   dwarf2out_assembly_start,
2575   dwarf2out_define,
2576   dwarf2out_undef,
2577   dwarf2out_start_source_file,
2578   dwarf2out_end_source_file,
2579   dwarf2out_begin_block,
2580   dwarf2out_end_block,
2581   dwarf2out_ignore_block,
2582   dwarf2out_source_line,
2583   dwarf2out_begin_prologue,
2584 #if VMS_DEBUGGING_INFO
2585   dwarf2out_vms_end_prologue,
2586   dwarf2out_vms_begin_epilogue,
2587 #else
2588   debug_nothing_int_charstar,
2589   debug_nothing_int_charstar,
2590 #endif
2591   dwarf2out_end_epilogue,
2592   dwarf2out_begin_function,
2593   debug_nothing_int,            /* end_function */
2594   dwarf2out_function_decl,      /* function_decl */
2595   dwarf2out_global_decl,
2596   dwarf2out_type_decl,          /* type_decl */
2597   dwarf2out_imported_module_or_decl,
2598   debug_nothing_tree,           /* deferred_inline_function */
2599   /* The DWARF 2 backend tries to reduce debugging bloat by not
2600      emitting the abstract description of inline functions until
2601      something tries to reference them.  */
2602   dwarf2out_abstract_function,  /* outlining_inline_function */
2603   debug_nothing_rtx,            /* label */
2604   debug_nothing_int,            /* handle_pch */
2605   dwarf2out_var_location,
2606   dwarf2out_switch_text_section,
2607   dwarf2out_set_name,
2608   1,                            /* start_end_main_source_file */
2609   TYPE_SYMTAB_IS_DIE            /* tree_type_symtab_field */
2610 };
2611 \f
2612 /* NOTE: In the comments in this file, many references are made to
2613    "Debugging Information Entries".  This term is abbreviated as `DIE'
2614    throughout the remainder of this file.  */
2615
2616 /* An internal representation of the DWARF output is built, and then
2617    walked to generate the DWARF debugging info.  The walk of the internal
2618    representation is done after the entire program has been compiled.
2619    The types below are used to describe the internal representation.  */
2620
2621 /* Whether to put type DIEs into their own section .debug_types instead
2622    of making them part of the .debug_info section.  Only supported for
2623    Dwarf V4 or higher and the user didn't disable them through
2624    -fno-debug-types-section.  It is more efficient to put them in a
2625    separate comdat sections since the linker will then be able to
2626    remove duplicates.  But not all tools support .debug_types sections
2627    yet.  */
2628
2629 #define use_debug_types (dwarf_version >= 4 && flag_debug_types_section)
2630
2631 /* Various DIE's use offsets relative to the beginning of the
2632    .debug_info section to refer to each other.  */
2633
2634 typedef long int dw_offset;
2635
2636 /* Define typedefs here to avoid circular dependencies.  */
2637
2638 typedef struct dw_attr_struct *dw_attr_ref;
2639 typedef struct dw_line_info_struct *dw_line_info_ref;
2640 typedef struct pubname_struct *pubname_ref;
2641 typedef struct dw_ranges_struct *dw_ranges_ref;
2642 typedef struct dw_ranges_by_label_struct *dw_ranges_by_label_ref;
2643 typedef struct comdat_type_struct *comdat_type_node_ref;
2644
2645 /* The entries in the line_info table more-or-less mirror the opcodes
2646    that are used in the real dwarf line table.  Arrays of these entries
2647    are collected per section when DWARF2_ASM_LINE_DEBUG_INFO is not
2648    supported.  */
2649
2650 enum dw_line_info_opcode {
2651   /* Emit DW_LNE_set_address; the operand is the label index.  */
2652   LI_set_address,
2653
2654   /* Emit a row to the matrix with the given line.  This may be done
2655      via any combination of DW_LNS_copy, DW_LNS_advance_line, and
2656      special opcodes.  */
2657   LI_set_line,
2658
2659   /* Emit a DW_LNS_set_file.  */
2660   LI_set_file,
2661
2662   /* Emit a DW_LNS_set_column.  */
2663   LI_set_column,
2664
2665   /* Emit a DW_LNS_negate_stmt; the operand is ignored.  */
2666   LI_negate_stmt,
2667
2668   /* Emit a DW_LNS_set_prologue_end/epilogue_begin; the operand is ignored.  */
2669   LI_set_prologue_end,
2670   LI_set_epilogue_begin,
2671
2672   /* Emit a DW_LNE_set_discriminator.  */
2673   LI_set_discriminator
2674 };
2675
2676 typedef struct GTY(()) dw_line_info_struct {
2677   enum dw_line_info_opcode opcode;
2678   unsigned int val;
2679 } dw_line_info_entry;
2680
2681 DEF_VEC_O(dw_line_info_entry);
2682 DEF_VEC_ALLOC_O(dw_line_info_entry, gc);
2683
2684 typedef struct GTY(()) dw_line_info_table_struct {
2685   /* The label that marks the end of this section.  */
2686   const char *end_label;
2687
2688   /* The values for the last row of the matrix, as collected in the table.
2689      These are used to minimize the changes to the next row.  */
2690   unsigned int file_num;
2691   unsigned int line_num;
2692   unsigned int column_num;
2693   int discrim_num;
2694   bool is_stmt;
2695   bool in_use;
2696
2697   VEC(dw_line_info_entry, gc) *entries;
2698 } dw_line_info_table;
2699
2700 typedef dw_line_info_table *dw_line_info_table_p;
2701
2702 DEF_VEC_P(dw_line_info_table_p);
2703 DEF_VEC_ALLOC_P(dw_line_info_table_p, gc);
2704
2705 /* Each DIE attribute has a field specifying the attribute kind,
2706    a link to the next attribute in the chain, and an attribute value.
2707    Attributes are typically linked below the DIE they modify.  */
2708
2709 typedef struct GTY(()) dw_attr_struct {
2710   enum dwarf_attribute dw_attr;
2711   dw_val_node dw_attr_val;
2712 }
2713 dw_attr_node;
2714
2715 DEF_VEC_O(dw_attr_node);
2716 DEF_VEC_ALLOC_O(dw_attr_node,gc);
2717
2718 /* The Debugging Information Entry (DIE) structure.  DIEs form a tree.
2719    The children of each node form a circular list linked by
2720    die_sib.  die_child points to the node *before* the "first" child node.  */
2721
2722 typedef struct GTY((chain_circular ("%h.die_sib"))) die_struct {
2723   union die_symbol_or_type_node
2724     {
2725       char * GTY ((tag ("0"))) die_symbol;
2726       comdat_type_node_ref GTY ((tag ("1"))) die_type_node;
2727     }
2728   GTY ((desc ("use_debug_types"))) die_id;
2729   VEC(dw_attr_node,gc) * die_attr;
2730   dw_die_ref die_parent;
2731   dw_die_ref die_child;
2732   dw_die_ref die_sib;
2733   dw_die_ref die_definition; /* ref from a specification to its definition */
2734   dw_offset die_offset;
2735   unsigned long die_abbrev;
2736   int die_mark;
2737   /* Die is used and must not be pruned as unused.  */
2738   int die_perennial_p;
2739   unsigned int decl_id;
2740   enum dwarf_tag die_tag;
2741 }
2742 die_node;
2743
2744 /* Evaluate 'expr' while 'c' is set to each child of DIE in order.  */
2745 #define FOR_EACH_CHILD(die, c, expr) do {       \
2746   c = die->die_child;                           \
2747   if (c) do {                                   \
2748     c = c->die_sib;                             \
2749     expr;                                       \
2750   } while (c != die->die_child);                \
2751 } while (0)
2752
2753 /* The pubname structure */
2754
2755 typedef struct GTY(()) pubname_struct {
2756   dw_die_ref die;
2757   const char *name;
2758 }
2759 pubname_entry;
2760
2761 DEF_VEC_O(pubname_entry);
2762 DEF_VEC_ALLOC_O(pubname_entry, gc);
2763
2764 struct GTY(()) dw_ranges_struct {
2765   /* If this is positive, it's a block number, otherwise it's a
2766      bitwise-negated index into dw_ranges_by_label.  */
2767   int num;
2768 };
2769
2770 /* A structure to hold a macinfo entry.  */
2771
2772 typedef struct GTY(()) macinfo_struct {
2773   unsigned HOST_WIDE_INT code;
2774   unsigned HOST_WIDE_INT lineno;
2775   const char *info;
2776 }
2777 macinfo_entry;
2778
2779 DEF_VEC_O(macinfo_entry);
2780 DEF_VEC_ALLOC_O(macinfo_entry, gc);
2781
2782 struct GTY(()) dw_ranges_by_label_struct {
2783   const char *begin;
2784   const char *end;
2785 };
2786
2787 /* The comdat type node structure.  */
2788 typedef struct GTY(()) comdat_type_struct
2789 {
2790   dw_die_ref root_die;
2791   dw_die_ref type_die;
2792   char signature[DWARF_TYPE_SIGNATURE_SIZE];
2793   struct comdat_type_struct *next;
2794 }
2795 comdat_type_node;
2796
2797 /* The limbo die list structure.  */
2798 typedef struct GTY(()) limbo_die_struct {
2799   dw_die_ref die;
2800   tree created_for;
2801   struct limbo_die_struct *next;
2802 }
2803 limbo_die_node;
2804
2805 typedef struct skeleton_chain_struct
2806 {
2807   dw_die_ref old_die;
2808   dw_die_ref new_die;
2809   struct skeleton_chain_struct *parent;
2810 }
2811 skeleton_chain_node;
2812
2813 /* Define a macro which returns nonzero for a TYPE_DECL which was
2814    implicitly generated for a type.
2815
2816    Note that, unlike the C front-end (which generates a NULL named
2817    TYPE_DECL node for each complete tagged type, each array type,
2818    and each function type node created) the C++ front-end generates
2819    a _named_ TYPE_DECL node for each tagged type node created.
2820    These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
2821    generate a DW_TAG_typedef DIE for them.  Likewise with the Ada
2822    front-end, but for each type, tagged or not.  */
2823
2824 #define TYPE_DECL_IS_STUB(decl)                         \
2825   (DECL_NAME (decl) == NULL_TREE                        \
2826    || (DECL_ARTIFICIAL (decl)                           \
2827        && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl)))  \
2828            /* This is necessary for stub decls that     \
2829               appear in nested inline functions.  */    \
2830            || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
2831                && (decl_ultimate_origin (decl)          \
2832                    == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
2833
2834 /* Information concerning the compilation unit's programming
2835    language, and compiler version.  */
2836
2837 /* Fixed size portion of the DWARF compilation unit header.  */
2838 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
2839   (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
2840
2841 /* Fixed size portion of the DWARF comdat type unit header.  */
2842 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
2843   (DWARF_COMPILE_UNIT_HEADER_SIZE + DWARF_TYPE_SIGNATURE_SIZE \
2844    + DWARF_OFFSET_SIZE)
2845
2846 /* Fixed size portion of public names info.  */
2847 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
2848
2849 /* Fixed size portion of the address range info.  */
2850 #define DWARF_ARANGES_HEADER_SIZE                                       \
2851   (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4,      \
2852                 DWARF2_ADDR_SIZE * 2)                                   \
2853    - DWARF_INITIAL_LENGTH_SIZE)
2854
2855 /* Size of padding portion in the address range info.  It must be
2856    aligned to twice the pointer size.  */
2857 #define DWARF_ARANGES_PAD_SIZE \
2858   (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
2859                 DWARF2_ADDR_SIZE * 2)                              \
2860    - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
2861
2862 /* Use assembler line directives if available.  */
2863 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
2864 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
2865 #define DWARF2_ASM_LINE_DEBUG_INFO 1
2866 #else
2867 #define DWARF2_ASM_LINE_DEBUG_INFO 0
2868 #endif
2869 #endif
2870
2871 /* Minimum line offset in a special line info. opcode.
2872    This value was chosen to give a reasonable range of values.  */
2873 #define DWARF_LINE_BASE  -10
2874
2875 /* First special line opcode - leave room for the standard opcodes.  */
2876 #define DWARF_LINE_OPCODE_BASE  ((int)DW_LNS_set_isa + 1)
2877
2878 /* Range of line offsets in a special line info. opcode.  */
2879 #define DWARF_LINE_RANGE  (254-DWARF_LINE_OPCODE_BASE+1)
2880
2881 /* Flag that indicates the initial value of the is_stmt_start flag.
2882    In the present implementation, we do not mark any lines as
2883    the beginning of a source statement, because that information
2884    is not made available by the GCC front-end.  */
2885 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
2886
2887 /* Maximum number of operations per instruction bundle.  */
2888 #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
2889 #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
2890 #endif
2891
2892 /* This location is used by calc_die_sizes() to keep track
2893    the offset of each DIE within the .debug_info section.  */
2894 static unsigned long next_die_offset;
2895
2896 /* Record the root of the DIE's built for the current compilation unit.  */
2897 static GTY(()) dw_die_ref single_comp_unit_die;
2898
2899 /* A list of type DIEs that have been separated into comdat sections.  */
2900 static GTY(()) comdat_type_node *comdat_type_list;
2901
2902 /* A list of DIEs with a NULL parent waiting to be relocated.  */
2903 static GTY(()) limbo_die_node *limbo_die_list;
2904
2905 /* A list of DIEs for which we may have to generate
2906    DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set.  */
2907 static GTY(()) limbo_die_node *deferred_asm_name;
2908
2909 /* Filenames referenced by this compilation unit.  */
2910 static GTY((param_is (struct dwarf_file_data))) htab_t file_table;
2911
2912 /* A hash table of references to DIE's that describe declarations.
2913    The key is a DECL_UID() which is a unique number identifying each decl.  */
2914 static GTY ((param_is (struct die_struct))) htab_t decl_die_table;
2915
2916 /* A hash table of references to DIE's that describe COMMON blocks.
2917    The key is DECL_UID() ^ die_parent.  */
2918 static GTY ((param_is (struct die_struct))) htab_t common_block_die_table;
2919
2920 typedef struct GTY(()) die_arg_entry_struct {
2921     dw_die_ref die;
2922     tree arg;
2923 } die_arg_entry;
2924
2925 DEF_VEC_O(die_arg_entry);
2926 DEF_VEC_ALLOC_O(die_arg_entry,gc);
2927
2928 /* Node of the variable location list.  */
2929 struct GTY ((chain_next ("%h.next"))) var_loc_node {
2930   /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
2931      EXPR_LIST chain.  For small bitsizes, bitsize is encoded
2932      in mode of the EXPR_LIST node and first EXPR_LIST operand
2933      is either NOTE_INSN_VAR_LOCATION for a piece with a known
2934      location or NULL for padding.  For larger bitsizes,
2935      mode is 0 and first operand is a CONCAT with bitsize
2936      as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
2937      NULL as second operand.  */
2938   rtx GTY (()) loc;
2939   const char * GTY (()) label;
2940   struct var_loc_node * GTY (()) next;
2941 };
2942
2943 /* Variable location list.  */
2944 struct GTY (()) var_loc_list_def {
2945   struct var_loc_node * GTY (()) first;
2946
2947   /* Pointer to the last but one or last element of the
2948      chained list.  If the list is empty, both first and
2949      last are NULL, if the list contains just one node
2950      or the last node certainly is not redundant, it points
2951      to the last node, otherwise points to the last but one.
2952      Do not mark it for GC because it is marked through the chain.  */
2953   struct var_loc_node * GTY ((skip ("%h"))) last;
2954
2955   /* Pointer to the last element before section switch,
2956      if NULL, either sections weren't switched or first
2957      is after section switch.  */
2958   struct var_loc_node * GTY ((skip ("%h"))) last_before_switch;
2959
2960   /* DECL_UID of the variable decl.  */
2961   unsigned int decl_id;
2962 };
2963 typedef struct var_loc_list_def var_loc_list;
2964
2965 /* Call argument location list.  */
2966 struct GTY ((chain_next ("%h.next"))) call_arg_loc_node {
2967   rtx GTY (()) call_arg_loc_note;
2968   const char * GTY (()) label;
2969   tree GTY (()) block;
2970   bool tail_call_p;
2971   rtx GTY (()) symbol_ref;
2972   struct call_arg_loc_node * GTY (()) next;
2973 };
2974
2975
2976 /* Table of decl location linked lists.  */
2977 static GTY ((param_is (var_loc_list))) htab_t decl_loc_table;
2978
2979 /* Head and tail of call_arg_loc chain.  */
2980 static GTY (()) struct call_arg_loc_node *call_arg_locations;
2981 static struct call_arg_loc_node *call_arg_loc_last;
2982
2983 /* Number of call sites in the current function.  */
2984 static int call_site_count = -1;
2985 /* Number of tail call sites in the current function.  */
2986 static int tail_call_site_count = -1;
2987
2988 /* Vector mapping block numbers to DW_TAG_{lexical_block,inlined_subroutine}
2989    DIEs.  */
2990 static VEC (dw_die_ref, heap) *block_map;
2991
2992 /* A cached location list.  */
2993 struct GTY (()) cached_dw_loc_list_def {
2994   /* The DECL_UID of the decl that this entry describes.  */
2995   unsigned int decl_id;
2996
2997   /* The cached location list.  */
2998   dw_loc_list_ref loc_list;
2999 };
3000 typedef struct cached_dw_loc_list_def cached_dw_loc_list;
3001
3002 /* Table of cached location lists.  */
3003 static GTY ((param_is (cached_dw_loc_list))) htab_t cached_dw_loc_list_table;
3004
3005 /* A pointer to the base of a list of references to DIE's that
3006    are uniquely identified by their tag, presence/absence of
3007    children DIE's, and list of attribute/value pairs.  */
3008 static GTY((length ("abbrev_die_table_allocated")))
3009   dw_die_ref *abbrev_die_table;
3010
3011 /* Number of elements currently allocated for abbrev_die_table.  */
3012 static GTY(()) unsigned abbrev_die_table_allocated;
3013
3014 /* Number of elements in type_die_table currently in use.  */
3015 static GTY(()) unsigned abbrev_die_table_in_use;
3016
3017 /* Size (in elements) of increments by which we may expand the
3018    abbrev_die_table.  */
3019 #define ABBREV_DIE_TABLE_INCREMENT 256
3020
3021 /* A global counter for generating labels for line number data.  */
3022 static unsigned int line_info_label_num;
3023
3024 /* The current table to which we should emit line number information
3025    for the current function.  This will be set up at the beginning of
3026    assembly for the function.  */
3027 static dw_line_info_table *cur_line_info_table;
3028
3029 /* The two default tables of line number info.  */
3030 static GTY(()) dw_line_info_table *text_section_line_info;
3031 static GTY(()) dw_line_info_table *cold_text_section_line_info;
3032
3033 /* The set of all non-default tables of line number info.  */
3034 static GTY(()) VEC (dw_line_info_table_p, gc) *separate_line_info;
3035
3036 /* A flag to tell pubnames/types export if there is an info section to
3037    refer to.  */
3038 static bool info_section_emitted;
3039
3040 /* A pointer to the base of a table that contains a list of publicly
3041    accessible names.  */
3042 static GTY (()) VEC (pubname_entry, gc) *  pubname_table;
3043
3044 /* A pointer to the base of a table that contains a list of publicly
3045    accessible types.  */
3046 static GTY (()) VEC (pubname_entry, gc) * pubtype_table;
3047
3048 /* A pointer to the base of a table that contains a list of macro
3049    defines/undefines (and file start/end markers).  */
3050 static GTY (()) VEC (macinfo_entry, gc) * macinfo_table;
3051
3052 /* Array of dies for which we should generate .debug_ranges info.  */
3053 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
3054
3055 /* Number of elements currently allocated for ranges_table.  */
3056 static GTY(()) unsigned ranges_table_allocated;
3057
3058 /* Number of elements in ranges_table currently in use.  */
3059 static GTY(()) unsigned ranges_table_in_use;
3060
3061 /* Array of pairs of labels referenced in ranges_table.  */
3062 static GTY ((length ("ranges_by_label_allocated")))
3063      dw_ranges_by_label_ref ranges_by_label;
3064
3065 /* Number of elements currently allocated for ranges_by_label.  */
3066 static GTY(()) unsigned ranges_by_label_allocated;
3067
3068 /* Number of elements in ranges_by_label currently in use.  */
3069 static GTY(()) unsigned ranges_by_label_in_use;
3070
3071 /* Size (in elements) of increments by which we may expand the
3072    ranges_table.  */
3073 #define RANGES_TABLE_INCREMENT 64
3074
3075 /* Whether we have location lists that need outputting */
3076 static GTY(()) bool have_location_lists;
3077
3078 /* Unique label counter.  */
3079 static GTY(()) unsigned int loclabel_num;
3080
3081 /* Unique label counter for point-of-call tables.  */
3082 static GTY(()) unsigned int poc_label_num;
3083
3084 /* Record whether the function being analyzed contains inlined functions.  */
3085 static int current_function_has_inlines;
3086
3087 /* The last file entry emitted by maybe_emit_file().  */
3088 static GTY(()) struct dwarf_file_data * last_emitted_file;
3089
3090 /* Number of internal labels generated by gen_internal_sym().  */
3091 static GTY(()) int label_num;
3092
3093 /* Cached result of previous call to lookup_filename.  */
3094 static GTY(()) struct dwarf_file_data * file_table_last_lookup;
3095
3096 static GTY(()) VEC(die_arg_entry,gc) *tmpl_value_parm_die_table;
3097
3098 /* Instances of generic types for which we need to generate debug
3099    info that describe their generic parameters and arguments. That
3100    generation needs to happen once all types are properly laid out so
3101    we do it at the end of compilation.  */
3102 static GTY(()) VEC(tree,gc) *generic_type_instances;
3103
3104 /* Offset from the "steady-state frame pointer" to the frame base,
3105    within the current function.  */
3106 static HOST_WIDE_INT frame_pointer_fb_offset;
3107 static bool frame_pointer_fb_offset_valid;
3108
3109 static VEC (dw_die_ref, heap) *base_types;
3110
3111 /* Forward declarations for functions defined in this file.  */
3112
3113 static int is_pseudo_reg (const_rtx);
3114 static tree type_main_variant (tree);
3115 static int is_tagged_type (const_tree);
3116 static const char *dwarf_tag_name (unsigned);
3117 static const char *dwarf_attr_name (unsigned);
3118 static const char *dwarf_form_name (unsigned);
3119 static tree decl_ultimate_origin (const_tree);
3120 static tree decl_class_context (tree);
3121 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
3122 static inline enum dw_val_class AT_class (dw_attr_ref);
3123 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
3124 static inline unsigned AT_flag (dw_attr_ref);
3125 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
3126 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
3127 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
3128 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
3129 static void add_AT_double (dw_die_ref, enum dwarf_attribute,
3130                            HOST_WIDE_INT, unsigned HOST_WIDE_INT);
3131 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
3132                                unsigned int, unsigned char *);
3133 static void add_AT_data8 (dw_die_ref, enum dwarf_attribute, unsigned char *);
3134 static hashval_t debug_str_do_hash (const void *);
3135 static int debug_str_eq (const void *, const void *);
3136 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
3137 static inline const char *AT_string (dw_attr_ref);
3138 static enum dwarf_form AT_string_form (dw_attr_ref);
3139 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
3140 static void add_AT_specification (dw_die_ref, dw_die_ref);
3141 static inline dw_die_ref AT_ref (dw_attr_ref);
3142 static inline int AT_ref_external (dw_attr_ref);
3143 static inline void set_AT_ref_external (dw_attr_ref, int);
3144 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
3145 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
3146 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
3147 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
3148                              dw_loc_list_ref);
3149 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
3150 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
3151 static inline rtx AT_addr (dw_attr_ref);
3152 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
3153 static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *);
3154 static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *);
3155 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
3156                            unsigned HOST_WIDE_INT);
3157 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
3158                                unsigned long);
3159 static inline const char *AT_lbl (dw_attr_ref);
3160 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
3161 static const char *get_AT_low_pc (dw_die_ref);
3162 static const char *get_AT_hi_pc (dw_die_ref);
3163 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
3164 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
3165 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
3166 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
3167 static bool is_cxx (void);
3168 static bool is_fortran (void);
3169 static bool is_ada (void);
3170 static void remove_AT (dw_die_ref, enum dwarf_attribute);
3171 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
3172 static void add_child_die (dw_die_ref, dw_die_ref);
3173 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
3174 static dw_die_ref lookup_type_die (tree);
3175 static dw_die_ref strip_naming_typedef (tree, dw_die_ref);
3176 static dw_die_ref lookup_type_die_strip_naming_typedef (tree);
3177 static void equate_type_number_to_die (tree, dw_die_ref);
3178 static hashval_t decl_die_table_hash (const void *);
3179 static int decl_die_table_eq (const void *, const void *);
3180 static dw_die_ref lookup_decl_die (tree);
3181 static hashval_t common_block_die_table_hash (const void *);
3182 static int common_block_die_table_eq (const void *, const void *);
3183 static hashval_t decl_loc_table_hash (const void *);
3184 static int decl_loc_table_eq (const void *, const void *);
3185 static var_loc_list *lookup_decl_loc (const_tree);
3186 static void equate_decl_number_to_die (tree, dw_die_ref);
3187 static struct var_loc_node *add_var_loc_to_decl (tree, rtx, const char *);
3188 static void print_spaces (FILE *);
3189 static void print_die (dw_die_ref, FILE *);
3190 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
3191 static dw_die_ref pop_compile_unit (dw_die_ref);
3192 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
3193 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
3194 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
3195 static void checksum_sleb128 (HOST_WIDE_INT, struct md5_ctx *);
3196 static void checksum_uleb128 (unsigned HOST_WIDE_INT, struct md5_ctx *);
3197 static void loc_checksum_ordered (dw_loc_descr_ref, struct md5_ctx *);
3198 static void attr_checksum_ordered (enum dwarf_tag, dw_attr_ref,
3199                                    struct md5_ctx *, int *);
3200 struct checksum_attributes;
3201 static void collect_checksum_attributes (struct checksum_attributes *, dw_die_ref);
3202 static void die_checksum_ordered (dw_die_ref, struct md5_ctx *, int *);
3203 static void checksum_die_context (dw_die_ref, struct md5_ctx *);
3204 static void generate_type_signature (dw_die_ref, comdat_type_node *);
3205 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
3206 static int same_dw_val_p (const dw_val_node *, const dw_val_node *, int *);
3207 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
3208 static int same_die_p (dw_die_ref, dw_die_ref, int *);
3209 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
3210 static void compute_section_prefix (dw_die_ref);
3211 static int is_type_die (dw_die_ref);
3212 static int is_comdat_die (dw_die_ref);
3213 static int is_symbol_die (dw_die_ref);
3214 static void assign_symbol_names (dw_die_ref);
3215 static void break_out_includes (dw_die_ref);
3216 static int is_declaration_die (dw_die_ref);
3217 static int should_move_die_to_comdat (dw_die_ref);
3218 static dw_die_ref clone_as_declaration (dw_die_ref);
3219 static dw_die_ref clone_die (dw_die_ref);
3220 static dw_die_ref clone_tree (dw_die_ref);
3221 static void copy_declaration_context (dw_die_ref, dw_die_ref);
3222 static void generate_skeleton_ancestor_tree (skeleton_chain_node *);
3223 static void generate_skeleton_bottom_up (skeleton_chain_node *);
3224 static dw_die_ref generate_skeleton (dw_die_ref);
3225 static dw_die_ref remove_child_or_replace_with_skeleton (dw_die_ref,
3226                                                          dw_die_ref);
3227 static void break_out_comdat_types (dw_die_ref);
3228 static dw_die_ref copy_ancestor_tree (dw_die_ref, dw_die_ref, htab_t);
3229 static void copy_decls_walk (dw_die_ref, dw_die_ref, htab_t);
3230 static void copy_decls_for_unworthy_types (dw_die_ref);
3231
3232 static hashval_t htab_cu_hash (const void *);
3233 static int htab_cu_eq (const void *, const void *);
3234 static void htab_cu_del (void *);
3235 static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
3236 static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
3237 static void add_sibling_attributes (dw_die_ref);
3238 static void build_abbrev_table (dw_die_ref);
3239 static void output_location_lists (dw_die_ref);
3240 static int constant_size (unsigned HOST_WIDE_INT);
3241 static unsigned long size_of_die (dw_die_ref);
3242 static void calc_die_sizes (dw_die_ref);
3243 static void calc_base_type_die_sizes (void);
3244 static void mark_dies (dw_die_ref);
3245 static void unmark_dies (dw_die_ref);
3246 static void unmark_all_dies (dw_die_ref);
3247 static unsigned long size_of_pubnames (VEC (pubname_entry,gc) *);
3248 static unsigned long size_of_aranges (void);
3249 static enum dwarf_form value_format (dw_attr_ref);
3250 static void output_value_format (dw_attr_ref);
3251 static void output_abbrev_section (void);
3252 static void output_die_symbol (dw_die_ref);
3253 static void output_die (dw_die_ref);
3254 static void output_compilation_unit_header (void);
3255 static void output_comp_unit (dw_die_ref, int);
3256 static void output_comdat_type_unit (comdat_type_node *);
3257 static const char *dwarf2_name (tree, int);
3258 static void add_pubname (tree, dw_die_ref);
3259 static void add_pubname_string (const char *, dw_die_ref);
3260 static void add_pubtype (tree, dw_die_ref);
3261 static void output_pubnames (VEC (pubname_entry,gc) *);
3262 static void output_aranges (unsigned long);
3263 static unsigned int add_ranges_num (int);
3264 static unsigned int add_ranges (const_tree);
3265 static void add_ranges_by_labels (dw_die_ref, const char *, const char *,
3266                                   bool *);
3267 static void output_ranges (void);
3268 static dw_line_info_table *new_line_info_table (void);
3269 static void output_line_info (void);
3270 static void output_file_names (void);
3271 static dw_die_ref base_type_die (tree);
3272 static int is_base_type (tree);
3273 static dw_die_ref subrange_type_die (tree, tree, tree, dw_die_ref);
3274 static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
3275 static dw_die_ref generic_parameter_die (tree, tree, bool, dw_die_ref);
3276 static dw_die_ref template_parameter_pack_die (tree, tree, dw_die_ref);
3277 static int type_is_enum (const_tree);
3278 static unsigned int dbx_reg_number (const_rtx);
3279 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
3280 static dw_loc_descr_ref reg_loc_descriptor (rtx, enum var_init_status);
3281 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int,
3282                                                 enum var_init_status);
3283 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx,
3284                                                      enum var_init_status);
3285 static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT,
3286                                          enum var_init_status);
3287 static int is_based_loc (const_rtx);
3288 static int resolve_one_addr (rtx *, void *);
3289 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx,
3290                                                enum var_init_status);
3291 static dw_loc_descr_ref loc_descriptor (rtx, enum machine_mode mode,
3292                                         enum var_init_status);
3293 static dw_loc_list_ref loc_list_from_tree (tree, int);
3294 static dw_loc_descr_ref loc_descriptor_from_tree (tree, int);
3295 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
3296 static tree field_type (const_tree);
3297 static unsigned int simple_type_align_in_bits (const_tree);
3298 static unsigned int simple_decl_align_in_bits (const_tree);
3299 static unsigned HOST_WIDE_INT simple_type_size_in_bits (const_tree);
3300 static HOST_WIDE_INT field_byte_offset (const_tree);
3301 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
3302                                          dw_loc_list_ref);
3303 static void add_data_member_location_attribute (dw_die_ref, tree);
3304 static bool add_const_value_attribute (dw_die_ref, rtx);
3305 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
3306 static void insert_double (double_int, unsigned char *);
3307 static void insert_float (const_rtx, unsigned char *);
3308 static rtx rtl_for_decl_location (tree);
3309 static bool add_location_or_const_value_attribute (dw_die_ref, tree, bool,
3310                                                    enum dwarf_attribute);
3311 static bool tree_add_const_value_attribute (dw_die_ref, tree);
3312 static bool tree_add_const_value_attribute_for_decl (dw_die_ref, tree);
3313 static void add_name_attribute (dw_die_ref, const char *);
3314 static void add_gnat_descriptive_type_attribute (dw_die_ref, tree, dw_die_ref);
3315 static void add_comp_dir_attribute (dw_die_ref);
3316 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
3317 static void add_subscript_info (dw_die_ref, tree, bool);
3318 static void add_byte_size_attribute (dw_die_ref, tree);
3319 static void add_bit_offset_attribute (dw_die_ref, tree);
3320 static void add_bit_size_attribute (dw_die_ref, tree);
3321 static void add_prototyped_attribute (dw_die_ref, tree);
3322 static dw_die_ref add_abstract_origin_attribute (dw_die_ref, tree);
3323 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
3324 static void add_src_coords_attributes (dw_die_ref, tree);
3325 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
3326 static void push_decl_scope (tree);
3327 static void pop_decl_scope (void);
3328 static dw_die_ref scope_die_for (tree, dw_die_ref);
3329 static inline int local_scope_p (dw_die_ref);
3330 static inline int class_scope_p (dw_die_ref);
3331 static inline int class_or_namespace_scope_p (dw_die_ref);
3332 static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
3333 static void add_calling_convention_attribute (dw_die_ref, tree);
3334 static const char *type_tag (const_tree);
3335 static tree member_declared_type (const_tree);
3336 #if 0
3337 static const char *decl_start_label (tree);
3338 #endif
3339 static void gen_array_type_die (tree, dw_die_ref);
3340 static void gen_descr_array_type_die (tree, struct array_descr_info *, dw_die_ref);
3341 #if 0
3342 static void gen_entry_point_die (tree, dw_die_ref);
3343 #endif
3344 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
3345 static dw_die_ref gen_formal_parameter_die (tree, tree, bool, dw_die_ref);
3346 static dw_die_ref gen_formal_parameter_pack_die  (tree, tree, dw_die_ref, tree*);
3347 static void gen_unspecified_parameters_die (tree, dw_die_ref);
3348 static void gen_formal_types_die (tree, dw_die_ref);
3349 static void gen_subprogram_die (tree, dw_die_ref);
3350 static void gen_variable_die (tree, tree, dw_die_ref);
3351 static void gen_const_die (tree, dw_die_ref);
3352 static void gen_label_die (tree, dw_die_ref);
3353 static void gen_lexical_block_die (tree, dw_die_ref, int);
3354 static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
3355 static void gen_field_die (tree, dw_die_ref);
3356 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
3357 static dw_die_ref gen_compile_unit_die (const char *);
3358 static void gen_inheritance_die (tree, tree, dw_die_ref);
3359 static void gen_member_die (tree, dw_die_ref);
3360 static void gen_struct_or_union_type_die (tree, dw_die_ref,
3361                                                 enum debug_info_usage);
3362 static void gen_subroutine_type_die (tree, dw_die_ref);
3363 static void gen_typedef_die (tree, dw_die_ref);
3364 static void gen_type_die (tree, dw_die_ref);
3365 static void gen_block_die (tree, dw_die_ref, int);
3366 static void decls_for_scope (tree, dw_die_ref, int);
3367 static inline int is_redundant_typedef (const_tree);
3368 static bool is_naming_typedef_decl (const_tree);
3369 static inline dw_die_ref get_context_die (tree);
3370 static void gen_namespace_die (tree, dw_die_ref);
3371 static dw_die_ref gen_decl_die (tree, tree, dw_die_ref);
3372 static dw_die_ref force_decl_die (tree);
3373 static dw_die_ref force_type_die (tree);
3374 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
3375 static dw_die_ref declare_in_namespace (tree, dw_die_ref);
3376 static struct dwarf_file_data * lookup_filename (const char *);
3377 static void retry_incomplete_types (void);
3378 static void gen_type_die_for_member (tree, tree, dw_die_ref);
3379 static void gen_generic_params_dies (tree);
3380 static void gen_tagged_type_die (tree, dw_die_ref, enum debug_info_usage);
3381 static void gen_type_die_with_usage (tree, dw_die_ref, enum debug_info_usage);
3382 static void splice_child_die (dw_die_ref, dw_die_ref);
3383 static int file_info_cmp (const void *, const void *);
3384 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
3385                                      const char *, const char *);
3386 static void output_loc_list (dw_loc_list_ref);
3387 static char *gen_internal_sym (const char *);
3388
3389 static void prune_unmark_dies (dw_die_ref);
3390 static void prune_unused_types_mark_generic_parms_dies (dw_die_ref);
3391 static void prune_unused_types_mark (dw_die_ref, int);
3392 static void prune_unused_types_walk (dw_die_ref);
3393 static void prune_unused_types_walk_attribs (dw_die_ref);
3394 static void prune_unused_types_prune (dw_die_ref);
3395 static void prune_unused_types (void);
3396 static int maybe_emit_file (struct dwarf_file_data *fd);
3397 static inline const char *AT_vms_delta1 (dw_attr_ref);
3398 static inline const char *AT_vms_delta2 (dw_attr_ref);
3399 static inline void add_AT_vms_delta (dw_die_ref, enum dwarf_attribute,
3400                                      const char *, const char *);
3401 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref, tree);
3402 static void gen_remaining_tmpl_value_param_die_attribute (void);
3403 static bool generic_type_p (tree);
3404 static void schedule_generic_params_dies_gen (tree t);
3405 static void gen_scheduled_generic_parms_dies (void);
3406
3407 /* Section names used to hold DWARF debugging information.  */
3408 #ifndef DEBUG_INFO_SECTION
3409 #define DEBUG_INFO_SECTION      ".debug_info"
3410 #endif
3411 #ifndef DEBUG_ABBREV_SECTION
3412 #define DEBUG_ABBREV_SECTION    ".debug_abbrev"
3413 #endif
3414 #ifndef DEBUG_ARANGES_SECTION
3415 #define DEBUG_ARANGES_SECTION   ".debug_aranges"
3416 #endif
3417 #ifndef DEBUG_MACINFO_SECTION
3418 #define DEBUG_MACINFO_SECTION   ".debug_macinfo"
3419 #endif
3420 #ifndef DEBUG_LINE_SECTION
3421 #define DEBUG_LINE_SECTION      ".debug_line"
3422 #endif
3423 #ifndef DEBUG_LOC_SECTION
3424 #define DEBUG_LOC_SECTION       ".debug_loc"
3425 #endif
3426 #ifndef DEBUG_PUBNAMES_SECTION
3427 #define DEBUG_PUBNAMES_SECTION  ".debug_pubnames"
3428 #endif
3429 #ifndef DEBUG_PUBTYPES_SECTION
3430 #define DEBUG_PUBTYPES_SECTION  ".debug_pubtypes"
3431 #endif
3432 #ifndef DEBUG_STR_SECTION
3433 #define DEBUG_STR_SECTION       ".debug_str"
3434 #endif
3435 #ifndef DEBUG_RANGES_SECTION
3436 #define DEBUG_RANGES_SECTION    ".debug_ranges"
3437 #endif
3438
3439 /* Standard ELF section names for compiled code and data.  */
3440 #ifndef TEXT_SECTION_NAME
3441 #define TEXT_SECTION_NAME       ".text"
3442 #endif
3443
3444 /* Section flags for .debug_str section.  */
3445 #define DEBUG_STR_SECTION_FLAGS \
3446   (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings               \
3447    ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1        \
3448    : SECTION_DEBUG)
3449
3450 /* Labels we insert at beginning sections we can reference instead of
3451    the section names themselves.  */
3452
3453 #ifndef TEXT_SECTION_LABEL
3454 #define TEXT_SECTION_LABEL              "Ltext"
3455 #endif
3456 #ifndef COLD_TEXT_SECTION_LABEL
3457 #define COLD_TEXT_SECTION_LABEL         "Ltext_cold"
3458 #endif
3459 #ifndef DEBUG_LINE_SECTION_LABEL
3460 #define DEBUG_LINE_SECTION_LABEL        "Ldebug_line"
3461 #endif
3462 #ifndef DEBUG_INFO_SECTION_LABEL
3463 #define DEBUG_INFO_SECTION_LABEL        "Ldebug_info"
3464 #endif
3465 #ifndef DEBUG_ABBREV_SECTION_LABEL
3466 #define DEBUG_ABBREV_SECTION_LABEL      "Ldebug_abbrev"
3467 #endif
3468 #ifndef DEBUG_LOC_SECTION_LABEL
3469 #define DEBUG_LOC_SECTION_LABEL         "Ldebug_loc"
3470 #endif
3471 #ifndef DEBUG_RANGES_SECTION_LABEL
3472 #define DEBUG_RANGES_SECTION_LABEL      "Ldebug_ranges"
3473 #endif
3474 #ifndef DEBUG_MACINFO_SECTION_LABEL
3475 #define DEBUG_MACINFO_SECTION_LABEL     "Ldebug_macinfo"
3476 #endif
3477
3478
3479 /* Definitions of defaults for formats and names of various special
3480    (artificial) labels which may be generated within this file (when the -g
3481    options is used and DWARF2_DEBUGGING_INFO is in effect.
3482    If necessary, these may be overridden from within the tm.h file, but
3483    typically, overriding these defaults is unnecessary.  */
3484
3485 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
3486 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3487 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3488 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
3489 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3490 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3491 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3492 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3493 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3494 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
3495
3496 #ifndef TEXT_END_LABEL
3497 #define TEXT_END_LABEL          "Letext"
3498 #endif
3499 #ifndef COLD_END_LABEL
3500 #define COLD_END_LABEL          "Letext_cold"
3501 #endif
3502 #ifndef BLOCK_BEGIN_LABEL
3503 #define BLOCK_BEGIN_LABEL       "LBB"
3504 #endif
3505 #ifndef BLOCK_END_LABEL
3506 #define BLOCK_END_LABEL         "LBE"
3507 #endif
3508 #ifndef LINE_CODE_LABEL
3509 #define LINE_CODE_LABEL         "LM"
3510 #endif
3511
3512 \f
3513 /* Return the root of the DIE's built for the current compilation unit.  */
3514 static dw_die_ref
3515 comp_unit_die (void)
3516 {
3517   if (!single_comp_unit_die)
3518     single_comp_unit_die = gen_compile_unit_die (NULL);
3519   return single_comp_unit_die;
3520 }
3521
3522 /* We allow a language front-end to designate a function that is to be
3523    called to "demangle" any name before it is put into a DIE.  */
3524
3525 static const char *(*demangle_name_func) (const char *);
3526
3527 void
3528 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
3529 {
3530   demangle_name_func = func;
3531 }
3532
3533 /* Test if rtl node points to a pseudo register.  */
3534
3535 static inline int
3536 is_pseudo_reg (const_rtx rtl)
3537 {
3538   return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
3539           || (GET_CODE (rtl) == SUBREG
3540               && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
3541 }
3542
3543 /* Return a reference to a type, with its const and volatile qualifiers
3544    removed.  */
3545
3546 static inline tree
3547 type_main_variant (tree type)
3548 {
3549   type = TYPE_MAIN_VARIANT (type);
3550
3551   /* ??? There really should be only one main variant among any group of
3552      variants of a given type (and all of the MAIN_VARIANT values for all
3553      members of the group should point to that one type) but sometimes the C
3554      front-end messes this up for array types, so we work around that bug
3555      here.  */
3556   if (TREE_CODE (type) == ARRAY_TYPE)
3557     while (type != TYPE_MAIN_VARIANT (type))
3558       type = TYPE_MAIN_VARIANT (type);
3559
3560   return type;
3561 }
3562
3563 /* Return nonzero if the given type node represents a tagged type.  */
3564
3565 static inline int
3566 is_tagged_type (const_tree type)
3567 {
3568   enum tree_code code = TREE_CODE (type);
3569
3570   return (code == RECORD_TYPE || code == UNION_TYPE
3571           || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
3572 }
3573
3574 /* Set label to debug_info_section_label + die_offset of a DIE reference.  */
3575
3576 static void
3577 get_ref_die_offset_label (char *label, dw_die_ref ref)
3578 {
3579   sprintf (label, "%s+%ld", debug_info_section_label, ref->die_offset);
3580 }
3581
3582 /* Return die_offset of a DIE reference to a base type.  */
3583
3584 static unsigned long int
3585 get_base_type_offset (dw_die_ref ref)
3586 {
3587   if (ref->die_offset)
3588     return ref->die_offset;
3589   if (comp_unit_die ()->die_abbrev)
3590     {
3591       calc_base_type_die_sizes ();
3592       gcc_assert (ref->die_offset);
3593     }
3594   return ref->die_offset;
3595 }
3596
3597 /* Return die_offset of a DIE reference other than base type.  */
3598
3599 static unsigned long int
3600 get_ref_die_offset (dw_die_ref ref)
3601 {
3602   gcc_assert (ref->die_offset);
3603   return ref->die_offset;
3604 }
3605
3606 /* Convert a DIE tag into its string name.  */
3607
3608 static const char *
3609 dwarf_tag_name (unsigned int tag)
3610 {
3611   switch (tag)
3612     {
3613     case DW_TAG_padding:
3614       return "DW_TAG_padding";
3615     case DW_TAG_array_type:
3616       return "DW_TAG_array_type";
3617     case DW_TAG_class_type:
3618       return "DW_TAG_class_type";
3619     case DW_TAG_entry_point:
3620       return "DW_TAG_entry_point";
3621     case DW_TAG_enumeration_type:
3622       return "DW_TAG_enumeration_type";
3623     case DW_TAG_formal_parameter:
3624       return "DW_TAG_formal_parameter";
3625     case DW_TAG_imported_declaration: