PR sanitizer/65400
[official-gcc.git] / gcc / dwarf2out.c
blob6c8e51fcab42447dddd0f587b1db67e1cd345cc4
1 /* Output Dwarf2 format symbol table information from GCC.
2 Copyright (C) 1992-2015 Free Software Foundation, Inc.
3 Contributed by Gary Funck (gary@intrepid.com).
4 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
5 Extensively modified by Jason Merrill (jason@cygnus.com).
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
12 version.
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 /* TODO: Emit .debug_line header even when there are no functions, since
24 the file numbers are used by .debug_info. Alternately, leave
25 out locations for types and decls.
26 Avoid talking about ctors and op= for PODs.
27 Factor out common prologue sequences into multiple CIEs. */
29 /* The first part of this file deals with the DWARF 2 frame unwind
30 information, which is also used by the GCC efficient exception handling
31 mechanism. The second part, controlled only by an #ifdef
32 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
33 information. */
35 /* DWARF2 Abbreviation Glossary:
37 CFA = Canonical Frame Address
38 a fixed address on the stack which identifies a call frame.
39 We define it to be the value of SP just before the call insn.
40 The CFA register and offset, which may change during the course
41 of the function, are used to calculate its value at runtime.
43 CFI = Call Frame Instruction
44 an instruction for the DWARF2 abstract machine
46 CIE = Common Information Entry
47 information describing information common to one or more FDEs
49 DIE = Debugging Information Entry
51 FDE = Frame Description Entry
52 information describing the stack call frame, in particular,
53 how to restore registers
55 DW_CFA_... = DWARF2 CFA call frame instruction
56 DW_TAG_... = DWARF2 DIE tag */
58 #include "config.h"
59 #include "system.h"
60 #include "coretypes.h"
61 #include "tm.h"
62 #include "rtl.h"
63 #include "hash-set.h"
64 #include "machmode.h"
65 #include "vec.h"
66 #include "double-int.h"
67 #include "input.h"
68 #include "alias.h"
69 #include "symtab.h"
70 #include "wide-int.h"
71 #include "inchash.h"
72 #include "real.h"
73 #include "tree.h"
74 #include "fold-const.h"
75 #include "stringpool.h"
76 #include "stor-layout.h"
77 #include "varasm.h"
78 #include "hashtab.h"
79 #include "hard-reg-set.h"
80 #include "function.h"
81 #include "emit-rtl.h"
82 #include "hash-table.h"
83 #include "version.h"
84 #include "flags.h"
85 #include "regs.h"
86 #include "rtlhash.h"
87 #include "insn-config.h"
88 #include "reload.h"
89 #include "output.h"
90 #include "statistics.h"
91 #include "fixed-value.h"
92 #include "expmed.h"
93 #include "dojump.h"
94 #include "explow.h"
95 #include "calls.h"
96 #include "stmt.h"
97 #include "expr.h"
98 #include "except.h"
99 #include "dwarf2.h"
100 #include "dwarf2out.h"
101 #include "dwarf2asm.h"
102 #include "toplev.h"
103 #include "md5.h"
104 #include "tm_p.h"
105 #include "diagnostic.h"
106 #include "tree-pretty-print.h"
107 #include "debug.h"
108 #include "target.h"
109 #include "common/common-target.h"
110 #include "langhooks.h"
111 #include "hash-map.h"
112 #include "is-a.h"
113 #include "plugin-api.h"
114 #include "ipa-ref.h"
115 #include "cgraph.h"
116 #include "ira.h"
117 #include "lra.h"
118 #include "dumpfile.h"
119 #include "opts.h"
120 #include "tree-dfa.h"
121 #include "gdb/gdb-index.h"
122 #include "rtl-iter.h"
124 static void dwarf2out_source_line (unsigned int, const char *, int, bool);
125 static rtx_insn *last_var_location_insn;
126 static rtx_insn *cached_next_real_insn;
127 static void dwarf2out_decl (tree);
129 #ifdef VMS_DEBUGGING_INFO
130 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
132 /* Define this macro to be a nonzero value if the directory specifications
133 which are output in the debug info should end with a separator. */
134 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
135 /* Define this macro to evaluate to a nonzero value if GCC should refrain
136 from generating indirect strings in DWARF2 debug information, for instance
137 if your target is stuck with an old version of GDB that is unable to
138 process them properly or uses VMS Debug. */
139 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
140 #else
141 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
142 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
143 #endif
145 /* ??? Poison these here until it can be done generically. They've been
146 totally replaced in this file; make sure it stays that way. */
147 #undef DWARF2_UNWIND_INFO
148 #undef DWARF2_FRAME_INFO
149 #if (GCC_VERSION >= 3000)
150 #pragma GCC poison DWARF2_UNWIND_INFO DWARF2_FRAME_INFO
151 #endif
153 /* The size of the target's pointer type. */
154 #ifndef PTR_SIZE
155 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
156 #endif
158 /* Array of RTXes referenced by the debugging information, which therefore
159 must be kept around forever. */
160 static GTY(()) vec<rtx, va_gc> *used_rtx_array;
162 /* A pointer to the base of a list of incomplete types which might be
163 completed at some later time. incomplete_types_list needs to be a
164 vec<tree, va_gc> *because we want to tell the garbage collector about
165 it. */
166 static GTY(()) vec<tree, va_gc> *incomplete_types;
168 /* A pointer to the base of a table of references to declaration
169 scopes. This table is a display which tracks the nesting
170 of declaration scopes at the current scope and containing
171 scopes. This table is used to find the proper place to
172 define type declaration DIE's. */
173 static GTY(()) vec<tree, va_gc> *decl_scope_table;
175 /* Pointers to various DWARF2 sections. */
176 static GTY(()) section *debug_info_section;
177 static GTY(()) section *debug_skeleton_info_section;
178 static GTY(()) section *debug_abbrev_section;
179 static GTY(()) section *debug_skeleton_abbrev_section;
180 static GTY(()) section *debug_aranges_section;
181 static GTY(()) section *debug_addr_section;
182 static GTY(()) section *debug_macinfo_section;
183 static GTY(()) section *debug_line_section;
184 static GTY(()) section *debug_skeleton_line_section;
185 static GTY(()) section *debug_loc_section;
186 static GTY(()) section *debug_pubnames_section;
187 static GTY(()) section *debug_pubtypes_section;
188 static GTY(()) section *debug_str_section;
189 static GTY(()) section *debug_str_dwo_section;
190 static GTY(()) section *debug_str_offsets_section;
191 static GTY(()) section *debug_ranges_section;
192 static GTY(()) section *debug_frame_section;
194 /* Maximum size (in bytes) of an artificially generated label. */
195 #define MAX_ARTIFICIAL_LABEL_BYTES 30
197 /* According to the (draft) DWARF 3 specification, the initial length
198 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
199 bytes are 0xffffffff, followed by the length stored in the next 8
200 bytes.
202 However, the SGI/MIPS ABI uses an initial length which is equal to
203 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
205 #ifndef DWARF_INITIAL_LENGTH_SIZE
206 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
207 #endif
209 /* Round SIZE up to the nearest BOUNDARY. */
210 #define DWARF_ROUND(SIZE,BOUNDARY) \
211 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
213 /* CIE identifier. */
214 #if HOST_BITS_PER_WIDE_INT >= 64
215 #define DWARF_CIE_ID \
216 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
217 #else
218 #define DWARF_CIE_ID DW_CIE_ID
219 #endif
222 /* A vector for a table that contains frame description
223 information for each routine. */
224 #define NOT_INDEXED (-1U)
225 #define NO_INDEX_ASSIGNED (-2U)
227 static GTY(()) vec<dw_fde_ref, va_gc> *fde_vec;
229 struct GTY((for_user)) indirect_string_node {
230 const char *str;
231 unsigned int refcount;
232 enum dwarf_form form;
233 char *label;
234 unsigned int index;
237 struct indirect_string_hasher : ggc_hasher<indirect_string_node *>
239 typedef const char *compare_type;
241 static hashval_t hash (indirect_string_node *);
242 static bool equal (indirect_string_node *, const char *);
245 static GTY (()) hash_table<indirect_string_hasher> *debug_str_hash;
247 /* With split_debug_info, both the comp_dir and dwo_name go in the
248 main object file, rather than the dwo, similar to the force_direct
249 parameter elsewhere but with additional complications:
251 1) The string is needed in both the main object file and the dwo.
252 That is, the comp_dir and dwo_name will appear in both places.
254 2) Strings can use three forms: DW_FORM_string, DW_FORM_strp or
255 DW_FORM_GNU_str_index.
257 3) GCC chooses the form to use late, depending on the size and
258 reference count.
260 Rather than forcing the all debug string handling functions and
261 callers to deal with these complications, simply use a separate,
262 special-cased string table for any attribute that should go in the
263 main object file. This limits the complexity to just the places
264 that need it. */
266 static GTY (()) hash_table<indirect_string_hasher> *skeleton_debug_str_hash;
268 static GTY(()) int dw2_string_counter;
270 /* True if the compilation unit places functions in more than one section. */
271 static GTY(()) bool have_multiple_function_sections = false;
273 /* Whether the default text and cold text sections have been used at all. */
275 static GTY(()) bool text_section_used = false;
276 static GTY(()) bool cold_text_section_used = false;
278 /* The default cold text section. */
279 static GTY(()) section *cold_text_section;
281 /* The DIE for C++14 'auto' in a function return type. */
282 static GTY(()) dw_die_ref auto_die;
284 /* The DIE for C++14 'decltype(auto)' in a function return type. */
285 static GTY(()) dw_die_ref decltype_auto_die;
287 /* Forward declarations for functions defined in this file. */
289 static char *stripattributes (const char *);
290 static void output_call_frame_info (int);
291 static void dwarf2out_note_section_used (void);
293 /* Personality decl of current unit. Used only when assembler does not support
294 personality CFI. */
295 static GTY(()) rtx current_unit_personality;
297 /* Data and reference forms for relocatable data. */
298 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
299 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
301 #ifndef DEBUG_FRAME_SECTION
302 #define DEBUG_FRAME_SECTION ".debug_frame"
303 #endif
305 #ifndef FUNC_BEGIN_LABEL
306 #define FUNC_BEGIN_LABEL "LFB"
307 #endif
309 #ifndef FUNC_END_LABEL
310 #define FUNC_END_LABEL "LFE"
311 #endif
313 #ifndef PROLOGUE_END_LABEL
314 #define PROLOGUE_END_LABEL "LPE"
315 #endif
317 #ifndef EPILOGUE_BEGIN_LABEL
318 #define EPILOGUE_BEGIN_LABEL "LEB"
319 #endif
321 #ifndef FRAME_BEGIN_LABEL
322 #define FRAME_BEGIN_LABEL "Lframe"
323 #endif
324 #define CIE_AFTER_SIZE_LABEL "LSCIE"
325 #define CIE_END_LABEL "LECIE"
326 #define FDE_LABEL "LSFDE"
327 #define FDE_AFTER_SIZE_LABEL "LASFDE"
328 #define FDE_END_LABEL "LEFDE"
329 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
330 #define LINE_NUMBER_END_LABEL "LELT"
331 #define LN_PROLOG_AS_LABEL "LASLTP"
332 #define LN_PROLOG_END_LABEL "LELTP"
333 #define DIE_LABEL_PREFIX "DW"
335 /* Match the base name of a file to the base name of a compilation unit. */
337 static int
338 matches_main_base (const char *path)
340 /* Cache the last query. */
341 static const char *last_path = NULL;
342 static int last_match = 0;
343 if (path != last_path)
345 const char *base;
346 int length = base_of_path (path, &base);
347 last_path = path;
348 last_match = (length == main_input_baselength
349 && memcmp (base, main_input_basename, length) == 0);
351 return last_match;
354 #ifdef DEBUG_DEBUG_STRUCT
356 static int
357 dump_struct_debug (tree type, enum debug_info_usage usage,
358 enum debug_struct_file criterion, int generic,
359 int matches, int result)
361 /* Find the type name. */
362 tree type_decl = TYPE_STUB_DECL (type);
363 tree t = type_decl;
364 const char *name = 0;
365 if (TREE_CODE (t) == TYPE_DECL)
366 t = DECL_NAME (t);
367 if (t)
368 name = IDENTIFIER_POINTER (t);
370 fprintf (stderr, " struct %d %s %s %s %s %d %p %s\n",
371 criterion,
372 DECL_IN_SYSTEM_HEADER (type_decl) ? "sys" : "usr",
373 matches ? "bas" : "hdr",
374 generic ? "gen" : "ord",
375 usage == DINFO_USAGE_DFN ? ";" :
376 usage == DINFO_USAGE_DIR_USE ? "." : "*",
377 result,
378 (void*) type_decl, name);
379 return result;
381 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
382 dump_struct_debug (type, usage, criterion, generic, matches, result)
384 #else
386 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
387 (result)
389 #endif
391 /* Get the number of HOST_WIDE_INTs needed to represent the precision
392 of the number. */
394 static unsigned int
395 get_full_len (const wide_int &op)
397 return ((op.get_precision () + HOST_BITS_PER_WIDE_INT - 1)
398 / HOST_BITS_PER_WIDE_INT);
401 static bool
402 should_emit_struct_debug (tree type, enum debug_info_usage usage)
404 enum debug_struct_file criterion;
405 tree type_decl;
406 bool generic = lang_hooks.types.generic_p (type);
408 if (generic)
409 criterion = debug_struct_generic[usage];
410 else
411 criterion = debug_struct_ordinary[usage];
413 if (criterion == DINFO_STRUCT_FILE_NONE)
414 return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
415 if (criterion == DINFO_STRUCT_FILE_ANY)
416 return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
418 type_decl = TYPE_STUB_DECL (TYPE_MAIN_VARIANT (type));
420 if (type_decl != NULL)
422 if (criterion == DINFO_STRUCT_FILE_SYS && DECL_IN_SYSTEM_HEADER (type_decl))
423 return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
425 if (matches_main_base (DECL_SOURCE_FILE (type_decl)))
426 return DUMP_GSTRUCT (type, usage, criterion, generic, true, true);
429 return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
432 /* Return a pointer to a copy of the section string name S with all
433 attributes stripped off, and an asterisk prepended (for assemble_name). */
435 static inline char *
436 stripattributes (const char *s)
438 char *stripped = XNEWVEC (char, strlen (s) + 2);
439 char *p = stripped;
441 *p++ = '*';
443 while (*s && *s != ',')
444 *p++ = *s++;
446 *p = '\0';
447 return stripped;
450 /* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section,
451 switch to the data section instead, and write out a synthetic start label
452 for collect2 the first time around. */
454 static void
455 switch_to_eh_frame_section (bool back)
457 tree label;
459 #ifdef EH_FRAME_SECTION_NAME
460 if (eh_frame_section == 0)
462 int flags;
464 if (EH_TABLES_CAN_BE_READ_ONLY)
466 int fde_encoding;
467 int per_encoding;
468 int lsda_encoding;
470 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
471 /*global=*/0);
472 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
473 /*global=*/1);
474 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
475 /*global=*/0);
476 flags = ((! flag_pic
477 || ((fde_encoding & 0x70) != DW_EH_PE_absptr
478 && (fde_encoding & 0x70) != DW_EH_PE_aligned
479 && (per_encoding & 0x70) != DW_EH_PE_absptr
480 && (per_encoding & 0x70) != DW_EH_PE_aligned
481 && (lsda_encoding & 0x70) != DW_EH_PE_absptr
482 && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
483 ? 0 : SECTION_WRITE);
485 else
486 flags = SECTION_WRITE;
487 eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
489 #endif /* EH_FRAME_SECTION_NAME */
491 if (eh_frame_section)
492 switch_to_section (eh_frame_section);
493 else
495 /* We have no special eh_frame section. Put the information in
496 the data section and emit special labels to guide collect2. */
497 switch_to_section (data_section);
499 if (!back)
501 label = get_file_function_name ("F");
502 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
503 targetm.asm_out.globalize_label (asm_out_file,
504 IDENTIFIER_POINTER (label));
505 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
510 /* Switch [BACK] to the eh or debug frame table section, depending on
511 FOR_EH. */
513 static void
514 switch_to_frame_table_section (int for_eh, bool back)
516 if (for_eh)
517 switch_to_eh_frame_section (back);
518 else
520 if (!debug_frame_section)
521 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
522 SECTION_DEBUG, NULL);
523 switch_to_section (debug_frame_section);
527 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
529 enum dw_cfi_oprnd_type
530 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
532 switch (cfi)
534 case DW_CFA_nop:
535 case DW_CFA_GNU_window_save:
536 case DW_CFA_remember_state:
537 case DW_CFA_restore_state:
538 return dw_cfi_oprnd_unused;
540 case DW_CFA_set_loc:
541 case DW_CFA_advance_loc1:
542 case DW_CFA_advance_loc2:
543 case DW_CFA_advance_loc4:
544 case DW_CFA_MIPS_advance_loc8:
545 return dw_cfi_oprnd_addr;
547 case DW_CFA_offset:
548 case DW_CFA_offset_extended:
549 case DW_CFA_def_cfa:
550 case DW_CFA_offset_extended_sf:
551 case DW_CFA_def_cfa_sf:
552 case DW_CFA_restore:
553 case DW_CFA_restore_extended:
554 case DW_CFA_undefined:
555 case DW_CFA_same_value:
556 case DW_CFA_def_cfa_register:
557 case DW_CFA_register:
558 case DW_CFA_expression:
559 return dw_cfi_oprnd_reg_num;
561 case DW_CFA_def_cfa_offset:
562 case DW_CFA_GNU_args_size:
563 case DW_CFA_def_cfa_offset_sf:
564 return dw_cfi_oprnd_offset;
566 case DW_CFA_def_cfa_expression:
567 return dw_cfi_oprnd_loc;
569 default:
570 gcc_unreachable ();
574 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
576 enum dw_cfi_oprnd_type
577 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
579 switch (cfi)
581 case DW_CFA_def_cfa:
582 case DW_CFA_def_cfa_sf:
583 case DW_CFA_offset:
584 case DW_CFA_offset_extended_sf:
585 case DW_CFA_offset_extended:
586 return dw_cfi_oprnd_offset;
588 case DW_CFA_register:
589 return dw_cfi_oprnd_reg_num;
591 case DW_CFA_expression:
592 return dw_cfi_oprnd_loc;
594 default:
595 return dw_cfi_oprnd_unused;
599 /* Output one FDE. */
601 static void
602 output_fde (dw_fde_ref fde, bool for_eh, bool second,
603 char *section_start_label, int fde_encoding, char *augmentation,
604 bool any_lsda_needed, int lsda_encoding)
606 const char *begin, *end;
607 static unsigned int j;
608 char l1[20], l2[20];
610 targetm.asm_out.emit_unwind_label (asm_out_file, fde->decl, for_eh,
611 /* empty */ 0);
612 targetm.asm_out.internal_label (asm_out_file, FDE_LABEL,
613 for_eh + j);
614 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + j);
615 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + j);
616 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
617 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
618 " indicating 64-bit DWARF extension");
619 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
620 "FDE Length");
621 ASM_OUTPUT_LABEL (asm_out_file, l1);
623 if (for_eh)
624 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
625 else
626 dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
627 debug_frame_section, "FDE CIE offset");
629 begin = second ? fde->dw_fde_second_begin : fde->dw_fde_begin;
630 end = second ? fde->dw_fde_second_end : fde->dw_fde_end;
632 if (for_eh)
634 rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, begin);
635 SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
636 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref, false,
637 "FDE initial location");
638 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
639 end, begin, "FDE address range");
641 else
643 dw2_asm_output_addr (DWARF2_ADDR_SIZE, begin, "FDE initial location");
644 dw2_asm_output_delta (DWARF2_ADDR_SIZE, end, begin, "FDE address range");
647 if (augmentation[0])
649 if (any_lsda_needed)
651 int size = size_of_encoded_value (lsda_encoding);
653 if (lsda_encoding == DW_EH_PE_aligned)
655 int offset = ( 4 /* Length */
656 + 4 /* CIE offset */
657 + 2 * size_of_encoded_value (fde_encoding)
658 + 1 /* Augmentation size */ );
659 int pad = -offset & (PTR_SIZE - 1);
661 size += pad;
662 gcc_assert (size_of_uleb128 (size) == 1);
665 dw2_asm_output_data_uleb128 (size, "Augmentation size");
667 if (fde->uses_eh_lsda)
669 ASM_GENERATE_INTERNAL_LABEL (l1, second ? "LLSDAC" : "LLSDA",
670 fde->funcdef_number);
671 dw2_asm_output_encoded_addr_rtx (lsda_encoding,
672 gen_rtx_SYMBOL_REF (Pmode, l1),
673 false,
674 "Language Specific Data Area");
676 else
678 if (lsda_encoding == DW_EH_PE_aligned)
679 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
680 dw2_asm_output_data (size_of_encoded_value (lsda_encoding), 0,
681 "Language Specific Data Area (none)");
684 else
685 dw2_asm_output_data_uleb128 (0, "Augmentation size");
688 /* Loop through the Call Frame Instructions associated with this FDE. */
689 fde->dw_fde_current_label = begin;
691 size_t from, until, i;
693 from = 0;
694 until = vec_safe_length (fde->dw_fde_cfi);
696 if (fde->dw_fde_second_begin == NULL)
698 else if (!second)
699 until = fde->dw_fde_switch_cfi_index;
700 else
701 from = fde->dw_fde_switch_cfi_index;
703 for (i = from; i < until; i++)
704 output_cfi ((*fde->dw_fde_cfi)[i], fde, for_eh);
707 /* If we are to emit a ref/link from function bodies to their frame tables,
708 do it now. This is typically performed to make sure that tables
709 associated with functions are dragged with them and not discarded in
710 garbage collecting links. We need to do this on a per function basis to
711 cope with -ffunction-sections. */
713 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
714 /* Switch to the function section, emit the ref to the tables, and
715 switch *back* into the table section. */
716 switch_to_section (function_section (fde->decl));
717 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label);
718 switch_to_frame_table_section (for_eh, true);
719 #endif
721 /* Pad the FDE out to an address sized boundary. */
722 ASM_OUTPUT_ALIGN (asm_out_file,
723 floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
724 ASM_OUTPUT_LABEL (asm_out_file, l2);
726 j += 2;
729 /* Return true if frame description entry FDE is needed for EH. */
731 static bool
732 fde_needed_for_eh_p (dw_fde_ref fde)
734 if (flag_asynchronous_unwind_tables)
735 return true;
737 if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde->decl))
738 return true;
740 if (fde->uses_eh_lsda)
741 return true;
743 /* If exceptions are enabled, we have collected nothrow info. */
744 if (flag_exceptions && (fde->all_throwers_are_sibcalls || fde->nothrow))
745 return false;
747 return true;
750 /* Output the call frame information used to record information
751 that relates to calculating the frame pointer, and records the
752 location of saved registers. */
754 static void
755 output_call_frame_info (int for_eh)
757 unsigned int i;
758 dw_fde_ref fde;
759 dw_cfi_ref cfi;
760 char l1[20], l2[20], section_start_label[20];
761 bool any_lsda_needed = false;
762 char augmentation[6];
763 int augmentation_size;
764 int fde_encoding = DW_EH_PE_absptr;
765 int per_encoding = DW_EH_PE_absptr;
766 int lsda_encoding = DW_EH_PE_absptr;
767 int return_reg;
768 rtx personality = NULL;
769 int dw_cie_version;
771 /* Don't emit a CIE if there won't be any FDEs. */
772 if (!fde_vec)
773 return;
775 /* Nothing to do if the assembler's doing it all. */
776 if (dwarf2out_do_cfi_asm ())
777 return;
779 /* If we don't have any functions we'll want to unwind out of, don't emit
780 any EH unwind information. If we make FDEs linkonce, we may have to
781 emit an empty label for an FDE that wouldn't otherwise be emitted. We
782 want to avoid having an FDE kept around when the function it refers to
783 is discarded. Example where this matters: a primary function template
784 in C++ requires EH information, an explicit specialization doesn't. */
785 if (for_eh)
787 bool any_eh_needed = false;
789 FOR_EACH_VEC_ELT (*fde_vec, i, fde)
791 if (fde->uses_eh_lsda)
792 any_eh_needed = any_lsda_needed = true;
793 else if (fde_needed_for_eh_p (fde))
794 any_eh_needed = true;
795 else if (TARGET_USES_WEAK_UNWIND_INFO)
796 targetm.asm_out.emit_unwind_label (asm_out_file, fde->decl, 1, 1);
799 if (!any_eh_needed)
800 return;
803 /* We're going to be generating comments, so turn on app. */
804 if (flag_debug_asm)
805 app_enable ();
807 /* Switch to the proper frame section, first time. */
808 switch_to_frame_table_section (for_eh, false);
810 ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
811 ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
813 /* Output the CIE. */
814 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
815 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
816 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
817 dw2_asm_output_data (4, 0xffffffff,
818 "Initial length escape value indicating 64-bit DWARF extension");
819 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
820 "Length of Common Information Entry");
821 ASM_OUTPUT_LABEL (asm_out_file, l1);
823 /* Now that the CIE pointer is PC-relative for EH,
824 use 0 to identify the CIE. */
825 dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
826 (for_eh ? 0 : DWARF_CIE_ID),
827 "CIE Identifier Tag");
829 /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
830 use CIE version 1, unless that would produce incorrect results
831 due to overflowing the return register column. */
832 return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
833 dw_cie_version = 1;
834 if (return_reg >= 256 || dwarf_version > 2)
835 dw_cie_version = 3;
836 dw2_asm_output_data (1, dw_cie_version, "CIE Version");
838 augmentation[0] = 0;
839 augmentation_size = 0;
841 personality = current_unit_personality;
842 if (for_eh)
844 char *p;
846 /* Augmentation:
847 z Indicates that a uleb128 is present to size the
848 augmentation section.
849 L Indicates the encoding (and thus presence) of
850 an LSDA pointer in the FDE augmentation.
851 R Indicates a non-default pointer encoding for
852 FDE code pointers.
853 P Indicates the presence of an encoding + language
854 personality routine in the CIE augmentation. */
856 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
857 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
858 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
860 p = augmentation + 1;
861 if (personality)
863 *p++ = 'P';
864 augmentation_size += 1 + size_of_encoded_value (per_encoding);
865 assemble_external_libcall (personality);
867 if (any_lsda_needed)
869 *p++ = 'L';
870 augmentation_size += 1;
872 if (fde_encoding != DW_EH_PE_absptr)
874 *p++ = 'R';
875 augmentation_size += 1;
877 if (p > augmentation + 1)
879 augmentation[0] = 'z';
880 *p = '\0';
883 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
884 if (personality && per_encoding == DW_EH_PE_aligned)
886 int offset = ( 4 /* Length */
887 + 4 /* CIE Id */
888 + 1 /* CIE version */
889 + strlen (augmentation) + 1 /* Augmentation */
890 + size_of_uleb128 (1) /* Code alignment */
891 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
892 + 1 /* RA column */
893 + 1 /* Augmentation size */
894 + 1 /* Personality encoding */ );
895 int pad = -offset & (PTR_SIZE - 1);
897 augmentation_size += pad;
899 /* Augmentations should be small, so there's scarce need to
900 iterate for a solution. Die if we exceed one uleb128 byte. */
901 gcc_assert (size_of_uleb128 (augmentation_size) == 1);
905 dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
906 if (dw_cie_version >= 4)
908 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "CIE Address Size");
909 dw2_asm_output_data (1, 0, "CIE Segment Size");
911 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
912 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
913 "CIE Data Alignment Factor");
915 if (dw_cie_version == 1)
916 dw2_asm_output_data (1, return_reg, "CIE RA Column");
917 else
918 dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
920 if (augmentation[0])
922 dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
923 if (personality)
925 dw2_asm_output_data (1, per_encoding, "Personality (%s)",
926 eh_data_format_name (per_encoding));
927 dw2_asm_output_encoded_addr_rtx (per_encoding,
928 personality,
929 true, NULL);
932 if (any_lsda_needed)
933 dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
934 eh_data_format_name (lsda_encoding));
936 if (fde_encoding != DW_EH_PE_absptr)
937 dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
938 eh_data_format_name (fde_encoding));
941 FOR_EACH_VEC_ELT (*cie_cfi_vec, i, cfi)
942 output_cfi (cfi, NULL, for_eh);
944 /* Pad the CIE out to an address sized boundary. */
945 ASM_OUTPUT_ALIGN (asm_out_file,
946 floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
947 ASM_OUTPUT_LABEL (asm_out_file, l2);
949 /* Loop through all of the FDE's. */
950 FOR_EACH_VEC_ELT (*fde_vec, i, fde)
952 unsigned int k;
954 /* Don't emit EH unwind info for leaf functions that don't need it. */
955 if (for_eh && !fde_needed_for_eh_p (fde))
956 continue;
958 for (k = 0; k < (fde->dw_fde_second_begin ? 2 : 1); k++)
959 output_fde (fde, for_eh, k, section_start_label, fde_encoding,
960 augmentation, any_lsda_needed, lsda_encoding);
963 if (for_eh && targetm.terminate_dw2_eh_frame_info)
964 dw2_asm_output_data (4, 0, "End of Table");
966 /* Turn off app to make assembly quicker. */
967 if (flag_debug_asm)
968 app_disable ();
971 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed. */
973 static void
974 dwarf2out_do_cfi_startproc (bool second)
976 int enc;
977 rtx ref;
978 rtx personality = get_personality_function (current_function_decl);
980 fprintf (asm_out_file, "\t.cfi_startproc\n");
982 if (personality)
984 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
985 ref = personality;
987 /* ??? The GAS support isn't entirely consistent. We have to
988 handle indirect support ourselves, but PC-relative is done
989 in the assembler. Further, the assembler can't handle any
990 of the weirder relocation types. */
991 if (enc & DW_EH_PE_indirect)
992 ref = dw2_force_const_mem (ref, true);
994 fprintf (asm_out_file, "\t.cfi_personality %#x,", enc);
995 output_addr_const (asm_out_file, ref);
996 fputc ('\n', asm_out_file);
999 if (crtl->uses_eh_lsda)
1001 char lab[20];
1003 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
1004 ASM_GENERATE_INTERNAL_LABEL (lab, second ? "LLSDAC" : "LLSDA",
1005 current_function_funcdef_no);
1006 ref = gen_rtx_SYMBOL_REF (Pmode, lab);
1007 SYMBOL_REF_FLAGS (ref) = SYMBOL_FLAG_LOCAL;
1009 if (enc & DW_EH_PE_indirect)
1010 ref = dw2_force_const_mem (ref, true);
1012 fprintf (asm_out_file, "\t.cfi_lsda %#x,", enc);
1013 output_addr_const (asm_out_file, ref);
1014 fputc ('\n', asm_out_file);
1018 /* Allocate CURRENT_FDE. Immediately initialize all we can, noting that
1019 this allocation may be done before pass_final. */
1021 dw_fde_ref
1022 dwarf2out_alloc_current_fde (void)
1024 dw_fde_ref fde;
1026 fde = ggc_cleared_alloc<dw_fde_node> ();
1027 fde->decl = current_function_decl;
1028 fde->funcdef_number = current_function_funcdef_no;
1029 fde->fde_index = vec_safe_length (fde_vec);
1030 fde->all_throwers_are_sibcalls = crtl->all_throwers_are_sibcalls;
1031 fde->uses_eh_lsda = crtl->uses_eh_lsda;
1032 fde->nothrow = crtl->nothrow;
1033 fde->drap_reg = INVALID_REGNUM;
1034 fde->vdrap_reg = INVALID_REGNUM;
1036 /* Record the FDE associated with this function. */
1037 cfun->fde = fde;
1038 vec_safe_push (fde_vec, fde);
1040 return fde;
1043 /* Output a marker (i.e. a label) for the beginning of a function, before
1044 the prologue. */
1046 void
1047 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
1048 const char *file ATTRIBUTE_UNUSED)
1050 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1051 char * dup_label;
1052 dw_fde_ref fde;
1053 section *fnsec;
1054 bool do_frame;
1056 current_function_func_begin_label = NULL;
1058 do_frame = dwarf2out_do_frame ();
1060 /* ??? current_function_func_begin_label is also used by except.c for
1061 call-site information. We must emit this label if it might be used. */
1062 if (!do_frame
1063 && (!flag_exceptions
1064 || targetm_common.except_unwind_info (&global_options) == UI_SJLJ))
1065 return;
1067 fnsec = function_section (current_function_decl);
1068 switch_to_section (fnsec);
1069 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
1070 current_function_funcdef_no);
1071 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
1072 current_function_funcdef_no);
1073 dup_label = xstrdup (label);
1074 current_function_func_begin_label = dup_label;
1076 /* We can elide the fde allocation if we're not emitting debug info. */
1077 if (!do_frame)
1078 return;
1080 /* Cater to the various TARGET_ASM_OUTPUT_MI_THUNK implementations that
1081 emit insns as rtx but bypass the bulk of rest_of_compilation, which
1082 would include pass_dwarf2_frame. If we've not created the FDE yet,
1083 do so now. */
1084 fde = cfun->fde;
1085 if (fde == NULL)
1086 fde = dwarf2out_alloc_current_fde ();
1088 /* Initialize the bits of CURRENT_FDE that were not available earlier. */
1089 fde->dw_fde_begin = dup_label;
1090 fde->dw_fde_current_label = dup_label;
1091 fde->in_std_section = (fnsec == text_section
1092 || (cold_text_section && fnsec == cold_text_section));
1094 /* We only want to output line number information for the genuine dwarf2
1095 prologue case, not the eh frame case. */
1096 #ifdef DWARF2_DEBUGGING_INFO
1097 if (file)
1098 dwarf2out_source_line (line, file, 0, true);
1099 #endif
1101 if (dwarf2out_do_cfi_asm ())
1102 dwarf2out_do_cfi_startproc (false);
1103 else
1105 rtx personality = get_personality_function (current_function_decl);
1106 if (!current_unit_personality)
1107 current_unit_personality = personality;
1109 /* We cannot keep a current personality per function as without CFI
1110 asm, at the point where we emit the CFI data, there is no current
1111 function anymore. */
1112 if (personality && current_unit_personality != personality)
1113 sorry ("multiple EH personalities are supported only with assemblers "
1114 "supporting .cfi_personality directive");
1118 /* Output a marker (i.e. a label) for the end of the generated code
1119 for a function prologue. This gets called *after* the prologue code has
1120 been generated. */
1122 void
1123 dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED,
1124 const char *file ATTRIBUTE_UNUSED)
1126 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1128 /* Output a label to mark the endpoint of the code generated for this
1129 function. */
1130 ASM_GENERATE_INTERNAL_LABEL (label, PROLOGUE_END_LABEL,
1131 current_function_funcdef_no);
1132 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, PROLOGUE_END_LABEL,
1133 current_function_funcdef_no);
1134 cfun->fde->dw_fde_vms_end_prologue = xstrdup (label);
1137 /* Output a marker (i.e. a label) for the beginning of the generated code
1138 for a function epilogue. This gets called *before* the prologue code has
1139 been generated. */
1141 void
1142 dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED,
1143 const char *file ATTRIBUTE_UNUSED)
1145 dw_fde_ref fde = cfun->fde;
1146 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1148 if (fde->dw_fde_vms_begin_epilogue)
1149 return;
1151 /* Output a label to mark the endpoint of the code generated for this
1152 function. */
1153 ASM_GENERATE_INTERNAL_LABEL (label, EPILOGUE_BEGIN_LABEL,
1154 current_function_funcdef_no);
1155 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, EPILOGUE_BEGIN_LABEL,
1156 current_function_funcdef_no);
1157 fde->dw_fde_vms_begin_epilogue = xstrdup (label);
1160 /* Output a marker (i.e. a label) for the absolute end of the generated code
1161 for a function definition. This gets called *after* the epilogue code has
1162 been generated. */
1164 void
1165 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
1166 const char *file ATTRIBUTE_UNUSED)
1168 dw_fde_ref fde;
1169 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1171 last_var_location_insn = NULL;
1172 cached_next_real_insn = NULL;
1174 if (dwarf2out_do_cfi_asm ())
1175 fprintf (asm_out_file, "\t.cfi_endproc\n");
1177 /* Output a label to mark the endpoint of the code generated for this
1178 function. */
1179 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
1180 current_function_funcdef_no);
1181 ASM_OUTPUT_LABEL (asm_out_file, label);
1182 fde = cfun->fde;
1183 gcc_assert (fde != NULL);
1184 if (fde->dw_fde_second_begin == NULL)
1185 fde->dw_fde_end = xstrdup (label);
1188 void
1189 dwarf2out_frame_finish (void)
1191 /* Output call frame information. */
1192 if (targetm.debug_unwind_info () == UI_DWARF2)
1193 output_call_frame_info (0);
1195 /* Output another copy for the unwinder. */
1196 if ((flag_unwind_tables || flag_exceptions)
1197 && targetm_common.except_unwind_info (&global_options) == UI_DWARF2)
1198 output_call_frame_info (1);
1201 /* Note that the current function section is being used for code. */
1203 static void
1204 dwarf2out_note_section_used (void)
1206 section *sec = current_function_section ();
1207 if (sec == text_section)
1208 text_section_used = true;
1209 else if (sec == cold_text_section)
1210 cold_text_section_used = true;
1213 static void var_location_switch_text_section (void);
1214 static void set_cur_line_info_table (section *);
1216 void
1217 dwarf2out_switch_text_section (void)
1219 section *sect;
1220 dw_fde_ref fde = cfun->fde;
1222 gcc_assert (cfun && fde && fde->dw_fde_second_begin == NULL);
1224 if (!in_cold_section_p)
1226 fde->dw_fde_end = crtl->subsections.cold_section_end_label;
1227 fde->dw_fde_second_begin = crtl->subsections.hot_section_label;
1228 fde->dw_fde_second_end = crtl->subsections.hot_section_end_label;
1230 else
1232 fde->dw_fde_end = crtl->subsections.hot_section_end_label;
1233 fde->dw_fde_second_begin = crtl->subsections.cold_section_label;
1234 fde->dw_fde_second_end = crtl->subsections.cold_section_end_label;
1236 have_multiple_function_sections = true;
1238 /* There is no need to mark used sections when not debugging. */
1239 if (cold_text_section != NULL)
1240 dwarf2out_note_section_used ();
1242 if (dwarf2out_do_cfi_asm ())
1243 fprintf (asm_out_file, "\t.cfi_endproc\n");
1245 /* Now do the real section switch. */
1246 sect = current_function_section ();
1247 switch_to_section (sect);
1249 fde->second_in_std_section
1250 = (sect == text_section
1251 || (cold_text_section && sect == cold_text_section));
1253 if (dwarf2out_do_cfi_asm ())
1254 dwarf2out_do_cfi_startproc (true);
1256 var_location_switch_text_section ();
1258 if (cold_text_section != NULL)
1259 set_cur_line_info_table (sect);
1262 /* And now, the subset of the debugging information support code necessary
1263 for emitting location expressions. */
1265 /* Data about a single source file. */
1266 struct GTY((for_user)) dwarf_file_data {
1267 const char * filename;
1268 int emitted_number;
1271 typedef struct GTY(()) deferred_locations_struct
1273 tree variable;
1274 dw_die_ref die;
1275 } deferred_locations;
1278 static GTY(()) vec<deferred_locations, va_gc> *deferred_locations_list;
1281 /* Describe an entry into the .debug_addr section. */
1283 enum ate_kind {
1284 ate_kind_rtx,
1285 ate_kind_rtx_dtprel,
1286 ate_kind_label
1289 typedef struct GTY((for_user)) addr_table_entry_struct {
1290 enum ate_kind kind;
1291 unsigned int refcount;
1292 unsigned int index;
1293 union addr_table_entry_struct_union
1295 rtx GTY ((tag ("0"))) rtl;
1296 char * GTY ((tag ("1"))) label;
1298 GTY ((desc ("%1.kind"))) addr;
1300 addr_table_entry;
1302 /* Location lists are ranges + location descriptions for that range,
1303 so you can track variables that are in different places over
1304 their entire life. */
1305 typedef struct GTY(()) dw_loc_list_struct {
1306 dw_loc_list_ref dw_loc_next;
1307 const char *begin; /* Label and addr_entry for start of range */
1308 addr_table_entry *begin_entry;
1309 const char *end; /* Label for end of range */
1310 char *ll_symbol; /* Label for beginning of location list.
1311 Only on head of list */
1312 const char *section; /* Section this loclist is relative to */
1313 dw_loc_descr_ref expr;
1314 hashval_t hash;
1315 /* True if all addresses in this and subsequent lists are known to be
1316 resolved. */
1317 bool resolved_addr;
1318 /* True if this list has been replaced by dw_loc_next. */
1319 bool replaced;
1320 bool emitted;
1321 /* True if the range should be emitted even if begin and end
1322 are the same. */
1323 bool force;
1324 } dw_loc_list_node;
1326 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
1328 /* Convert a DWARF stack opcode into its string name. */
1330 static const char *
1331 dwarf_stack_op_name (unsigned int op)
1333 const char *name = get_DW_OP_name (op);
1335 if (name != NULL)
1336 return name;
1338 return "OP_<unknown>";
1341 /* Return a pointer to a newly allocated location description. Location
1342 descriptions are simple expression terms that can be strung
1343 together to form more complicated location (address) descriptions. */
1345 static inline dw_loc_descr_ref
1346 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
1347 unsigned HOST_WIDE_INT oprnd2)
1349 dw_loc_descr_ref descr = ggc_cleared_alloc<dw_loc_descr_node> ();
1351 descr->dw_loc_opc = op;
1352 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
1353 descr->dw_loc_oprnd1.val_entry = NULL;
1354 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
1355 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
1356 descr->dw_loc_oprnd2.val_entry = NULL;
1357 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
1359 return descr;
1362 /* Return a pointer to a newly allocated location description for
1363 REG and OFFSET. */
1365 static inline dw_loc_descr_ref
1366 new_reg_loc_descr (unsigned int reg, unsigned HOST_WIDE_INT offset)
1368 if (reg <= 31)
1369 return new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + reg),
1370 offset, 0);
1371 else
1372 return new_loc_descr (DW_OP_bregx, reg, offset);
1375 /* Add a location description term to a location description expression. */
1377 static inline void
1378 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
1380 dw_loc_descr_ref *d;
1382 /* Find the end of the chain. */
1383 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
1386 *d = descr;
1389 /* Compare two location operands for exact equality. */
1391 static bool
1392 dw_val_equal_p (dw_val_node *a, dw_val_node *b)
1394 if (a->val_class != b->val_class)
1395 return false;
1396 switch (a->val_class)
1398 case dw_val_class_none:
1399 return true;
1400 case dw_val_class_addr:
1401 return rtx_equal_p (a->v.val_addr, b->v.val_addr);
1403 case dw_val_class_offset:
1404 case dw_val_class_unsigned_const:
1405 case dw_val_class_const:
1406 case dw_val_class_range_list:
1407 case dw_val_class_lineptr:
1408 case dw_val_class_macptr:
1409 /* These are all HOST_WIDE_INT, signed or unsigned. */
1410 return a->v.val_unsigned == b->v.val_unsigned;
1412 case dw_val_class_loc:
1413 return a->v.val_loc == b->v.val_loc;
1414 case dw_val_class_loc_list:
1415 return a->v.val_loc_list == b->v.val_loc_list;
1416 case dw_val_class_die_ref:
1417 return a->v.val_die_ref.die == b->v.val_die_ref.die;
1418 case dw_val_class_fde_ref:
1419 return a->v.val_fde_index == b->v.val_fde_index;
1420 case dw_val_class_lbl_id:
1421 case dw_val_class_high_pc:
1422 return strcmp (a->v.val_lbl_id, b->v.val_lbl_id) == 0;
1423 case dw_val_class_str:
1424 return a->v.val_str == b->v.val_str;
1425 case dw_val_class_flag:
1426 return a->v.val_flag == b->v.val_flag;
1427 case dw_val_class_file:
1428 return a->v.val_file == b->v.val_file;
1429 case dw_val_class_decl_ref:
1430 return a->v.val_decl_ref == b->v.val_decl_ref;
1432 case dw_val_class_const_double:
1433 return (a->v.val_double.high == b->v.val_double.high
1434 && a->v.val_double.low == b->v.val_double.low);
1436 case dw_val_class_wide_int:
1437 return *a->v.val_wide == *b->v.val_wide;
1439 case dw_val_class_vec:
1441 size_t a_len = a->v.val_vec.elt_size * a->v.val_vec.length;
1442 size_t b_len = b->v.val_vec.elt_size * b->v.val_vec.length;
1444 return (a_len == b_len
1445 && !memcmp (a->v.val_vec.array, b->v.val_vec.array, a_len));
1448 case dw_val_class_data8:
1449 return memcmp (a->v.val_data8, b->v.val_data8, 8) == 0;
1451 case dw_val_class_vms_delta:
1452 return (!strcmp (a->v.val_vms_delta.lbl1, b->v.val_vms_delta.lbl1)
1453 && !strcmp (a->v.val_vms_delta.lbl1, b->v.val_vms_delta.lbl1));
1455 gcc_unreachable ();
1458 /* Compare two location atoms for exact equality. */
1460 static bool
1461 loc_descr_equal_p_1 (dw_loc_descr_ref a, dw_loc_descr_ref b)
1463 if (a->dw_loc_opc != b->dw_loc_opc)
1464 return false;
1466 /* ??? This is only ever set for DW_OP_constNu, for N equal to the
1467 address size, but since we always allocate cleared storage it
1468 should be zero for other types of locations. */
1469 if (a->dtprel != b->dtprel)
1470 return false;
1472 return (dw_val_equal_p (&a->dw_loc_oprnd1, &b->dw_loc_oprnd1)
1473 && dw_val_equal_p (&a->dw_loc_oprnd2, &b->dw_loc_oprnd2));
1476 /* Compare two complete location expressions for exact equality. */
1478 bool
1479 loc_descr_equal_p (dw_loc_descr_ref a, dw_loc_descr_ref b)
1481 while (1)
1483 if (a == b)
1484 return true;
1485 if (a == NULL || b == NULL)
1486 return false;
1487 if (!loc_descr_equal_p_1 (a, b))
1488 return false;
1490 a = a->dw_loc_next;
1491 b = b->dw_loc_next;
1496 /* Add a constant OFFSET to a location expression. */
1498 static void
1499 loc_descr_plus_const (dw_loc_descr_ref *list_head, HOST_WIDE_INT offset)
1501 dw_loc_descr_ref loc;
1502 HOST_WIDE_INT *p;
1504 gcc_assert (*list_head != NULL);
1506 if (!offset)
1507 return;
1509 /* Find the end of the chain. */
1510 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
1513 p = NULL;
1514 if (loc->dw_loc_opc == DW_OP_fbreg
1515 || (loc->dw_loc_opc >= DW_OP_breg0 && loc->dw_loc_opc <= DW_OP_breg31))
1516 p = &loc->dw_loc_oprnd1.v.val_int;
1517 else if (loc->dw_loc_opc == DW_OP_bregx)
1518 p = &loc->dw_loc_oprnd2.v.val_int;
1520 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
1521 offset. Don't optimize if an signed integer overflow would happen. */
1522 if (p != NULL
1523 && ((offset > 0 && *p <= INTTYPE_MAXIMUM (HOST_WIDE_INT) - offset)
1524 || (offset < 0 && *p >= INTTYPE_MINIMUM (HOST_WIDE_INT) - offset)))
1525 *p += offset;
1527 else if (offset > 0)
1528 loc->dw_loc_next = new_loc_descr (DW_OP_plus_uconst, offset, 0);
1530 else
1532 loc->dw_loc_next = int_loc_descriptor (-offset);
1533 add_loc_descr (&loc->dw_loc_next, new_loc_descr (DW_OP_minus, 0, 0));
1537 /* Add a constant OFFSET to a location list. */
1539 static void
1540 loc_list_plus_const (dw_loc_list_ref list_head, HOST_WIDE_INT offset)
1542 dw_loc_list_ref d;
1543 for (d = list_head; d != NULL; d = d->dw_loc_next)
1544 loc_descr_plus_const (&d->expr, offset);
1547 #define DWARF_REF_SIZE \
1548 (dwarf_version == 2 ? DWARF2_ADDR_SIZE : DWARF_OFFSET_SIZE)
1550 static unsigned long int get_base_type_offset (dw_die_ref);
1552 /* Return the size of a location descriptor. */
1554 static unsigned long
1555 size_of_loc_descr (dw_loc_descr_ref loc)
1557 unsigned long size = 1;
1559 switch (loc->dw_loc_opc)
1561 case DW_OP_addr:
1562 size += DWARF2_ADDR_SIZE;
1563 break;
1564 case DW_OP_GNU_addr_index:
1565 case DW_OP_GNU_const_index:
1566 gcc_assert (loc->dw_loc_oprnd1.val_entry->index != NO_INDEX_ASSIGNED);
1567 size += size_of_uleb128 (loc->dw_loc_oprnd1.val_entry->index);
1568 break;
1569 case DW_OP_const1u:
1570 case DW_OP_const1s:
1571 size += 1;
1572 break;
1573 case DW_OP_const2u:
1574 case DW_OP_const2s:
1575 size += 2;
1576 break;
1577 case DW_OP_const4u:
1578 case DW_OP_const4s:
1579 size += 4;
1580 break;
1581 case DW_OP_const8u:
1582 case DW_OP_const8s:
1583 size += 8;
1584 break;
1585 case DW_OP_constu:
1586 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1587 break;
1588 case DW_OP_consts:
1589 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
1590 break;
1591 case DW_OP_pick:
1592 size += 1;
1593 break;
1594 case DW_OP_plus_uconst:
1595 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1596 break;
1597 case DW_OP_skip:
1598 case DW_OP_bra:
1599 size += 2;
1600 break;
1601 case DW_OP_breg0:
1602 case DW_OP_breg1:
1603 case DW_OP_breg2:
1604 case DW_OP_breg3:
1605 case DW_OP_breg4:
1606 case DW_OP_breg5:
1607 case DW_OP_breg6:
1608 case DW_OP_breg7:
1609 case DW_OP_breg8:
1610 case DW_OP_breg9:
1611 case DW_OP_breg10:
1612 case DW_OP_breg11:
1613 case DW_OP_breg12:
1614 case DW_OP_breg13:
1615 case DW_OP_breg14:
1616 case DW_OP_breg15:
1617 case DW_OP_breg16:
1618 case DW_OP_breg17:
1619 case DW_OP_breg18:
1620 case DW_OP_breg19:
1621 case DW_OP_breg20:
1622 case DW_OP_breg21:
1623 case DW_OP_breg22:
1624 case DW_OP_breg23:
1625 case DW_OP_breg24:
1626 case DW_OP_breg25:
1627 case DW_OP_breg26:
1628 case DW_OP_breg27:
1629 case DW_OP_breg28:
1630 case DW_OP_breg29:
1631 case DW_OP_breg30:
1632 case DW_OP_breg31:
1633 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
1634 break;
1635 case DW_OP_regx:
1636 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1637 break;
1638 case DW_OP_fbreg:
1639 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
1640 break;
1641 case DW_OP_bregx:
1642 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1643 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
1644 break;
1645 case DW_OP_piece:
1646 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1647 break;
1648 case DW_OP_bit_piece:
1649 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1650 size += size_of_uleb128 (loc->dw_loc_oprnd2.v.val_unsigned);
1651 break;
1652 case DW_OP_deref_size:
1653 case DW_OP_xderef_size:
1654 size += 1;
1655 break;
1656 case DW_OP_call2:
1657 size += 2;
1658 break;
1659 case DW_OP_call4:
1660 size += 4;
1661 break;
1662 case DW_OP_call_ref:
1663 size += DWARF_REF_SIZE;
1664 break;
1665 case DW_OP_implicit_value:
1666 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned)
1667 + loc->dw_loc_oprnd1.v.val_unsigned;
1668 break;
1669 case DW_OP_GNU_implicit_pointer:
1670 size += DWARF_REF_SIZE + size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
1671 break;
1672 case DW_OP_GNU_entry_value:
1674 unsigned long op_size = size_of_locs (loc->dw_loc_oprnd1.v.val_loc);
1675 size += size_of_uleb128 (op_size) + op_size;
1676 break;
1678 case DW_OP_GNU_const_type:
1680 unsigned long o
1681 = get_base_type_offset (loc->dw_loc_oprnd1.v.val_die_ref.die);
1682 size += size_of_uleb128 (o) + 1;
1683 switch (loc->dw_loc_oprnd2.val_class)
1685 case dw_val_class_vec:
1686 size += loc->dw_loc_oprnd2.v.val_vec.length
1687 * loc->dw_loc_oprnd2.v.val_vec.elt_size;
1688 break;
1689 case dw_val_class_const:
1690 size += HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT;
1691 break;
1692 case dw_val_class_const_double:
1693 size += HOST_BITS_PER_DOUBLE_INT / BITS_PER_UNIT;
1694 break;
1695 case dw_val_class_wide_int:
1696 size += (get_full_len (*loc->dw_loc_oprnd2.v.val_wide)
1697 * HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT);
1698 break;
1699 default:
1700 gcc_unreachable ();
1702 break;
1704 case DW_OP_GNU_regval_type:
1706 unsigned long o
1707 = get_base_type_offset (loc->dw_loc_oprnd2.v.val_die_ref.die);
1708 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned)
1709 + size_of_uleb128 (o);
1711 break;
1712 case DW_OP_GNU_deref_type:
1714 unsigned long o
1715 = get_base_type_offset (loc->dw_loc_oprnd2.v.val_die_ref.die);
1716 size += 1 + size_of_uleb128 (o);
1718 break;
1719 case DW_OP_GNU_convert:
1720 case DW_OP_GNU_reinterpret:
1721 if (loc->dw_loc_oprnd1.val_class == dw_val_class_unsigned_const)
1722 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1723 else
1725 unsigned long o
1726 = get_base_type_offset (loc->dw_loc_oprnd1.v.val_die_ref.die);
1727 size += size_of_uleb128 (o);
1729 break;
1730 case DW_OP_GNU_parameter_ref:
1731 size += 4;
1732 break;
1733 default:
1734 break;
1737 return size;
1740 /* Return the size of a series of location descriptors. */
1742 unsigned long
1743 size_of_locs (dw_loc_descr_ref loc)
1745 dw_loc_descr_ref l;
1746 unsigned long size;
1748 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
1749 field, to avoid writing to a PCH file. */
1750 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
1752 if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra)
1753 break;
1754 size += size_of_loc_descr (l);
1756 if (! l)
1757 return size;
1759 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
1761 l->dw_loc_addr = size;
1762 size += size_of_loc_descr (l);
1765 return size;
1768 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
1769 static void get_ref_die_offset_label (char *, dw_die_ref);
1770 static unsigned long int get_ref_die_offset (dw_die_ref);
1772 /* Output location description stack opcode's operands (if any).
1773 The for_eh_or_skip parameter controls whether register numbers are
1774 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
1775 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
1776 info). This should be suppressed for the cases that have not been converted
1777 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
1779 static void
1780 output_loc_operands (dw_loc_descr_ref loc, int for_eh_or_skip)
1782 dw_val_ref val1 = &loc->dw_loc_oprnd1;
1783 dw_val_ref val2 = &loc->dw_loc_oprnd2;
1785 switch (loc->dw_loc_opc)
1787 #ifdef DWARF2_DEBUGGING_INFO
1788 case DW_OP_const2u:
1789 case DW_OP_const2s:
1790 dw2_asm_output_data (2, val1->v.val_int, NULL);
1791 break;
1792 case DW_OP_const4u:
1793 if (loc->dtprel)
1795 gcc_assert (targetm.asm_out.output_dwarf_dtprel);
1796 targetm.asm_out.output_dwarf_dtprel (asm_out_file, 4,
1797 val1->v.val_addr);
1798 fputc ('\n', asm_out_file);
1799 break;
1801 /* FALLTHRU */
1802 case DW_OP_const4s:
1803 dw2_asm_output_data (4, val1->v.val_int, NULL);
1804 break;
1805 case DW_OP_const8u:
1806 if (loc->dtprel)
1808 gcc_assert (targetm.asm_out.output_dwarf_dtprel);
1809 targetm.asm_out.output_dwarf_dtprel (asm_out_file, 8,
1810 val1->v.val_addr);
1811 fputc ('\n', asm_out_file);
1812 break;
1814 /* FALLTHRU */
1815 case DW_OP_const8s:
1816 gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
1817 dw2_asm_output_data (8, val1->v.val_int, NULL);
1818 break;
1819 case DW_OP_skip:
1820 case DW_OP_bra:
1822 int offset;
1824 gcc_assert (val1->val_class == dw_val_class_loc);
1825 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
1827 dw2_asm_output_data (2, offset, NULL);
1829 break;
1830 case DW_OP_implicit_value:
1831 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
1832 switch (val2->val_class)
1834 case dw_val_class_const:
1835 dw2_asm_output_data (val1->v.val_unsigned, val2->v.val_int, NULL);
1836 break;
1837 case dw_val_class_vec:
1839 unsigned int elt_size = val2->v.val_vec.elt_size;
1840 unsigned int len = val2->v.val_vec.length;
1841 unsigned int i;
1842 unsigned char *p;
1844 if (elt_size > sizeof (HOST_WIDE_INT))
1846 elt_size /= 2;
1847 len *= 2;
1849 for (i = 0, p = val2->v.val_vec.array;
1850 i < len;
1851 i++, p += elt_size)
1852 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
1853 "fp or vector constant word %u", i);
1855 break;
1856 case dw_val_class_const_double:
1858 unsigned HOST_WIDE_INT first, second;
1860 if (WORDS_BIG_ENDIAN)
1862 first = val2->v.val_double.high;
1863 second = val2->v.val_double.low;
1865 else
1867 first = val2->v.val_double.low;
1868 second = val2->v.val_double.high;
1870 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
1871 first, NULL);
1872 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
1873 second, NULL);
1875 break;
1876 case dw_val_class_wide_int:
1878 int i;
1879 int len = get_full_len (*val2->v.val_wide);
1880 if (WORDS_BIG_ENDIAN)
1881 for (i = len - 1; i >= 0; --i)
1882 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
1883 val2->v.val_wide->elt (i), NULL);
1884 else
1885 for (i = 0; i < len; ++i)
1886 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
1887 val2->v.val_wide->elt (i), NULL);
1889 break;
1890 case dw_val_class_addr:
1891 gcc_assert (val1->v.val_unsigned == DWARF2_ADDR_SIZE);
1892 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val2->v.val_addr, NULL);
1893 break;
1894 default:
1895 gcc_unreachable ();
1897 break;
1898 #else
1899 case DW_OP_const2u:
1900 case DW_OP_const2s:
1901 case DW_OP_const4u:
1902 case DW_OP_const4s:
1903 case DW_OP_const8u:
1904 case DW_OP_const8s:
1905 case DW_OP_skip:
1906 case DW_OP_bra:
1907 case DW_OP_implicit_value:
1908 /* We currently don't make any attempt to make sure these are
1909 aligned properly like we do for the main unwind info, so
1910 don't support emitting things larger than a byte if we're
1911 only doing unwinding. */
1912 gcc_unreachable ();
1913 #endif
1914 case DW_OP_const1u:
1915 case DW_OP_const1s:
1916 dw2_asm_output_data (1, val1->v.val_int, NULL);
1917 break;
1918 case DW_OP_constu:
1919 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
1920 break;
1921 case DW_OP_consts:
1922 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
1923 break;
1924 case DW_OP_pick:
1925 dw2_asm_output_data (1, val1->v.val_int, NULL);
1926 break;
1927 case DW_OP_plus_uconst:
1928 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
1929 break;
1930 case DW_OP_breg0:
1931 case DW_OP_breg1:
1932 case DW_OP_breg2:
1933 case DW_OP_breg3:
1934 case DW_OP_breg4:
1935 case DW_OP_breg5:
1936 case DW_OP_breg6:
1937 case DW_OP_breg7:
1938 case DW_OP_breg8:
1939 case DW_OP_breg9:
1940 case DW_OP_breg10:
1941 case DW_OP_breg11:
1942 case DW_OP_breg12:
1943 case DW_OP_breg13:
1944 case DW_OP_breg14:
1945 case DW_OP_breg15:
1946 case DW_OP_breg16:
1947 case DW_OP_breg17:
1948 case DW_OP_breg18:
1949 case DW_OP_breg19:
1950 case DW_OP_breg20:
1951 case DW_OP_breg21:
1952 case DW_OP_breg22:
1953 case DW_OP_breg23:
1954 case DW_OP_breg24:
1955 case DW_OP_breg25:
1956 case DW_OP_breg26:
1957 case DW_OP_breg27:
1958 case DW_OP_breg28:
1959 case DW_OP_breg29:
1960 case DW_OP_breg30:
1961 case DW_OP_breg31:
1962 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
1963 break;
1964 case DW_OP_regx:
1966 unsigned r = val1->v.val_unsigned;
1967 if (for_eh_or_skip >= 0)
1968 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
1969 gcc_assert (size_of_uleb128 (r)
1970 == size_of_uleb128 (val1->v.val_unsigned));
1971 dw2_asm_output_data_uleb128 (r, NULL);
1973 break;
1974 case DW_OP_fbreg:
1975 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
1976 break;
1977 case DW_OP_bregx:
1979 unsigned r = val1->v.val_unsigned;
1980 if (for_eh_or_skip >= 0)
1981 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
1982 gcc_assert (size_of_uleb128 (r)
1983 == size_of_uleb128 (val1->v.val_unsigned));
1984 dw2_asm_output_data_uleb128 (r, NULL);
1985 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
1987 break;
1988 case DW_OP_piece:
1989 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
1990 break;
1991 case DW_OP_bit_piece:
1992 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
1993 dw2_asm_output_data_uleb128 (val2->v.val_unsigned, NULL);
1994 break;
1995 case DW_OP_deref_size:
1996 case DW_OP_xderef_size:
1997 dw2_asm_output_data (1, val1->v.val_int, NULL);
1998 break;
2000 case DW_OP_addr:
2001 if (loc->dtprel)
2003 if (targetm.asm_out.output_dwarf_dtprel)
2005 targetm.asm_out.output_dwarf_dtprel (asm_out_file,
2006 DWARF2_ADDR_SIZE,
2007 val1->v.val_addr);
2008 fputc ('\n', asm_out_file);
2010 else
2011 gcc_unreachable ();
2013 else
2015 #ifdef DWARF2_DEBUGGING_INFO
2016 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
2017 #else
2018 gcc_unreachable ();
2019 #endif
2021 break;
2023 case DW_OP_GNU_addr_index:
2024 case DW_OP_GNU_const_index:
2025 gcc_assert (loc->dw_loc_oprnd1.val_entry->index != NO_INDEX_ASSIGNED);
2026 dw2_asm_output_data_uleb128 (loc->dw_loc_oprnd1.val_entry->index,
2027 "(index into .debug_addr)");
2028 break;
2030 case DW_OP_GNU_implicit_pointer:
2032 char label[MAX_ARTIFICIAL_LABEL_BYTES
2033 + HOST_BITS_PER_WIDE_INT / 2 + 2];
2034 gcc_assert (val1->val_class == dw_val_class_die_ref);
2035 get_ref_die_offset_label (label, val1->v.val_die_ref.die);
2036 dw2_asm_output_offset (DWARF_REF_SIZE, label, debug_info_section, NULL);
2037 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
2039 break;
2041 case DW_OP_GNU_entry_value:
2042 dw2_asm_output_data_uleb128 (size_of_locs (val1->v.val_loc), NULL);
2043 output_loc_sequence (val1->v.val_loc, for_eh_or_skip);
2044 break;
2046 case DW_OP_GNU_const_type:
2048 unsigned long o = get_base_type_offset (val1->v.val_die_ref.die), l;
2049 gcc_assert (o);
2050 dw2_asm_output_data_uleb128 (o, NULL);
2051 switch (val2->val_class)
2053 case dw_val_class_const:
2054 l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
2055 dw2_asm_output_data (1, l, NULL);
2056 dw2_asm_output_data (l, val2->v.val_int, NULL);
2057 break;
2058 case dw_val_class_vec:
2060 unsigned int elt_size = val2->v.val_vec.elt_size;
2061 unsigned int len = val2->v.val_vec.length;
2062 unsigned int i;
2063 unsigned char *p;
2065 l = len * elt_size;
2066 dw2_asm_output_data (1, l, NULL);
2067 if (elt_size > sizeof (HOST_WIDE_INT))
2069 elt_size /= 2;
2070 len *= 2;
2072 for (i = 0, p = val2->v.val_vec.array;
2073 i < len;
2074 i++, p += elt_size)
2075 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
2076 "fp or vector constant word %u", i);
2078 break;
2079 case dw_val_class_const_double:
2081 unsigned HOST_WIDE_INT first, second;
2082 l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
2084 dw2_asm_output_data (1, 2 * l, NULL);
2085 if (WORDS_BIG_ENDIAN)
2087 first = val2->v.val_double.high;
2088 second = val2->v.val_double.low;
2090 else
2092 first = val2->v.val_double.low;
2093 second = val2->v.val_double.high;
2095 dw2_asm_output_data (l, first, NULL);
2096 dw2_asm_output_data (l, second, NULL);
2098 break;
2099 case dw_val_class_wide_int:
2101 int i;
2102 int len = get_full_len (*val2->v.val_wide);
2103 l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
2105 dw2_asm_output_data (1, len * l, NULL);
2106 if (WORDS_BIG_ENDIAN)
2107 for (i = len - 1; i >= 0; --i)
2108 dw2_asm_output_data (l, val2->v.val_wide->elt (i), NULL);
2109 else
2110 for (i = 0; i < len; ++i)
2111 dw2_asm_output_data (l, val2->v.val_wide->elt (i), NULL);
2113 break;
2114 default:
2115 gcc_unreachable ();
2118 break;
2119 case DW_OP_GNU_regval_type:
2121 unsigned r = val1->v.val_unsigned;
2122 unsigned long o = get_base_type_offset (val2->v.val_die_ref.die);
2123 gcc_assert (o);
2124 if (for_eh_or_skip >= 0)
2126 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2127 gcc_assert (size_of_uleb128 (r)
2128 == size_of_uleb128 (val1->v.val_unsigned));
2130 dw2_asm_output_data_uleb128 (r, NULL);
2131 dw2_asm_output_data_uleb128 (o, NULL);
2133 break;
2134 case DW_OP_GNU_deref_type:
2136 unsigned long o = get_base_type_offset (val2->v.val_die_ref.die);
2137 gcc_assert (o);
2138 dw2_asm_output_data (1, val1->v.val_int, NULL);
2139 dw2_asm_output_data_uleb128 (o, NULL);
2141 break;
2142 case DW_OP_GNU_convert:
2143 case DW_OP_GNU_reinterpret:
2144 if (loc->dw_loc_oprnd1.val_class == dw_val_class_unsigned_const)
2145 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2146 else
2148 unsigned long o = get_base_type_offset (val1->v.val_die_ref.die);
2149 gcc_assert (o);
2150 dw2_asm_output_data_uleb128 (o, NULL);
2152 break;
2154 case DW_OP_GNU_parameter_ref:
2156 unsigned long o;
2157 gcc_assert (val1->val_class == dw_val_class_die_ref);
2158 o = get_ref_die_offset (val1->v.val_die_ref.die);
2159 dw2_asm_output_data (4, o, NULL);
2161 break;
2163 default:
2164 /* Other codes have no operands. */
2165 break;
2169 /* Output a sequence of location operations.
2170 The for_eh_or_skip parameter controls whether register numbers are
2171 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2172 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2173 info). This should be suppressed for the cases that have not been converted
2174 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2176 void
2177 output_loc_sequence (dw_loc_descr_ref loc, int for_eh_or_skip)
2179 for (; loc != NULL; loc = loc->dw_loc_next)
2181 enum dwarf_location_atom opc = loc->dw_loc_opc;
2182 /* Output the opcode. */
2183 if (for_eh_or_skip >= 0
2184 && opc >= DW_OP_breg0 && opc <= DW_OP_breg31)
2186 unsigned r = (opc - DW_OP_breg0);
2187 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2188 gcc_assert (r <= 31);
2189 opc = (enum dwarf_location_atom) (DW_OP_breg0 + r);
2191 else if (for_eh_or_skip >= 0
2192 && opc >= DW_OP_reg0 && opc <= DW_OP_reg31)
2194 unsigned r = (opc - DW_OP_reg0);
2195 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2196 gcc_assert (r <= 31);
2197 opc = (enum dwarf_location_atom) (DW_OP_reg0 + r);
2200 dw2_asm_output_data (1, opc,
2201 "%s", dwarf_stack_op_name (opc));
2203 /* Output the operand(s) (if any). */
2204 output_loc_operands (loc, for_eh_or_skip);
2208 /* Output location description stack opcode's operands (if any).
2209 The output is single bytes on a line, suitable for .cfi_escape. */
2211 static void
2212 output_loc_operands_raw (dw_loc_descr_ref loc)
2214 dw_val_ref val1 = &loc->dw_loc_oprnd1;
2215 dw_val_ref val2 = &loc->dw_loc_oprnd2;
2217 switch (loc->dw_loc_opc)
2219 case DW_OP_addr:
2220 case DW_OP_GNU_addr_index:
2221 case DW_OP_GNU_const_index:
2222 case DW_OP_implicit_value:
2223 /* We cannot output addresses in .cfi_escape, only bytes. */
2224 gcc_unreachable ();
2226 case DW_OP_const1u:
2227 case DW_OP_const1s:
2228 case DW_OP_pick:
2229 case DW_OP_deref_size:
2230 case DW_OP_xderef_size:
2231 fputc (',', asm_out_file);
2232 dw2_asm_output_data_raw (1, val1->v.val_int);
2233 break;
2235 case DW_OP_const2u:
2236 case DW_OP_const2s:
2237 fputc (',', asm_out_file);
2238 dw2_asm_output_data_raw (2, val1->v.val_int);
2239 break;
2241 case DW_OP_const4u:
2242 case DW_OP_const4s:
2243 fputc (',', asm_out_file);
2244 dw2_asm_output_data_raw (4, val1->v.val_int);
2245 break;
2247 case DW_OP_const8u:
2248 case DW_OP_const8s:
2249 gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
2250 fputc (',', asm_out_file);
2251 dw2_asm_output_data_raw (8, val1->v.val_int);
2252 break;
2254 case DW_OP_skip:
2255 case DW_OP_bra:
2257 int offset;
2259 gcc_assert (val1->val_class == dw_val_class_loc);
2260 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
2262 fputc (',', asm_out_file);
2263 dw2_asm_output_data_raw (2, offset);
2265 break;
2267 case DW_OP_regx:
2269 unsigned r = DWARF2_FRAME_REG_OUT (val1->v.val_unsigned, 1);
2270 gcc_assert (size_of_uleb128 (r)
2271 == size_of_uleb128 (val1->v.val_unsigned));
2272 fputc (',', asm_out_file);
2273 dw2_asm_output_data_uleb128_raw (r);
2275 break;
2277 case DW_OP_constu:
2278 case DW_OP_plus_uconst:
2279 case DW_OP_piece:
2280 fputc (',', asm_out_file);
2281 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
2282 break;
2284 case DW_OP_bit_piece:
2285 fputc (',', asm_out_file);
2286 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
2287 dw2_asm_output_data_uleb128_raw (val2->v.val_unsigned);
2288 break;
2290 case DW_OP_consts:
2291 case DW_OP_breg0:
2292 case DW_OP_breg1:
2293 case DW_OP_breg2:
2294 case DW_OP_breg3:
2295 case DW_OP_breg4:
2296 case DW_OP_breg5:
2297 case DW_OP_breg6:
2298 case DW_OP_breg7:
2299 case DW_OP_breg8:
2300 case DW_OP_breg9:
2301 case DW_OP_breg10:
2302 case DW_OP_breg11:
2303 case DW_OP_breg12:
2304 case DW_OP_breg13:
2305 case DW_OP_breg14:
2306 case DW_OP_breg15:
2307 case DW_OP_breg16:
2308 case DW_OP_breg17:
2309 case DW_OP_breg18:
2310 case DW_OP_breg19:
2311 case DW_OP_breg20:
2312 case DW_OP_breg21:
2313 case DW_OP_breg22:
2314 case DW_OP_breg23:
2315 case DW_OP_breg24:
2316 case DW_OP_breg25:
2317 case DW_OP_breg26:
2318 case DW_OP_breg27:
2319 case DW_OP_breg28:
2320 case DW_OP_breg29:
2321 case DW_OP_breg30:
2322 case DW_OP_breg31:
2323 case DW_OP_fbreg:
2324 fputc (',', asm_out_file);
2325 dw2_asm_output_data_sleb128_raw (val1->v.val_int);
2326 break;
2328 case DW_OP_bregx:
2330 unsigned r = DWARF2_FRAME_REG_OUT (val1->v.val_unsigned, 1);
2331 gcc_assert (size_of_uleb128 (r)
2332 == size_of_uleb128 (val1->v.val_unsigned));
2333 fputc (',', asm_out_file);
2334 dw2_asm_output_data_uleb128_raw (r);
2335 fputc (',', asm_out_file);
2336 dw2_asm_output_data_sleb128_raw (val2->v.val_int);
2338 break;
2340 case DW_OP_GNU_implicit_pointer:
2341 case DW_OP_GNU_entry_value:
2342 case DW_OP_GNU_const_type:
2343 case DW_OP_GNU_regval_type:
2344 case DW_OP_GNU_deref_type:
2345 case DW_OP_GNU_convert:
2346 case DW_OP_GNU_reinterpret:
2347 case DW_OP_GNU_parameter_ref:
2348 gcc_unreachable ();
2349 break;
2351 default:
2352 /* Other codes have no operands. */
2353 break;
2357 void
2358 output_loc_sequence_raw (dw_loc_descr_ref loc)
2360 while (1)
2362 enum dwarf_location_atom opc = loc->dw_loc_opc;
2363 /* Output the opcode. */
2364 if (opc >= DW_OP_breg0 && opc <= DW_OP_breg31)
2366 unsigned r = (opc - DW_OP_breg0);
2367 r = DWARF2_FRAME_REG_OUT (r, 1);
2368 gcc_assert (r <= 31);
2369 opc = (enum dwarf_location_atom) (DW_OP_breg0 + r);
2371 else if (opc >= DW_OP_reg0 && opc <= DW_OP_reg31)
2373 unsigned r = (opc - DW_OP_reg0);
2374 r = DWARF2_FRAME_REG_OUT (r, 1);
2375 gcc_assert (r <= 31);
2376 opc = (enum dwarf_location_atom) (DW_OP_reg0 + r);
2378 /* Output the opcode. */
2379 fprintf (asm_out_file, "%#x", opc);
2380 output_loc_operands_raw (loc);
2382 if (!loc->dw_loc_next)
2383 break;
2384 loc = loc->dw_loc_next;
2386 fputc (',', asm_out_file);
2390 /* This function builds a dwarf location descriptor sequence from a
2391 dw_cfa_location, adding the given OFFSET to the result of the
2392 expression. */
2394 struct dw_loc_descr_node *
2395 build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset)
2397 struct dw_loc_descr_node *head, *tmp;
2399 offset += cfa->offset;
2401 if (cfa->indirect)
2403 head = new_reg_loc_descr (cfa->reg, cfa->base_offset);
2404 head->dw_loc_oprnd1.val_class = dw_val_class_const;
2405 head->dw_loc_oprnd1.val_entry = NULL;
2406 tmp = new_loc_descr (DW_OP_deref, 0, 0);
2407 add_loc_descr (&head, tmp);
2408 if (offset != 0)
2410 tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0);
2411 add_loc_descr (&head, tmp);
2414 else
2415 head = new_reg_loc_descr (cfa->reg, offset);
2417 return head;
2420 /* This function builds a dwarf location descriptor sequence for
2421 the address at OFFSET from the CFA when stack is aligned to
2422 ALIGNMENT byte. */
2424 struct dw_loc_descr_node *
2425 build_cfa_aligned_loc (dw_cfa_location *cfa,
2426 HOST_WIDE_INT offset, HOST_WIDE_INT alignment)
2428 struct dw_loc_descr_node *head;
2429 unsigned int dwarf_fp
2430 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM);
2432 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
2433 if (cfa->reg == HARD_FRAME_POINTER_REGNUM && cfa->indirect == 0)
2435 head = new_reg_loc_descr (dwarf_fp, 0);
2436 add_loc_descr (&head, int_loc_descriptor (alignment));
2437 add_loc_descr (&head, new_loc_descr (DW_OP_and, 0, 0));
2438 loc_descr_plus_const (&head, offset);
2440 else
2441 head = new_reg_loc_descr (dwarf_fp, offset);
2442 return head;
2445 /* And now, the support for symbolic debugging information. */
2447 /* .debug_str support. */
2449 static void dwarf2out_init (const char *);
2450 static void dwarf2out_finish (const char *);
2451 static void dwarf2out_assembly_start (void);
2452 static void dwarf2out_define (unsigned int, const char *);
2453 static void dwarf2out_undef (unsigned int, const char *);
2454 static void dwarf2out_start_source_file (unsigned, const char *);
2455 static void dwarf2out_end_source_file (unsigned);
2456 static void dwarf2out_function_decl (tree);
2457 static void dwarf2out_begin_block (unsigned, unsigned);
2458 static void dwarf2out_end_block (unsigned, unsigned);
2459 static bool dwarf2out_ignore_block (const_tree);
2460 static void dwarf2out_global_decl (tree);
2461 static void dwarf2out_type_decl (tree, int);
2462 static void dwarf2out_imported_module_or_decl (tree, tree, tree, bool);
2463 static void dwarf2out_imported_module_or_decl_1 (tree, tree, tree,
2464 dw_die_ref);
2465 static void dwarf2out_abstract_function (tree);
2466 static void dwarf2out_var_location (rtx_insn *);
2467 static void dwarf2out_begin_function (tree);
2468 static void dwarf2out_end_function (unsigned int);
2469 static void dwarf2out_set_name (tree, tree);
2471 /* The debug hooks structure. */
2473 const struct gcc_debug_hooks dwarf2_debug_hooks =
2475 dwarf2out_init,
2476 dwarf2out_finish,
2477 dwarf2out_assembly_start,
2478 dwarf2out_define,
2479 dwarf2out_undef,
2480 dwarf2out_start_source_file,
2481 dwarf2out_end_source_file,
2482 dwarf2out_begin_block,
2483 dwarf2out_end_block,
2484 dwarf2out_ignore_block,
2485 dwarf2out_source_line,
2486 dwarf2out_begin_prologue,
2487 #if VMS_DEBUGGING_INFO
2488 dwarf2out_vms_end_prologue,
2489 dwarf2out_vms_begin_epilogue,
2490 #else
2491 debug_nothing_int_charstar,
2492 debug_nothing_int_charstar,
2493 #endif
2494 dwarf2out_end_epilogue,
2495 dwarf2out_begin_function,
2496 dwarf2out_end_function, /* end_function */
2497 dwarf2out_function_decl, /* function_decl */
2498 dwarf2out_global_decl,
2499 dwarf2out_type_decl, /* type_decl */
2500 dwarf2out_imported_module_or_decl,
2501 debug_nothing_tree, /* deferred_inline_function */
2502 /* The DWARF 2 backend tries to reduce debugging bloat by not
2503 emitting the abstract description of inline functions until
2504 something tries to reference them. */
2505 dwarf2out_abstract_function, /* outlining_inline_function */
2506 debug_nothing_rtx_code_label, /* label */
2507 debug_nothing_int, /* handle_pch */
2508 dwarf2out_var_location,
2509 dwarf2out_switch_text_section,
2510 dwarf2out_set_name,
2511 1, /* start_end_main_source_file */
2512 TYPE_SYMTAB_IS_DIE /* tree_type_symtab_field */
2515 /* NOTE: In the comments in this file, many references are made to
2516 "Debugging Information Entries". This term is abbreviated as `DIE'
2517 throughout the remainder of this file. */
2519 /* An internal representation of the DWARF output is built, and then
2520 walked to generate the DWARF debugging info. The walk of the internal
2521 representation is done after the entire program has been compiled.
2522 The types below are used to describe the internal representation. */
2524 /* Whether to put type DIEs into their own section .debug_types instead
2525 of making them part of the .debug_info section. Only supported for
2526 Dwarf V4 or higher and the user didn't disable them through
2527 -fno-debug-types-section. It is more efficient to put them in a
2528 separate comdat sections since the linker will then be able to
2529 remove duplicates. But not all tools support .debug_types sections
2530 yet. */
2532 #define use_debug_types (dwarf_version >= 4 && flag_debug_types_section)
2534 /* Various DIE's use offsets relative to the beginning of the
2535 .debug_info section to refer to each other. */
2537 typedef long int dw_offset;
2539 /* Define typedefs here to avoid circular dependencies. */
2541 typedef struct dw_attr_struct *dw_attr_ref;
2542 typedef struct dw_line_info_struct *dw_line_info_ref;
2543 typedef struct pubname_struct *pubname_ref;
2544 typedef struct dw_ranges_struct *dw_ranges_ref;
2545 typedef struct dw_ranges_by_label_struct *dw_ranges_by_label_ref;
2546 typedef struct comdat_type_struct *comdat_type_node_ref;
2548 /* The entries in the line_info table more-or-less mirror the opcodes
2549 that are used in the real dwarf line table. Arrays of these entries
2550 are collected per section when DWARF2_ASM_LINE_DEBUG_INFO is not
2551 supported. */
2553 enum dw_line_info_opcode {
2554 /* Emit DW_LNE_set_address; the operand is the label index. */
2555 LI_set_address,
2557 /* Emit a row to the matrix with the given line. This may be done
2558 via any combination of DW_LNS_copy, DW_LNS_advance_line, and
2559 special opcodes. */
2560 LI_set_line,
2562 /* Emit a DW_LNS_set_file. */
2563 LI_set_file,
2565 /* Emit a DW_LNS_set_column. */
2566 LI_set_column,
2568 /* Emit a DW_LNS_negate_stmt; the operand is ignored. */
2569 LI_negate_stmt,
2571 /* Emit a DW_LNS_set_prologue_end/epilogue_begin; the operand is ignored. */
2572 LI_set_prologue_end,
2573 LI_set_epilogue_begin,
2575 /* Emit a DW_LNE_set_discriminator. */
2576 LI_set_discriminator
2579 typedef struct GTY(()) dw_line_info_struct {
2580 enum dw_line_info_opcode opcode;
2581 unsigned int val;
2582 } dw_line_info_entry;
2585 typedef struct GTY(()) dw_line_info_table_struct {
2586 /* The label that marks the end of this section. */
2587 const char *end_label;
2589 /* The values for the last row of the matrix, as collected in the table.
2590 These are used to minimize the changes to the next row. */
2591 unsigned int file_num;
2592 unsigned int line_num;
2593 unsigned int column_num;
2594 int discrim_num;
2595 bool is_stmt;
2596 bool in_use;
2598 vec<dw_line_info_entry, va_gc> *entries;
2599 } dw_line_info_table;
2601 typedef dw_line_info_table *dw_line_info_table_p;
2604 /* Each DIE attribute has a field specifying the attribute kind,
2605 a link to the next attribute in the chain, and an attribute value.
2606 Attributes are typically linked below the DIE they modify. */
2608 typedef struct GTY(()) dw_attr_struct {
2609 enum dwarf_attribute dw_attr;
2610 dw_val_node dw_attr_val;
2612 dw_attr_node;
2615 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
2616 The children of each node form a circular list linked by
2617 die_sib. die_child points to the node *before* the "first" child node. */
2619 typedef struct GTY((chain_circular ("%h.die_sib"), for_user)) die_struct {
2620 union die_symbol_or_type_node
2622 const char * GTY ((tag ("0"))) die_symbol;
2623 comdat_type_node_ref GTY ((tag ("1"))) die_type_node;
2625 GTY ((desc ("%0.comdat_type_p"))) die_id;
2626 vec<dw_attr_node, va_gc> *die_attr;
2627 dw_die_ref die_parent;
2628 dw_die_ref die_child;
2629 dw_die_ref die_sib;
2630 dw_die_ref die_definition; /* ref from a specification to its definition */
2631 dw_offset die_offset;
2632 unsigned long die_abbrev;
2633 int die_mark;
2634 unsigned int decl_id;
2635 enum dwarf_tag die_tag;
2636 /* Die is used and must not be pruned as unused. */
2637 BOOL_BITFIELD die_perennial_p : 1;
2638 BOOL_BITFIELD comdat_type_p : 1; /* DIE has a type signature */
2639 /* Lots of spare bits. */
2641 die_node;
2643 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
2644 #define FOR_EACH_CHILD(die, c, expr) do { \
2645 c = die->die_child; \
2646 if (c) do { \
2647 c = c->die_sib; \
2648 expr; \
2649 } while (c != die->die_child); \
2650 } while (0)
2652 /* The pubname structure */
2654 typedef struct GTY(()) pubname_struct {
2655 dw_die_ref die;
2656 const char *name;
2658 pubname_entry;
2661 struct GTY(()) dw_ranges_struct {
2662 /* If this is positive, it's a block number, otherwise it's a
2663 bitwise-negated index into dw_ranges_by_label. */
2664 int num;
2667 /* A structure to hold a macinfo entry. */
2669 typedef struct GTY(()) macinfo_struct {
2670 unsigned char code;
2671 unsigned HOST_WIDE_INT lineno;
2672 const char *info;
2674 macinfo_entry;
2677 struct GTY(()) dw_ranges_by_label_struct {
2678 const char *begin;
2679 const char *end;
2682 /* The comdat type node structure. */
2683 typedef struct GTY(()) comdat_type_struct
2685 dw_die_ref root_die;
2686 dw_die_ref type_die;
2687 dw_die_ref skeleton_die;
2688 char signature[DWARF_TYPE_SIGNATURE_SIZE];
2689 struct comdat_type_struct *next;
2691 comdat_type_node;
2693 /* The limbo die list structure. */
2694 typedef struct GTY(()) limbo_die_struct {
2695 dw_die_ref die;
2696 tree created_for;
2697 struct limbo_die_struct *next;
2699 limbo_die_node;
2701 typedef struct skeleton_chain_struct
2703 dw_die_ref old_die;
2704 dw_die_ref new_die;
2705 struct skeleton_chain_struct *parent;
2707 skeleton_chain_node;
2709 /* Define a macro which returns nonzero for a TYPE_DECL which was
2710 implicitly generated for a type.
2712 Note that, unlike the C front-end (which generates a NULL named
2713 TYPE_DECL node for each complete tagged type, each array type,
2714 and each function type node created) the C++ front-end generates
2715 a _named_ TYPE_DECL node for each tagged type node created.
2716 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
2717 generate a DW_TAG_typedef DIE for them. Likewise with the Ada
2718 front-end, but for each type, tagged or not. */
2720 #define TYPE_DECL_IS_STUB(decl) \
2721 (DECL_NAME (decl) == NULL_TREE \
2722 || (DECL_ARTIFICIAL (decl) \
2723 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
2724 /* This is necessary for stub decls that \
2725 appear in nested inline functions. */ \
2726 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
2727 && (decl_ultimate_origin (decl) \
2728 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
2730 /* Information concerning the compilation unit's programming
2731 language, and compiler version. */
2733 /* Fixed size portion of the DWARF compilation unit header. */
2734 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
2735 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
2737 /* Fixed size portion of the DWARF comdat type unit header. */
2738 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
2739 (DWARF_COMPILE_UNIT_HEADER_SIZE + DWARF_TYPE_SIGNATURE_SIZE \
2740 + DWARF_OFFSET_SIZE)
2742 /* Fixed size portion of public names info. */
2743 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
2745 /* Fixed size portion of the address range info. */
2746 #define DWARF_ARANGES_HEADER_SIZE \
2747 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
2748 DWARF2_ADDR_SIZE * 2) \
2749 - DWARF_INITIAL_LENGTH_SIZE)
2751 /* Size of padding portion in the address range info. It must be
2752 aligned to twice the pointer size. */
2753 #define DWARF_ARANGES_PAD_SIZE \
2754 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
2755 DWARF2_ADDR_SIZE * 2) \
2756 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
2758 /* Use assembler line directives if available. */
2759 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
2760 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
2761 #define DWARF2_ASM_LINE_DEBUG_INFO 1
2762 #else
2763 #define DWARF2_ASM_LINE_DEBUG_INFO 0
2764 #endif
2765 #endif
2767 /* Minimum line offset in a special line info. opcode.
2768 This value was chosen to give a reasonable range of values. */
2769 #define DWARF_LINE_BASE -10
2771 /* First special line opcode - leave room for the standard opcodes. */
2772 #define DWARF_LINE_OPCODE_BASE ((int)DW_LNS_set_isa + 1)
2774 /* Range of line offsets in a special line info. opcode. */
2775 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
2777 /* Flag that indicates the initial value of the is_stmt_start flag.
2778 In the present implementation, we do not mark any lines as
2779 the beginning of a source statement, because that information
2780 is not made available by the GCC front-end. */
2781 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
2783 /* Maximum number of operations per instruction bundle. */
2784 #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
2785 #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
2786 #endif
2788 /* This location is used by calc_die_sizes() to keep track
2789 the offset of each DIE within the .debug_info section. */
2790 static unsigned long next_die_offset;
2792 /* Record the root of the DIE's built for the current compilation unit. */
2793 static GTY(()) dw_die_ref single_comp_unit_die;
2795 /* A list of type DIEs that have been separated into comdat sections. */
2796 static GTY(()) comdat_type_node *comdat_type_list;
2798 /* A list of DIEs with a NULL parent waiting to be relocated. */
2799 static GTY(()) limbo_die_node *limbo_die_list;
2801 /* A list of DIEs for which we may have to generate
2802 DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set. */
2803 static GTY(()) limbo_die_node *deferred_asm_name;
2805 struct dwarf_file_hasher : ggc_hasher<dwarf_file_data *>
2807 typedef const char *compare_type;
2809 static hashval_t hash (dwarf_file_data *);
2810 static bool equal (dwarf_file_data *, const char *);
2813 /* Filenames referenced by this compilation unit. */
2814 static GTY(()) hash_table<dwarf_file_hasher> *file_table;
2816 struct decl_die_hasher : ggc_hasher<die_node *>
2818 typedef tree compare_type;
2820 static hashval_t hash (die_node *);
2821 static bool equal (die_node *, tree);
2823 /* A hash table of references to DIE's that describe declarations.
2824 The key is a DECL_UID() which is a unique number identifying each decl. */
2825 static GTY (()) hash_table<decl_die_hasher> *decl_die_table;
2827 struct block_die_hasher : ggc_hasher<die_struct *>
2829 static hashval_t hash (die_struct *);
2830 static bool equal (die_struct *, die_struct *);
2833 /* A hash table of references to DIE's that describe COMMON blocks.
2834 The key is DECL_UID() ^ die_parent. */
2835 static GTY (()) hash_table<block_die_hasher> *common_block_die_table;
2837 typedef struct GTY(()) die_arg_entry_struct {
2838 dw_die_ref die;
2839 tree arg;
2840 } die_arg_entry;
2843 /* Node of the variable location list. */
2844 struct GTY ((chain_next ("%h.next"))) var_loc_node {
2845 /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
2846 EXPR_LIST chain. For small bitsizes, bitsize is encoded
2847 in mode of the EXPR_LIST node and first EXPR_LIST operand
2848 is either NOTE_INSN_VAR_LOCATION for a piece with a known
2849 location or NULL for padding. For larger bitsizes,
2850 mode is 0 and first operand is a CONCAT with bitsize
2851 as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
2852 NULL as second operand. */
2853 rtx GTY (()) loc;
2854 const char * GTY (()) label;
2855 struct var_loc_node * GTY (()) next;
2858 /* Variable location list. */
2859 struct GTY ((for_user)) var_loc_list_def {
2860 struct var_loc_node * GTY (()) first;
2862 /* Pointer to the last but one or last element of the
2863 chained list. If the list is empty, both first and
2864 last are NULL, if the list contains just one node
2865 or the last node certainly is not redundant, it points
2866 to the last node, otherwise points to the last but one.
2867 Do not mark it for GC because it is marked through the chain. */
2868 struct var_loc_node * GTY ((skip ("%h"))) last;
2870 /* Pointer to the last element before section switch,
2871 if NULL, either sections weren't switched or first
2872 is after section switch. */
2873 struct var_loc_node * GTY ((skip ("%h"))) last_before_switch;
2875 /* DECL_UID of the variable decl. */
2876 unsigned int decl_id;
2878 typedef struct var_loc_list_def var_loc_list;
2880 /* Call argument location list. */
2881 struct GTY ((chain_next ("%h.next"))) call_arg_loc_node {
2882 rtx GTY (()) call_arg_loc_note;
2883 const char * GTY (()) label;
2884 tree GTY (()) block;
2885 bool tail_call_p;
2886 rtx GTY (()) symbol_ref;
2887 struct call_arg_loc_node * GTY (()) next;
2891 struct decl_loc_hasher : ggc_hasher<var_loc_list *>
2893 typedef const_tree compare_type;
2895 static hashval_t hash (var_loc_list *);
2896 static bool equal (var_loc_list *, const_tree);
2899 /* Table of decl location linked lists. */
2900 static GTY (()) hash_table<decl_loc_hasher> *decl_loc_table;
2902 /* Head and tail of call_arg_loc chain. */
2903 static GTY (()) struct call_arg_loc_node *call_arg_locations;
2904 static struct call_arg_loc_node *call_arg_loc_last;
2906 /* Number of call sites in the current function. */
2907 static int call_site_count = -1;
2908 /* Number of tail call sites in the current function. */
2909 static int tail_call_site_count = -1;
2911 /* Vector mapping block numbers to DW_TAG_{lexical_block,inlined_subroutine}
2912 DIEs. */
2913 static vec<dw_die_ref> block_map;
2915 /* A cached location list. */
2916 struct GTY ((for_user)) cached_dw_loc_list_def {
2917 /* The DECL_UID of the decl that this entry describes. */
2918 unsigned int decl_id;
2920 /* The cached location list. */
2921 dw_loc_list_ref loc_list;
2923 typedef struct cached_dw_loc_list_def cached_dw_loc_list;
2925 struct dw_loc_list_hasher : ggc_hasher<cached_dw_loc_list *>
2928 typedef const_tree compare_type;
2930 static hashval_t hash (cached_dw_loc_list *);
2931 static bool equal (cached_dw_loc_list *, const_tree);
2934 /* Table of cached location lists. */
2935 static GTY (()) hash_table<dw_loc_list_hasher> *cached_dw_loc_list_table;
2937 /* A pointer to the base of a list of references to DIE's that
2938 are uniquely identified by their tag, presence/absence of
2939 children DIE's, and list of attribute/value pairs. */
2940 static GTY((length ("abbrev_die_table_allocated")))
2941 dw_die_ref *abbrev_die_table;
2943 /* Number of elements currently allocated for abbrev_die_table. */
2944 static GTY(()) unsigned abbrev_die_table_allocated;
2946 /* Number of elements in type_die_table currently in use. */
2947 static GTY(()) unsigned abbrev_die_table_in_use;
2949 /* Size (in elements) of increments by which we may expand the
2950 abbrev_die_table. */
2951 #define ABBREV_DIE_TABLE_INCREMENT 256
2953 /* A global counter for generating labels for line number data. */
2954 static unsigned int line_info_label_num;
2956 /* The current table to which we should emit line number information
2957 for the current function. This will be set up at the beginning of
2958 assembly for the function. */
2959 static dw_line_info_table *cur_line_info_table;
2961 /* The two default tables of line number info. */
2962 static GTY(()) dw_line_info_table *text_section_line_info;
2963 static GTY(()) dw_line_info_table *cold_text_section_line_info;
2965 /* The set of all non-default tables of line number info. */
2966 static GTY(()) vec<dw_line_info_table_p, va_gc> *separate_line_info;
2968 /* A flag to tell pubnames/types export if there is an info section to
2969 refer to. */
2970 static bool info_section_emitted;
2972 /* A pointer to the base of a table that contains a list of publicly
2973 accessible names. */
2974 static GTY (()) vec<pubname_entry, va_gc> *pubname_table;
2976 /* A pointer to the base of a table that contains a list of publicly
2977 accessible types. */
2978 static GTY (()) vec<pubname_entry, va_gc> *pubtype_table;
2980 /* A pointer to the base of a table that contains a list of macro
2981 defines/undefines (and file start/end markers). */
2982 static GTY (()) vec<macinfo_entry, va_gc> *macinfo_table;
2984 /* True if .debug_macinfo or .debug_macros section is going to be
2985 emitted. */
2986 #define have_macinfo \
2987 (debug_info_level >= DINFO_LEVEL_VERBOSE \
2988 && !macinfo_table->is_empty ())
2990 /* Array of dies for which we should generate .debug_ranges info. */
2991 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
2993 /* Number of elements currently allocated for ranges_table. */
2994 static GTY(()) unsigned ranges_table_allocated;
2996 /* Number of elements in ranges_table currently in use. */
2997 static GTY(()) unsigned ranges_table_in_use;
2999 /* Array of pairs of labels referenced in ranges_table. */
3000 static GTY ((length ("ranges_by_label_allocated")))
3001 dw_ranges_by_label_ref ranges_by_label;
3003 /* Number of elements currently allocated for ranges_by_label. */
3004 static GTY(()) unsigned ranges_by_label_allocated;
3006 /* Number of elements in ranges_by_label currently in use. */
3007 static GTY(()) unsigned ranges_by_label_in_use;
3009 /* Size (in elements) of increments by which we may expand the
3010 ranges_table. */
3011 #define RANGES_TABLE_INCREMENT 64
3013 /* Whether we have location lists that need outputting */
3014 static GTY(()) bool have_location_lists;
3016 /* Unique label counter. */
3017 static GTY(()) unsigned int loclabel_num;
3019 /* Unique label counter for point-of-call tables. */
3020 static GTY(()) unsigned int poc_label_num;
3022 /* The last file entry emitted by maybe_emit_file(). */
3023 static GTY(()) struct dwarf_file_data * last_emitted_file;
3025 /* Number of internal labels generated by gen_internal_sym(). */
3026 static GTY(()) int label_num;
3028 /* Cached result of previous call to lookup_filename. */
3029 static GTY(()) struct dwarf_file_data * file_table_last_lookup;
3031 static GTY(()) vec<die_arg_entry, va_gc> *tmpl_value_parm_die_table;
3033 /* Instances of generic types for which we need to generate debug
3034 info that describe their generic parameters and arguments. That
3035 generation needs to happen once all types are properly laid out so
3036 we do it at the end of compilation. */
3037 static GTY(()) vec<tree, va_gc> *generic_type_instances;
3039 /* Offset from the "steady-state frame pointer" to the frame base,
3040 within the current function. */
3041 static HOST_WIDE_INT frame_pointer_fb_offset;
3042 static bool frame_pointer_fb_offset_valid;
3044 static vec<dw_die_ref> base_types;
3046 /* Flags to represent a set of attribute classes for attributes that represent
3047 a scalar value (bounds, pointers, ...). */
3048 enum dw_scalar_form
3050 dw_scalar_form_constant = 0x01,
3051 dw_scalar_form_exprloc = 0x02,
3052 dw_scalar_form_reference = 0x04
3055 /* Forward declarations for functions defined in this file. */
3057 static int is_pseudo_reg (const_rtx);
3058 static tree type_main_variant (tree);
3059 static int is_tagged_type (const_tree);
3060 static const char *dwarf_tag_name (unsigned);
3061 static const char *dwarf_attr_name (unsigned);
3062 static const char *dwarf_form_name (unsigned);
3063 static tree decl_ultimate_origin (const_tree);
3064 static tree decl_class_context (tree);
3065 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
3066 static inline enum dw_val_class AT_class (dw_attr_ref);
3067 static inline unsigned int AT_index (dw_attr_ref);
3068 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
3069 static inline unsigned AT_flag (dw_attr_ref);
3070 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
3071 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
3072 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
3073 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
3074 static void add_AT_double (dw_die_ref, enum dwarf_attribute,
3075 HOST_WIDE_INT, unsigned HOST_WIDE_INT);
3076 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
3077 unsigned int, unsigned char *);
3078 static void add_AT_data8 (dw_die_ref, enum dwarf_attribute, unsigned char *);
3079 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
3080 static inline const char *AT_string (dw_attr_ref);
3081 static enum dwarf_form AT_string_form (dw_attr_ref);
3082 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
3083 static void add_AT_specification (dw_die_ref, dw_die_ref);
3084 static inline dw_die_ref AT_ref (dw_attr_ref);
3085 static inline int AT_ref_external (dw_attr_ref);
3086 static inline void set_AT_ref_external (dw_attr_ref, int);
3087 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
3088 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
3089 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
3090 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
3091 dw_loc_list_ref);
3092 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
3093 static addr_table_entry *add_addr_table_entry (void *, enum ate_kind);
3094 static void remove_addr_table_entry (addr_table_entry *);
3095 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx, bool);
3096 static inline rtx AT_addr (dw_attr_ref);
3097 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
3098 static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *);
3099 static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *);
3100 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
3101 unsigned HOST_WIDE_INT);
3102 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
3103 unsigned long, bool);
3104 static inline const char *AT_lbl (dw_attr_ref);
3105 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
3106 static const char *get_AT_low_pc (dw_die_ref);
3107 static const char *get_AT_hi_pc (dw_die_ref);
3108 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
3109 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
3110 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
3111 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
3112 static bool is_cxx (void);
3113 static bool is_fortran (void);
3114 static bool is_ada (void);
3115 static void remove_AT (dw_die_ref, enum dwarf_attribute);
3116 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
3117 static void add_child_die (dw_die_ref, dw_die_ref);
3118 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
3119 static dw_die_ref lookup_type_die (tree);
3120 static dw_die_ref strip_naming_typedef (tree, dw_die_ref);
3121 static dw_die_ref lookup_type_die_strip_naming_typedef (tree);
3122 static void equate_type_number_to_die (tree, dw_die_ref);
3123 static dw_die_ref lookup_decl_die (tree);
3124 static var_loc_list *lookup_decl_loc (const_tree);
3125 static void equate_decl_number_to_die (tree, dw_die_ref);
3126 static struct var_loc_node *add_var_loc_to_decl (tree, rtx, const char *);
3127 static void print_spaces (FILE *);
3128 static void print_die (dw_die_ref, FILE *);
3129 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
3130 static dw_die_ref pop_compile_unit (dw_die_ref);
3131 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
3132 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
3133 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
3134 static void checksum_sleb128 (HOST_WIDE_INT, struct md5_ctx *);
3135 static void checksum_uleb128 (unsigned HOST_WIDE_INT, struct md5_ctx *);
3136 static void loc_checksum_ordered (dw_loc_descr_ref, struct md5_ctx *);
3137 static void attr_checksum_ordered (enum dwarf_tag, dw_attr_ref,
3138 struct md5_ctx *, int *);
3139 struct checksum_attributes;
3140 static void collect_checksum_attributes (struct checksum_attributes *, dw_die_ref);
3141 static void die_checksum_ordered (dw_die_ref, struct md5_ctx *, int *);
3142 static void checksum_die_context (dw_die_ref, struct md5_ctx *);
3143 static void generate_type_signature (dw_die_ref, comdat_type_node *);
3144 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
3145 static int same_dw_val_p (const dw_val_node *, const dw_val_node *, int *);
3146 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
3147 static int same_die_p (dw_die_ref, dw_die_ref, int *);
3148 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
3149 static void compute_section_prefix (dw_die_ref);
3150 static int is_type_die (dw_die_ref);
3151 static int is_comdat_die (dw_die_ref);
3152 static int is_symbol_die (dw_die_ref);
3153 static inline bool is_template_instantiation (dw_die_ref);
3154 static void assign_symbol_names (dw_die_ref);
3155 static void break_out_includes (dw_die_ref);
3156 static int is_declaration_die (dw_die_ref);
3157 static int should_move_die_to_comdat (dw_die_ref);
3158 static dw_die_ref clone_as_declaration (dw_die_ref);
3159 static dw_die_ref clone_die (dw_die_ref);
3160 static dw_die_ref clone_tree (dw_die_ref);
3161 static dw_die_ref copy_declaration_context (dw_die_ref, dw_die_ref);
3162 static void generate_skeleton_ancestor_tree (skeleton_chain_node *);
3163 static void generate_skeleton_bottom_up (skeleton_chain_node *);
3164 static dw_die_ref generate_skeleton (dw_die_ref);
3165 static dw_die_ref remove_child_or_replace_with_skeleton (dw_die_ref,
3166 dw_die_ref,
3167 dw_die_ref);
3168 static void break_out_comdat_types (dw_die_ref);
3169 static void copy_decls_for_unworthy_types (dw_die_ref);
3171 static void add_sibling_attributes (dw_die_ref);
3172 static void output_location_lists (dw_die_ref);
3173 static int constant_size (unsigned HOST_WIDE_INT);
3174 static unsigned long size_of_die (dw_die_ref);
3175 static void calc_die_sizes (dw_die_ref);
3176 static void calc_base_type_die_sizes (void);
3177 static void mark_dies (dw_die_ref);
3178 static void unmark_dies (dw_die_ref);
3179 static void unmark_all_dies (dw_die_ref);
3180 static unsigned long size_of_pubnames (vec<pubname_entry, va_gc> *);
3181 static unsigned long size_of_aranges (void);
3182 static enum dwarf_form value_format (dw_attr_ref);
3183 static void output_value_format (dw_attr_ref);
3184 static void output_abbrev_section (void);
3185 static void output_die_abbrevs (unsigned long, dw_die_ref);
3186 static void output_die_symbol (dw_die_ref);
3187 static void output_die (dw_die_ref);
3188 static void output_compilation_unit_header (void);
3189 static void output_comp_unit (dw_die_ref, int);
3190 static void output_comdat_type_unit (comdat_type_node *);
3191 static const char *dwarf2_name (tree, int);
3192 static void add_pubname (tree, dw_die_ref);
3193 static void add_enumerator_pubname (const char *, dw_die_ref);
3194 static void add_pubname_string (const char *, dw_die_ref);
3195 static void add_pubtype (tree, dw_die_ref);
3196 static void output_pubnames (vec<pubname_entry, va_gc> *);
3197 static void output_aranges (unsigned long);
3198 static unsigned int add_ranges_num (int);
3199 static unsigned int add_ranges (const_tree);
3200 static void add_ranges_by_labels (dw_die_ref, const char *, const char *,
3201 bool *, bool);
3202 static void output_ranges (void);
3203 static dw_line_info_table *new_line_info_table (void);
3204 static void output_line_info (bool);
3205 static void output_file_names (void);
3206 static dw_die_ref base_type_die (tree);
3207 static int is_base_type (tree);
3208 static dw_die_ref subrange_type_die (tree, tree, tree, dw_die_ref);
3209 static int decl_quals (const_tree);
3210 static dw_die_ref modified_type_die (tree, int, dw_die_ref);
3211 static dw_die_ref generic_parameter_die (tree, tree, bool, dw_die_ref);
3212 static dw_die_ref template_parameter_pack_die (tree, tree, dw_die_ref);
3213 static int type_is_enum (const_tree);
3214 static unsigned int dbx_reg_number (const_rtx);
3215 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
3216 static dw_loc_descr_ref reg_loc_descriptor (rtx, enum var_init_status);
3217 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int,
3218 enum var_init_status);
3219 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx,
3220 enum var_init_status);
3221 static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT,
3222 enum var_init_status);
3223 static int is_based_loc (const_rtx);
3224 static bool resolve_one_addr (rtx *);
3225 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx,
3226 enum var_init_status);
3227 static dw_loc_descr_ref loc_descriptor (rtx, machine_mode mode,
3228 enum var_init_status);
3229 struct loc_descr_context;
3230 static dw_loc_list_ref loc_list_from_tree (tree, int,
3231 const struct loc_descr_context *);
3232 static dw_loc_descr_ref loc_descriptor_from_tree (tree, int,
3233 const struct loc_descr_context *);
3234 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
3235 static tree field_type (const_tree);
3236 static unsigned int simple_type_align_in_bits (const_tree);
3237 static unsigned int simple_decl_align_in_bits (const_tree);
3238 static unsigned HOST_WIDE_INT simple_type_size_in_bits (const_tree);
3239 static HOST_WIDE_INT field_byte_offset (const_tree);
3240 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
3241 dw_loc_list_ref);
3242 static void add_data_member_location_attribute (dw_die_ref, tree);
3243 static bool add_const_value_attribute (dw_die_ref, rtx);
3244 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
3245 static void insert_wide_int (const wide_int &, unsigned char *, int);
3246 static void insert_float (const_rtx, unsigned char *);
3247 static rtx rtl_for_decl_location (tree);
3248 static bool add_location_or_const_value_attribute (dw_die_ref, tree, bool,
3249 enum dwarf_attribute);
3250 static bool tree_add_const_value_attribute (dw_die_ref, tree);
3251 static bool tree_add_const_value_attribute_for_decl (dw_die_ref, tree);
3252 static void add_name_attribute (dw_die_ref, const char *);
3253 static void add_gnat_descriptive_type_attribute (dw_die_ref, tree, dw_die_ref);
3254 static void add_comp_dir_attribute (dw_die_ref);
3255 static void add_scalar_info (dw_die_ref, enum dwarf_attribute, tree, int,
3256 const struct loc_descr_context *);
3257 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree,
3258 const struct loc_descr_context *);
3259 static void add_subscript_info (dw_die_ref, tree, bool);
3260 static void add_byte_size_attribute (dw_die_ref, tree);
3261 static void add_bit_offset_attribute (dw_die_ref, tree);
3262 static void add_bit_size_attribute (dw_die_ref, tree);
3263 static void add_prototyped_attribute (dw_die_ref, tree);
3264 static dw_die_ref add_abstract_origin_attribute (dw_die_ref, tree);
3265 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
3266 static void add_src_coords_attributes (dw_die_ref, tree);
3267 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
3268 static void push_decl_scope (tree);
3269 static void pop_decl_scope (void);
3270 static dw_die_ref scope_die_for (tree, dw_die_ref);
3271 static inline int local_scope_p (dw_die_ref);
3272 static inline int class_scope_p (dw_die_ref);
3273 static inline int class_or_namespace_scope_p (dw_die_ref);
3274 static void add_type_attribute (dw_die_ref, tree, int, dw_die_ref);
3275 static void add_calling_convention_attribute (dw_die_ref, tree);
3276 static const char *type_tag (const_tree);
3277 static tree member_declared_type (const_tree);
3278 #if 0
3279 static const char *decl_start_label (tree);
3280 #endif
3281 static void gen_array_type_die (tree, dw_die_ref);
3282 static void gen_descr_array_type_die (tree, struct array_descr_info *, dw_die_ref);
3283 #if 0
3284 static void gen_entry_point_die (tree, dw_die_ref);
3285 #endif
3286 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
3287 static dw_die_ref gen_formal_parameter_die (tree, tree, bool, dw_die_ref);
3288 static dw_die_ref gen_formal_parameter_pack_die (tree, tree, dw_die_ref, tree*);
3289 static void gen_unspecified_parameters_die (tree, dw_die_ref);
3290 static void gen_formal_types_die (tree, dw_die_ref);
3291 static void gen_subprogram_die (tree, dw_die_ref);
3292 static void gen_variable_die (tree, tree, dw_die_ref);
3293 static void gen_const_die (tree, dw_die_ref);
3294 static void gen_label_die (tree, dw_die_ref);
3295 static void gen_lexical_block_die (tree, dw_die_ref);
3296 static void gen_inlined_subroutine_die (tree, dw_die_ref);
3297 static void gen_field_die (tree, dw_die_ref);
3298 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
3299 static dw_die_ref gen_compile_unit_die (const char *);
3300 static void gen_inheritance_die (tree, tree, dw_die_ref);
3301 static void gen_member_die (tree, dw_die_ref);
3302 static void gen_struct_or_union_type_die (tree, dw_die_ref,
3303 enum debug_info_usage);
3304 static void gen_subroutine_type_die (tree, dw_die_ref);
3305 static void gen_typedef_die (tree, dw_die_ref);
3306 static void gen_type_die (tree, dw_die_ref);
3307 static void gen_block_die (tree, dw_die_ref);
3308 static void decls_for_scope (tree, dw_die_ref);
3309 static inline int is_redundant_typedef (const_tree);
3310 static bool is_naming_typedef_decl (const_tree);
3311 static inline dw_die_ref get_context_die (tree);
3312 static void gen_namespace_die (tree, dw_die_ref);
3313 static dw_die_ref gen_namelist_decl (tree, dw_die_ref, tree);
3314 static dw_die_ref gen_decl_die (tree, tree, dw_die_ref);
3315 static dw_die_ref force_decl_die (tree);
3316 static dw_die_ref force_type_die (tree);
3317 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
3318 static dw_die_ref declare_in_namespace (tree, dw_die_ref);
3319 static struct dwarf_file_data * lookup_filename (const char *);
3320 static void retry_incomplete_types (void);
3321 static void gen_type_die_for_member (tree, tree, dw_die_ref);
3322 static void gen_generic_params_dies (tree);
3323 static void gen_tagged_type_die (tree, dw_die_ref, enum debug_info_usage);
3324 static void gen_type_die_with_usage (tree, dw_die_ref, enum debug_info_usage);
3325 static void splice_child_die (dw_die_ref, dw_die_ref);
3326 static int file_info_cmp (const void *, const void *);
3327 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
3328 const char *, const char *);
3329 static void output_loc_list (dw_loc_list_ref);
3330 static char *gen_internal_sym (const char *);
3331 static bool want_pubnames (void);
3333 static void prune_unmark_dies (dw_die_ref);
3334 static void prune_unused_types_mark_generic_parms_dies (dw_die_ref);
3335 static void prune_unused_types_mark (dw_die_ref, int);
3336 static void prune_unused_types_walk (dw_die_ref);
3337 static void prune_unused_types_walk_attribs (dw_die_ref);
3338 static void prune_unused_types_prune (dw_die_ref);
3339 static void prune_unused_types (void);
3340 static int maybe_emit_file (struct dwarf_file_data *fd);
3341 static inline const char *AT_vms_delta1 (dw_attr_ref);
3342 static inline const char *AT_vms_delta2 (dw_attr_ref);
3343 static inline void add_AT_vms_delta (dw_die_ref, enum dwarf_attribute,
3344 const char *, const char *);
3345 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref, tree);
3346 static void gen_remaining_tmpl_value_param_die_attribute (void);
3347 static bool generic_type_p (tree);
3348 static void schedule_generic_params_dies_gen (tree t);
3349 static void gen_scheduled_generic_parms_dies (void);
3351 static const char *comp_dir_string (void);
3353 static void hash_loc_operands (dw_loc_descr_ref, inchash::hash &);
3355 /* enum for tracking thread-local variables whose address is really an offset
3356 relative to the TLS pointer, which will need link-time relocation, but will
3357 not need relocation by the DWARF consumer. */
3359 enum dtprel_bool
3361 dtprel_false = 0,
3362 dtprel_true = 1
3365 /* Return the operator to use for an address of a variable. For dtprel_true, we
3366 use DW_OP_const*. For regular variables, which need both link-time
3367 relocation and consumer-level relocation (e.g., to account for shared objects
3368 loaded at a random address), we use DW_OP_addr*. */
3370 static inline enum dwarf_location_atom
3371 dw_addr_op (enum dtprel_bool dtprel)
3373 if (dtprel == dtprel_true)
3374 return (dwarf_split_debug_info ? DW_OP_GNU_const_index
3375 : (DWARF2_ADDR_SIZE == 4 ? DW_OP_const4u : DW_OP_const8u));
3376 else
3377 return dwarf_split_debug_info ? DW_OP_GNU_addr_index : DW_OP_addr;
3380 /* Return a pointer to a newly allocated address location description. If
3381 dwarf_split_debug_info is true, then record the address with the appropriate
3382 relocation. */
3383 static inline dw_loc_descr_ref
3384 new_addr_loc_descr (rtx addr, enum dtprel_bool dtprel)
3386 dw_loc_descr_ref ref = new_loc_descr (dw_addr_op (dtprel), 0, 0);
3388 ref->dw_loc_oprnd1.val_class = dw_val_class_addr;
3389 ref->dw_loc_oprnd1.v.val_addr = addr;
3390 ref->dtprel = dtprel;
3391 if (dwarf_split_debug_info)
3392 ref->dw_loc_oprnd1.val_entry
3393 = add_addr_table_entry (addr,
3394 dtprel ? ate_kind_rtx_dtprel : ate_kind_rtx);
3395 else
3396 ref->dw_loc_oprnd1.val_entry = NULL;
3398 return ref;
3401 /* Section names used to hold DWARF debugging information. */
3403 #ifndef DEBUG_INFO_SECTION
3404 #define DEBUG_INFO_SECTION ".debug_info"
3405 #endif
3406 #ifndef DEBUG_DWO_INFO_SECTION
3407 #define DEBUG_DWO_INFO_SECTION ".debug_info.dwo"
3408 #endif
3409 #ifndef DEBUG_ABBREV_SECTION
3410 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
3411 #endif
3412 #ifndef DEBUG_DWO_ABBREV_SECTION
3413 #define DEBUG_DWO_ABBREV_SECTION ".debug_abbrev.dwo"
3414 #endif
3415 #ifndef DEBUG_ARANGES_SECTION
3416 #define DEBUG_ARANGES_SECTION ".debug_aranges"
3417 #endif
3418 #ifndef DEBUG_ADDR_SECTION
3419 #define DEBUG_ADDR_SECTION ".debug_addr"
3420 #endif
3421 #ifndef DEBUG_NORM_MACINFO_SECTION
3422 #define DEBUG_NORM_MACINFO_SECTION ".debug_macinfo"
3423 #endif
3424 #ifndef DEBUG_DWO_MACINFO_SECTION
3425 #define DEBUG_DWO_MACINFO_SECTION ".debug_macinfo.dwo"
3426 #endif
3427 #ifndef DEBUG_MACINFO_SECTION
3428 #define DEBUG_MACINFO_SECTION \
3429 (!dwarf_split_debug_info \
3430 ? (DEBUG_NORM_MACINFO_SECTION) : (DEBUG_DWO_MACINFO_SECTION))
3431 #endif
3432 #ifndef DEBUG_NORM_MACRO_SECTION
3433 #define DEBUG_NORM_MACRO_SECTION ".debug_macro"
3434 #endif
3435 #ifndef DEBUG_DWO_MACRO_SECTION
3436 #define DEBUG_DWO_MACRO_SECTION ".debug_macro.dwo"
3437 #endif
3438 #ifndef DEBUG_MACRO_SECTION
3439 #define DEBUG_MACRO_SECTION \
3440 (!dwarf_split_debug_info \
3441 ? (DEBUG_NORM_MACRO_SECTION) : (DEBUG_DWO_MACRO_SECTION))
3442 #endif
3443 #ifndef DEBUG_LINE_SECTION
3444 #define DEBUG_LINE_SECTION ".debug_line"
3445 #endif
3446 #ifndef DEBUG_DWO_LINE_SECTION
3447 #define DEBUG_DWO_LINE_SECTION ".debug_line.dwo"
3448 #endif
3449 #ifndef DEBUG_LOC_SECTION
3450 #define DEBUG_LOC_SECTION ".debug_loc"
3451 #endif
3452 #ifndef DEBUG_DWO_LOC_SECTION
3453 #define DEBUG_DWO_LOC_SECTION ".debug_loc.dwo"
3454 #endif
3455 #ifndef DEBUG_PUBNAMES_SECTION
3456 #define DEBUG_PUBNAMES_SECTION \
3457 ((debug_generate_pub_sections == 2) \
3458 ? ".debug_gnu_pubnames" : ".debug_pubnames")
3459 #endif
3460 #ifndef DEBUG_PUBTYPES_SECTION
3461 #define DEBUG_PUBTYPES_SECTION \
3462 ((debug_generate_pub_sections == 2) \
3463 ? ".debug_gnu_pubtypes" : ".debug_pubtypes")
3464 #endif
3465 #define DEBUG_NORM_STR_OFFSETS_SECTION ".debug_str_offsets"
3466 #define DEBUG_DWO_STR_OFFSETS_SECTION ".debug_str_offsets.dwo"
3467 #ifndef DEBUG_STR_OFFSETS_SECTION
3468 #define DEBUG_STR_OFFSETS_SECTION \
3469 (!dwarf_split_debug_info \
3470 ? (DEBUG_NORM_STR_OFFSETS_SECTION) : (DEBUG_DWO_STR_OFFSETS_SECTION))
3471 #endif
3472 #ifndef DEBUG_STR_DWO_SECTION
3473 #define DEBUG_STR_DWO_SECTION ".debug_str.dwo"
3474 #endif
3475 #ifndef DEBUG_STR_SECTION
3476 #define DEBUG_STR_SECTION ".debug_str"
3477 #endif
3478 #ifndef DEBUG_RANGES_SECTION
3479 #define DEBUG_RANGES_SECTION ".debug_ranges"
3480 #endif
3482 /* Standard ELF section names for compiled code and data. */
3483 #ifndef TEXT_SECTION_NAME
3484 #define TEXT_SECTION_NAME ".text"
3485 #endif
3487 /* Section flags for .debug_macinfo/.debug_macro section. */
3488 #define DEBUG_MACRO_SECTION_FLAGS \
3489 (dwarf_split_debug_info ? SECTION_DEBUG | SECTION_EXCLUDE : SECTION_DEBUG)
3491 /* Section flags for .debug_str section. */
3492 #define DEBUG_STR_SECTION_FLAGS \
3493 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
3494 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
3495 : SECTION_DEBUG)
3497 /* Section flags for .debug_str.dwo section. */
3498 #define DEBUG_STR_DWO_SECTION_FLAGS (SECTION_DEBUG | SECTION_EXCLUDE)
3500 /* Labels we insert at beginning sections we can reference instead of
3501 the section names themselves. */
3503 #ifndef TEXT_SECTION_LABEL
3504 #define TEXT_SECTION_LABEL "Ltext"
3505 #endif
3506 #ifndef COLD_TEXT_SECTION_LABEL
3507 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
3508 #endif
3509 #ifndef DEBUG_LINE_SECTION_LABEL
3510 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
3511 #endif
3512 #ifndef DEBUG_SKELETON_LINE_SECTION_LABEL
3513 #define DEBUG_SKELETON_LINE_SECTION_LABEL "Lskeleton_debug_line"
3514 #endif
3515 #ifndef DEBUG_INFO_SECTION_LABEL
3516 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
3517 #endif
3518 #ifndef DEBUG_SKELETON_INFO_SECTION_LABEL
3519 #define DEBUG_SKELETON_INFO_SECTION_LABEL "Lskeleton_debug_info"
3520 #endif
3521 #ifndef DEBUG_ABBREV_SECTION_LABEL
3522 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
3523 #endif
3524 #ifndef DEBUG_SKELETON_ABBREV_SECTION_LABEL
3525 #define DEBUG_SKELETON_ABBREV_SECTION_LABEL "Lskeleton_debug_abbrev"
3526 #endif
3527 #ifndef DEBUG_ADDR_SECTION_LABEL
3528 #define DEBUG_ADDR_SECTION_LABEL "Ldebug_addr"
3529 #endif
3530 #ifndef DEBUG_LOC_SECTION_LABEL
3531 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
3532 #endif
3533 #ifndef DEBUG_RANGES_SECTION_LABEL
3534 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
3535 #endif
3536 #ifndef DEBUG_MACINFO_SECTION_LABEL
3537 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
3538 #endif
3539 #ifndef DEBUG_MACRO_SECTION_LABEL
3540 #define DEBUG_MACRO_SECTION_LABEL "Ldebug_macro"
3541 #endif
3542 #define SKELETON_COMP_DIE_ABBREV 1
3543 #define SKELETON_TYPE_DIE_ABBREV 2
3545 /* Definitions of defaults for formats and names of various special
3546 (artificial) labels which may be generated within this file (when the -g
3547 options is used and DWARF2_DEBUGGING_INFO is in effect.
3548 If necessary, these may be overridden from within the tm.h file, but
3549 typically, overriding these defaults is unnecessary. */
3551 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
3552 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3553 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3554 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
3555 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3556 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3557 static char debug_skeleton_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3558 static char debug_skeleton_abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3559 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3560 static char debug_addr_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3561 static char debug_skeleton_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3562 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3563 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3564 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
3566 #ifndef TEXT_END_LABEL
3567 #define TEXT_END_LABEL "Letext"
3568 #endif
3569 #ifndef COLD_END_LABEL
3570 #define COLD_END_LABEL "Letext_cold"
3571 #endif
3572 #ifndef BLOCK_BEGIN_LABEL
3573 #define BLOCK_BEGIN_LABEL "LBB"
3574 #endif
3575 #ifndef BLOCK_END_LABEL
3576 #define BLOCK_END_LABEL "LBE"
3577 #endif
3578 #ifndef LINE_CODE_LABEL
3579 #define LINE_CODE_LABEL "LM"
3580 #endif
3583 /* Return the root of the DIE's built for the current compilation unit. */
3584 static dw_die_ref
3585 comp_unit_die (void)
3587 if (!single_comp_unit_die)
3588 single_comp_unit_die = gen_compile_unit_die (NULL);
3589 return single_comp_unit_die;
3592 /* We allow a language front-end to designate a function that is to be
3593 called to "demangle" any name before it is put into a DIE. */
3595 static const char *(*demangle_name_func) (const char *);
3597 void
3598 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
3600 demangle_name_func = func;
3603 /* Test if rtl node points to a pseudo register. */
3605 static inline int
3606 is_pseudo_reg (const_rtx rtl)
3608 return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
3609 || (GET_CODE (rtl) == SUBREG
3610 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
3613 /* Return a reference to a type, with its const and volatile qualifiers
3614 removed. */
3616 static inline tree
3617 type_main_variant (tree type)
3619 type = TYPE_MAIN_VARIANT (type);
3621 /* ??? There really should be only one main variant among any group of
3622 variants of a given type (and all of the MAIN_VARIANT values for all
3623 members of the group should point to that one type) but sometimes the C
3624 front-end messes this up for array types, so we work around that bug
3625 here. */
3626 if (TREE_CODE (type) == ARRAY_TYPE)
3627 while (type != TYPE_MAIN_VARIANT (type))
3628 type = TYPE_MAIN_VARIANT (type);
3630 return type;
3633 /* Return nonzero if the given type node represents a tagged type. */
3635 static inline int
3636 is_tagged_type (const_tree type)
3638 enum tree_code code = TREE_CODE (type);
3640 return (code == RECORD_TYPE || code == UNION_TYPE
3641 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
3644 /* Set label to debug_info_section_label + die_offset of a DIE reference. */
3646 static void
3647 get_ref_die_offset_label (char *label, dw_die_ref ref)
3649 sprintf (label, "%s+%ld", debug_info_section_label, ref->die_offset);
3652 /* Return die_offset of a DIE reference to a base type. */
3654 static unsigned long int
3655 get_base_type_offset (dw_die_ref ref)
3657 if (ref->die_offset)
3658 return ref->die_offset;
3659 if (comp_unit_die ()->die_abbrev)
3661 calc_base_type_die_sizes ();
3662 gcc_assert (ref->die_offset);
3664 return ref->die_offset;
3667 /* Return die_offset of a DIE reference other than base type. */
3669 static unsigned long int
3670 get_ref_die_offset (dw_die_ref ref)
3672 gcc_assert (ref->die_offset);
3673 return ref->die_offset;
3676 /* Convert a DIE tag into its string name. */
3678 static const char *
3679 dwarf_tag_name (unsigned int tag)
3681 const char *name = get_DW_TAG_name (tag);
3683 if (name != NULL)
3684 return name;
3686 return "DW_TAG_<unknown>";
3689 /* Convert a DWARF attribute code into its string name. */
3691 static const char *
3692 dwarf_attr_name (unsigned int attr)
3694 const char *name;
3696 switch (attr)
3698 #if VMS_DEBUGGING_INFO
3699 case DW_AT_HP_prologue:
3700 return "DW_AT_HP_prologue";
3701 #else
3702 case DW_AT_MIPS_loop_unroll_factor:
3703 return "DW_AT_MIPS_loop_unroll_factor";
3704 #endif
3706 #if VMS_DEBUGGING_INFO
3707 case DW_AT_HP_epilogue:
3708 return "DW_AT_HP_epilogue";
3709 #else
3710 case DW_AT_MIPS_stride:
3711 return "DW_AT_MIPS_stride";
3712 #endif
3715 name = get_DW_AT_name (attr);
3717 if (name != NULL)
3718 return name;
3720 return "DW_AT_<unknown>";
3723 /* Convert a DWARF value form code into its string name. */
3725 static const char *
3726 dwarf_form_name (unsigned int form)
3728 const char *name = get_DW_FORM_name (form);
3730 if (name != NULL)
3731 return name;
3733 return "DW_FORM_<unknown>";
3736 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
3737 instance of an inlined instance of a decl which is local to an inline
3738 function, so we have to trace all of the way back through the origin chain
3739 to find out what sort of node actually served as the original seed for the
3740 given block. */
3742 static tree
3743 decl_ultimate_origin (const_tree decl)
3745 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
3746 return NULL_TREE;
3748 /* DECL_ABSTRACT_ORIGIN can point to itself; ignore that if
3749 we're trying to output the abstract instance of this function. */
3750 if (DECL_ABSTRACT_P (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
3751 return NULL_TREE;
3753 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
3754 most distant ancestor, this should never happen. */
3755 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
3757 return DECL_ABSTRACT_ORIGIN (decl);
3760 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
3761 of a virtual function may refer to a base class, so we check the 'this'
3762 parameter. */
3764 static tree
3765 decl_class_context (tree decl)
3767 tree context = NULL_TREE;
3769 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
3770 context = DECL_CONTEXT (decl);
3771 else
3772 context = TYPE_MAIN_VARIANT
3773 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
3775 if (context && !TYPE_P (context))
3776 context = NULL_TREE;
3778 return context;
3781 /* Add an attribute/value pair to a DIE. */
3783 static inline void
3784 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
3786 /* Maybe this should be an assert? */
3787 if (die == NULL)
3788 return;
3790 vec_safe_reserve (die->die_attr, 1);
3791 vec_safe_push (die->die_attr, *attr);
3794 static inline enum dw_val_class
3795 AT_class (dw_attr_ref a)
3797 return a->dw_attr_val.val_class;
3800 /* Return the index for any attribute that will be referenced with a
3801 DW_FORM_GNU_addr_index or DW_FORM_GNU_str_index. String indices
3802 are stored in dw_attr_val.v.val_str for reference counting
3803 pruning. */
3805 static inline unsigned int
3806 AT_index (dw_attr_ref a)
3808 if (AT_class (a) == dw_val_class_str)
3809 return a->dw_attr_val.v.val_str->index;
3810 else if (a->dw_attr_val.val_entry != NULL)
3811 return a->dw_attr_val.val_entry->index;
3812 return NOT_INDEXED;
3815 /* Add a flag value attribute to a DIE. */
3817 static inline void
3818 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
3820 dw_attr_node attr;
3822 attr.dw_attr = attr_kind;
3823 attr.dw_attr_val.val_class = dw_val_class_flag;
3824 attr.dw_attr_val.val_entry = NULL;
3825 attr.dw_attr_val.v.val_flag = flag;
3826 add_dwarf_attr (die, &attr);
3829 static inline unsigned
3830 AT_flag (dw_attr_ref a)
3832 gcc_assert (a && AT_class (a) == dw_val_class_flag);
3833 return a->dw_attr_val.v.val_flag;
3836 /* Add a signed integer attribute value to a DIE. */
3838 static inline void
3839 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
3841 dw_attr_node attr;
3843 attr.dw_attr = attr_kind;
3844 attr.dw_attr_val.val_class = dw_val_class_const;
3845 attr.dw_attr_val.val_entry = NULL;
3846 attr.dw_attr_val.v.val_int = int_val;
3847 add_dwarf_attr (die, &attr);
3850 static inline HOST_WIDE_INT
3851 AT_int (dw_attr_ref a)
3853 gcc_assert (a && AT_class (a) == dw_val_class_const);
3854 return a->dw_attr_val.v.val_int;
3857 /* Add an unsigned integer attribute value to a DIE. */
3859 static inline void
3860 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
3861 unsigned HOST_WIDE_INT unsigned_val)
3863 dw_attr_node attr;
3865 attr.dw_attr = attr_kind;
3866 attr.dw_attr_val.val_class = dw_val_class_unsigned_const;
3867 attr.dw_attr_val.val_entry = NULL;
3868 attr.dw_attr_val.v.val_unsigned = unsigned_val;
3869 add_dwarf_attr (die, &attr);
3872 static inline unsigned HOST_WIDE_INT
3873 AT_unsigned (dw_attr_ref a)
3875 gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
3876 return a->dw_attr_val.v.val_unsigned;
3879 /* Add an unsigned wide integer attribute value to a DIE. */
3881 static inline void
3882 add_AT_wide (dw_die_ref die, enum dwarf_attribute attr_kind,
3883 const wide_int& w)
3885 dw_attr_node attr;
3887 attr.dw_attr = attr_kind;
3888 attr.dw_attr_val.val_class = dw_val_class_wide_int;
3889 attr.dw_attr_val.v.val_wide = ggc_alloc<wide_int> ();
3890 *attr.dw_attr_val.v.val_wide = w;
3891 add_dwarf_attr (die, &attr);
3894 /* Add an unsigned double integer attribute value to a DIE. */
3896 static inline void
3897 add_AT_double (dw_die_ref die, enum dwarf_attribute attr_kind,
3898 HOST_WIDE_INT high, unsigned HOST_WIDE_INT low)
3900 dw_attr_node attr;
3902 attr.dw_attr = attr_kind;
3903 attr.dw_attr_val.val_class = dw_val_class_const_double;
3904 attr.dw_attr_val.val_entry = NULL;
3905 attr.dw_attr_val.v.val_double.high = high;
3906 attr.dw_attr_val.v.val_double.low = low;
3907 add_dwarf_attr (die, &attr);
3910 /* Add a floating point attribute value to a DIE and return it. */
3912 static inline void
3913 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
3914 unsigned int length, unsigned int elt_size, unsigned char *array)
3916 dw_attr_node attr;
3918 attr.dw_attr = attr_kind;
3919 attr.dw_attr_val.val_class = dw_val_class_vec;
3920 attr.dw_attr_val.val_entry = NULL;
3921 attr.dw_attr_val.v.val_vec.length = length;
3922 attr.dw_attr_val.v.val_vec.elt_size = elt_size;
3923 attr.dw_attr_val.v.val_vec.array = array;
3924 add_dwarf_attr (die, &attr);
3927 /* Add an 8-byte data attribute value to a DIE. */
3929 static inline void
3930 add_AT_data8 (dw_die_ref die, enum dwarf_attribute attr_kind,
3931 unsigned char data8[8])
3933 dw_attr_node attr;
3935 attr.dw_attr = attr_kind;
3936 attr.dw_attr_val.val_class = dw_val_class_data8;
3937 attr.dw_attr_val.val_entry = NULL;
3938 memcpy (attr.dw_attr_val.v.val_data8, data8, 8);
3939 add_dwarf_attr (die, &attr);
3942 /* Add DW_AT_low_pc and DW_AT_high_pc to a DIE. When using
3943 dwarf_split_debug_info, address attributes in dies destined for the
3944 final executable have force_direct set to avoid using indexed
3945 references. */
3947 static inline void
3948 add_AT_low_high_pc (dw_die_ref die, const char *lbl_low, const char *lbl_high,
3949 bool force_direct)
3951 dw_attr_node attr;
3952 char * lbl_id;
3954 lbl_id = xstrdup (lbl_low);
3955 attr.dw_attr = DW_AT_low_pc;
3956 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
3957 attr.dw_attr_val.v.val_lbl_id = lbl_id;
3958 if (dwarf_split_debug_info && !force_direct)
3959 attr.dw_attr_val.val_entry
3960 = add_addr_table_entry (lbl_id, ate_kind_label);
3961 else
3962 attr.dw_attr_val.val_entry = NULL;
3963 add_dwarf_attr (die, &attr);
3965 attr.dw_attr = DW_AT_high_pc;
3966 if (dwarf_version < 4)
3967 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
3968 else
3969 attr.dw_attr_val.val_class = dw_val_class_high_pc;
3970 lbl_id = xstrdup (lbl_high);
3971 attr.dw_attr_val.v.val_lbl_id = lbl_id;
3972 if (attr.dw_attr_val.val_class == dw_val_class_lbl_id
3973 && dwarf_split_debug_info && !force_direct)
3974 attr.dw_attr_val.val_entry
3975 = add_addr_table_entry (lbl_id, ate_kind_label);
3976 else
3977 attr.dw_attr_val.val_entry = NULL;
3978 add_dwarf_attr (die, &attr);
3981 /* Hash and equality functions for debug_str_hash. */
3983 hashval_t
3984 indirect_string_hasher::hash (indirect_string_node *x)
3986 return htab_hash_string (x->str);
3989 bool
3990 indirect_string_hasher::equal (indirect_string_node *x1, const char *x2)
3992 return strcmp (x1->str, x2) == 0;
3995 /* Add STR to the given string hash table. */
3997 static struct indirect_string_node *
3998 find_AT_string_in_table (const char *str,
3999 hash_table<indirect_string_hasher> *table)
4001 struct indirect_string_node *node;
4003 indirect_string_node **slot
4004 = table->find_slot_with_hash (str, htab_hash_string (str), INSERT);
4005 if (*slot == NULL)
4007 node = ggc_cleared_alloc<indirect_string_node> ();
4008 node->str = ggc_strdup (str);
4009 *slot = node;
4011 else
4012 node = *slot;
4014 node->refcount++;
4015 return node;
4018 /* Add STR to the indirect string hash table. */
4020 static struct indirect_string_node *
4021 find_AT_string (const char *str)
4023 if (! debug_str_hash)
4024 debug_str_hash = hash_table<indirect_string_hasher>::create_ggc (10);
4026 return find_AT_string_in_table (str, debug_str_hash);
4029 /* Add a string attribute value to a DIE. */
4031 static inline void
4032 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
4034 dw_attr_node attr;
4035 struct indirect_string_node *node;
4037 node = find_AT_string (str);
4039 attr.dw_attr = attr_kind;
4040 attr.dw_attr_val.val_class = dw_val_class_str;
4041 attr.dw_attr_val.val_entry = NULL;
4042 attr.dw_attr_val.v.val_str = node;
4043 add_dwarf_attr (die, &attr);
4046 static inline const char *
4047 AT_string (dw_attr_ref a)
4049 gcc_assert (a && AT_class (a) == dw_val_class_str);
4050 return a->dw_attr_val.v.val_str->str;
4053 /* Call this function directly to bypass AT_string_form's logic to put
4054 the string inline in the die. */
4056 static void
4057 set_indirect_string (struct indirect_string_node *node)
4059 char label[32];
4060 /* Already indirect is a no op. */
4061 if (node->form == DW_FORM_strp || node->form == DW_FORM_GNU_str_index)
4063 gcc_assert (node->label);
4064 return;
4066 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
4067 ++dw2_string_counter;
4068 node->label = xstrdup (label);
4070 if (!dwarf_split_debug_info)
4072 node->form = DW_FORM_strp;
4073 node->index = NOT_INDEXED;
4075 else
4077 node->form = DW_FORM_GNU_str_index;
4078 node->index = NO_INDEX_ASSIGNED;
4082 /* Find out whether a string should be output inline in DIE
4083 or out-of-line in .debug_str section. */
4085 static enum dwarf_form
4086 find_string_form (struct indirect_string_node *node)
4088 unsigned int len;
4090 if (node->form)
4091 return node->form;
4093 len = strlen (node->str) + 1;
4095 /* If the string is shorter or equal to the size of the reference, it is
4096 always better to put it inline. */
4097 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
4098 return node->form = DW_FORM_string;
4100 /* If we cannot expect the linker to merge strings in .debug_str
4101 section, only put it into .debug_str if it is worth even in this
4102 single module. */
4103 if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
4104 || ((debug_str_section->common.flags & SECTION_MERGE) == 0
4105 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len))
4106 return node->form = DW_FORM_string;
4108 set_indirect_string (node);
4110 return node->form;
4113 /* Find out whether the string referenced from the attribute should be
4114 output inline in DIE or out-of-line in .debug_str section. */
4116 static enum dwarf_form
4117 AT_string_form (dw_attr_ref a)
4119 gcc_assert (a && AT_class (a) == dw_val_class_str);
4120 return find_string_form (a->dw_attr_val.v.val_str);
4123 /* Add a DIE reference attribute value to a DIE. */
4125 static inline void
4126 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
4128 dw_attr_node attr;
4130 #ifdef ENABLE_CHECKING
4131 gcc_assert (targ_die != NULL);
4132 #else
4133 /* With LTO we can end up trying to reference something we didn't create
4134 a DIE for. Avoid crashing later on a NULL referenced DIE. */
4135 if (targ_die == NULL)
4136 return;
4137 #endif
4139 attr.dw_attr = attr_kind;
4140 attr.dw_attr_val.val_class = dw_val_class_die_ref;
4141 attr.dw_attr_val.val_entry = NULL;
4142 attr.dw_attr_val.v.val_die_ref.die = targ_die;
4143 attr.dw_attr_val.v.val_die_ref.external = 0;
4144 add_dwarf_attr (die, &attr);
4147 /* Change DIE reference REF to point to NEW_DIE instead. */
4149 static inline void
4150 change_AT_die_ref (dw_attr_ref ref, dw_die_ref new_die)
4152 gcc_assert (ref->dw_attr_val.val_class == dw_val_class_die_ref);
4153 ref->dw_attr_val.v.val_die_ref.die = new_die;
4154 ref->dw_attr_val.v.val_die_ref.external = 0;
4157 /* Add an AT_specification attribute to a DIE, and also make the back
4158 pointer from the specification to the definition. */
4160 static inline void
4161 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
4163 add_AT_die_ref (die, DW_AT_specification, targ_die);
4164 gcc_assert (!targ_die->die_definition);
4165 targ_die->die_definition = die;
4168 static inline dw_die_ref
4169 AT_ref (dw_attr_ref a)
4171 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
4172 return a->dw_attr_val.v.val_die_ref.die;
4175 static inline int
4176 AT_ref_external (dw_attr_ref a)
4178 if (a && AT_class (a) == dw_val_class_die_ref)
4179 return a->dw_attr_val.v.val_die_ref.external;
4181 return 0;
4184 static inline void
4185 set_AT_ref_external (dw_attr_ref a, int i)
4187 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
4188 a->dw_attr_val.v.val_die_ref.external = i;
4191 /* Add an FDE reference attribute value to a DIE. */
4193 static inline void
4194 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
4196 dw_attr_node attr;
4198 attr.dw_attr = attr_kind;
4199 attr.dw_attr_val.val_class = dw_val_class_fde_ref;
4200 attr.dw_attr_val.val_entry = NULL;
4201 attr.dw_attr_val.v.val_fde_index = targ_fde;
4202 add_dwarf_attr (die, &attr);
4205 /* Add a location description attribute value to a DIE. */
4207 static inline void
4208 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
4210 dw_attr_node attr;
4212 attr.dw_attr = attr_kind;
4213 attr.dw_attr_val.val_class = dw_val_class_loc;
4214 attr.dw_attr_val.val_entry = NULL;
4215 attr.dw_attr_val.v.val_loc = loc;
4216 add_dwarf_attr (die, &attr);
4219 static inline dw_loc_descr_ref
4220 AT_loc (dw_attr_ref a)
4222 gcc_assert (a && AT_class (a) == dw_val_class_loc);
4223 return a->dw_attr_val.v.val_loc;
4226 static inline void
4227 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
4229 dw_attr_node attr;
4231 attr.dw_attr = attr_kind;
4232 attr.dw_attr_val.val_class = dw_val_class_loc_list;
4233 attr.dw_attr_val.val_entry = NULL;
4234 attr.dw_attr_val.v.val_loc_list = loc_list;
4235 add_dwarf_attr (die, &attr);
4236 have_location_lists = true;
4239 static inline dw_loc_list_ref
4240 AT_loc_list (dw_attr_ref a)
4242 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
4243 return a->dw_attr_val.v.val_loc_list;
4246 static inline dw_loc_list_ref *
4247 AT_loc_list_ptr (dw_attr_ref a)
4249 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
4250 return &a->dw_attr_val.v.val_loc_list;
4253 struct addr_hasher : ggc_hasher<addr_table_entry *>
4255 static hashval_t hash (addr_table_entry *);
4256 static bool equal (addr_table_entry *, addr_table_entry *);
4259 /* Table of entries into the .debug_addr section. */
4261 static GTY (()) hash_table<addr_hasher> *addr_index_table;
4263 /* Hash an address_table_entry. */
4265 hashval_t
4266 addr_hasher::hash (addr_table_entry *a)
4268 inchash::hash hstate;
4269 switch (a->kind)
4271 case ate_kind_rtx:
4272 hstate.add_int (0);
4273 break;
4274 case ate_kind_rtx_dtprel:
4275 hstate.add_int (1);
4276 break;
4277 case ate_kind_label:
4278 return htab_hash_string (a->addr.label);
4279 default:
4280 gcc_unreachable ();
4282 inchash::add_rtx (a->addr.rtl, hstate);
4283 return hstate.end ();
4286 /* Determine equality for two address_table_entries. */
4288 bool
4289 addr_hasher::equal (addr_table_entry *a1, addr_table_entry *a2)
4291 if (a1->kind != a2->kind)
4292 return 0;
4293 switch (a1->kind)
4295 case ate_kind_rtx:
4296 case ate_kind_rtx_dtprel:
4297 return rtx_equal_p (a1->addr.rtl, a2->addr.rtl);
4298 case ate_kind_label:
4299 return strcmp (a1->addr.label, a2->addr.label) == 0;
4300 default:
4301 gcc_unreachable ();
4305 /* Initialize an addr_table_entry. */
4307 void
4308 init_addr_table_entry (addr_table_entry *e, enum ate_kind kind, void *addr)
4310 e->kind = kind;
4311 switch (kind)
4313 case ate_kind_rtx:
4314 case ate_kind_rtx_dtprel:
4315 e->addr.rtl = (rtx) addr;
4316 break;
4317 case ate_kind_label:
4318 e->addr.label = (char *) addr;
4319 break;
4321 e->refcount = 0;
4322 e->index = NO_INDEX_ASSIGNED;
4325 /* Add attr to the address table entry to the table. Defer setting an
4326 index until output time. */
4328 static addr_table_entry *
4329 add_addr_table_entry (void *addr, enum ate_kind kind)
4331 addr_table_entry *node;
4332 addr_table_entry finder;
4334 gcc_assert (dwarf_split_debug_info);
4335 if (! addr_index_table)
4336 addr_index_table = hash_table<addr_hasher>::create_ggc (10);
4337 init_addr_table_entry (&finder, kind, addr);
4338 addr_table_entry **slot = addr_index_table->find_slot (&finder, INSERT);
4340 if (*slot == HTAB_EMPTY_ENTRY)
4342 node = ggc_cleared_alloc<addr_table_entry> ();
4343 init_addr_table_entry (node, kind, addr);
4344 *slot = node;
4346 else
4347 node = *slot;
4349 node->refcount++;
4350 return node;
4353 /* Remove an entry from the addr table by decrementing its refcount.
4354 Strictly, decrementing the refcount would be enough, but the
4355 assertion that the entry is actually in the table has found
4356 bugs. */
4358 static void
4359 remove_addr_table_entry (addr_table_entry *entry)
4361 gcc_assert (dwarf_split_debug_info && addr_index_table);
4362 /* After an index is assigned, the table is frozen. */
4363 gcc_assert (entry->refcount > 0 && entry->index == NO_INDEX_ASSIGNED);
4364 entry->refcount--;
4367 /* Given a location list, remove all addresses it refers to from the
4368 address_table. */
4370 static void
4371 remove_loc_list_addr_table_entries (dw_loc_descr_ref descr)
4373 for (; descr; descr = descr->dw_loc_next)
4374 if (descr->dw_loc_oprnd1.val_entry != NULL)
4376 gcc_assert (descr->dw_loc_oprnd1.val_entry->index == NO_INDEX_ASSIGNED);
4377 remove_addr_table_entry (descr->dw_loc_oprnd1.val_entry);
4381 /* A helper function for dwarf2out_finish called through
4382 htab_traverse. Assign an addr_table_entry its index. All entries
4383 must be collected into the table when this function is called,
4384 because the indexing code relies on htab_traverse to traverse nodes
4385 in the same order for each run. */
4388 index_addr_table_entry (addr_table_entry **h, unsigned int *index)
4390 addr_table_entry *node = *h;
4392 /* Don't index unreferenced nodes. */
4393 if (node->refcount == 0)
4394 return 1;
4396 gcc_assert (node->index == NO_INDEX_ASSIGNED);
4397 node->index = *index;
4398 *index += 1;
4400 return 1;
4403 /* Add an address constant attribute value to a DIE. When using
4404 dwarf_split_debug_info, address attributes in dies destined for the
4405 final executable should be direct references--setting the parameter
4406 force_direct ensures this behavior. */
4408 static inline void
4409 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr,
4410 bool force_direct)
4412 dw_attr_node attr;
4414 attr.dw_attr = attr_kind;
4415 attr.dw_attr_val.val_class = dw_val_class_addr;
4416 attr.dw_attr_val.v.val_addr = addr;
4417 if (dwarf_split_debug_info && !force_direct)
4418 attr.dw_attr_val.val_entry = add_addr_table_entry (addr, ate_kind_rtx);
4419 else
4420 attr.dw_attr_val.val_entry = NULL;
4421 add_dwarf_attr (die, &attr);
4424 /* Get the RTX from to an address DIE attribute. */
4426 static inline rtx
4427 AT_addr (dw_attr_ref a)
4429 gcc_assert (a && AT_class (a) == dw_val_class_addr);
4430 return a->dw_attr_val.v.val_addr;
4433 /* Add a file attribute value to a DIE. */
4435 static inline void
4436 add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind,
4437 struct dwarf_file_data *fd)
4439 dw_attr_node attr;
4441 attr.dw_attr = attr_kind;
4442 attr.dw_attr_val.val_class = dw_val_class_file;
4443 attr.dw_attr_val.val_entry = NULL;
4444 attr.dw_attr_val.v.val_file = fd;
4445 add_dwarf_attr (die, &attr);
4448 /* Get the dwarf_file_data from a file DIE attribute. */
4450 static inline struct dwarf_file_data *
4451 AT_file (dw_attr_ref a)
4453 gcc_assert (a && AT_class (a) == dw_val_class_file);
4454 return a->dw_attr_val.v.val_file;
4457 /* Add a vms delta attribute value to a DIE. */
4459 static inline void
4460 add_AT_vms_delta (dw_die_ref die, enum dwarf_attribute attr_kind,
4461 const char *lbl1, const char *lbl2)
4463 dw_attr_node attr;
4465 attr.dw_attr = attr_kind;
4466 attr.dw_attr_val.val_class = dw_val_class_vms_delta;
4467 attr.dw_attr_val.val_entry = NULL;
4468 attr.dw_attr_val.v.val_vms_delta.lbl1 = xstrdup (lbl1);
4469 attr.dw_attr_val.v.val_vms_delta.lbl2 = xstrdup (lbl2);
4470 add_dwarf_attr (die, &attr);
4473 /* Add a label identifier attribute value to a DIE. */
4475 static inline void
4476 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind,
4477 const char *lbl_id)
4479 dw_attr_node attr;
4481 attr.dw_attr = attr_kind;
4482 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
4483 attr.dw_attr_val.val_entry = NULL;
4484 attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
4485 if (dwarf_split_debug_info)
4486 attr.dw_attr_val.val_entry
4487 = add_addr_table_entry (attr.dw_attr_val.v.val_lbl_id,
4488 ate_kind_label);
4489 add_dwarf_attr (die, &attr);
4492 /* Add a section offset attribute value to a DIE, an offset into the
4493 debug_line section. */
4495 static inline void
4496 add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind,
4497 const char *label)
4499 dw_attr_node attr;
4501 attr.dw_attr = attr_kind;
4502 attr.dw_attr_val.val_class = dw_val_class_lineptr;
4503 attr.dw_attr_val.val_entry = NULL;
4504 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
4505 add_dwarf_attr (die, &attr);
4508 /* Add a section offset attribute value to a DIE, an offset into the
4509 debug_macinfo section. */
4511 static inline void
4512 add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind,
4513 const char *label)
4515 dw_attr_node attr;
4517 attr.dw_attr = attr_kind;
4518 attr.dw_attr_val.val_class = dw_val_class_macptr;
4519 attr.dw_attr_val.val_entry = NULL;
4520 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
4521 add_dwarf_attr (die, &attr);
4524 /* Add an offset attribute value to a DIE. */
4526 static inline void
4527 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
4528 unsigned HOST_WIDE_INT offset)
4530 dw_attr_node attr;
4532 attr.dw_attr = attr_kind;
4533 attr.dw_attr_val.val_class = dw_val_class_offset;
4534 attr.dw_attr_val.val_entry = NULL;
4535 attr.dw_attr_val.v.val_offset = offset;
4536 add_dwarf_attr (die, &attr);
4539 /* Add a range_list attribute value to a DIE. When using
4540 dwarf_split_debug_info, address attributes in dies destined for the
4541 final executable should be direct references--setting the parameter
4542 force_direct ensures this behavior. */
4544 #define UNRELOCATED_OFFSET ((addr_table_entry *) 1)
4545 #define RELOCATED_OFFSET (NULL)
4547 static void
4548 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
4549 long unsigned int offset, bool force_direct)
4551 dw_attr_node attr;
4553 attr.dw_attr = attr_kind;
4554 attr.dw_attr_val.val_class = dw_val_class_range_list;
4555 /* For the range_list attribute, use val_entry to store whether the
4556 offset should follow split-debug-info or normal semantics. This
4557 value is read in output_range_list_offset. */
4558 if (dwarf_split_debug_info && !force_direct)
4559 attr.dw_attr_val.val_entry = UNRELOCATED_OFFSET;
4560 else
4561 attr.dw_attr_val.val_entry = RELOCATED_OFFSET;
4562 attr.dw_attr_val.v.val_offset = offset;
4563 add_dwarf_attr (die, &attr);
4566 /* Return the start label of a delta attribute. */
4568 static inline const char *
4569 AT_vms_delta1 (dw_attr_ref a)
4571 gcc_assert (a && (AT_class (a) == dw_val_class_vms_delta));
4572 return a->dw_attr_val.v.val_vms_delta.lbl1;
4575 /* Return the end label of a delta attribute. */
4577 static inline const char *
4578 AT_vms_delta2 (dw_attr_ref a)
4580 gcc_assert (a && (AT_class (a) == dw_val_class_vms_delta));
4581 return a->dw_attr_val.v.val_vms_delta.lbl2;
4584 static inline const char *
4585 AT_lbl (dw_attr_ref a)
4587 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
4588 || AT_class (a) == dw_val_class_lineptr
4589 || AT_class (a) == dw_val_class_macptr
4590 || AT_class (a) == dw_val_class_high_pc));
4591 return a->dw_attr_val.v.val_lbl_id;
4594 /* Get the attribute of type attr_kind. */
4596 static dw_attr_ref
4597 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
4599 dw_attr_ref a;
4600 unsigned ix;
4601 dw_die_ref spec = NULL;
4603 if (! die)
4604 return NULL;
4606 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
4607 if (a->dw_attr == attr_kind)
4608 return a;
4609 else if (a->dw_attr == DW_AT_specification
4610 || a->dw_attr == DW_AT_abstract_origin)
4611 spec = AT_ref (a);
4613 if (spec)
4614 return get_AT (spec, attr_kind);
4616 return NULL;
4619 /* Returns the parent of the declaration of DIE. */
4621 static dw_die_ref
4622 get_die_parent (dw_die_ref die)
4624 dw_die_ref t;
4626 if (!die)
4627 return NULL;
4629 if ((t = get_AT_ref (die, DW_AT_abstract_origin))
4630 || (t = get_AT_ref (die, DW_AT_specification)))
4631 die = t;
4633 return die->die_parent;
4636 /* Return the "low pc" attribute value, typically associated with a subprogram
4637 DIE. Return null if the "low pc" attribute is either not present, or if it
4638 cannot be represented as an assembler label identifier. */
4640 static inline const char *
4641 get_AT_low_pc (dw_die_ref die)
4643 dw_attr_ref a = get_AT (die, DW_AT_low_pc);
4645 return a ? AT_lbl (a) : NULL;
4648 /* Return the "high pc" attribute value, typically associated with a subprogram
4649 DIE. Return null if the "high pc" attribute is either not present, or if it
4650 cannot be represented as an assembler label identifier. */
4652 static inline const char *
4653 get_AT_hi_pc (dw_die_ref die)
4655 dw_attr_ref a = get_AT (die, DW_AT_high_pc);
4657 return a ? AT_lbl (a) : NULL;
4660 /* Return the value of the string attribute designated by ATTR_KIND, or
4661 NULL if it is not present. */
4663 static inline const char *
4664 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
4666 dw_attr_ref a = get_AT (die, attr_kind);
4668 return a ? AT_string (a) : NULL;
4671 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
4672 if it is not present. */
4674 static inline int
4675 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
4677 dw_attr_ref a = get_AT (die, attr_kind);
4679 return a ? AT_flag (a) : 0;
4682 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
4683 if it is not present. */
4685 static inline unsigned
4686 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
4688 dw_attr_ref a = get_AT (die, attr_kind);
4690 return a ? AT_unsigned (a) : 0;
4693 static inline dw_die_ref
4694 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
4696 dw_attr_ref a = get_AT (die, attr_kind);
4698 return a ? AT_ref (a) : NULL;
4701 static inline struct dwarf_file_data *
4702 get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind)
4704 dw_attr_ref a = get_AT (die, attr_kind);
4706 return a ? AT_file (a) : NULL;
4709 /* Return TRUE if the language is C++. */
4711 static inline bool
4712 is_cxx (void)
4714 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
4716 return (lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus
4717 || lang == DW_LANG_C_plus_plus_11 || lang == DW_LANG_C_plus_plus_14);
4720 /* Return TRUE if the language is Java. */
4722 static inline bool
4723 is_java (void)
4725 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
4727 return lang == DW_LANG_Java;
4730 /* Return TRUE if the language is Fortran. */
4732 static inline bool
4733 is_fortran (void)
4735 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
4737 return (lang == DW_LANG_Fortran77
4738 || lang == DW_LANG_Fortran90
4739 || lang == DW_LANG_Fortran95
4740 || lang == DW_LANG_Fortran03
4741 || lang == DW_LANG_Fortran08);
4744 /* Return TRUE if the language is Ada. */
4746 static inline bool
4747 is_ada (void)
4749 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
4751 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
4754 /* Remove the specified attribute if present. */
4756 static void
4757 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
4759 dw_attr_ref a;
4760 unsigned ix;
4762 if (! die)
4763 return;
4765 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
4766 if (a->dw_attr == attr_kind)
4768 if (AT_class (a) == dw_val_class_str)
4769 if (a->dw_attr_val.v.val_str->refcount)
4770 a->dw_attr_val.v.val_str->refcount--;
4772 /* vec::ordered_remove should help reduce the number of abbrevs
4773 that are needed. */
4774 die->die_attr->ordered_remove (ix);
4775 return;
4779 /* Remove CHILD from its parent. PREV must have the property that
4780 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
4782 static void
4783 remove_child_with_prev (dw_die_ref child, dw_die_ref prev)
4785 gcc_assert (child->die_parent == prev->die_parent);
4786 gcc_assert (prev->die_sib == child);
4787 if (prev == child)
4789 gcc_assert (child->die_parent->die_child == child);
4790 prev = NULL;
4792 else
4793 prev->die_sib = child->die_sib;
4794 if (child->die_parent->die_child == child)
4795 child->die_parent->die_child = prev;
4798 /* Replace OLD_CHILD with NEW_CHILD. PREV must have the property that
4799 PREV->DIE_SIB == OLD_CHILD. Does not alter OLD_CHILD. */
4801 static void
4802 replace_child (dw_die_ref old_child, dw_die_ref new_child, dw_die_ref prev)
4804 dw_die_ref parent = old_child->die_parent;
4806 gcc_assert (parent == prev->die_parent);
4807 gcc_assert (prev->die_sib == old_child);
4809 new_child->die_parent = parent;
4810 if (prev == old_child)
4812 gcc_assert (parent->die_child == old_child);
4813 new_child->die_sib = new_child;
4815 else
4817 prev->die_sib = new_child;
4818 new_child->die_sib = old_child->die_sib;
4820 if (old_child->die_parent->die_child == old_child)
4821 old_child->die_parent->die_child = new_child;
4824 /* Move all children from OLD_PARENT to NEW_PARENT. */
4826 static void
4827 move_all_children (dw_die_ref old_parent, dw_die_ref new_parent)
4829 dw_die_ref c;
4830 new_parent->die_child = old_parent->die_child;
4831 old_parent->die_child = NULL;
4832 FOR_EACH_CHILD (new_parent, c, c->die_parent = new_parent);
4835 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
4836 matches TAG. */
4838 static void
4839 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
4841 dw_die_ref c;
4843 c = die->die_child;
4844 if (c) do {
4845 dw_die_ref prev = c;
4846 c = c->die_sib;
4847 while (c->die_tag == tag)
4849 remove_child_with_prev (c, prev);
4850 /* Might have removed every child. */
4851 if (c == c->die_sib)
4852 return;
4853 c = c->die_sib;
4855 } while (c != die->die_child);
4858 /* Add a CHILD_DIE as the last child of DIE. */
4860 static void
4861 add_child_die (dw_die_ref die, dw_die_ref child_die)
4863 /* FIXME this should probably be an assert. */
4864 if (! die || ! child_die)
4865 return;
4866 gcc_assert (die != child_die);
4868 child_die->die_parent = die;
4869 if (die->die_child)
4871 child_die->die_sib = die->die_child->die_sib;
4872 die->die_child->die_sib = child_die;
4874 else
4875 child_die->die_sib = child_die;
4876 die->die_child = child_die;
4879 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
4880 is the specification, to the end of PARENT's list of children.
4881 This is done by removing and re-adding it. */
4883 static void
4884 splice_child_die (dw_die_ref parent, dw_die_ref child)
4886 dw_die_ref p;
4888 /* We want the declaration DIE from inside the class, not the
4889 specification DIE at toplevel. */
4890 if (child->die_parent != parent)
4892 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
4894 if (tmp)
4895 child = tmp;
4898 gcc_assert (child->die_parent == parent
4899 || (child->die_parent
4900 == get_AT_ref (parent, DW_AT_specification)));
4902 for (p = child->die_parent->die_child; ; p = p->die_sib)
4903 if (p->die_sib == child)
4905 remove_child_with_prev (child, p);
4906 break;
4909 add_child_die (parent, child);
4912 /* Return a pointer to a newly created DIE node. */
4914 static inline dw_die_ref
4915 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
4917 dw_die_ref die = ggc_cleared_alloc<die_node> ();
4919 die->die_tag = tag_value;
4921 if (parent_die != NULL)
4922 add_child_die (parent_die, die);
4923 else
4925 limbo_die_node *limbo_node;
4927 limbo_node = ggc_cleared_alloc<limbo_die_node> ();
4928 limbo_node->die = die;
4929 limbo_node->created_for = t;
4930 limbo_node->next = limbo_die_list;
4931 limbo_die_list = limbo_node;
4934 return die;
4937 /* Return the DIE associated with the given type specifier. */
4939 static inline dw_die_ref
4940 lookup_type_die (tree type)
4942 return TYPE_SYMTAB_DIE (type);
4945 /* Given a TYPE_DIE representing the type TYPE, if TYPE is an
4946 anonymous type named by the typedef TYPE_DIE, return the DIE of the
4947 anonymous type instead the one of the naming typedef. */
4949 static inline dw_die_ref
4950 strip_naming_typedef (tree type, dw_die_ref type_die)
4952 if (type
4953 && TREE_CODE (type) == RECORD_TYPE
4954 && type_die
4955 && type_die->die_tag == DW_TAG_typedef
4956 && is_naming_typedef_decl (TYPE_NAME (type)))
4957 type_die = get_AT_ref (type_die, DW_AT_type);
4958 return type_die;
4961 /* Like lookup_type_die, but if type is an anonymous type named by a
4962 typedef[1], return the DIE of the anonymous type instead the one of
4963 the naming typedef. This is because in gen_typedef_die, we did
4964 equate the anonymous struct named by the typedef with the DIE of
4965 the naming typedef. So by default, lookup_type_die on an anonymous
4966 struct yields the DIE of the naming typedef.
4968 [1]: Read the comment of is_naming_typedef_decl to learn about what
4969 a naming typedef is. */
4971 static inline dw_die_ref
4972 lookup_type_die_strip_naming_typedef (tree type)
4974 dw_die_ref die = lookup_type_die (type);
4975 return strip_naming_typedef (type, die);
4978 /* Equate a DIE to a given type specifier. */
4980 static inline void
4981 equate_type_number_to_die (tree type, dw_die_ref type_die)
4983 TYPE_SYMTAB_DIE (type) = type_die;
4986 /* Returns a hash value for X (which really is a die_struct). */
4988 inline hashval_t
4989 decl_die_hasher::hash (die_node *x)
4991 return (hashval_t) x->decl_id;
4994 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
4996 inline bool
4997 decl_die_hasher::equal (die_node *x, tree y)
4999 return (x->decl_id == DECL_UID (y));
5002 /* Return the DIE associated with a given declaration. */
5004 static inline dw_die_ref
5005 lookup_decl_die (tree decl)
5007 return decl_die_table->find_with_hash (decl, DECL_UID (decl));
5010 /* Returns a hash value for X (which really is a var_loc_list). */
5012 inline hashval_t
5013 decl_loc_hasher::hash (var_loc_list *x)
5015 return (hashval_t) x->decl_id;
5018 /* Return nonzero if decl_id of var_loc_list X is the same as
5019 UID of decl *Y. */
5021 inline bool
5022 decl_loc_hasher::equal (var_loc_list *x, const_tree y)
5024 return (x->decl_id == DECL_UID (y));
5027 /* Return the var_loc list associated with a given declaration. */
5029 static inline var_loc_list *
5030 lookup_decl_loc (const_tree decl)
5032 if (!decl_loc_table)
5033 return NULL;
5034 return decl_loc_table->find_with_hash (decl, DECL_UID (decl));
5037 /* Returns a hash value for X (which really is a cached_dw_loc_list_list). */
5039 inline hashval_t
5040 dw_loc_list_hasher::hash (cached_dw_loc_list *x)
5042 return (hashval_t) x->decl_id;
5045 /* Return nonzero if decl_id of cached_dw_loc_list X is the same as
5046 UID of decl *Y. */
5048 inline bool
5049 dw_loc_list_hasher::equal (cached_dw_loc_list *x, const_tree y)
5051 return (x->decl_id == DECL_UID (y));
5054 /* Equate a DIE to a particular declaration. */
5056 static void
5057 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
5059 unsigned int decl_id = DECL_UID (decl);
5061 *decl_die_table->find_slot_with_hash (decl, decl_id, INSERT) = decl_die;
5062 decl_die->decl_id = decl_id;
5065 /* Return how many bits covers PIECE EXPR_LIST. */
5067 static HOST_WIDE_INT
5068 decl_piece_bitsize (rtx piece)
5070 int ret = (int) GET_MODE (piece);
5071 if (ret)
5072 return ret;
5073 gcc_assert (GET_CODE (XEXP (piece, 0)) == CONCAT
5074 && CONST_INT_P (XEXP (XEXP (piece, 0), 0)));
5075 return INTVAL (XEXP (XEXP (piece, 0), 0));
5078 /* Return pointer to the location of location note in PIECE EXPR_LIST. */
5080 static rtx *
5081 decl_piece_varloc_ptr (rtx piece)
5083 if ((int) GET_MODE (piece))
5084 return &XEXP (piece, 0);
5085 else
5086 return &XEXP (XEXP (piece, 0), 1);
5089 /* Create an EXPR_LIST for location note LOC_NOTE covering BITSIZE bits.
5090 Next is the chain of following piece nodes. */
5092 static rtx_expr_list *
5093 decl_piece_node (rtx loc_note, HOST_WIDE_INT bitsize, rtx next)
5095 if (bitsize > 0 && bitsize <= (int) MAX_MACHINE_MODE)
5096 return alloc_EXPR_LIST (bitsize, loc_note, next);
5097 else
5098 return alloc_EXPR_LIST (0, gen_rtx_CONCAT (VOIDmode,
5099 GEN_INT (bitsize),
5100 loc_note), next);
5103 /* Return rtx that should be stored into loc field for
5104 LOC_NOTE and BITPOS/BITSIZE. */
5106 static rtx
5107 construct_piece_list (rtx loc_note, HOST_WIDE_INT bitpos,
5108 HOST_WIDE_INT bitsize)
5110 if (bitsize != -1)
5112 loc_note = decl_piece_node (loc_note, bitsize, NULL_RTX);
5113 if (bitpos != 0)
5114 loc_note = decl_piece_node (NULL_RTX, bitpos, loc_note);
5116 return loc_note;
5119 /* This function either modifies location piece list *DEST in
5120 place (if SRC and INNER is NULL), or copies location piece list
5121 *SRC to *DEST while modifying it. Location BITPOS is modified
5122 to contain LOC_NOTE, any pieces overlapping it are removed resp.
5123 not copied and if needed some padding around it is added.
5124 When modifying in place, DEST should point to EXPR_LIST where
5125 earlier pieces cover PIECE_BITPOS bits, when copying SRC points
5126 to the start of the whole list and INNER points to the EXPR_LIST
5127 where earlier pieces cover PIECE_BITPOS bits. */
5129 static void
5130 adjust_piece_list (rtx *dest, rtx *src, rtx *inner,
5131 HOST_WIDE_INT bitpos, HOST_WIDE_INT piece_bitpos,
5132 HOST_WIDE_INT bitsize, rtx loc_note)
5134 HOST_WIDE_INT diff;
5135 bool copy = inner != NULL;
5137 if (copy)
5139 /* First copy all nodes preceding the current bitpos. */
5140 while (src != inner)
5142 *dest = decl_piece_node (*decl_piece_varloc_ptr (*src),
5143 decl_piece_bitsize (*src), NULL_RTX);
5144 dest = &XEXP (*dest, 1);
5145 src = &XEXP (*src, 1);
5148 /* Add padding if needed. */
5149 if (bitpos != piece_bitpos)
5151 *dest = decl_piece_node (NULL_RTX, bitpos - piece_bitpos,
5152 copy ? NULL_RTX : *dest);
5153 dest = &XEXP (*dest, 1);
5155 else if (*dest && decl_piece_bitsize (*dest) == bitsize)
5157 gcc_assert (!copy);
5158 /* A piece with correct bitpos and bitsize already exist,
5159 just update the location for it and return. */
5160 *decl_piece_varloc_ptr (*dest) = loc_note;
5161 return;
5163 /* Add the piece that changed. */
5164 *dest = decl_piece_node (loc_note, bitsize, copy ? NULL_RTX : *dest);
5165 dest = &XEXP (*dest, 1);
5166 /* Skip over pieces that overlap it. */
5167 diff = bitpos - piece_bitpos + bitsize;
5168 if (!copy)
5169 src = dest;
5170 while (diff > 0 && *src)
5172 rtx piece = *src;
5173 diff -= decl_piece_bitsize (piece);
5174 if (copy)
5175 src = &XEXP (piece, 1);
5176 else
5178 *src = XEXP (piece, 1);
5179 free_EXPR_LIST_node (piece);
5182 /* Add padding if needed. */
5183 if (diff < 0 && *src)
5185 if (!copy)
5186 dest = src;
5187 *dest = decl_piece_node (NULL_RTX, -diff, copy ? NULL_RTX : *dest);
5188 dest = &XEXP (*dest, 1);
5190 if (!copy)
5191 return;
5192 /* Finally copy all nodes following it. */
5193 while (*src)
5195 *dest = decl_piece_node (*decl_piece_varloc_ptr (*src),
5196 decl_piece_bitsize (*src), NULL_RTX);
5197 dest = &XEXP (*dest, 1);
5198 src = &XEXP (*src, 1);
5202 /* Add a variable location node to the linked list for DECL. */
5204 static struct var_loc_node *
5205 add_var_loc_to_decl (tree decl, rtx loc_note, const char *label)
5207 unsigned int decl_id;
5208 var_loc_list *temp;
5209 struct var_loc_node *loc = NULL;
5210 HOST_WIDE_INT bitsize = -1, bitpos = -1;
5212 if (TREE_CODE (decl) == VAR_DECL
5213 && DECL_HAS_DEBUG_EXPR_P (decl))
5215 tree realdecl = DECL_DEBUG_EXPR (decl);
5216 if (handled_component_p (realdecl)
5217 || (TREE_CODE (realdecl) == MEM_REF
5218 && TREE_CODE (TREE_OPERAND (realdecl, 0)) == ADDR_EXPR))
5220 HOST_WIDE_INT maxsize;
5221 tree innerdecl;
5222 innerdecl
5223 = get_ref_base_and_extent (realdecl, &bitpos, &bitsize, &maxsize);
5224 if (!DECL_P (innerdecl)
5225 || DECL_IGNORED_P (innerdecl)
5226 || TREE_STATIC (innerdecl)
5227 || bitsize <= 0
5228 || bitpos + bitsize > 256
5229 || bitsize != maxsize)
5230 return NULL;
5231 decl = innerdecl;
5235 decl_id = DECL_UID (decl);
5236 var_loc_list **slot
5237 = decl_loc_table->find_slot_with_hash (decl, decl_id, INSERT);
5238 if (*slot == NULL)
5240 temp = ggc_cleared_alloc<var_loc_list> ();
5241 temp->decl_id = decl_id;
5242 *slot = temp;
5244 else
5245 temp = *slot;
5247 /* For PARM_DECLs try to keep around the original incoming value,
5248 even if that means we'll emit a zero-range .debug_loc entry. */
5249 if (temp->last
5250 && temp->first == temp->last
5251 && TREE_CODE (decl) == PARM_DECL
5252 && NOTE_P (temp->first->loc)
5253 && NOTE_VAR_LOCATION_DECL (temp->first->loc) == decl
5254 && DECL_INCOMING_RTL (decl)
5255 && NOTE_VAR_LOCATION_LOC (temp->first->loc)
5256 && GET_CODE (NOTE_VAR_LOCATION_LOC (temp->first->loc))
5257 == GET_CODE (DECL_INCOMING_RTL (decl))
5258 && prev_real_insn (temp->first->loc) == NULL_RTX
5259 && (bitsize != -1
5260 || !rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->first->loc),
5261 NOTE_VAR_LOCATION_LOC (loc_note))
5262 || (NOTE_VAR_LOCATION_STATUS (temp->first->loc)
5263 != NOTE_VAR_LOCATION_STATUS (loc_note))))
5265 loc = ggc_cleared_alloc<var_loc_node> ();
5266 temp->first->next = loc;
5267 temp->last = loc;
5268 loc->loc = construct_piece_list (loc_note, bitpos, bitsize);
5270 else if (temp->last)
5272 struct var_loc_node *last = temp->last, *unused = NULL;
5273 rtx *piece_loc = NULL, last_loc_note;
5274 HOST_WIDE_INT piece_bitpos = 0;
5275 if (last->next)
5277 last = last->next;
5278 gcc_assert (last->next == NULL);
5280 if (bitsize != -1 && GET_CODE (last->loc) == EXPR_LIST)
5282 piece_loc = &last->loc;
5285 HOST_WIDE_INT cur_bitsize = decl_piece_bitsize (*piece_loc);
5286 if (piece_bitpos + cur_bitsize > bitpos)
5287 break;
5288 piece_bitpos += cur_bitsize;
5289 piece_loc = &XEXP (*piece_loc, 1);
5291 while (*piece_loc);
5293 /* TEMP->LAST here is either pointer to the last but one or
5294 last element in the chained list, LAST is pointer to the
5295 last element. */
5296 if (label && strcmp (last->label, label) == 0)
5298 /* For SRA optimized variables if there weren't any real
5299 insns since last note, just modify the last node. */
5300 if (piece_loc != NULL)
5302 adjust_piece_list (piece_loc, NULL, NULL,
5303 bitpos, piece_bitpos, bitsize, loc_note);
5304 return NULL;
5306 /* If the last note doesn't cover any instructions, remove it. */
5307 if (temp->last != last)
5309 temp->last->next = NULL;
5310 unused = last;
5311 last = temp->last;
5312 gcc_assert (strcmp (last->label, label) != 0);
5314 else
5316 gcc_assert (temp->first == temp->last
5317 || (temp->first->next == temp->last
5318 && TREE_CODE (decl) == PARM_DECL));
5319 memset (temp->last, '\0', sizeof (*temp->last));
5320 temp->last->loc = construct_piece_list (loc_note, bitpos, bitsize);
5321 return temp->last;
5324 if (bitsize == -1 && NOTE_P (last->loc))
5325 last_loc_note = last->loc;
5326 else if (piece_loc != NULL
5327 && *piece_loc != NULL_RTX
5328 && piece_bitpos == bitpos
5329 && decl_piece_bitsize (*piece_loc) == bitsize)
5330 last_loc_note = *decl_piece_varloc_ptr (*piece_loc);
5331 else
5332 last_loc_note = NULL_RTX;
5333 /* If the current location is the same as the end of the list,
5334 and either both or neither of the locations is uninitialized,
5335 we have nothing to do. */
5336 if (last_loc_note == NULL_RTX
5337 || (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (last_loc_note),
5338 NOTE_VAR_LOCATION_LOC (loc_note)))
5339 || ((NOTE_VAR_LOCATION_STATUS (last_loc_note)
5340 != NOTE_VAR_LOCATION_STATUS (loc_note))
5341 && ((NOTE_VAR_LOCATION_STATUS (last_loc_note)
5342 == VAR_INIT_STATUS_UNINITIALIZED)
5343 || (NOTE_VAR_LOCATION_STATUS (loc_note)
5344 == VAR_INIT_STATUS_UNINITIALIZED))))
5346 /* Add LOC to the end of list and update LAST. If the last
5347 element of the list has been removed above, reuse its
5348 memory for the new node, otherwise allocate a new one. */
5349 if (unused)
5351 loc = unused;
5352 memset (loc, '\0', sizeof (*loc));
5354 else
5355 loc = ggc_cleared_alloc<var_loc_node> ();
5356 if (bitsize == -1 || piece_loc == NULL)
5357 loc->loc = construct_piece_list (loc_note, bitpos, bitsize);
5358 else
5359 adjust_piece_list (&loc->loc, &last->loc, piece_loc,
5360 bitpos, piece_bitpos, bitsize, loc_note);
5361 last->next = loc;
5362 /* Ensure TEMP->LAST will point either to the new last but one
5363 element of the chain, or to the last element in it. */
5364 if (last != temp->last)
5365 temp->last = last;
5367 else if (unused)
5368 ggc_free (unused);
5370 else
5372 loc = ggc_cleared_alloc<var_loc_node> ();
5373 temp->first = loc;
5374 temp->last = loc;
5375 loc->loc = construct_piece_list (loc_note, bitpos, bitsize);
5377 return loc;
5380 /* Keep track of the number of spaces used to indent the
5381 output of the debugging routines that print the structure of
5382 the DIE internal representation. */
5383 static int print_indent;
5385 /* Indent the line the number of spaces given by print_indent. */
5387 static inline void
5388 print_spaces (FILE *outfile)
5390 fprintf (outfile, "%*s", print_indent, "");
5393 /* Print a type signature in hex. */
5395 static inline void
5396 print_signature (FILE *outfile, char *sig)
5398 int i;
5400 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
5401 fprintf (outfile, "%02x", sig[i] & 0xff);
5404 static void print_loc_descr (dw_loc_descr_ref, FILE *);
5406 /* Print the value associated to the VAL DWARF value node to OUTFILE. If
5407 RECURSE, output location descriptor operations. */
5409 static void
5410 print_dw_val (dw_val_node *val, bool recurse, FILE *outfile)
5412 switch (val->val_class)
5414 case dw_val_class_addr:
5415 fprintf (outfile, "address");
5416 break;
5417 case dw_val_class_offset:
5418 fprintf (outfile, "offset");
5419 break;
5420 case dw_val_class_loc:
5421 fprintf (outfile, "location descriptor");
5422 if (val->v.val_loc == NULL)
5423 fprintf (outfile, " -> <null>\n");
5424 else if (recurse)
5426 fprintf (outfile, ":\n");
5427 print_indent += 4;
5428 print_loc_descr (val->v.val_loc, outfile);
5429 print_indent -= 4;
5431 else
5432 fprintf (outfile, " (%p)\n", (void *) val->v.val_loc);
5433 break;
5434 case dw_val_class_loc_list:
5435 fprintf (outfile, "location list -> label:%s",
5436 val->v.val_loc_list->ll_symbol);
5437 break;
5438 case dw_val_class_range_list:
5439 fprintf (outfile, "range list");
5440 break;
5441 case dw_val_class_const:
5442 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, val->v.val_int);
5443 break;
5444 case dw_val_class_unsigned_const:
5445 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, val->v.val_unsigned);
5446 break;
5447 case dw_val_class_const_double:
5448 fprintf (outfile, "constant ("HOST_WIDE_INT_PRINT_DEC","\
5449 HOST_WIDE_INT_PRINT_UNSIGNED")",
5450 val->v.val_double.high,
5451 val->v.val_double.low);
5452 break;
5453 case dw_val_class_wide_int:
5455 int i = val->v.val_wide->get_len ();
5456 fprintf (outfile, "constant (");
5457 gcc_assert (i > 0);
5458 if (val->v.val_wide->elt (i - 1) == 0)
5459 fprintf (outfile, "0x");
5460 fprintf (outfile, HOST_WIDE_INT_PRINT_HEX,
5461 val->v.val_wide->elt (--i));
5462 while (--i >= 0)
5463 fprintf (outfile, HOST_WIDE_INT_PRINT_PADDED_HEX,
5464 val->v.val_wide->elt (i));
5465 fprintf (outfile, ")");
5466 break;
5468 case dw_val_class_vec:
5469 fprintf (outfile, "floating-point or vector constant");
5470 break;
5471 case dw_val_class_flag:
5472 fprintf (outfile, "%u", val->v.val_flag);
5473 break;
5474 case dw_val_class_die_ref:
5475 if (val->v.val_die_ref.die != NULL)
5477 dw_die_ref die = val->v.val_die_ref.die;
5479 if (die->comdat_type_p)
5481 fprintf (outfile, "die -> signature: ");
5482 print_signature (outfile,
5483 die->die_id.die_type_node->signature);
5485 else if (die->die_id.die_symbol)
5486 fprintf (outfile, "die -> label: %s", die->die_id.die_symbol);
5487 else
5488 fprintf (outfile, "die -> %ld", die->die_offset);
5489 fprintf (outfile, " (%p)", (void *) die);
5491 else
5492 fprintf (outfile, "die -> <null>");
5493 break;
5494 case dw_val_class_vms_delta:
5495 fprintf (outfile, "delta: @slotcount(%s-%s)",
5496 val->v.val_vms_delta.lbl2, val->v.val_vms_delta.lbl1);
5497 break;
5498 case dw_val_class_lbl_id:
5499 case dw_val_class_lineptr:
5500 case dw_val_class_macptr:
5501 case dw_val_class_high_pc:
5502 fprintf (outfile, "label: %s", val->v.val_lbl_id);
5503 break;
5504 case dw_val_class_str:
5505 if (val->v.val_str->str != NULL)
5506 fprintf (outfile, "\"%s\"", val->v.val_str->str);
5507 else
5508 fprintf (outfile, "<null>");
5509 break;
5510 case dw_val_class_file:
5511 fprintf (outfile, "\"%s\" (%d)", val->v.val_file->filename,
5512 val->v.val_file->emitted_number);
5513 break;
5514 case dw_val_class_data8:
5516 int i;
5518 for (i = 0; i < 8; i++)
5519 fprintf (outfile, "%02x", val->v.val_data8[i]);
5520 break;
5522 default:
5523 break;
5527 /* Likewise, for a DIE attribute. */
5529 static void
5530 print_attribute (dw_attr_ref a, bool recurse, FILE *outfile)
5532 print_dw_val (&a->dw_attr_val, recurse, outfile);
5536 /* Print the list of operands in the LOC location description to OUTFILE. This
5537 routine is a debugging aid only. */
5539 static void
5540 print_loc_descr (dw_loc_descr_ref loc, FILE *outfile)
5542 dw_loc_descr_ref l = loc;
5544 if (loc == NULL)
5546 print_spaces (outfile);
5547 fprintf (outfile, "<null>\n");
5548 return;
5551 for (l = loc; l != NULL; l = l->dw_loc_next)
5553 print_spaces (outfile);
5554 fprintf (outfile, "(%p) %s",
5555 (void *) l,
5556 dwarf_stack_op_name (l->dw_loc_opc));
5557 if (l->dw_loc_oprnd1.val_class != dw_val_class_none)
5559 fprintf (outfile, " ");
5560 print_dw_val (&l->dw_loc_oprnd1, false, outfile);
5562 if (l->dw_loc_oprnd2.val_class != dw_val_class_none)
5564 fprintf (outfile, ", ");
5565 print_dw_val (&l->dw_loc_oprnd2, false, outfile);
5567 fprintf (outfile, "\n");
5571 /* Print the information associated with a given DIE, and its children.
5572 This routine is a debugging aid only. */
5574 static void
5575 print_die (dw_die_ref die, FILE *outfile)
5577 dw_attr_ref a;
5578 dw_die_ref c;
5579 unsigned ix;
5581 print_spaces (outfile);
5582 fprintf (outfile, "DIE %4ld: %s (%p)\n",
5583 die->die_offset, dwarf_tag_name (die->die_tag),
5584 (void*) die);
5585 print_spaces (outfile);
5586 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
5587 fprintf (outfile, " offset: %ld", die->die_offset);
5588 fprintf (outfile, " mark: %d\n", die->die_mark);
5590 if (die->comdat_type_p)
5592 print_spaces (outfile);
5593 fprintf (outfile, " signature: ");
5594 print_signature (outfile, die->die_id.die_type_node->signature);
5595 fprintf (outfile, "\n");
5598 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
5600 print_spaces (outfile);
5601 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
5603 print_attribute (a, true, outfile);
5604 fprintf (outfile, "\n");
5607 if (die->die_child != NULL)
5609 print_indent += 4;
5610 FOR_EACH_CHILD (die, c, print_die (c, outfile));
5611 print_indent -= 4;
5613 if (print_indent == 0)
5614 fprintf (outfile, "\n");
5617 /* Print the list of operations in the LOC location description. */
5619 DEBUG_FUNCTION void
5620 debug_dwarf_loc_descr (dw_loc_descr_ref loc)
5622 print_loc_descr (loc, stderr);
5625 /* Print the information collected for a given DIE. */
5627 DEBUG_FUNCTION void
5628 debug_dwarf_die (dw_die_ref die)
5630 print_die (die, stderr);
5633 DEBUG_FUNCTION void
5634 debug (die_struct &ref)
5636 print_die (&ref, stderr);
5639 DEBUG_FUNCTION void
5640 debug (die_struct *ptr)
5642 if (ptr)
5643 debug (*ptr);
5644 else
5645 fprintf (stderr, "<nil>\n");
5649 /* Print all DWARF information collected for the compilation unit.
5650 This routine is a debugging aid only. */
5652 DEBUG_FUNCTION void
5653 debug_dwarf (void)
5655 print_indent = 0;
5656 print_die (comp_unit_die (), stderr);
5659 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
5660 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
5661 DIE that marks the start of the DIEs for this include file. */
5663 static dw_die_ref
5664 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
5666 const char *filename = get_AT_string (bincl_die, DW_AT_name);
5667 dw_die_ref new_unit = gen_compile_unit_die (filename);
5669 new_unit->die_sib = old_unit;
5670 return new_unit;
5673 /* Close an include-file CU and reopen the enclosing one. */
5675 static dw_die_ref
5676 pop_compile_unit (dw_die_ref old_unit)
5678 dw_die_ref new_unit = old_unit->die_sib;
5680 old_unit->die_sib = NULL;
5681 return new_unit;
5684 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5685 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
5686 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
5688 /* Calculate the checksum of a location expression. */
5690 static inline void
5691 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
5693 int tem;
5694 inchash::hash hstate;
5695 hashval_t hash;
5697 tem = (loc->dtprel << 8) | ((unsigned int) loc->dw_loc_opc);
5698 CHECKSUM (tem);
5699 hash_loc_operands (loc, hstate);
5700 hash = hstate.end();
5701 CHECKSUM (hash);
5704 /* Calculate the checksum of an attribute. */
5706 static void
5707 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
5709 dw_loc_descr_ref loc;
5710 rtx r;
5712 CHECKSUM (at->dw_attr);
5714 /* We don't care that this was compiled with a different compiler
5715 snapshot; if the output is the same, that's what matters. */
5716 if (at->dw_attr == DW_AT_producer)
5717 return;
5719 switch (AT_class (at))
5721 case dw_val_class_const:
5722 CHECKSUM (at->dw_attr_val.v.val_int);
5723 break;
5724 case dw_val_class_unsigned_const:
5725 CHECKSUM (at->dw_attr_val.v.val_unsigned);
5726 break;
5727 case dw_val_class_const_double:
5728 CHECKSUM (at->dw_attr_val.v.val_double);
5729 break;
5730 case dw_val_class_wide_int:
5731 CHECKSUM_BLOCK (at->dw_attr_val.v.val_wide->get_val (),
5732 get_full_len (*at->dw_attr_val.v.val_wide)
5733 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR);
5734 break;
5735 case dw_val_class_vec:
5736 CHECKSUM_BLOCK (at->dw_attr_val.v.val_vec.array,
5737 (at->dw_attr_val.v.val_vec.length
5738 * at->dw_attr_val.v.val_vec.elt_size));
5739 break;
5740 case dw_val_class_flag:
5741 CHECKSUM (at->dw_attr_val.v.val_flag);
5742 break;
5743 case dw_val_class_str:
5744 CHECKSUM_STRING (AT_string (at));
5745 break;
5747 case dw_val_class_addr:
5748 r = AT_addr (at);
5749 gcc_assert (GET_CODE (r) == SYMBOL_REF);
5750 CHECKSUM_STRING (XSTR (r, 0));
5751 break;
5753 case dw_val_class_offset:
5754 CHECKSUM (at->dw_attr_val.v.val_offset);
5755 break;
5757 case dw_val_class_loc:
5758 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
5759 loc_checksum (loc, ctx);
5760 break;
5762 case dw_val_class_die_ref:
5763 die_checksum (AT_ref (at), ctx, mark);
5764 break;
5766 case dw_val_class_fde_ref:
5767 case dw_val_class_vms_delta:
5768 case dw_val_class_lbl_id:
5769 case dw_val_class_lineptr:
5770 case dw_val_class_macptr:
5771 case dw_val_class_high_pc:
5772 break;
5774 case dw_val_class_file:
5775 CHECKSUM_STRING (AT_file (at)->filename);
5776 break;
5778 case dw_val_class_data8:
5779 CHECKSUM (at->dw_attr_val.v.val_data8);
5780 break;
5782 default:
5783 break;
5787 /* Calculate the checksum of a DIE. */
5789 static void
5790 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
5792 dw_die_ref c;
5793 dw_attr_ref a;
5794 unsigned ix;
5796 /* To avoid infinite recursion. */
5797 if (die->die_mark)
5799 CHECKSUM (die->die_mark);
5800 return;
5802 die->die_mark = ++(*mark);
5804 CHECKSUM (die->die_tag);
5806 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
5807 attr_checksum (a, ctx, mark);
5809 FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark));
5812 #undef CHECKSUM
5813 #undef CHECKSUM_BLOCK
5814 #undef CHECKSUM_STRING
5816 /* For DWARF-4 types, include the trailing NULL when checksumming strings. */
5817 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5818 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
5819 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO) + 1, ctx)
5820 #define CHECKSUM_SLEB128(FOO) checksum_sleb128 ((FOO), ctx)
5821 #define CHECKSUM_ULEB128(FOO) checksum_uleb128 ((FOO), ctx)
5822 #define CHECKSUM_ATTR(FOO) \
5823 if (FOO) attr_checksum_ordered (die->die_tag, (FOO), ctx, mark)
5825 /* Calculate the checksum of a number in signed LEB128 format. */
5827 static void
5828 checksum_sleb128 (HOST_WIDE_INT value, struct md5_ctx *ctx)
5830 unsigned char byte;
5831 bool more;
5833 while (1)
5835 byte = (value & 0x7f);
5836 value >>= 7;
5837 more = !((value == 0 && (byte & 0x40) == 0)
5838 || (value == -1 && (byte & 0x40) != 0));
5839 if (more)
5840 byte |= 0x80;
5841 CHECKSUM (byte);
5842 if (!more)
5843 break;
5847 /* Calculate the checksum of a number in unsigned LEB128 format. */
5849 static void
5850 checksum_uleb128 (unsigned HOST_WIDE_INT value, struct md5_ctx *ctx)
5852 while (1)
5854 unsigned char byte = (value & 0x7f);
5855 value >>= 7;
5856 if (value != 0)
5857 /* More bytes to follow. */
5858 byte |= 0x80;
5859 CHECKSUM (byte);
5860 if (value == 0)
5861 break;
5865 /* Checksum the context of the DIE. This adds the names of any
5866 surrounding namespaces or structures to the checksum. */
5868 static void
5869 checksum_die_context (dw_die_ref die, struct md5_ctx *ctx)
5871 const char *name;
5872 dw_die_ref spec;
5873 int tag = die->die_tag;
5875 if (tag != DW_TAG_namespace
5876 && tag != DW_TAG_structure_type
5877 && tag != DW_TAG_class_type)
5878 return;
5880 name = get_AT_string (die, DW_AT_name);
5882 spec = get_AT_ref (die, DW_AT_specification);
5883 if (spec != NULL)
5884 die = spec;
5886 if (die->die_parent != NULL)
5887 checksum_die_context (die->die_parent, ctx);
5889 CHECKSUM_ULEB128 ('C');
5890 CHECKSUM_ULEB128 (tag);
5891 if (name != NULL)
5892 CHECKSUM_STRING (name);
5895 /* Calculate the checksum of a location expression. */
5897 static inline void
5898 loc_checksum_ordered (dw_loc_descr_ref loc, struct md5_ctx *ctx)
5900 /* Special case for lone DW_OP_plus_uconst: checksum as if the location
5901 were emitted as a DW_FORM_sdata instead of a location expression. */
5902 if (loc->dw_loc_opc == DW_OP_plus_uconst && loc->dw_loc_next == NULL)
5904 CHECKSUM_ULEB128 (DW_FORM_sdata);
5905 CHECKSUM_SLEB128 ((HOST_WIDE_INT) loc->dw_loc_oprnd1.v.val_unsigned);
5906 return;
5909 /* Otherwise, just checksum the raw location expression. */
5910 while (loc != NULL)
5912 inchash::hash hstate;
5913 hashval_t hash;
5915 CHECKSUM_ULEB128 (loc->dtprel);
5916 CHECKSUM_ULEB128 (loc->dw_loc_opc);
5917 hash_loc_operands (loc, hstate);
5918 hash = hstate.end ();
5919 CHECKSUM (hash);
5920 loc = loc->dw_loc_next;
5924 /* Calculate the checksum of an attribute. */
5926 static void
5927 attr_checksum_ordered (enum dwarf_tag tag, dw_attr_ref at,
5928 struct md5_ctx *ctx, int *mark)
5930 dw_loc_descr_ref loc;
5931 rtx r;
5933 if (AT_class (at) == dw_val_class_die_ref)
5935 dw_die_ref target_die = AT_ref (at);
5937 /* For pointer and reference types, we checksum only the (qualified)
5938 name of the target type (if there is a name). For friend entries,
5939 we checksum only the (qualified) name of the target type or function.
5940 This allows the checksum to remain the same whether the target type
5941 is complete or not. */
5942 if ((at->dw_attr == DW_AT_type
5943 && (tag == DW_TAG_pointer_type
5944 || tag == DW_TAG_reference_type
5945 || tag == DW_TAG_rvalue_reference_type
5946 || tag == DW_TAG_ptr_to_member_type))
5947 || (at->dw_attr == DW_AT_friend
5948 && tag == DW_TAG_friend))
5950 dw_attr_ref name_attr = get_AT (target_die, DW_AT_name);
5952 if (name_attr != NULL)
5954 dw_die_ref decl = get_AT_ref (target_die, DW_AT_specification);
5956 if (decl == NULL)
5957 decl = target_die;
5958 CHECKSUM_ULEB128 ('N');
5959 CHECKSUM_ULEB128 (at->dw_attr);
5960 if (decl->die_parent != NULL)
5961 checksum_die_context (decl->die_parent, ctx);
5962 CHECKSUM_ULEB128 ('E');
5963 CHECKSUM_STRING (AT_string (name_attr));
5964 return;
5968 /* For all other references to another DIE, we check to see if the
5969 target DIE has already been visited. If it has, we emit a
5970 backward reference; if not, we descend recursively. */
5971 if (target_die->die_mark > 0)
5973 CHECKSUM_ULEB128 ('R');
5974 CHECKSUM_ULEB128 (at->dw_attr);
5975 CHECKSUM_ULEB128 (target_die->die_mark);
5977 else
5979 dw_die_ref decl = get_AT_ref (target_die, DW_AT_specification);
5981 if (decl == NULL)
5982 decl = target_die;
5983 target_die->die_mark = ++(*mark);
5984 CHECKSUM_ULEB128 ('T');
5985 CHECKSUM_ULEB128 (at->dw_attr);
5986 if (decl->die_parent != NULL)
5987 checksum_die_context (decl->die_parent, ctx);
5988 die_checksum_ordered (target_die, ctx, mark);
5990 return;
5993 CHECKSUM_ULEB128 ('A');
5994 CHECKSUM_ULEB128 (at->dw_attr);
5996 switch (AT_class (at))
5998 case dw_val_class_const:
5999 CHECKSUM_ULEB128 (DW_FORM_sdata);
6000 CHECKSUM_SLEB128 (at->dw_attr_val.v.val_int);
6001 break;
6003 case dw_val_class_unsigned_const:
6004 CHECKSUM_ULEB128 (DW_FORM_sdata);
6005 CHECKSUM_SLEB128 ((int) at->dw_attr_val.v.val_unsigned);
6006 break;
6008 case dw_val_class_const_double:
6009 CHECKSUM_ULEB128 (DW_FORM_block);
6010 CHECKSUM_ULEB128 (sizeof (at->dw_attr_val.v.val_double));
6011 CHECKSUM (at->dw_attr_val.v.val_double);
6012 break;
6014 case dw_val_class_wide_int:
6015 CHECKSUM_ULEB128 (DW_FORM_block);
6016 CHECKSUM_ULEB128 (get_full_len (*at->dw_attr_val.v.val_wide)
6017 * HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT);
6018 CHECKSUM_BLOCK (at->dw_attr_val.v.val_wide->get_val (),
6019 get_full_len (*at->dw_attr_val.v.val_wide)
6020 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR);
6021 break;
6023 case dw_val_class_vec:
6024 CHECKSUM_ULEB128 (DW_FORM_block);
6025 CHECKSUM_ULEB128 (at->dw_attr_val.v.val_vec.length
6026 * at->dw_attr_val.v.val_vec.elt_size);
6027 CHECKSUM_BLOCK (at->dw_attr_val.v.val_vec.array,
6028 (at->dw_attr_val.v.val_vec.length
6029 * at->dw_attr_val.v.val_vec.elt_size));
6030 break;
6032 case dw_val_class_flag:
6033 CHECKSUM_ULEB128 (DW_FORM_flag);
6034 CHECKSUM_ULEB128 (at->dw_attr_val.v.val_flag ? 1 : 0);
6035 break;
6037 case dw_val_class_str:
6038 CHECKSUM_ULEB128 (DW_FORM_string);
6039 CHECKSUM_STRING (AT_string (at));
6040 break;
6042 case dw_val_class_addr:
6043 r = AT_addr (at);
6044 gcc_assert (GET_CODE (r) == SYMBOL_REF);
6045 CHECKSUM_ULEB128 (DW_FORM_string);
6046 CHECKSUM_STRING (XSTR (r, 0));
6047 break;
6049 case dw_val_class_offset:
6050 CHECKSUM_ULEB128 (DW_FORM_sdata);
6051 CHECKSUM_ULEB128 (at->dw_attr_val.v.val_offset);
6052 break;
6054 case dw_val_class_loc:
6055 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
6056 loc_checksum_ordered (loc, ctx);
6057 break;
6059 case dw_val_class_fde_ref:
6060 case dw_val_class_lbl_id:
6061 case dw_val_class_lineptr:
6062 case dw_val_class_macptr:
6063 case dw_val_class_high_pc:
6064 break;
6066 case dw_val_class_file:
6067 CHECKSUM_ULEB128 (DW_FORM_string);
6068 CHECKSUM_STRING (AT_file (at)->filename);
6069 break;
6071 case dw_val_class_data8:
6072 CHECKSUM (at->dw_attr_val.v.val_data8);
6073 break;
6075 default:
6076 break;
6080 struct checksum_attributes
6082 dw_attr_ref at_name;
6083 dw_attr_ref at_type;
6084 dw_attr_ref at_friend;
6085 dw_attr_ref at_accessibility;
6086 dw_attr_ref at_address_class;
6087 dw_attr_ref at_allocated;
6088 dw_attr_ref at_artificial;
6089 dw_attr_ref at_associated;
6090 dw_attr_ref at_binary_scale;
6091 dw_attr_ref at_bit_offset;
6092 dw_attr_ref at_bit_size;
6093 dw_attr_ref at_bit_stride;
6094 dw_attr_ref at_byte_size;
6095 dw_attr_ref at_byte_stride;
6096 dw_attr_ref at_const_value;
6097 dw_attr_ref at_containing_type;
6098 dw_attr_ref at_count;
6099 dw_attr_ref at_data_location;
6100 dw_attr_ref at_data_member_location;
6101 dw_attr_ref at_decimal_scale;
6102 dw_attr_ref at_decimal_sign;
6103 dw_attr_ref at_default_value;
6104 dw_attr_ref at_digit_count;
6105 dw_attr_ref at_discr;
6106 dw_attr_ref at_discr_list;
6107 dw_attr_ref at_discr_value;
6108 dw_attr_ref at_encoding;
6109 dw_attr_ref at_endianity;
6110 dw_attr_ref at_explicit;
6111 dw_attr_ref at_is_optional;
6112 dw_attr_ref at_location;
6113 dw_attr_ref at_lower_bound;
6114 dw_attr_ref at_mutable;
6115 dw_attr_ref at_ordering;
6116 dw_attr_ref at_picture_string;
6117 dw_attr_ref at_prototyped;
6118 dw_attr_ref at_small;
6119 dw_attr_ref at_segment;
6120 dw_attr_ref at_string_length;
6121 dw_attr_ref at_threads_scaled;
6122 dw_attr_ref at_upper_bound;
6123 dw_attr_ref at_use_location;
6124 dw_attr_ref at_use_UTF8;
6125 dw_attr_ref at_variable_parameter;
6126 dw_attr_ref at_virtuality;
6127 dw_attr_ref at_visibility;
6128 dw_attr_ref at_vtable_elem_location;
6131 /* Collect the attributes that we will want to use for the checksum. */
6133 static void
6134 collect_checksum_attributes (struct checksum_attributes *attrs, dw_die_ref die)
6136 dw_attr_ref a;
6137 unsigned ix;
6139 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
6141 switch (a->dw_attr)
6143 case DW_AT_name:
6144 attrs->at_name = a;
6145 break;
6146 case DW_AT_type:
6147 attrs->at_type = a;
6148 break;
6149 case DW_AT_friend:
6150 attrs->at_friend = a;
6151 break;
6152 case DW_AT_accessibility:
6153 attrs->at_accessibility = a;
6154 break;
6155 case DW_AT_address_class:
6156 attrs->at_address_class = a;
6157 break;
6158 case DW_AT_allocated:
6159 attrs->at_allocated = a;
6160 break;
6161 case DW_AT_artificial:
6162 attrs->at_artificial = a;
6163 break;
6164 case DW_AT_associated:
6165 attrs->at_associated = a;
6166 break;
6167 case DW_AT_binary_scale:
6168 attrs->at_binary_scale = a;
6169 break;
6170 case DW_AT_bit_offset:
6171 attrs->at_bit_offset = a;
6172 break;
6173 case DW_AT_bit_size:
6174 attrs->at_bit_size = a;
6175 break;
6176 case DW_AT_bit_stride:
6177 attrs->at_bit_stride = a;
6178 break;
6179 case DW_AT_byte_size:
6180 attrs->at_byte_size = a;
6181 break;
6182 case DW_AT_byte_stride:
6183 attrs->at_byte_stride = a;
6184 break;
6185 case DW_AT_const_value:
6186 attrs->at_const_value = a;
6187 break;
6188 case DW_AT_containing_type:
6189 attrs->at_containing_type = a;
6190 break;
6191 case DW_AT_count:
6192 attrs->at_count = a;
6193 break;
6194 case DW_AT_data_location:
6195 attrs->at_data_location = a;
6196 break;
6197 case DW_AT_data_member_location:
6198 attrs->at_data_member_location = a;
6199 break;
6200 case DW_AT_decimal_scale:
6201 attrs->at_decimal_scale = a;
6202 break;
6203 case DW_AT_decimal_sign:
6204 attrs->at_decimal_sign = a;
6205 break;
6206 case DW_AT_default_value:
6207 attrs->at_default_value = a;
6208 break;
6209 case DW_AT_digit_count:
6210 attrs->at_digit_count = a;
6211 break;
6212 case DW_AT_discr:
6213 attrs->at_discr = a;
6214 break;
6215 case DW_AT_discr_list:
6216 attrs->at_discr_list = a;
6217 break;
6218 case DW_AT_discr_value:
6219 attrs->at_discr_value = a;
6220 break;
6221 case DW_AT_encoding:
6222 attrs->at_encoding = a;
6223 break;
6224 case DW_AT_endianity:
6225 attrs->at_endianity = a;
6226 break;
6227 case DW_AT_explicit:
6228 attrs->at_explicit = a;
6229 break;
6230 case DW_AT_is_optional:
6231 attrs->at_is_optional = a;
6232 break;
6233 case DW_AT_location:
6234 attrs->at_location = a;
6235 break;
6236 case DW_AT_lower_bound:
6237 attrs->at_lower_bound = a;
6238 break;
6239 case DW_AT_mutable:
6240 attrs->at_mutable = a;
6241 break;
6242 case DW_AT_ordering:
6243 attrs->at_ordering = a;
6244 break;
6245 case DW_AT_picture_string:
6246 attrs->at_picture_string = a;
6247 break;
6248 case DW_AT_prototyped:
6249 attrs->at_prototyped = a;
6250 break;
6251 case DW_AT_small:
6252 attrs->at_small = a;
6253 break;
6254 case DW_AT_segment:
6255 attrs->at_segment = a;
6256 break;
6257 case DW_AT_string_length:
6258 attrs->at_string_length = a;
6259 break;
6260 case DW_AT_threads_scaled:
6261 attrs->at_threads_scaled = a;
6262 break;
6263 case DW_AT_upper_bound:
6264 attrs->at_upper_bound = a;
6265 break;
6266 case DW_AT_use_location:
6267 attrs->at_use_location = a;
6268 break;
6269 case DW_AT_use_UTF8:
6270 attrs->at_use_UTF8 = a;
6271 break;
6272 case DW_AT_variable_parameter:
6273 attrs->at_variable_parameter = a;
6274 break;
6275 case DW_AT_virtuality:
6276 attrs->at_virtuality = a;
6277 break;
6278 case DW_AT_visibility:
6279 attrs->at_visibility = a;
6280 break;
6281 case DW_AT_vtable_elem_location:
6282 attrs->at_vtable_elem_location = a;
6283 break;
6284 default:
6285 break;
6290 /* Calculate the checksum of a DIE, using an ordered subset of attributes. */
6292 static void
6293 die_checksum_ordered (dw_die_ref die, struct md5_ctx *ctx, int *mark)
6295 dw_die_ref c;
6296 dw_die_ref decl;
6297 struct checksum_attributes attrs;
6299 CHECKSUM_ULEB128 ('D');
6300 CHECKSUM_ULEB128 (die->die_tag);
6302 memset (&attrs, 0, sizeof (attrs));
6304 decl = get_AT_ref (die, DW_AT_specification);
6305 if (decl != NULL)
6306 collect_checksum_attributes (&attrs, decl);
6307 collect_checksum_attributes (&attrs, die);
6309 CHECKSUM_ATTR (attrs.at_name);
6310 CHECKSUM_ATTR (attrs.at_accessibility);
6311 CHECKSUM_ATTR (attrs.at_address_class);
6312 CHECKSUM_ATTR (attrs.at_allocated);
6313 CHECKSUM_ATTR (attrs.at_artificial);
6314 CHECKSUM_ATTR (attrs.at_associated);
6315 CHECKSUM_ATTR (attrs.at_binary_scale);
6316 CHECKSUM_ATTR (attrs.at_bit_offset);
6317 CHECKSUM_ATTR (attrs.at_bit_size);
6318 CHECKSUM_ATTR (attrs.at_bit_stride);
6319 CHECKSUM_ATTR (attrs.at_byte_size);
6320 CHECKSUM_ATTR (attrs.at_byte_stride);
6321 CHECKSUM_ATTR (attrs.at_const_value);
6322 CHECKSUM_ATTR (attrs.at_containing_type);
6323 CHECKSUM_ATTR (attrs.at_count);
6324 CHECKSUM_ATTR (attrs.at_data_location);
6325 CHECKSUM_ATTR (attrs.at_data_member_location);
6326 CHECKSUM_ATTR (attrs.at_decimal_scale);
6327 CHECKSUM_ATTR (attrs.at_decimal_sign);
6328 CHECKSUM_ATTR (attrs.at_default_value);
6329 CHECKSUM_ATTR (attrs.at_digit_count);
6330 CHECKSUM_ATTR (attrs.at_discr);
6331 CHECKSUM_ATTR (attrs.at_discr_list);
6332 CHECKSUM_ATTR (attrs.at_discr_value);
6333 CHECKSUM_ATTR (attrs.at_encoding);
6334 CHECKSUM_ATTR (attrs.at_endianity);
6335 CHECKSUM_ATTR (attrs.at_explicit);
6336 CHECKSUM_ATTR (attrs.at_is_optional);
6337 CHECKSUM_ATTR (attrs.at_location);
6338 CHECKSUM_ATTR (attrs.at_lower_bound);
6339 CHECKSUM_ATTR (attrs.at_mutable);
6340 CHECKSUM_ATTR (attrs.at_ordering);
6341 CHECKSUM_ATTR (attrs.at_picture_string);
6342 CHECKSUM_ATTR (attrs.at_prototyped);
6343 CHECKSUM_ATTR (attrs.at_small);
6344 CHECKSUM_ATTR (attrs.at_segment);
6345 CHECKSUM_ATTR (attrs.at_string_length);
6346 CHECKSUM_ATTR (attrs.at_threads_scaled);
6347 CHECKSUM_ATTR (attrs.at_upper_bound);
6348 CHECKSUM_ATTR (attrs.at_use_location);
6349 CHECKSUM_ATTR (attrs.at_use_UTF8);
6350 CHECKSUM_ATTR (attrs.at_variable_parameter);
6351 CHECKSUM_ATTR (attrs.at_virtuality);
6352 CHECKSUM_ATTR (attrs.at_visibility);
6353 CHECKSUM_ATTR (attrs.at_vtable_elem_location);
6354 CHECKSUM_ATTR (attrs.at_type);
6355 CHECKSUM_ATTR (attrs.at_friend);
6357 /* Checksum the child DIEs. */
6358 c = die->die_child;
6359 if (c) do {
6360 dw_attr_ref name_attr;
6362 c = c->die_sib;
6363 name_attr = get_AT (c, DW_AT_name);
6364 if (is_template_instantiation (c))
6366 /* Ignore instantiations of member type and function templates. */
6368 else if (name_attr != NULL
6369 && (is_type_die (c) || c->die_tag == DW_TAG_subprogram))
6371 /* Use a shallow checksum for named nested types and member
6372 functions. */
6373 CHECKSUM_ULEB128 ('S');
6374 CHECKSUM_ULEB128 (c->die_tag);
6375 CHECKSUM_STRING (AT_string (name_attr));
6377 else
6379 /* Use a deep checksum for other children. */
6380 /* Mark this DIE so it gets processed when unmarking. */
6381 if (c->die_mark == 0)
6382 c->die_mark = -1;
6383 die_checksum_ordered (c, ctx, mark);
6385 } while (c != die->die_child);
6387 CHECKSUM_ULEB128 (0);
6390 /* Add a type name and tag to a hash. */
6391 static void
6392 die_odr_checksum (int tag, const char *name, md5_ctx *ctx)
6394 CHECKSUM_ULEB128 (tag);
6395 CHECKSUM_STRING (name);
6398 #undef CHECKSUM
6399 #undef CHECKSUM_STRING
6400 #undef CHECKSUM_ATTR
6401 #undef CHECKSUM_LEB128
6402 #undef CHECKSUM_ULEB128
6404 /* Generate the type signature for DIE. This is computed by generating an
6405 MD5 checksum over the DIE's tag, its relevant attributes, and its
6406 children. Attributes that are references to other DIEs are processed
6407 by recursion, using the MARK field to prevent infinite recursion.
6408 If the DIE is nested inside a namespace or another type, we also
6409 need to include that context in the signature. The lower 64 bits
6410 of the resulting MD5 checksum comprise the signature. */
6412 static void
6413 generate_type_signature (dw_die_ref die, comdat_type_node *type_node)
6415 int mark;
6416 const char *name;
6417 unsigned char checksum[16];
6418 struct md5_ctx ctx;
6419 dw_die_ref decl;
6420 dw_die_ref parent;
6422 name = get_AT_string (die, DW_AT_name);
6423 decl = get_AT_ref (die, DW_AT_specification);
6424 parent = get_die_parent (die);
6426 /* First, compute a signature for just the type name (and its surrounding
6427 context, if any. This is stored in the type unit DIE for link-time
6428 ODR (one-definition rule) checking. */
6430 if (is_cxx () && name != NULL)
6432 md5_init_ctx (&ctx);
6434 /* Checksum the names of surrounding namespaces and structures. */
6435 if (parent != NULL)
6436 checksum_die_context (parent, &ctx);
6438 /* Checksum the current DIE. */
6439 die_odr_checksum (die->die_tag, name, &ctx);
6440 md5_finish_ctx (&ctx, checksum);
6442 add_AT_data8 (type_node->root_die, DW_AT_GNU_odr_signature, &checksum[8]);
6445 /* Next, compute the complete type signature. */
6447 md5_init_ctx (&ctx);
6448 mark = 1;
6449 die->die_mark = mark;
6451 /* Checksum the names of surrounding namespaces and structures. */
6452 if (parent != NULL)
6453 checksum_die_context (parent, &ctx);
6455 /* Checksum the DIE and its children. */
6456 die_checksum_ordered (die, &ctx, &mark);
6457 unmark_all_dies (die);
6458 md5_finish_ctx (&ctx, checksum);
6460 /* Store the signature in the type node and link the type DIE and the
6461 type node together. */
6462 memcpy (type_node->signature, &checksum[16 - DWARF_TYPE_SIGNATURE_SIZE],
6463 DWARF_TYPE_SIGNATURE_SIZE);
6464 die->comdat_type_p = true;
6465 die->die_id.die_type_node = type_node;
6466 type_node->type_die = die;
6468 /* If the DIE is a specification, link its declaration to the type node
6469 as well. */
6470 if (decl != NULL)
6472 decl->comdat_type_p = true;
6473 decl->die_id.die_type_node = type_node;
6477 /* Do the location expressions look same? */
6478 static inline int
6479 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
6481 return loc1->dw_loc_opc == loc2->dw_loc_opc
6482 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
6483 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
6486 /* Do the values look the same? */
6487 static int
6488 same_dw_val_p (const dw_val_node *v1, const dw_val_node *v2, int *mark)
6490 dw_loc_descr_ref loc1, loc2;
6491 rtx r1, r2;
6493 if (v1->val_class != v2->val_class)
6494 return 0;
6496 switch (v1->val_class)
6498 case dw_val_class_const:
6499 return v1->v.val_int == v2->v.val_int;
6500 case dw_val_class_unsigned_const:
6501 return v1->v.val_unsigned == v2->v.val_unsigned;
6502 case dw_val_class_const_double:
6503 return v1->v.val_double.high == v2->v.val_double.high
6504 && v1->v.val_double.low == v2->v.val_double.low;
6505 case dw_val_class_wide_int:
6506 return *v1->v.val_wide == *v2->v.val_wide;
6507 case dw_val_class_vec:
6508 if (v1->v.val_vec.length != v2->v.val_vec.length
6509 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
6510 return 0;
6511 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
6512 v1->v.val_vec.length * v1->v.val_vec.elt_size))
6513 return 0;
6514 return 1;
6515 case dw_val_class_flag:
6516 return v1->v.val_flag == v2->v.val_flag;
6517 case dw_val_class_str:
6518 return !strcmp (v1->v.val_str->str, v2->v.val_str->str);
6520 case dw_val_class_addr:
6521 r1 = v1->v.val_addr;
6522 r2 = v2->v.val_addr;
6523 if (GET_CODE (r1) != GET_CODE (r2))
6524 return 0;
6525 return !rtx_equal_p (r1, r2);
6527 case dw_val_class_offset:
6528 return v1->v.val_offset == v2->v.val_offset;
6530 case dw_val_class_loc:
6531 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
6532 loc1 && loc2;
6533 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
6534 if (!same_loc_p (loc1, loc2, mark))
6535 return 0;
6536 return !loc1 && !loc2;
6538 case dw_val_class_die_ref:
6539 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
6541 case dw_val_class_fde_ref:
6542 case dw_val_class_vms_delta:
6543 case dw_val_class_lbl_id:
6544 case dw_val_class_lineptr:
6545 case dw_val_class_macptr:
6546 case dw_val_class_high_pc:
6547 return 1;
6549 case dw_val_class_file:
6550 return v1->v.val_file == v2->v.val_file;
6552 case dw_val_class_data8:
6553 return !memcmp (v1->v.val_data8, v2->v.val_data8, 8);
6555 default:
6556 return 1;
6560 /* Do the attributes look the same? */
6562 static int
6563 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
6565 if (at1->dw_attr != at2->dw_attr)
6566 return 0;
6568 /* We don't care that this was compiled with a different compiler
6569 snapshot; if the output is the same, that's what matters. */
6570 if (at1->dw_attr == DW_AT_producer)
6571 return 1;
6573 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
6576 /* Do the dies look the same? */
6578 static int
6579 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
6581 dw_die_ref c1, c2;
6582 dw_attr_ref a1;
6583 unsigned ix;
6585 /* To avoid infinite recursion. */
6586 if (die1->die_mark)
6587 return die1->die_mark == die2->die_mark;
6588 die1->die_mark = die2->die_mark = ++(*mark);
6590 if (die1->die_tag != die2->die_tag)
6591 return 0;
6593 if (vec_safe_length (die1->die_attr) != vec_safe_length (die2->die_attr))
6594 return 0;
6596 FOR_EACH_VEC_SAFE_ELT (die1->die_attr, ix, a1)
6597 if (!same_attr_p (a1, &(*die2->die_attr)[ix], mark))
6598 return 0;
6600 c1 = die1->die_child;
6601 c2 = die2->die_child;
6602 if (! c1)
6604 if (c2)
6605 return 0;
6607 else
6608 for (;;)
6610 if (!same_die_p (c1, c2, mark))
6611 return 0;
6612 c1 = c1->die_sib;
6613 c2 = c2->die_sib;
6614 if (c1 == die1->die_child)
6616 if (c2 == die2->die_child)
6617 break;
6618 else
6619 return 0;
6623 return 1;
6626 /* Do the dies look the same? Wrapper around same_die_p. */
6628 static int
6629 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
6631 int mark = 0;
6632 int ret = same_die_p (die1, die2, &mark);
6634 unmark_all_dies (die1);
6635 unmark_all_dies (die2);
6637 return ret;
6640 /* The prefix to attach to symbols on DIEs in the current comdat debug
6641 info section. */
6642 static const char *comdat_symbol_id;
6644 /* The index of the current symbol within the current comdat CU. */
6645 static unsigned int comdat_symbol_number;
6647 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
6648 children, and set comdat_symbol_id accordingly. */
6650 static void
6651 compute_section_prefix (dw_die_ref unit_die)
6653 const char *die_name = get_AT_string (unit_die, DW_AT_name);
6654 const char *base = die_name ? lbasename (die_name) : "anonymous";
6655 char *name = XALLOCAVEC (char, strlen (base) + 64);
6656 char *p;
6657 int i, mark;
6658 unsigned char checksum[16];
6659 struct md5_ctx ctx;
6661 /* Compute the checksum of the DIE, then append part of it as hex digits to
6662 the name filename of the unit. */
6664 md5_init_ctx (&ctx);
6665 mark = 0;
6666 die_checksum (unit_die, &ctx, &mark);
6667 unmark_all_dies (unit_die);
6668 md5_finish_ctx (&ctx, checksum);
6670 sprintf (name, "%s.", base);
6671 clean_symbol_name (name);
6673 p = name + strlen (name);
6674 for (i = 0; i < 4; i++)
6676 sprintf (p, "%.2x", checksum[i]);
6677 p += 2;
6680 comdat_symbol_id = unit_die->die_id.die_symbol = xstrdup (name);
6681 comdat_symbol_number = 0;
6684 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
6686 static int
6687 is_type_die (dw_die_ref die)
6689 switch (die->die_tag)
6691 case DW_TAG_array_type:
6692 case DW_TAG_class_type:
6693 case DW_TAG_interface_type:
6694 case DW_TAG_enumeration_type:
6695 case DW_TAG_pointer_type:
6696 case DW_TAG_reference_type:
6697 case DW_TAG_rvalue_reference_type:
6698 case DW_TAG_string_type:
6699 case DW_TAG_structure_type:
6700 case DW_TAG_subroutine_type:
6701 case DW_TAG_union_type:
6702 case DW_TAG_ptr_to_member_type:
6703 case DW_TAG_set_type:
6704 case DW_TAG_subrange_type:
6705 case DW_TAG_base_type:
6706 case DW_TAG_const_type:
6707 case DW_TAG_file_type:
6708 case DW_TAG_packed_type:
6709 case DW_TAG_volatile_type:
6710 case DW_TAG_typedef:
6711 return 1;
6712 default:
6713 return 0;
6717 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
6718 Basically, we want to choose the bits that are likely to be shared between
6719 compilations (types) and leave out the bits that are specific to individual
6720 compilations (functions). */
6722 static int
6723 is_comdat_die (dw_die_ref c)
6725 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
6726 we do for stabs. The advantage is a greater likelihood of sharing between
6727 objects that don't include headers in the same order (and therefore would
6728 put the base types in a different comdat). jason 8/28/00 */
6730 if (c->die_tag == DW_TAG_base_type)
6731 return 0;
6733 if (c->die_tag == DW_TAG_pointer_type
6734 || c->die_tag == DW_TAG_reference_type
6735 || c->die_tag == DW_TAG_rvalue_reference_type
6736 || c->die_tag == DW_TAG_const_type
6737 || c->die_tag == DW_TAG_volatile_type)
6739 dw_die_ref t = get_AT_ref (c, DW_AT_type);
6741 return t ? is_comdat_die (t) : 0;
6744 return is_type_die (c);
6747 /* Returns 1 iff C is the sort of DIE that might be referred to from another
6748 compilation unit. */
6750 static int
6751 is_symbol_die (dw_die_ref c)
6753 return (is_type_die (c)
6754 || is_declaration_die (c)
6755 || c->die_tag == DW_TAG_namespace
6756 || c->die_tag == DW_TAG_module);
6759 /* Returns true iff C is a compile-unit DIE. */
6761 static inline bool
6762 is_cu_die (dw_die_ref c)
6764 return c && c->die_tag == DW_TAG_compile_unit;
6767 /* Returns true iff C is a unit DIE of some sort. */
6769 static inline bool
6770 is_unit_die (dw_die_ref c)
6772 return c && (c->die_tag == DW_TAG_compile_unit
6773 || c->die_tag == DW_TAG_partial_unit
6774 || c->die_tag == DW_TAG_type_unit);
6777 /* Returns true iff C is a namespace DIE. */
6779 static inline bool
6780 is_namespace_die (dw_die_ref c)
6782 return c && c->die_tag == DW_TAG_namespace;
6785 /* Returns true iff C is a class or structure DIE. */
6787 static inline bool
6788 is_class_die (dw_die_ref c)
6790 return c && (c->die_tag == DW_TAG_class_type
6791 || c->die_tag == DW_TAG_structure_type);
6794 /* Return non-zero if this DIE is a template parameter. */
6796 static inline bool
6797 is_template_parameter (dw_die_ref die)
6799 switch (die->die_tag)
6801 case DW_TAG_template_type_param:
6802 case DW_TAG_template_value_param:
6803 case DW_TAG_GNU_template_template_param:
6804 case DW_TAG_GNU_template_parameter_pack:
6805 return true;
6806 default:
6807 return false;
6811 /* Return non-zero if this DIE represents a template instantiation. */
6813 static inline bool
6814 is_template_instantiation (dw_die_ref die)
6816 dw_die_ref c;
6818 if (!is_type_die (die) && die->die_tag != DW_TAG_subprogram)
6819 return false;
6820 FOR_EACH_CHILD (die, c, if (is_template_parameter (c)) return true);
6821 return false;
6824 static char *
6825 gen_internal_sym (const char *prefix)
6827 char buf[256];
6829 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
6830 return xstrdup (buf);
6833 /* Assign symbols to all worthy DIEs under DIE. */
6835 static void
6836 assign_symbol_names (dw_die_ref die)
6838 dw_die_ref c;
6840 if (is_symbol_die (die) && !die->comdat_type_p)
6842 if (comdat_symbol_id)
6844 char *p = XALLOCAVEC (char, strlen (comdat_symbol_id) + 64);
6846 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
6847 comdat_symbol_id, comdat_symbol_number++);
6848 die->die_id.die_symbol = xstrdup (p);
6850 else
6851 die->die_id.die_symbol = gen_internal_sym ("LDIE");
6854 FOR_EACH_CHILD (die, c, assign_symbol_names (c));
6857 struct cu_hash_table_entry
6859 dw_die_ref cu;
6860 unsigned min_comdat_num, max_comdat_num;
6861 struct cu_hash_table_entry *next;
6864 /* Helpers to manipulate hash table of CUs. */
6866 struct cu_hash_table_entry_hasher
6868 typedef cu_hash_table_entry value_type;
6869 typedef die_struct compare_type;
6870 static inline hashval_t hash (const value_type *);
6871 static inline bool equal (const value_type *, const compare_type *);
6872 static inline void remove (value_type *);
6875 inline hashval_t
6876 cu_hash_table_entry_hasher::hash (const value_type *entry)
6878 return htab_hash_string (entry->cu->die_id.die_symbol);
6881 inline bool
6882 cu_hash_table_entry_hasher::equal (const value_type *entry1,
6883 const compare_type *entry2)
6885 return !strcmp (entry1->cu->die_id.die_symbol, entry2->die_id.die_symbol);
6888 inline void
6889 cu_hash_table_entry_hasher::remove (value_type *entry)
6891 struct cu_hash_table_entry *next;
6893 while (entry)
6895 next = entry->next;
6896 free (entry);
6897 entry = next;
6901 typedef hash_table<cu_hash_table_entry_hasher> cu_hash_type;
6903 /* Check whether we have already seen this CU and set up SYM_NUM
6904 accordingly. */
6905 static int
6906 check_duplicate_cu (dw_die_ref cu, cu_hash_type *htable, unsigned int *sym_num)
6908 struct cu_hash_table_entry dummy;
6909 struct cu_hash_table_entry **slot, *entry, *last = &dummy;
6911 dummy.max_comdat_num = 0;
6913 slot = htable->find_slot_with_hash (cu,
6914 htab_hash_string (cu->die_id.die_symbol),
6915 INSERT);
6916 entry = *slot;
6918 for (; entry; last = entry, entry = entry->next)
6920 if (same_die_p_wrap (cu, entry->cu))
6921 break;
6924 if (entry)
6926 *sym_num = entry->min_comdat_num;
6927 return 1;
6930 entry = XCNEW (struct cu_hash_table_entry);
6931 entry->cu = cu;
6932 entry->min_comdat_num = *sym_num = last->max_comdat_num;
6933 entry->next = *slot;
6934 *slot = entry;
6936 return 0;
6939 /* Record SYM_NUM to record of CU in HTABLE. */
6940 static void
6941 record_comdat_symbol_number (dw_die_ref cu, cu_hash_type *htable,
6942 unsigned int sym_num)
6944 struct cu_hash_table_entry **slot, *entry;
6946 slot = htable->find_slot_with_hash (cu,
6947 htab_hash_string (cu->die_id.die_symbol),
6948 NO_INSERT);
6949 entry = *slot;
6951 entry->max_comdat_num = sym_num;
6954 /* Traverse the DIE (which is always comp_unit_die), and set up
6955 additional compilation units for each of the include files we see
6956 bracketed by BINCL/EINCL. */
6958 static void
6959 break_out_includes (dw_die_ref die)
6961 dw_die_ref c;
6962 dw_die_ref unit = NULL;
6963 limbo_die_node *node, **pnode;
6965 c = die->die_child;
6966 if (c) do {
6967 dw_die_ref prev = c;
6968 c = c->die_sib;
6969 while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
6970 || (unit && is_comdat_die (c)))
6972 dw_die_ref next = c->die_sib;
6974 /* This DIE is for a secondary CU; remove it from the main one. */
6975 remove_child_with_prev (c, prev);
6977 if (c->die_tag == DW_TAG_GNU_BINCL)
6978 unit = push_new_compile_unit (unit, c);
6979 else if (c->die_tag == DW_TAG_GNU_EINCL)
6980 unit = pop_compile_unit (unit);
6981 else
6982 add_child_die (unit, c);
6983 c = next;
6984 if (c == die->die_child)
6985 break;
6987 } while (c != die->die_child);
6989 #if 0
6990 /* We can only use this in debugging, since the frontend doesn't check
6991 to make sure that we leave every include file we enter. */
6992 gcc_assert (!unit);
6993 #endif
6995 assign_symbol_names (die);
6996 cu_hash_type cu_hash_table (10);
6997 for (node = limbo_die_list, pnode = &limbo_die_list;
6998 node;
6999 node = node->next)
7001 int is_dupl;
7003 compute_section_prefix (node->die);
7004 is_dupl = check_duplicate_cu (node->die, &cu_hash_table,
7005 &comdat_symbol_number);
7006 assign_symbol_names (node->die);
7007 if (is_dupl)
7008 *pnode = node->next;
7009 else
7011 pnode = &node->next;
7012 record_comdat_symbol_number (node->die, &cu_hash_table,
7013 comdat_symbol_number);
7018 /* Return non-zero if this DIE is a declaration. */
7020 static int
7021 is_declaration_die (dw_die_ref die)
7023 dw_attr_ref a;
7024 unsigned ix;
7026 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
7027 if (a->dw_attr == DW_AT_declaration)
7028 return 1;
7030 return 0;
7033 /* Return non-zero if this DIE is nested inside a subprogram. */
7035 static int
7036 is_nested_in_subprogram (dw_die_ref die)
7038 dw_die_ref decl = get_AT_ref (die, DW_AT_specification);
7040 if (decl == NULL)
7041 decl = die;
7042 return local_scope_p (decl);
7045 /* Return non-zero if this DIE contains a defining declaration of a
7046 subprogram. */
7048 static int
7049 contains_subprogram_definition (dw_die_ref die)
7051 dw_die_ref c;
7053 if (die->die_tag == DW_TAG_subprogram && ! is_declaration_die (die))
7054 return 1;
7055 FOR_EACH_CHILD (die, c, if (contains_subprogram_definition (c)) return 1);
7056 return 0;
7059 /* Return non-zero if this is a type DIE that should be moved to a
7060 COMDAT .debug_types section. */
7062 static int
7063 should_move_die_to_comdat (dw_die_ref die)
7065 switch (die->die_tag)
7067 case DW_TAG_class_type:
7068 case DW_TAG_structure_type:
7069 case DW_TAG_enumeration_type:
7070 case DW_TAG_union_type:
7071 /* Don't move declarations, inlined instances, types nested in a
7072 subprogram, or types that contain subprogram definitions. */
7073 if (is_declaration_die (die)
7074 || get_AT (die, DW_AT_abstract_origin)
7075 || is_nested_in_subprogram (die)
7076 || contains_subprogram_definition (die))
7077 return 0;
7078 return 1;
7079 case DW_TAG_array_type:
7080 case DW_TAG_interface_type:
7081 case DW_TAG_pointer_type:
7082 case DW_TAG_reference_type:
7083 case DW_TAG_rvalue_reference_type:
7084 case DW_TAG_string_type:
7085 case DW_TAG_subroutine_type:
7086 case DW_TAG_ptr_to_member_type:
7087 case DW_TAG_set_type:
7088 case DW_TAG_subrange_type:
7089 case DW_TAG_base_type:
7090 case DW_TAG_const_type:
7091 case DW_TAG_file_type:
7092 case DW_TAG_packed_type:
7093 case DW_TAG_volatile_type:
7094 case DW_TAG_typedef:
7095 default:
7096 return 0;
7100 /* Make a clone of DIE. */
7102 static dw_die_ref
7103 clone_die (dw_die_ref die)
7105 dw_die_ref clone;
7106 dw_attr_ref a;
7107 unsigned ix;
7109 clone = ggc_cleared_alloc<die_node> ();
7110 clone->die_tag = die->die_tag;
7112 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
7113 add_dwarf_attr (clone, a);
7115 return clone;
7118 /* Make a clone of the tree rooted at DIE. */
7120 static dw_die_ref
7121 clone_tree (dw_die_ref die)
7123 dw_die_ref c;
7124 dw_die_ref clone = clone_die (die);
7126 FOR_EACH_CHILD (die, c, add_child_die (clone, clone_tree (c)));
7128 return clone;
7131 /* Make a clone of DIE as a declaration. */
7133 static dw_die_ref
7134 clone_as_declaration (dw_die_ref die)
7136 dw_die_ref clone;
7137 dw_die_ref decl;
7138 dw_attr_ref a;
7139 unsigned ix;
7141 /* If the DIE is already a declaration, just clone it. */
7142 if (is_declaration_die (die))
7143 return clone_die (die);
7145 /* If the DIE is a specification, just clone its declaration DIE. */
7146 decl = get_AT_ref (die, DW_AT_specification);
7147 if (decl != NULL)
7149 clone = clone_die (decl);
7150 if (die->comdat_type_p)
7151 add_AT_die_ref (clone, DW_AT_signature, die);
7152 return clone;
7155 clone = ggc_cleared_alloc<die_node> ();
7156 clone->die_tag = die->die_tag;
7158 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
7160 /* We don't want to copy over all attributes.
7161 For example we don't want DW_AT_byte_size because otherwise we will no
7162 longer have a declaration and GDB will treat it as a definition. */
7164 switch (a->dw_attr)
7166 case DW_AT_abstract_origin:
7167 case DW_AT_artificial:
7168 case DW_AT_containing_type:
7169 case DW_AT_external:
7170 case DW_AT_name:
7171 case DW_AT_type:
7172 case DW_AT_virtuality:
7173 case DW_AT_linkage_name:
7174 case DW_AT_MIPS_linkage_name:
7175 add_dwarf_attr (clone, a);
7176 break;
7177 case DW_AT_byte_size:
7178 default:
7179 break;
7183 if (die->comdat_type_p)
7184 add_AT_die_ref (clone, DW_AT_signature, die);
7186 add_AT_flag (clone, DW_AT_declaration, 1);
7187 return clone;
7191 /* Structure to map a DIE in one CU to its copy in a comdat type unit. */
7193 struct decl_table_entry
7195 dw_die_ref orig;
7196 dw_die_ref copy;
7199 /* Helpers to manipulate hash table of copied declarations. */
7201 /* Hashtable helpers. */
7203 struct decl_table_entry_hasher : typed_free_remove <decl_table_entry>
7205 typedef decl_table_entry value_type;
7206 typedef die_struct compare_type;
7207 static inline hashval_t hash (const value_type *);
7208 static inline bool equal (const value_type *, const compare_type *);
7211 inline hashval_t
7212 decl_table_entry_hasher::hash (const value_type *entry)
7214 return htab_hash_pointer (entry->orig);
7217 inline bool
7218 decl_table_entry_hasher::equal (const value_type *entry1,
7219 const compare_type *entry2)
7221 return entry1->orig == entry2;
7224 typedef hash_table<decl_table_entry_hasher> decl_hash_type;
7226 /* Copy DIE and its ancestors, up to, but not including, the compile unit
7227 or type unit entry, to a new tree. Adds the new tree to UNIT and returns
7228 a pointer to the copy of DIE. If DECL_TABLE is provided, it is used
7229 to check if the ancestor has already been copied into UNIT. */
7231 static dw_die_ref
7232 copy_ancestor_tree (dw_die_ref unit, dw_die_ref die,
7233 decl_hash_type *decl_table)
7235 dw_die_ref parent = die->die_parent;
7236 dw_die_ref new_parent = unit;
7237 dw_die_ref copy;
7238 decl_table_entry **slot = NULL;
7239 struct decl_table_entry *entry = NULL;
7241 if (decl_table)
7243 /* Check if the entry has already been copied to UNIT. */
7244 slot = decl_table->find_slot_with_hash (die, htab_hash_pointer (die),
7245 INSERT);
7246 if (*slot != HTAB_EMPTY_ENTRY)
7248 entry = *slot;
7249 return entry->copy;
7252 /* Record in DECL_TABLE that DIE has been copied to UNIT. */
7253 entry = XCNEW (struct decl_table_entry);
7254 entry->orig = die;
7255 entry->copy = NULL;
7256 *slot = entry;
7259 if (parent != NULL)
7261 dw_die_ref spec = get_AT_ref (parent, DW_AT_specification);
7262 if (spec != NULL)
7263 parent = spec;
7264 if (!is_unit_die (parent))
7265 new_parent = copy_ancestor_tree (unit, parent, decl_table);
7268 copy = clone_as_declaration (die);
7269 add_child_die (new_parent, copy);
7271 if (decl_table)
7273 /* Record the pointer to the copy. */
7274 entry->copy = copy;
7277 return copy;
7279 /* Copy the declaration context to the new type unit DIE. This includes
7280 any surrounding namespace or type declarations. If the DIE has an
7281 AT_specification attribute, it also includes attributes and children
7282 attached to the specification, and returns a pointer to the original
7283 parent of the declaration DIE. Returns NULL otherwise. */
7285 static dw_die_ref
7286 copy_declaration_context (dw_die_ref unit, dw_die_ref die)
7288 dw_die_ref decl;
7289 dw_die_ref new_decl;
7290 dw_die_ref orig_parent = NULL;
7292 decl = get_AT_ref (die, DW_AT_specification);
7293 if (decl == NULL)
7294 decl = die;
7295 else
7297 unsigned ix;
7298 dw_die_ref c;
7299 dw_attr_ref a;
7301 /* The original DIE will be changed to a declaration, and must
7302 be moved to be a child of the original declaration DIE. */
7303 orig_parent = decl->die_parent;
7305 /* Copy the type node pointer from the new DIE to the original
7306 declaration DIE so we can forward references later. */
7307 decl->comdat_type_p = true;
7308 decl->die_id.die_type_node = die->die_id.die_type_node;
7310 remove_AT (die, DW_AT_specification);
7312 FOR_EACH_VEC_SAFE_ELT (decl->die_attr, ix, a)
7314 if (a->dw_attr != DW_AT_name
7315 && a->dw_attr != DW_AT_declaration
7316 && a->dw_attr != DW_AT_external)
7317 add_dwarf_attr (die, a);
7320 FOR_EACH_CHILD (decl, c, add_child_die (die, clone_tree (c)));
7323 if (decl->die_parent != NULL
7324 && !is_unit_die (decl->die_parent))
7326 new_decl = copy_ancestor_tree (unit, decl, NULL);
7327 if (new_decl != NULL)
7329 remove_AT (new_decl, DW_AT_signature);
7330 add_AT_specification (die, new_decl);
7334 return orig_parent;
7337 /* Generate the skeleton ancestor tree for the given NODE, then clone
7338 the DIE and add the clone into the tree. */
7340 static void
7341 generate_skeleton_ancestor_tree (skeleton_chain_node *node)
7343 if (node->new_die != NULL)
7344 return;
7346 node->new_die = clone_as_declaration (node->old_die);
7348 if (node->parent != NULL)
7350 generate_skeleton_ancestor_tree (node->parent);
7351 add_child_die (node->parent->new_die, node->new_die);
7355 /* Generate a skeleton tree of DIEs containing any declarations that are
7356 found in the original tree. We traverse the tree looking for declaration
7357 DIEs, and construct the skeleton from the bottom up whenever we find one. */
7359 static void
7360 generate_skeleton_bottom_up (skeleton_chain_node *parent)
7362 skeleton_chain_node node;
7363 dw_die_ref c;
7364 dw_die_ref first;
7365 dw_die_ref prev = NULL;
7366 dw_die_ref next = NULL;
7368 node.parent = parent;
7370 first = c = parent->old_die->die_child;
7371 if (c)
7372 next = c->die_sib;
7373 if (c) do {
7374 if (prev == NULL || prev->die_sib == c)
7375 prev = c;
7376 c = next;
7377 next = (c == first ? NULL : c->die_sib);
7378 node.old_die = c;
7379 node.new_die = NULL;
7380 if (is_declaration_die (c))
7382 if (is_template_instantiation (c))
7384 /* Instantiated templates do not need to be cloned into the
7385 type unit. Just move the DIE and its children back to
7386 the skeleton tree (in the main CU). */
7387 remove_child_with_prev (c, prev);
7388 add_child_die (parent->new_die, c);
7389 c = prev;
7391 else
7393 /* Clone the existing DIE, move the original to the skeleton
7394 tree (which is in the main CU), and put the clone, with
7395 all the original's children, where the original came from
7396 (which is about to be moved to the type unit). */
7397 dw_die_ref clone = clone_die (c);
7398 move_all_children (c, clone);
7400 /* If the original has a DW_AT_object_pointer attribute,
7401 it would now point to a child DIE just moved to the
7402 cloned tree, so we need to remove that attribute from
7403 the original. */
7404 remove_AT (c, DW_AT_object_pointer);
7406 replace_child (c, clone, prev);
7407 generate_skeleton_ancestor_tree (parent);
7408 add_child_die (parent->new_die, c);
7409 node.new_die = c;
7410 c = clone;
7413 generate_skeleton_bottom_up (&node);
7414 } while (next != NULL);
7417 /* Wrapper function for generate_skeleton_bottom_up. */
7419 static dw_die_ref
7420 generate_skeleton (dw_die_ref die)
7422 skeleton_chain_node node;
7424 node.old_die = die;
7425 node.new_die = NULL;
7426 node.parent = NULL;
7428 /* If this type definition is nested inside another type,
7429 and is not an instantiation of a template, always leave
7430 at least a declaration in its place. */
7431 if (die->die_parent != NULL
7432 && is_type_die (die->die_parent)
7433 && !is_template_instantiation (die))
7434 node.new_die = clone_as_declaration (die);
7436 generate_skeleton_bottom_up (&node);
7437 return node.new_die;
7440 /* Remove the CHILD DIE from its parent, possibly replacing it with a cloned
7441 declaration. The original DIE is moved to a new compile unit so that
7442 existing references to it follow it to the new location. If any of the
7443 original DIE's descendants is a declaration, we need to replace the
7444 original DIE with a skeleton tree and move the declarations back into the
7445 skeleton tree. */
7447 static dw_die_ref
7448 remove_child_or_replace_with_skeleton (dw_die_ref unit, dw_die_ref child,
7449 dw_die_ref prev)
7451 dw_die_ref skeleton, orig_parent;
7453 /* Copy the declaration context to the type unit DIE. If the returned
7454 ORIG_PARENT is not NULL, the skeleton needs to be added as a child of
7455 that DIE. */
7456 orig_parent = copy_declaration_context (unit, child);
7458 skeleton = generate_skeleton (child);
7459 if (skeleton == NULL)
7460 remove_child_with_prev (child, prev);
7461 else
7463 skeleton->comdat_type_p = true;
7464 skeleton->die_id.die_type_node = child->die_id.die_type_node;
7466 /* If the original DIE was a specification, we need to put
7467 the skeleton under the parent DIE of the declaration.
7468 This leaves the original declaration in the tree, but
7469 it will be pruned later since there are no longer any
7470 references to it. */
7471 if (orig_parent != NULL)
7473 remove_child_with_prev (child, prev);
7474 add_child_die (orig_parent, skeleton);
7476 else
7477 replace_child (child, skeleton, prev);
7480 return skeleton;
7483 /* Traverse the DIE and set up additional .debug_types sections for each
7484 type worthy of being placed in a COMDAT section. */
7486 static void
7487 break_out_comdat_types (dw_die_ref die)
7489 dw_die_ref c;
7490 dw_die_ref first;
7491 dw_die_ref prev = NULL;
7492 dw_die_ref next = NULL;
7493 dw_die_ref unit = NULL;
7495 first = c = die->die_child;
7496 if (c)
7497 next = c->die_sib;
7498 if (c) do {
7499 if (prev == NULL || prev->die_sib == c)
7500 prev = c;
7501 c = next;
7502 next = (c == first ? NULL : c->die_sib);
7503 if (should_move_die_to_comdat (c))
7505 dw_die_ref replacement;
7506 comdat_type_node_ref type_node;
7508 /* Break out nested types into their own type units. */
7509 break_out_comdat_types (c);
7511 /* Create a new type unit DIE as the root for the new tree, and
7512 add it to the list of comdat types. */
7513 unit = new_die (DW_TAG_type_unit, NULL, NULL);
7514 add_AT_unsigned (unit, DW_AT_language,
7515 get_AT_unsigned (comp_unit_die (), DW_AT_language));
7516 type_node = ggc_cleared_alloc<comdat_type_node> ();
7517 type_node->root_die = unit;
7518 type_node->next = comdat_type_list;
7519 comdat_type_list = type_node;
7521 /* Generate the type signature. */
7522 generate_type_signature (c, type_node);
7524 /* Copy the declaration context, attributes, and children of the
7525 declaration into the new type unit DIE, then remove this DIE
7526 from the main CU (or replace it with a skeleton if necessary). */
7527 replacement = remove_child_or_replace_with_skeleton (unit, c, prev);
7528 type_node->skeleton_die = replacement;
7530 /* Add the DIE to the new compunit. */
7531 add_child_die (unit, c);
7533 if (replacement != NULL)
7534 c = replacement;
7536 else if (c->die_tag == DW_TAG_namespace
7537 || c->die_tag == DW_TAG_class_type
7538 || c->die_tag == DW_TAG_structure_type
7539 || c->die_tag == DW_TAG_union_type)
7541 /* Look for nested types that can be broken out. */
7542 break_out_comdat_types (c);
7544 } while (next != NULL);
7547 /* Like clone_tree, but copy DW_TAG_subprogram DIEs as declarations.
7548 Enter all the cloned children into the hash table decl_table. */
7550 static dw_die_ref
7551 clone_tree_partial (dw_die_ref die, decl_hash_type *decl_table)
7553 dw_die_ref c;
7554 dw_die_ref clone;
7555 struct decl_table_entry *entry;
7556 decl_table_entry **slot;
7558 if (die->die_tag == DW_TAG_subprogram)
7559 clone = clone_as_declaration (die);
7560 else
7561 clone = clone_die (die);
7563 slot = decl_table->find_slot_with_hash (die,
7564 htab_hash_pointer (die), INSERT);
7566 /* Assert that DIE isn't in the hash table yet. If it would be there
7567 before, the ancestors would be necessarily there as well, therefore
7568 clone_tree_partial wouldn't be called. */
7569 gcc_assert (*slot == HTAB_EMPTY_ENTRY);
7571 entry = XCNEW (struct decl_table_entry);
7572 entry->orig = die;
7573 entry->copy = clone;
7574 *slot = entry;
7576 if (die->die_tag != DW_TAG_subprogram)
7577 FOR_EACH_CHILD (die, c,
7578 add_child_die (clone, clone_tree_partial (c, decl_table)));
7580 return clone;
7583 /* Walk the DIE and its children, looking for references to incomplete
7584 or trivial types that are unmarked (i.e., that are not in the current
7585 type_unit). */
7587 static void
7588 copy_decls_walk (dw_die_ref unit, dw_die_ref die, decl_hash_type *decl_table)
7590 dw_die_ref c;
7591 dw_attr_ref a;
7592 unsigned ix;
7594 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
7596 if (AT_class (a) == dw_val_class_die_ref)
7598 dw_die_ref targ = AT_ref (a);
7599 decl_table_entry **slot;
7600 struct decl_table_entry *entry;
7602 if (targ->die_mark != 0 || targ->comdat_type_p)
7603 continue;
7605 slot = decl_table->find_slot_with_hash (targ,
7606 htab_hash_pointer (targ),
7607 INSERT);
7609 if (*slot != HTAB_EMPTY_ENTRY)
7611 /* TARG has already been copied, so we just need to
7612 modify the reference to point to the copy. */
7613 entry = *slot;
7614 a->dw_attr_val.v.val_die_ref.die = entry->copy;
7616 else
7618 dw_die_ref parent = unit;
7619 dw_die_ref copy = clone_die (targ);
7621 /* Record in DECL_TABLE that TARG has been copied.
7622 Need to do this now, before the recursive call,
7623 because DECL_TABLE may be expanded and SLOT
7624 would no longer be a valid pointer. */
7625 entry = XCNEW (struct decl_table_entry);
7626 entry->orig = targ;
7627 entry->copy = copy;
7628 *slot = entry;
7630 /* If TARG is not a declaration DIE, we need to copy its
7631 children. */
7632 if (!is_declaration_die (targ))
7634 FOR_EACH_CHILD (
7635 targ, c,
7636 add_child_die (copy,
7637 clone_tree_partial (c, decl_table)));
7640 /* Make sure the cloned tree is marked as part of the
7641 type unit. */
7642 mark_dies (copy);
7644 /* If TARG has surrounding context, copy its ancestor tree
7645 into the new type unit. */
7646 if (targ->die_parent != NULL
7647 && !is_unit_die (targ->die_parent))
7648 parent = copy_ancestor_tree (unit, targ->die_parent,
7649 decl_table);
7651 add_child_die (parent, copy);
7652 a->dw_attr_val.v.val_die_ref.die = copy;
7654 /* Make sure the newly-copied DIE is walked. If it was
7655 installed in a previously-added context, it won't
7656 get visited otherwise. */
7657 if (parent != unit)
7659 /* Find the highest point of the newly-added tree,
7660 mark each node along the way, and walk from there. */
7661 parent->die_mark = 1;
7662 while (parent->die_parent
7663 && parent->die_parent->die_mark == 0)
7665 parent = parent->die_parent;
7666 parent->die_mark = 1;
7668 copy_decls_walk (unit, parent, decl_table);
7674 FOR_EACH_CHILD (die, c, copy_decls_walk (unit, c, decl_table));
7677 /* Copy declarations for "unworthy" types into the new comdat section.
7678 Incomplete types, modified types, and certain other types aren't broken
7679 out into comdat sections of their own, so they don't have a signature,
7680 and we need to copy the declaration into the same section so that we
7681 don't have an external reference. */
7683 static void
7684 copy_decls_for_unworthy_types (dw_die_ref unit)
7686 mark_dies (unit);
7687 decl_hash_type decl_table (10);
7688 copy_decls_walk (unit, unit, &decl_table);
7689 unmark_dies (unit);
7692 /* Traverse the DIE and add a sibling attribute if it may have the
7693 effect of speeding up access to siblings. To save some space,
7694 avoid generating sibling attributes for DIE's without children. */
7696 static void
7697 add_sibling_attributes (dw_die_ref die)
7699 dw_die_ref c;
7701 if (! die->die_child)
7702 return;
7704 if (die->die_parent && die != die->die_parent->die_child)
7705 add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
7707 FOR_EACH_CHILD (die, c, add_sibling_attributes (c));
7710 /* Output all location lists for the DIE and its children. */
7712 static void
7713 output_location_lists (dw_die_ref die)
7715 dw_die_ref c;
7716 dw_attr_ref a;
7717 unsigned ix;
7719 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
7720 if (AT_class (a) == dw_val_class_loc_list)
7721 output_loc_list (AT_loc_list (a));
7723 FOR_EACH_CHILD (die, c, output_location_lists (c));
7726 /* We want to limit the number of external references, because they are
7727 larger than local references: a relocation takes multiple words, and
7728 even a sig8 reference is always eight bytes, whereas a local reference
7729 can be as small as one byte (though DW_FORM_ref is usually 4 in GCC).
7730 So if we encounter multiple external references to the same type DIE, we
7731 make a local typedef stub for it and redirect all references there.
7733 This is the element of the hash table for keeping track of these
7734 references. */
7736 struct external_ref
7738 dw_die_ref type;
7739 dw_die_ref stub;
7740 unsigned n_refs;
7743 /* Hashtable helpers. */
7745 struct external_ref_hasher : typed_free_remove <external_ref>
7747 typedef external_ref value_type;
7748 typedef external_ref compare_type;
7749 static inline hashval_t hash (const value_type *);
7750 static inline bool equal (const value_type *, const compare_type *);
7753 inline hashval_t
7754 external_ref_hasher::hash (const value_type *r)
7756 dw_die_ref die = r->type;
7757 hashval_t h = 0;
7759 /* We can't use the address of the DIE for hashing, because
7760 that will make the order of the stub DIEs non-deterministic. */
7761 if (! die->comdat_type_p)
7762 /* We have a symbol; use it to compute a hash. */
7763 h = htab_hash_string (die->die_id.die_symbol);
7764 else
7766 /* We have a type signature; use a subset of the bits as the hash.
7767 The 8-byte signature is at least as large as hashval_t. */
7768 comdat_type_node_ref type_node = die->die_id.die_type_node;
7769 memcpy (&h, type_node->signature, sizeof (h));
7771 return h;
7774 inline bool
7775 external_ref_hasher::equal (const value_type *r1, const compare_type *r2)
7777 return r1->type == r2->type;
7780 typedef hash_table<external_ref_hasher> external_ref_hash_type;
7782 /* Return a pointer to the external_ref for references to DIE. */
7784 static struct external_ref *
7785 lookup_external_ref (external_ref_hash_type *map, dw_die_ref die)
7787 struct external_ref ref, *ref_p;
7788 external_ref **slot;
7790 ref.type = die;
7791 slot = map->find_slot (&ref, INSERT);
7792 if (*slot != HTAB_EMPTY_ENTRY)
7793 return *slot;
7795 ref_p = XCNEW (struct external_ref);
7796 ref_p->type = die;
7797 *slot = ref_p;
7798 return ref_p;
7801 /* Subroutine of optimize_external_refs, below.
7803 If we see a type skeleton, record it as our stub. If we see external
7804 references, remember how many we've seen. */
7806 static void
7807 optimize_external_refs_1 (dw_die_ref die, external_ref_hash_type *map)
7809 dw_die_ref c;
7810 dw_attr_ref a;
7811 unsigned ix;
7812 struct external_ref *ref_p;
7814 if (is_type_die (die)
7815 && (c = get_AT_ref (die, DW_AT_signature)))
7817 /* This is a local skeleton; use it for local references. */
7818 ref_p = lookup_external_ref (map, c);
7819 ref_p->stub = die;
7822 /* Scan the DIE references, and remember any that refer to DIEs from
7823 other CUs (i.e. those which are not marked). */
7824 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
7825 if (AT_class (a) == dw_val_class_die_ref
7826 && (c = AT_ref (a))->die_mark == 0
7827 && is_type_die (c))
7829 ref_p = lookup_external_ref (map, c);
7830 ref_p->n_refs++;
7833 FOR_EACH_CHILD (die, c, optimize_external_refs_1 (c, map));
7836 /* htab_traverse callback function for optimize_external_refs, below. SLOT
7837 points to an external_ref, DATA is the CU we're processing. If we don't
7838 already have a local stub, and we have multiple refs, build a stub. */
7841 dwarf2_build_local_stub (external_ref **slot, dw_die_ref data)
7843 struct external_ref *ref_p = *slot;
7845 if (ref_p->stub == NULL && ref_p->n_refs > 1 && !dwarf_strict)
7847 /* We have multiple references to this type, so build a small stub.
7848 Both of these forms are a bit dodgy from the perspective of the
7849 DWARF standard, since technically they should have names. */
7850 dw_die_ref cu = data;
7851 dw_die_ref type = ref_p->type;
7852 dw_die_ref stub = NULL;
7854 if (type->comdat_type_p)
7856 /* If we refer to this type via sig8, use AT_signature. */
7857 stub = new_die (type->die_tag, cu, NULL_TREE);
7858 add_AT_die_ref (stub, DW_AT_signature, type);
7860 else
7862 /* Otherwise, use a typedef with no name. */
7863 stub = new_die (DW_TAG_typedef, cu, NULL_TREE);
7864 add_AT_die_ref (stub, DW_AT_type, type);
7867 stub->die_mark++;
7868 ref_p->stub = stub;
7870 return 1;
7873 /* DIE is a unit; look through all the DIE references to see if there are
7874 any external references to types, and if so, create local stubs for
7875 them which will be applied in build_abbrev_table. This is useful because
7876 references to local DIEs are smaller. */
7878 static external_ref_hash_type *
7879 optimize_external_refs (dw_die_ref die)
7881 external_ref_hash_type *map = new external_ref_hash_type (10);
7882 optimize_external_refs_1 (die, map);
7883 map->traverse <dw_die_ref, dwarf2_build_local_stub> (die);
7884 return map;
7887 /* The format of each DIE (and its attribute value pairs) is encoded in an
7888 abbreviation table. This routine builds the abbreviation table and assigns
7889 a unique abbreviation id for each abbreviation entry. The children of each
7890 die are visited recursively. */
7892 static void
7893 build_abbrev_table (dw_die_ref die, external_ref_hash_type *extern_map)
7895 unsigned long abbrev_id;
7896 unsigned int n_alloc;
7897 dw_die_ref c;
7898 dw_attr_ref a;
7899 unsigned ix;
7901 /* Scan the DIE references, and replace any that refer to
7902 DIEs from other CUs (i.e. those which are not marked) with
7903 the local stubs we built in optimize_external_refs. */
7904 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
7905 if (AT_class (a) == dw_val_class_die_ref
7906 && (c = AT_ref (a))->die_mark == 0)
7908 struct external_ref *ref_p;
7909 gcc_assert (AT_ref (a)->comdat_type_p || AT_ref (a)->die_id.die_symbol);
7911 ref_p = lookup_external_ref (extern_map, c);
7912 if (ref_p->stub && ref_p->stub != die)
7913 change_AT_die_ref (a, ref_p->stub);
7914 else
7915 /* We aren't changing this reference, so mark it external. */
7916 set_AT_ref_external (a, 1);
7919 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
7921 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
7922 dw_attr_ref die_a, abbrev_a;
7923 unsigned ix;
7924 bool ok = true;
7926 if (abbrev->die_tag != die->die_tag)
7927 continue;
7928 if ((abbrev->die_child != NULL) != (die->die_child != NULL))
7929 continue;
7931 if (vec_safe_length (abbrev->die_attr) != vec_safe_length (die->die_attr))
7932 continue;
7934 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, die_a)
7936 abbrev_a = &(*abbrev->die_attr)[ix];
7937 if ((abbrev_a->dw_attr != die_a->dw_attr)
7938 || (value_format (abbrev_a) != value_format (die_a)))
7940 ok = false;
7941 break;
7944 if (ok)
7945 break;
7948 if (abbrev_id >= abbrev_die_table_in_use)
7950 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
7952 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
7953 abbrev_die_table = GGC_RESIZEVEC (dw_die_ref, abbrev_die_table,
7954 n_alloc);
7956 memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
7957 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
7958 abbrev_die_table_allocated = n_alloc;
7961 ++abbrev_die_table_in_use;
7962 abbrev_die_table[abbrev_id] = die;
7965 die->die_abbrev = abbrev_id;
7966 FOR_EACH_CHILD (die, c, build_abbrev_table (c, extern_map));
7969 /* Return the power-of-two number of bytes necessary to represent VALUE. */
7971 static int
7972 constant_size (unsigned HOST_WIDE_INT value)
7974 int log;
7976 if (value == 0)
7977 log = 0;
7978 else
7979 log = floor_log2 (value);
7981 log = log / 8;
7982 log = 1 << (floor_log2 (log) + 1);
7984 return log;
7987 /* Return the size of a DIE as it is represented in the
7988 .debug_info section. */
7990 static unsigned long
7991 size_of_die (dw_die_ref die)
7993 unsigned long size = 0;
7994 dw_attr_ref a;
7995 unsigned ix;
7996 enum dwarf_form form;
7998 size += size_of_uleb128 (die->die_abbrev);
7999 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
8001 switch (AT_class (a))
8003 case dw_val_class_addr:
8004 if (dwarf_split_debug_info && AT_index (a) != NOT_INDEXED)
8006 gcc_assert (AT_index (a) != NO_INDEX_ASSIGNED);
8007 size += size_of_uleb128 (AT_index (a));
8009 else
8010 size += DWARF2_ADDR_SIZE;
8011 break;
8012 case dw_val_class_offset:
8013 size += DWARF_OFFSET_SIZE;
8014 break;
8015 case dw_val_class_loc:
8017 unsigned long lsize = size_of_locs (AT_loc (a));
8019 /* Block length. */
8020 if (dwarf_version >= 4)
8021 size += size_of_uleb128 (lsize);
8022 else
8023 size += constant_size (lsize);
8024 size += lsize;
8026 break;
8027 case dw_val_class_loc_list:
8028 if (dwarf_split_debug_info && AT_index (a) != NOT_INDEXED)
8030 gcc_assert (AT_index (a) != NO_INDEX_ASSIGNED);
8031 size += size_of_uleb128 (AT_index (a));
8033 else
8034 size += DWARF_OFFSET_SIZE;
8035 break;
8036 case dw_val_class_range_list:
8037 size += DWARF_OFFSET_SIZE;
8038 break;
8039 case dw_val_class_const:
8040 size += size_of_sleb128 (AT_int (a));
8041 break;
8042 case dw_val_class_unsigned_const:
8044 int csize = constant_size (AT_unsigned (a));
8045 if (dwarf_version == 3
8046 && a->dw_attr == DW_AT_data_member_location
8047 && csize >= 4)
8048 size += size_of_uleb128 (AT_unsigned (a));
8049 else
8050 size += csize;
8052 break;
8053 case dw_val_class_const_double:
8054 size += HOST_BITS_PER_DOUBLE_INT / HOST_BITS_PER_CHAR;
8055 if (HOST_BITS_PER_WIDE_INT >= 64)
8056 size++; /* block */
8057 break;
8058 case dw_val_class_wide_int:
8059 size += (get_full_len (*a->dw_attr_val.v.val_wide)
8060 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR);
8061 if (get_full_len (*a->dw_attr_val.v.val_wide) * HOST_BITS_PER_WIDE_INT
8062 > 64)
8063 size++; /* block */
8064 break;
8065 case dw_val_class_vec:
8066 size += constant_size (a->dw_attr_val.v.val_vec.length
8067 * a->dw_attr_val.v.val_vec.elt_size)
8068 + a->dw_attr_val.v.val_vec.length
8069 * a->dw_attr_val.v.val_vec.elt_size; /* block */
8070 break;
8071 case dw_val_class_flag:
8072 if (dwarf_version >= 4)
8073 /* Currently all add_AT_flag calls pass in 1 as last argument,
8074 so DW_FORM_flag_present can be used. If that ever changes,
8075 we'll need to use DW_FORM_flag and have some optimization
8076 in build_abbrev_table that will change those to
8077 DW_FORM_flag_present if it is set to 1 in all DIEs using
8078 the same abbrev entry. */
8079 gcc_assert (a->dw_attr_val.v.val_flag == 1);
8080 else
8081 size += 1;
8082 break;
8083 case dw_val_class_die_ref:
8084 if (AT_ref_external (a))
8086 /* In DWARF4, we use DW_FORM_ref_sig8; for earlier versions
8087 we use DW_FORM_ref_addr. In DWARF2, DW_FORM_ref_addr
8088 is sized by target address length, whereas in DWARF3
8089 it's always sized as an offset. */
8090 if (use_debug_types)
8091 size += DWARF_TYPE_SIGNATURE_SIZE;
8092 else if (dwarf_version == 2)
8093 size += DWARF2_ADDR_SIZE;
8094 else
8095 size += DWARF_OFFSET_SIZE;
8097 else
8098 size += DWARF_OFFSET_SIZE;
8099 break;
8100 case dw_val_class_fde_ref:
8101 size += DWARF_OFFSET_SIZE;
8102 break;
8103 case dw_val_class_lbl_id:
8104 if (dwarf_split_debug_info && AT_index (a) != NOT_INDEXED)
8106 gcc_assert (AT_index (a) != NO_INDEX_ASSIGNED);
8107 size += size_of_uleb128 (AT_index (a));
8109 else
8110 size += DWARF2_ADDR_SIZE;
8111 break;
8112 case dw_val_class_lineptr:
8113 case dw_val_class_macptr:
8114 size += DWARF_OFFSET_SIZE;
8115 break;
8116 case dw_val_class_str:
8117 form = AT_string_form (a);
8118 if (form == DW_FORM_strp)
8119 size += DWARF_OFFSET_SIZE;
8120 else if (form == DW_FORM_GNU_str_index)
8121 size += size_of_uleb128 (AT_index (a));
8122 else
8123 size += strlen (a->dw_attr_val.v.val_str->str) + 1;
8124 break;
8125 case dw_val_class_file:
8126 size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file));
8127 break;
8128 case dw_val_class_data8:
8129 size += 8;
8130 break;
8131 case dw_val_class_vms_delta:
8132 size += DWARF_OFFSET_SIZE;
8133 break;
8134 case dw_val_class_high_pc:
8135 size += DWARF2_ADDR_SIZE;
8136 break;
8137 default:
8138 gcc_unreachable ();
8142 return size;
8145 /* Size the debugging information associated with a given DIE. Visits the
8146 DIE's children recursively. Updates the global variable next_die_offset, on
8147 each time through. Uses the current value of next_die_offset to update the
8148 die_offset field in each DIE. */
8150 static void
8151 calc_die_sizes (dw_die_ref die)
8153 dw_die_ref c;
8155 gcc_assert (die->die_offset == 0
8156 || (unsigned long int) die->die_offset == next_die_offset);
8157 die->die_offset = next_die_offset;
8158 next_die_offset += size_of_die (die);
8160 FOR_EACH_CHILD (die, c, calc_die_sizes (c));
8162 if (die->die_child != NULL)
8163 /* Count the null byte used to terminate sibling lists. */
8164 next_die_offset += 1;
8167 /* Size just the base type children at the start of the CU.
8168 This is needed because build_abbrev needs to size locs
8169 and sizing of type based stack ops needs to know die_offset
8170 values for the base types. */
8172 static void
8173 calc_base_type_die_sizes (void)
8175 unsigned long die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
8176 unsigned int i;
8177 dw_die_ref base_type;
8178 #if ENABLE_ASSERT_CHECKING
8179 dw_die_ref prev = comp_unit_die ()->die_child;
8180 #endif
8182 die_offset += size_of_die (comp_unit_die ());
8183 for (i = 0; base_types.iterate (i, &base_type); i++)
8185 #if ENABLE_ASSERT_CHECKING
8186 gcc_assert (base_type->die_offset == 0
8187 && prev->die_sib == base_type
8188 && base_type->die_child == NULL
8189 && base_type->die_abbrev);
8190 prev = base_type;
8191 #endif
8192 base_type->die_offset = die_offset;
8193 die_offset += size_of_die (base_type);
8197 /* Set the marks for a die and its children. We do this so
8198 that we know whether or not a reference needs to use FORM_ref_addr; only
8199 DIEs in the same CU will be marked. We used to clear out the offset
8200 and use that as the flag, but ran into ordering problems. */
8202 static void
8203 mark_dies (dw_die_ref die)
8205 dw_die_ref c;
8207 gcc_assert (!die->die_mark);
8209 die->die_mark = 1;
8210 FOR_EACH_CHILD (die, c, mark_dies (c));
8213 /* Clear the marks for a die and its children. */
8215 static void
8216 unmark_dies (dw_die_ref die)
8218 dw_die_ref c;
8220 if (! use_debug_types)
8221 gcc_assert (die->die_mark);
8223 die->die_mark = 0;
8224 FOR_EACH_CHILD (die, c, unmark_dies (c));
8227 /* Clear the marks for a die, its children and referred dies. */
8229 static void
8230 unmark_all_dies (dw_die_ref die)
8232 dw_die_ref c;
8233 dw_attr_ref a;
8234 unsigned ix;
8236 if (!die->die_mark)
8237 return;
8238 die->die_mark = 0;
8240 FOR_EACH_CHILD (die, c, unmark_all_dies (c));
8242 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
8243 if (AT_class (a) == dw_val_class_die_ref)
8244 unmark_all_dies (AT_ref (a));
8247 /* Calculate if the entry should appear in the final output file. It may be
8248 from a pruned a type. */
8250 static bool
8251 include_pubname_in_output (vec<pubname_entry, va_gc> *table, pubname_entry *p)
8253 /* By limiting gnu pubnames to definitions only, gold can generate a
8254 gdb index without entries for declarations, which don't include
8255 enough information to be useful. */
8256 if (debug_generate_pub_sections == 2 && is_declaration_die (p->die))
8257 return false;
8259 if (table == pubname_table)
8261 /* Enumerator names are part of the pubname table, but the
8262 parent DW_TAG_enumeration_type die may have been pruned.
8263 Don't output them if that is the case. */
8264 if (p->die->die_tag == DW_TAG_enumerator &&
8265 (p->die->die_parent == NULL
8266 || !p->die->die_parent->die_perennial_p))
8267 return false;
8269 /* Everything else in the pubname table is included. */
8270 return true;
8273 /* The pubtypes table shouldn't include types that have been
8274 pruned. */
8275 return (p->die->die_offset != 0
8276 || !flag_eliminate_unused_debug_types);
8279 /* Return the size of the .debug_pubnames or .debug_pubtypes table
8280 generated for the compilation unit. */
8282 static unsigned long
8283 size_of_pubnames (vec<pubname_entry, va_gc> *names)
8285 unsigned long size;
8286 unsigned i;
8287 pubname_ref p;
8288 int space_for_flags = (debug_generate_pub_sections == 2) ? 1 : 0;
8290 size = DWARF_PUBNAMES_HEADER_SIZE;
8291 FOR_EACH_VEC_ELT (*names, i, p)
8292 if (include_pubname_in_output (names, p))
8293 size += strlen (p->name) + DWARF_OFFSET_SIZE + 1 + space_for_flags;
8295 size += DWARF_OFFSET_SIZE;
8296 return size;
8299 /* Return the size of the information in the .debug_aranges section. */
8301 static unsigned long
8302 size_of_aranges (void)
8304 unsigned long size;
8306 size = DWARF_ARANGES_HEADER_SIZE;
8308 /* Count the address/length pair for this compilation unit. */
8309 if (text_section_used)
8310 size += 2 * DWARF2_ADDR_SIZE;
8311 if (cold_text_section_used)
8312 size += 2 * DWARF2_ADDR_SIZE;
8313 if (have_multiple_function_sections)
8315 unsigned fde_idx;
8316 dw_fde_ref fde;
8318 FOR_EACH_VEC_ELT (*fde_vec, fde_idx, fde)
8320 if (DECL_IGNORED_P (fde->decl))
8321 continue;
8322 if (!fde->in_std_section)
8323 size += 2 * DWARF2_ADDR_SIZE;
8324 if (fde->dw_fde_second_begin && !fde->second_in_std_section)
8325 size += 2 * DWARF2_ADDR_SIZE;
8329 /* Count the two zero words used to terminated the address range table. */
8330 size += 2 * DWARF2_ADDR_SIZE;
8331 return size;
8334 /* Select the encoding of an attribute value. */
8336 static enum dwarf_form
8337 value_format (dw_attr_ref a)
8339 switch (AT_class (a))
8341 case dw_val_class_addr:
8342 /* Only very few attributes allow DW_FORM_addr. */
8343 switch (a->dw_attr)
8345 case DW_AT_low_pc:
8346 case DW_AT_high_pc:
8347 case DW_AT_entry_pc:
8348 case DW_AT_trampoline:
8349 return (AT_index (a) == NOT_INDEXED
8350 ? DW_FORM_addr : DW_FORM_GNU_addr_index);
8351 default:
8352 break;
8354 switch (DWARF2_ADDR_SIZE)
8356 case 1:
8357 return DW_FORM_data1;
8358 case 2:
8359 return DW_FORM_data2;
8360 case 4:
8361 return DW_FORM_data4;
8362 case 8:
8363 return DW_FORM_data8;
8364 default:
8365 gcc_unreachable ();
8367 case dw_val_class_range_list:
8368 case dw_val_class_loc_list:
8369 if (dwarf_version >= 4)
8370 return DW_FORM_sec_offset;
8371 /* FALLTHRU */
8372 case dw_val_class_vms_delta:
8373 case dw_val_class_offset:
8374 switch (DWARF_OFFSET_SIZE)
8376 case 4:
8377 return DW_FORM_data4;
8378 case 8:
8379 return DW_FORM_data8;
8380 default:
8381 gcc_unreachable ();
8383 case dw_val_class_loc:
8384 if (dwarf_version >= 4)
8385 return DW_FORM_exprloc;
8386 switch (constant_size (size_of_locs (AT_loc (a))))
8388 case 1:
8389 return DW_FORM_block1;
8390 case 2:
8391 return DW_FORM_block2;
8392 case 4:
8393 return DW_FORM_block4;
8394 default:
8395 gcc_unreachable ();
8397 case dw_val_class_const:
8398 return DW_FORM_sdata;
8399 case dw_val_class_unsigned_const:
8400 switch (constant_size (AT_unsigned (a)))
8402 case 1:
8403 return DW_FORM_data1;
8404 case 2:
8405 return DW_FORM_data2;
8406 case 4:
8407 /* In DWARF3 DW_AT_data_member_location with
8408 DW_FORM_data4 or DW_FORM_data8 is a loclistptr, not
8409 constant, so we need to use DW_FORM_udata if we need
8410 a large constant. */
8411 if (dwarf_version == 3 && a->dw_attr == DW_AT_data_member_location)
8412 return DW_FORM_udata;
8413 return DW_FORM_data4;
8414 case 8:
8415 if (dwarf_version == 3 && a->dw_attr == DW_AT_data_member_location)
8416 return DW_FORM_udata;
8417 return DW_FORM_data8;
8418 default:
8419 gcc_unreachable ();
8421 case dw_val_class_const_double:
8422 switch (HOST_BITS_PER_WIDE_INT)
8424 case 8:
8425 return DW_FORM_data2;
8426 case 16:
8427 return DW_FORM_data4;
8428 case 32:
8429 return DW_FORM_data8;
8430 case 64:
8431 default:
8432 return DW_FORM_block1;
8434 case dw_val_class_wide_int:
8435 switch (get_full_len (*a->dw_attr_val.v.val_wide) * HOST_BITS_PER_WIDE_INT)
8437 case 8:
8438 return DW_FORM_data1;
8439 case 16:
8440 return DW_FORM_data2;
8441 case 32:
8442 return DW_FORM_data4;
8443 case 64:
8444 return DW_FORM_data8;
8445 default:
8446 return DW_FORM_block1;
8448 case dw_val_class_vec:
8449 switch (constant_size (a->dw_attr_val.v.val_vec.length
8450 * a->dw_attr_val.v.val_vec.elt_size))
8452 case 1:
8453 return DW_FORM_block1;
8454 case 2:
8455 return DW_FORM_block2;
8456 case 4:
8457 return DW_FORM_block4;
8458 default:
8459 gcc_unreachable ();
8461 case dw_val_class_flag:
8462 if (dwarf_version >= 4)
8464 /* Currently all add_AT_flag calls pass in 1 as last argument,
8465 so DW_FORM_flag_present can be used. If that ever changes,
8466 we'll need to use DW_FORM_flag and have some optimization
8467 in build_abbrev_table that will change those to
8468 DW_FORM_flag_present if it is set to 1 in all DIEs using
8469 the same abbrev entry. */
8470 gcc_assert (a->dw_attr_val.v.val_flag == 1);
8471 return DW_FORM_flag_present;
8473 return DW_FORM_flag;
8474 case dw_val_class_die_ref:
8475 if (AT_ref_external (a))
8476 return use_debug_types ? DW_FORM_ref_sig8 : DW_FORM_ref_addr;
8477 else
8478 return DW_FORM_ref;
8479 case dw_val_class_fde_ref:
8480 return DW_FORM_data;
8481 case dw_val_class_lbl_id:
8482 return (AT_index (a) == NOT_INDEXED
8483 ? DW_FORM_addr : DW_FORM_GNU_addr_index);
8484 case dw_val_class_lineptr:
8485 case dw_val_class_macptr:
8486 return dwarf_version >= 4 ? DW_FORM_sec_offset : DW_FORM_data;
8487 case dw_val_class_str:
8488 return AT_string_form (a);
8489 case dw_val_class_file:
8490 switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)))
8492 case 1:
8493 return DW_FORM_data1;
8494 case 2:
8495 return DW_FORM_data2;
8496 case 4:
8497 return DW_FORM_data4;
8498 default:
8499 gcc_unreachable ();
8502 case dw_val_class_data8:
8503 return DW_FORM_data8;
8505 case dw_val_class_high_pc:
8506 switch (DWARF2_ADDR_SIZE)
8508 case 1:
8509 return DW_FORM_data1;
8510 case 2:
8511 return DW_FORM_data2;
8512 case 4:
8513 return DW_FORM_data4;
8514 case 8:
8515 return DW_FORM_data8;
8516 default:
8517 gcc_unreachable ();
8520 default:
8521 gcc_unreachable ();
8525 /* Output the encoding of an attribute value. */
8527 static void
8528 output_value_format (dw_attr_ref a)
8530 enum dwarf_form form = value_format (a);
8532 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
8535 /* Given a die and id, produce the appropriate abbreviations. */
8537 static void
8538 output_die_abbrevs (unsigned long abbrev_id, dw_die_ref abbrev)
8540 unsigned ix;
8541 dw_attr_ref a_attr;
8543 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
8544 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
8545 dwarf_tag_name (abbrev->die_tag));
8547 if (abbrev->die_child != NULL)
8548 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
8549 else
8550 dw2_asm_output_data (1, DW_children_no, "DW_children_no");
8552 for (ix = 0; vec_safe_iterate (abbrev->die_attr, ix, &a_attr); ix++)
8554 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
8555 dwarf_attr_name (a_attr->dw_attr));
8556 output_value_format (a_attr);
8559 dw2_asm_output_data (1, 0, NULL);
8560 dw2_asm_output_data (1, 0, NULL);
8564 /* Output the .debug_abbrev section which defines the DIE abbreviation
8565 table. */
8567 static void
8568 output_abbrev_section (void)
8570 unsigned long abbrev_id;
8572 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
8573 output_die_abbrevs (abbrev_id, abbrev_die_table[abbrev_id]);
8575 /* Terminate the table. */
8576 dw2_asm_output_data (1, 0, NULL);
8579 /* Output a symbol we can use to refer to this DIE from another CU. */
8581 static inline void
8582 output_die_symbol (dw_die_ref die)
8584 const char *sym = die->die_id.die_symbol;
8586 gcc_assert (!die->comdat_type_p);
8588 if (sym == 0)
8589 return;
8591 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
8592 /* We make these global, not weak; if the target doesn't support
8593 .linkonce, it doesn't support combining the sections, so debugging
8594 will break. */
8595 targetm.asm_out.globalize_label (asm_out_file, sym);
8597 ASM_OUTPUT_LABEL (asm_out_file, sym);
8600 /* Return a new location list, given the begin and end range, and the
8601 expression. */
8603 static inline dw_loc_list_ref
8604 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
8605 const char *section)
8607 dw_loc_list_ref retlist = ggc_cleared_alloc<dw_loc_list_node> ();
8609 retlist->begin = begin;
8610 retlist->begin_entry = NULL;
8611 retlist->end = end;
8612 retlist->expr = expr;
8613 retlist->section = section;
8615 return retlist;
8618 /* Generate a new internal symbol for this location list node, if it
8619 hasn't got one yet. */
8621 static inline void
8622 gen_llsym (dw_loc_list_ref list)
8624 gcc_assert (!list->ll_symbol);
8625 list->ll_symbol = gen_internal_sym ("LLST");
8628 /* Output the location list given to us. */
8630 static void
8631 output_loc_list (dw_loc_list_ref list_head)
8633 dw_loc_list_ref curr = list_head;
8635 if (list_head->emitted)
8636 return;
8637 list_head->emitted = true;
8639 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
8641 /* Walk the location list, and output each range + expression. */
8642 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
8644 unsigned long size;
8645 /* Don't output an entry that starts and ends at the same address. */
8646 if (strcmp (curr->begin, curr->end) == 0 && !curr->force)
8647 continue;
8648 size = size_of_locs (curr->expr);
8649 /* If the expression is too large, drop it on the floor. We could
8650 perhaps put it into DW_TAG_dwarf_procedure and refer to that
8651 in the expression, but >= 64KB expressions for a single value
8652 in a single range are unlikely very useful. */
8653 if (size > 0xffff)
8654 continue;
8655 if (dwarf_split_debug_info)
8657 dw2_asm_output_data (1, DW_LLE_GNU_start_length_entry,
8658 "Location list start/length entry (%s)",
8659 list_head->ll_symbol);
8660 dw2_asm_output_data_uleb128 (curr->begin_entry->index,
8661 "Location list range start index (%s)",
8662 curr->begin);
8663 /* The length field is 4 bytes. If we ever need to support
8664 an 8-byte length, we can add a new DW_LLE code or fall back
8665 to DW_LLE_GNU_start_end_entry. */
8666 dw2_asm_output_delta (4, curr->end, curr->begin,
8667 "Location list range length (%s)",
8668 list_head->ll_symbol);
8670 else if (!have_multiple_function_sections)
8672 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
8673 "Location list begin address (%s)",
8674 list_head->ll_symbol);
8675 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
8676 "Location list end address (%s)",
8677 list_head->ll_symbol);
8679 else
8681 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
8682 "Location list begin address (%s)",
8683 list_head->ll_symbol);
8684 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
8685 "Location list end address (%s)",
8686 list_head->ll_symbol);
8689 /* Output the block length for this list of location operations. */
8690 gcc_assert (size <= 0xffff);
8691 dw2_asm_output_data (2, size, "%s", "Location expression size");
8693 output_loc_sequence (curr->expr, -1);
8696 if (dwarf_split_debug_info)
8697 dw2_asm_output_data (1, DW_LLE_GNU_end_of_list_entry,
8698 "Location list terminator (%s)",
8699 list_head->ll_symbol);
8700 else
8702 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
8703 "Location list terminator begin (%s)",
8704 list_head->ll_symbol);
8705 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
8706 "Location list terminator end (%s)",
8707 list_head->ll_symbol);
8711 /* Output a range_list offset into the debug_range section. Emit a
8712 relocated reference if val_entry is NULL, otherwise, emit an
8713 indirect reference. */
8715 static void
8716 output_range_list_offset (dw_attr_ref a)
8718 const char *name = dwarf_attr_name (a->dw_attr);
8720 if (a->dw_attr_val.val_entry == RELOCATED_OFFSET)
8722 char *p = strchr (ranges_section_label, '\0');
8723 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX, a->dw_attr_val.v.val_offset);
8724 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
8725 debug_ranges_section, "%s", name);
8726 *p = '\0';
8728 else
8729 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
8730 "%s (offset from %s)", name, ranges_section_label);
8733 /* Output the offset into the debug_loc section. */
8735 static void
8736 output_loc_list_offset (dw_attr_ref a)
8738 char *sym = AT_loc_list (a)->ll_symbol;
8740 gcc_assert (sym);
8741 if (dwarf_split_debug_info)
8742 dw2_asm_output_delta (DWARF_OFFSET_SIZE, sym, loc_section_label,
8743 "%s", dwarf_attr_name (a->dw_attr));
8744 else
8745 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section,
8746 "%s", dwarf_attr_name (a->dw_attr));
8749 /* Output an attribute's index or value appropriately. */
8751 static void
8752 output_attr_index_or_value (dw_attr_ref a)
8754 const char *name = dwarf_attr_name (a->dw_attr);
8756 if (dwarf_split_debug_info && AT_index (a) != NOT_INDEXED)
8758 dw2_asm_output_data_uleb128 (AT_index (a), "%s", name);
8759 return;
8761 switch (AT_class (a))
8763 case dw_val_class_addr:
8764 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
8765 break;
8766 case dw_val_class_high_pc:
8767 case dw_val_class_lbl_id:
8768 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
8769 break;
8770 case dw_val_class_loc_list:
8771 output_loc_list_offset (a);
8772 break;
8773 default:
8774 gcc_unreachable ();
8778 /* Output a type signature. */
8780 static inline void
8781 output_signature (const char *sig, const char *name)
8783 int i;
8785 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
8786 dw2_asm_output_data (1, sig[i], i == 0 ? "%s" : NULL, name);
8789 /* Output the DIE and its attributes. Called recursively to generate
8790 the definitions of each child DIE. */
8792 static void
8793 output_die (dw_die_ref die)
8795 dw_attr_ref a;
8796 dw_die_ref c;
8797 unsigned long size;
8798 unsigned ix;
8800 /* If someone in another CU might refer to us, set up a symbol for
8801 them to point to. */
8802 if (! die->comdat_type_p && die->die_id.die_symbol)
8803 output_die_symbol (die);
8805 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (%#lx) %s)",
8806 (unsigned long)die->die_offset,
8807 dwarf_tag_name (die->die_tag));
8809 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
8811 const char *name = dwarf_attr_name (a->dw_attr);
8813 switch (AT_class (a))
8815 case dw_val_class_addr:
8816 output_attr_index_or_value (a);
8817 break;
8819 case dw_val_class_offset:
8820 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
8821 "%s", name);
8822 break;
8824 case dw_val_class_range_list:
8825 output_range_list_offset (a);
8826 break;
8828 case dw_val_class_loc:
8829 size = size_of_locs (AT_loc (a));
8831 /* Output the block length for this list of location operations. */
8832 if (dwarf_version >= 4)
8833 dw2_asm_output_data_uleb128 (size, "%s", name);
8834 else
8835 dw2_asm_output_data (constant_size (size), size, "%s", name);
8837 output_loc_sequence (AT_loc (a), -1);
8838 break;
8840 case dw_val_class_const:
8841 /* ??? It would be slightly more efficient to use a scheme like is
8842 used for unsigned constants below, but gdb 4.x does not sign
8843 extend. Gdb 5.x does sign extend. */
8844 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
8845 break;
8847 case dw_val_class_unsigned_const:
8849 int csize = constant_size (AT_unsigned (a));
8850 if (dwarf_version == 3
8851 && a->dw_attr == DW_AT_data_member_location
8852 && csize >= 4)
8853 dw2_asm_output_data_uleb128 (AT_unsigned (a), "%s", name);
8854 else
8855 dw2_asm_output_data (csize, AT_unsigned (a), "%s", name);
8857 break;
8859 case dw_val_class_const_double:
8861 unsigned HOST_WIDE_INT first, second;
8863 if (HOST_BITS_PER_WIDE_INT >= 64)
8864 dw2_asm_output_data (1,
8865 HOST_BITS_PER_DOUBLE_INT
8866 / HOST_BITS_PER_CHAR,
8867 NULL);
8869 if (WORDS_BIG_ENDIAN)
8871 first = a->dw_attr_val.v.val_double.high;
8872 second = a->dw_attr_val.v.val_double.low;
8874 else
8876 first = a->dw_attr_val.v.val_double.low;
8877 second = a->dw_attr_val.v.val_double.high;
8880 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
8881 first, "%s", name);
8882 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
8883 second, NULL);
8885 break;
8887 case dw_val_class_wide_int:
8889 int i;
8890 int len = get_full_len (*a->dw_attr_val.v.val_wide);
8891 int l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
8892 if (len * HOST_BITS_PER_WIDE_INT > 64)
8893 dw2_asm_output_data (1, get_full_len (*a->dw_attr_val.v.val_wide) * l,
8894 NULL);
8896 if (WORDS_BIG_ENDIAN)
8897 for (i = len - 1; i >= 0; --i)
8899 dw2_asm_output_data (l, a->dw_attr_val.v.val_wide->elt (i),
8900 "%s", name);
8901 name = NULL;
8903 else
8904 for (i = 0; i < len; ++i)
8906 dw2_asm_output_data (l, a->dw_attr_val.v.val_wide->elt (i),
8907 "%s", name);
8908 name = NULL;
8911 break;
8913 case dw_val_class_vec:
8915 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
8916 unsigned int len = a->dw_attr_val.v.val_vec.length;
8917 unsigned int i;
8918 unsigned char *p;
8920 dw2_asm_output_data (constant_size (len * elt_size),
8921 len * elt_size, "%s", name);
8922 if (elt_size > sizeof (HOST_WIDE_INT))
8924 elt_size /= 2;
8925 len *= 2;
8927 for (i = 0, p = a->dw_attr_val.v.val_vec.array;
8928 i < len;
8929 i++, p += elt_size)
8930 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
8931 "fp or vector constant word %u", i);
8932 break;
8935 case dw_val_class_flag:
8936 if (dwarf_version >= 4)
8938 /* Currently all add_AT_flag calls pass in 1 as last argument,
8939 so DW_FORM_flag_present can be used. If that ever changes,
8940 we'll need to use DW_FORM_flag and have some optimization
8941 in build_abbrev_table that will change those to
8942 DW_FORM_flag_present if it is set to 1 in all DIEs using
8943 the same abbrev entry. */
8944 gcc_assert (AT_flag (a) == 1);
8945 if (flag_debug_asm)
8946 fprintf (asm_out_file, "\t\t\t%s %s\n",
8947 ASM_COMMENT_START, name);
8948 break;
8950 dw2_asm_output_data (1, AT_flag (a), "%s", name);
8951 break;
8953 case dw_val_class_loc_list:
8954 output_attr_index_or_value (a);
8955 break;
8957 case dw_val_class_die_ref:
8958 if (AT_ref_external (a))
8960 if (AT_ref (a)->comdat_type_p)
8962 comdat_type_node_ref type_node =
8963 AT_ref (a)->die_id.die_type_node;
8965 gcc_assert (type_node);
8966 output_signature (type_node->signature, name);
8968 else
8970 const char *sym = AT_ref (a)->die_id.die_symbol;
8971 int size;
8973 gcc_assert (sym);
8974 /* In DWARF2, DW_FORM_ref_addr is sized by target address
8975 length, whereas in DWARF3 it's always sized as an
8976 offset. */
8977 if (dwarf_version == 2)
8978 size = DWARF2_ADDR_SIZE;
8979 else
8980 size = DWARF_OFFSET_SIZE;
8981 dw2_asm_output_offset (size, sym, debug_info_section, "%s",
8982 name);
8985 else
8987 gcc_assert (AT_ref (a)->die_offset);
8988 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
8989 "%s", name);
8991 break;
8993 case dw_val_class_fde_ref:
8995 char l1[20];
8997 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
8998 a->dw_attr_val.v.val_fde_index * 2);
8999 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section,
9000 "%s", name);
9002 break;
9004 case dw_val_class_vms_delta:
9005 #ifdef ASM_OUTPUT_DWARF_VMS_DELTA
9006 dw2_asm_output_vms_delta (DWARF_OFFSET_SIZE,
9007 AT_vms_delta2 (a), AT_vms_delta1 (a),
9008 "%s", name);
9009 #else
9010 dw2_asm_output_delta (DWARF_OFFSET_SIZE,
9011 AT_vms_delta2 (a), AT_vms_delta1 (a),
9012 "%s", name);
9013 #endif
9014 break;
9016 case dw_val_class_lbl_id:
9017 output_attr_index_or_value (a);
9018 break;
9020 case dw_val_class_lineptr:
9021 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
9022 debug_line_section, "%s", name);
9023 break;
9025 case dw_val_class_macptr:
9026 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
9027 debug_macinfo_section, "%s", name);
9028 break;
9030 case dw_val_class_str:
9031 if (a->dw_attr_val.v.val_str->form == DW_FORM_strp)
9032 dw2_asm_output_offset (DWARF_OFFSET_SIZE,
9033 a->dw_attr_val.v.val_str->label,
9034 debug_str_section,
9035 "%s: \"%s\"", name, AT_string (a));
9036 else if (a->dw_attr_val.v.val_str->form == DW_FORM_GNU_str_index)
9037 dw2_asm_output_data_uleb128 (AT_index (a),
9038 "%s: \"%s\"", name, AT_string (a));
9039 else
9040 dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
9041 break;
9043 case dw_val_class_file:
9045 int f = maybe_emit_file (a->dw_attr_val.v.val_file);
9047 dw2_asm_output_data (constant_size (f), f, "%s (%s)", name,
9048 a->dw_attr_val.v.val_file->filename);
9049 break;
9052 case dw_val_class_data8:
9054 int i;
9056 for (i = 0; i < 8; i++)
9057 dw2_asm_output_data (1, a->dw_attr_val.v.val_data8[i],
9058 i == 0 ? "%s" : NULL, name);
9059 break;
9062 case dw_val_class_high_pc:
9063 dw2_asm_output_delta (DWARF2_ADDR_SIZE, AT_lbl (a),
9064 get_AT_low_pc (die), "DW_AT_high_pc");
9065 break;
9067 default:
9068 gcc_unreachable ();
9072 FOR_EACH_CHILD (die, c, output_die (c));
9074 /* Add null byte to terminate sibling list. */
9075 if (die->die_child != NULL)
9076 dw2_asm_output_data (1, 0, "end of children of DIE %#lx",
9077 (unsigned long) die->die_offset);
9080 /* Output the compilation unit that appears at the beginning of the
9081 .debug_info section, and precedes the DIE descriptions. */
9083 static void
9084 output_compilation_unit_header (void)
9086 /* We don't support actual DWARFv5 units yet, we just use some
9087 DWARFv5 draft DIE tags in DWARFv4 format. */
9088 int ver = dwarf_version < 5 ? dwarf_version : 4;
9090 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
9091 dw2_asm_output_data (4, 0xffffffff,
9092 "Initial length escape value indicating 64-bit DWARF extension");
9093 dw2_asm_output_data (DWARF_OFFSET_SIZE,
9094 next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
9095 "Length of Compilation Unit Info");
9096 dw2_asm_output_data (2, ver, "DWARF version number");
9097 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
9098 debug_abbrev_section,
9099 "Offset Into Abbrev. Section");
9100 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
9103 /* Output the compilation unit DIE and its children. */
9105 static void
9106 output_comp_unit (dw_die_ref die, int output_if_empty)
9108 const char *secname, *oldsym;
9109 char *tmp;
9111 /* Unless we are outputting main CU, we may throw away empty ones. */
9112 if (!output_if_empty && die->die_child == NULL)
9113 return;
9115 /* Even if there are no children of this DIE, we must output the information
9116 about the compilation unit. Otherwise, on an empty translation unit, we
9117 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
9118 will then complain when examining the file. First mark all the DIEs in
9119 this CU so we know which get local refs. */
9120 mark_dies (die);
9122 external_ref_hash_type *extern_map = optimize_external_refs (die);
9124 build_abbrev_table (die, extern_map);
9126 delete extern_map;
9128 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
9129 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
9130 calc_die_sizes (die);
9132 oldsym = die->die_id.die_symbol;
9133 if (oldsym)
9135 tmp = XALLOCAVEC (char, strlen (oldsym) + 24);
9137 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
9138 secname = tmp;
9139 die->die_id.die_symbol = NULL;
9140 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
9142 else
9144 switch_to_section (debug_info_section);
9145 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
9146 info_section_emitted = true;
9149 /* Output debugging information. */
9150 output_compilation_unit_header ();
9151 output_die (die);
9153 /* Leave the marks on the main CU, so we can check them in
9154 output_pubnames. */
9155 if (oldsym)
9157 unmark_dies (die);
9158 die->die_id.die_symbol = oldsym;
9162 /* Whether to generate the DWARF accelerator tables in .debug_pubnames
9163 and .debug_pubtypes. This is configured per-target, but can be
9164 overridden by the -gpubnames or -gno-pubnames options. */
9166 static inline bool
9167 want_pubnames (void)
9169 if (debug_info_level <= DINFO_LEVEL_TERSE)
9170 return false;
9171 if (debug_generate_pub_sections != -1)
9172 return debug_generate_pub_sections;
9173 return targetm.want_debug_pub_sections;
9176 /* Add the DW_AT_GNU_pubnames and DW_AT_GNU_pubtypes attributes. */
9178 static void
9179 add_AT_pubnames (dw_die_ref die)
9181 if (want_pubnames ())
9182 add_AT_flag (die, DW_AT_GNU_pubnames, 1);
9185 /* Add a string attribute value to a skeleton DIE. */
9187 static inline void
9188 add_skeleton_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind,
9189 const char *str)
9191 dw_attr_node attr;
9192 struct indirect_string_node *node;
9194 if (! skeleton_debug_str_hash)
9195 skeleton_debug_str_hash
9196 = hash_table<indirect_string_hasher>::create_ggc (10);
9198 node = find_AT_string_in_table (str, skeleton_debug_str_hash);
9199 find_string_form (node);
9200 if (node->form == DW_FORM_GNU_str_index)
9201 node->form = DW_FORM_strp;
9203 attr.dw_attr = attr_kind;
9204 attr.dw_attr_val.val_class = dw_val_class_str;
9205 attr.dw_attr_val.val_entry = NULL;
9206 attr.dw_attr_val.v.val_str = node;
9207 add_dwarf_attr (die, &attr);
9210 /* Helper function to generate top-level dies for skeleton debug_info and
9211 debug_types. */
9213 static void
9214 add_top_level_skeleton_die_attrs (dw_die_ref die)
9216 const char *dwo_file_name = concat (aux_base_name, ".dwo", NULL);
9217 const char *comp_dir = comp_dir_string ();
9219 add_skeleton_AT_string (die, DW_AT_GNU_dwo_name, dwo_file_name);
9220 if (comp_dir != NULL)
9221 add_skeleton_AT_string (die, DW_AT_comp_dir, comp_dir);
9222 add_AT_pubnames (die);
9223 add_AT_lineptr (die, DW_AT_GNU_addr_base, debug_addr_section_label);
9226 /* Output skeleton debug sections that point to the dwo file. */
9228 static void
9229 output_skeleton_debug_sections (dw_die_ref comp_unit)
9231 /* We don't support actual DWARFv5 units yet, we just use some
9232 DWARFv5 draft DIE tags in DWARFv4 format. */
9233 int ver = dwarf_version < 5 ? dwarf_version : 4;
9235 /* These attributes will be found in the full debug_info section. */
9236 remove_AT (comp_unit, DW_AT_producer);
9237 remove_AT (comp_unit, DW_AT_language);
9239 switch_to_section (debug_skeleton_info_section);
9240 ASM_OUTPUT_LABEL (asm_out_file, debug_skeleton_info_section_label);
9242 /* Produce the skeleton compilation-unit header. This one differs enough from
9243 a normal CU header that it's better not to call output_compilation_unit
9244 header. */
9245 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
9246 dw2_asm_output_data (4, 0xffffffff,
9247 "Initial length escape value indicating 64-bit DWARF extension");
9249 dw2_asm_output_data (DWARF_OFFSET_SIZE,
9250 DWARF_COMPILE_UNIT_HEADER_SIZE
9251 - DWARF_INITIAL_LENGTH_SIZE
9252 + size_of_die (comp_unit),
9253 "Length of Compilation Unit Info");
9254 dw2_asm_output_data (2, ver, "DWARF version number");
9255 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_skeleton_abbrev_section_label,
9256 debug_abbrev_section,
9257 "Offset Into Abbrev. Section");
9258 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
9260 comp_unit->die_abbrev = SKELETON_COMP_DIE_ABBREV;
9261 output_die (comp_unit);
9263 /* Build the skeleton debug_abbrev section. */
9264 switch_to_section (debug_skeleton_abbrev_section);
9265 ASM_OUTPUT_LABEL (asm_out_file, debug_skeleton_abbrev_section_label);
9267 output_die_abbrevs (SKELETON_COMP_DIE_ABBREV, comp_unit);
9269 dw2_asm_output_data (1, 0, "end of skeleton .debug_abbrev");
9272 /* Output a comdat type unit DIE and its children. */
9274 static void
9275 output_comdat_type_unit (comdat_type_node *node)
9277 const char *secname;
9278 char *tmp;
9279 int i;
9280 #if defined (OBJECT_FORMAT_ELF)
9281 tree comdat_key;
9282 #endif
9284 /* First mark all the DIEs in this CU so we know which get local refs. */
9285 mark_dies (node->root_die);
9287 external_ref_hash_type *extern_map = optimize_external_refs (node->root_die);
9289 build_abbrev_table (node->root_die, extern_map);
9291 delete extern_map;
9292 extern_map = NULL;
9294 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
9295 next_die_offset = DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE;
9296 calc_die_sizes (node->root_die);
9298 #if defined (OBJECT_FORMAT_ELF)
9299 if (!dwarf_split_debug_info)
9300 secname = ".debug_types";
9301 else
9302 secname = ".debug_types.dwo";
9304 tmp = XALLOCAVEC (char, 4 + DWARF_TYPE_SIGNATURE_SIZE * 2);
9305 sprintf (tmp, "wt.");
9306 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
9307 sprintf (tmp + 3 + i * 2, "%02x", node->signature[i] & 0xff);
9308 comdat_key = get_identifier (tmp);
9309 targetm.asm_out.named_section (secname,
9310 SECTION_DEBUG | SECTION_LINKONCE,
9311 comdat_key);
9312 #else
9313 tmp = XALLOCAVEC (char, 18 + DWARF_TYPE_SIGNATURE_SIZE * 2);
9314 sprintf (tmp, ".gnu.linkonce.wt.");
9315 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
9316 sprintf (tmp + 17 + i * 2, "%02x", node->signature[i] & 0xff);
9317 secname = tmp;
9318 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
9319 #endif
9321 /* Output debugging information. */
9322 output_compilation_unit_header ();
9323 output_signature (node->signature, "Type Signature");
9324 dw2_asm_output_data (DWARF_OFFSET_SIZE, node->type_die->die_offset,
9325 "Offset to Type DIE");
9326 output_die (node->root_die);
9328 unmark_dies (node->root_die);
9331 /* Return the DWARF2/3 pubname associated with a decl. */
9333 static const char *
9334 dwarf2_name (tree decl, int scope)
9336 if (DECL_NAMELESS (decl))
9337 return NULL;
9338 return lang_hooks.dwarf_name (decl, scope ? 1 : 0);
9341 /* Add a new entry to .debug_pubnames if appropriate. */
9343 static void
9344 add_pubname_string (const char *str, dw_die_ref die)
9346 pubname_entry e;
9348 e.die = die;
9349 e.name = xstrdup (str);
9350 vec_safe_push (pubname_table, e);
9353 static void
9354 add_pubname (tree decl, dw_die_ref die)
9356 if (!want_pubnames ())
9357 return;
9359 /* Don't add items to the table when we expect that the consumer will have
9360 just read the enclosing die. For example, if the consumer is looking at a
9361 class_member, it will either be inside the class already, or will have just
9362 looked up the class to find the member. Either way, searching the class is
9363 faster than searching the index. */
9364 if ((TREE_PUBLIC (decl) && !class_scope_p (die->die_parent))
9365 || is_cu_die (die->die_parent) || is_namespace_die (die->die_parent))
9367 const char *name = dwarf2_name (decl, 1);
9369 if (name)
9370 add_pubname_string (name, die);
9374 /* Add an enumerator to the pubnames section. */
9376 static void
9377 add_enumerator_pubname (const char *scope_name, dw_die_ref die)
9379 pubname_entry e;
9381 gcc_assert (scope_name);
9382 e.name = concat (scope_name, get_AT_string (die, DW_AT_name), NULL);
9383 e.die = die;
9384 vec_safe_push (pubname_table, e);
9387 /* Add a new entry to .debug_pubtypes if appropriate. */
9389 static void
9390 add_pubtype (tree decl, dw_die_ref die)
9392 pubname_entry e;
9394 if (!want_pubnames ())
9395 return;
9397 if ((TREE_PUBLIC (decl)
9398 || is_cu_die (die->die_parent) || is_namespace_die (die->die_parent))
9399 && (die->die_tag == DW_TAG_typedef || COMPLETE_TYPE_P (decl)))
9401 tree scope = NULL;
9402 const char *scope_name = "";
9403 const char *sep = is_cxx () ? "::" : ".";
9404 const char *name;
9406 scope = TYPE_P (decl) ? TYPE_CONTEXT (decl) : NULL;
9407 if (scope && TREE_CODE (scope) == NAMESPACE_DECL)
9409 scope_name = lang_hooks.dwarf_name (scope, 1);
9410 if (scope_name != NULL && scope_name[0] != '\0')
9411 scope_name = concat (scope_name, sep, NULL);
9412 else
9413 scope_name = "";
9416 if (TYPE_P (decl))
9417 name = type_tag (decl);
9418 else
9419 name = lang_hooks.dwarf_name (decl, 1);
9421 /* If we don't have a name for the type, there's no point in adding
9422 it to the table. */
9423 if (name != NULL && name[0] != '\0')
9425 e.die = die;
9426 e.name = concat (scope_name, name, NULL);
9427 vec_safe_push (pubtype_table, e);
9430 /* Although it might be more consistent to add the pubinfo for the
9431 enumerators as their dies are created, they should only be added if the
9432 enum type meets the criteria above. So rather than re-check the parent
9433 enum type whenever an enumerator die is created, just output them all
9434 here. This isn't protected by the name conditional because anonymous
9435 enums don't have names. */
9436 if (die->die_tag == DW_TAG_enumeration_type)
9438 dw_die_ref c;
9440 FOR_EACH_CHILD (die, c, add_enumerator_pubname (scope_name, c));
9445 /* Output a single entry in the pubnames table. */
9447 static void
9448 output_pubname (dw_offset die_offset, pubname_entry *entry)
9450 dw_die_ref die = entry->die;
9451 int is_static = get_AT_flag (die, DW_AT_external) ? 0 : 1;
9453 dw2_asm_output_data (DWARF_OFFSET_SIZE, die_offset, "DIE offset");
9455 if (debug_generate_pub_sections == 2)
9457 /* This logic follows gdb's method for determining the value of the flag
9458 byte. */
9459 uint32_t flags = GDB_INDEX_SYMBOL_KIND_NONE;
9460 switch (die->die_tag)
9462 case DW_TAG_typedef:
9463 case DW_TAG_base_type:
9464 case DW_TAG_subrange_type:
9465 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags, GDB_INDEX_SYMBOL_KIND_TYPE);
9466 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, 1);
9467 break;
9468 case DW_TAG_enumerator:
9469 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags,
9470 GDB_INDEX_SYMBOL_KIND_VARIABLE);
9471 if (!is_cxx () && !is_java ())
9472 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, 1);
9473 break;
9474 case DW_TAG_subprogram:
9475 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags,
9476 GDB_INDEX_SYMBOL_KIND_FUNCTION);
9477 if (!is_ada ())
9478 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, is_static);
9479 break;
9480 case DW_TAG_constant:
9481 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags,
9482 GDB_INDEX_SYMBOL_KIND_VARIABLE);
9483 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, is_static);
9484 break;
9485 case DW_TAG_variable:
9486 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags,
9487 GDB_INDEX_SYMBOL_KIND_VARIABLE);
9488 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, is_static);
9489 break;
9490 case DW_TAG_namespace:
9491 case DW_TAG_imported_declaration:
9492 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags, GDB_INDEX_SYMBOL_KIND_TYPE);
9493 break;
9494 case DW_TAG_class_type:
9495 case DW_TAG_interface_type:
9496 case DW_TAG_structure_type:
9497 case DW_TAG_union_type:
9498 case DW_TAG_enumeration_type:
9499 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags, GDB_INDEX_SYMBOL_KIND_TYPE);
9500 if (!is_cxx () && !is_java ())
9501 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, 1);
9502 break;
9503 default:
9504 /* An unusual tag. Leave the flag-byte empty. */
9505 break;
9507 dw2_asm_output_data (1, flags >> GDB_INDEX_CU_BITSIZE,
9508 "GDB-index flags");
9511 dw2_asm_output_nstring (entry->name, -1, "external name");
9515 /* Output the public names table used to speed up access to externally
9516 visible names; or the public types table used to find type definitions. */
9518 static void
9519 output_pubnames (vec<pubname_entry, va_gc> *names)
9521 unsigned i;
9522 unsigned long pubnames_length = size_of_pubnames (names);
9523 pubname_ref pub;
9525 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
9526 dw2_asm_output_data (4, 0xffffffff,
9527 "Initial length escape value indicating 64-bit DWARF extension");
9528 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length, "Pub Info Length");
9530 /* Version number for pubnames/pubtypes is independent of dwarf version. */
9531 dw2_asm_output_data (2, 2, "DWARF Version");
9533 if (dwarf_split_debug_info)
9534 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_skeleton_info_section_label,
9535 debug_skeleton_info_section,
9536 "Offset of Compilation Unit Info");
9537 else
9538 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
9539 debug_info_section,
9540 "Offset of Compilation Unit Info");
9541 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
9542 "Compilation Unit Length");
9544 FOR_EACH_VEC_ELT (*names, i, pub)
9546 if (include_pubname_in_output (names, pub))
9548 dw_offset die_offset = pub->die->die_offset;
9550 /* We shouldn't see pubnames for DIEs outside of the main CU. */
9551 if (names == pubname_table && pub->die->die_tag != DW_TAG_enumerator)
9552 gcc_assert (pub->die->die_mark);
9554 /* If we're putting types in their own .debug_types sections,
9555 the .debug_pubtypes table will still point to the compile
9556 unit (not the type unit), so we want to use the offset of
9557 the skeleton DIE (if there is one). */
9558 if (pub->die->comdat_type_p && names == pubtype_table)
9560 comdat_type_node_ref type_node = pub->die->die_id.die_type_node;
9562 if (type_node != NULL)
9563 die_offset = (type_node->skeleton_die != NULL
9564 ? type_node->skeleton_die->die_offset
9565 : comp_unit_die ()->die_offset);
9568 output_pubname (die_offset, pub);
9572 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
9575 /* Output public names and types tables if necessary. */
9577 static void
9578 output_pubtables (void)
9580 if (!want_pubnames () || !info_section_emitted)
9581 return;
9583 switch_to_section (debug_pubnames_section);
9584 output_pubnames (pubname_table);
9585 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
9586 It shouldn't hurt to emit it always, since pure DWARF2 consumers
9587 simply won't look for the section. */
9588 switch_to_section (debug_pubtypes_section);
9589 output_pubnames (pubtype_table);
9593 /* Output the information that goes into the .debug_aranges table.
9594 Namely, define the beginning and ending address range of the
9595 text section generated for this compilation unit. */
9597 static void
9598 output_aranges (unsigned long aranges_length)
9600 unsigned i;
9602 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
9603 dw2_asm_output_data (4, 0xffffffff,
9604 "Initial length escape value indicating 64-bit DWARF extension");
9605 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
9606 "Length of Address Ranges Info");
9607 /* Version number for aranges is still 2, even up to DWARF5. */
9608 dw2_asm_output_data (2, 2, "DWARF Version");
9609 if (dwarf_split_debug_info)
9610 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_skeleton_info_section_label,
9611 debug_skeleton_info_section,
9612 "Offset of Compilation Unit Info");
9613 else
9614 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
9615 debug_info_section,
9616 "Offset of Compilation Unit Info");
9617 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
9618 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
9620 /* We need to align to twice the pointer size here. */
9621 if (DWARF_ARANGES_PAD_SIZE)
9623 /* Pad using a 2 byte words so that padding is correct for any
9624 pointer size. */
9625 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
9626 2 * DWARF2_ADDR_SIZE);
9627 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
9628 dw2_asm_output_data (2, 0, NULL);
9631 /* It is necessary not to output these entries if the sections were
9632 not used; if the sections were not used, the length will be 0 and
9633 the address may end up as 0 if the section is discarded by ld
9634 --gc-sections, leaving an invalid (0, 0) entry that can be
9635 confused with the terminator. */
9636 if (text_section_used)
9638 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
9639 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
9640 text_section_label, "Length");
9642 if (cold_text_section_used)
9644 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
9645 "Address");
9646 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
9647 cold_text_section_label, "Length");
9650 if (have_multiple_function_sections)
9652 unsigned fde_idx;
9653 dw_fde_ref fde;
9655 FOR_EACH_VEC_ELT (*fde_vec, fde_idx, fde)
9657 if (DECL_IGNORED_P (fde->decl))
9658 continue;
9659 if (!fde->in_std_section)
9661 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin,
9662 "Address");
9663 dw2_asm_output_delta (DWARF2_ADDR_SIZE, fde->dw_fde_end,
9664 fde->dw_fde_begin, "Length");
9666 if (fde->dw_fde_second_begin && !fde->second_in_std_section)
9668 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_second_begin,
9669 "Address");
9670 dw2_asm_output_delta (DWARF2_ADDR_SIZE, fde->dw_fde_second_end,
9671 fde->dw_fde_second_begin, "Length");
9676 /* Output the terminator words. */
9677 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
9678 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
9681 /* Add a new entry to .debug_ranges. Return the offset at which it
9682 was placed. */
9684 static unsigned int
9685 add_ranges_num (int num)
9687 unsigned int in_use = ranges_table_in_use;
9689 if (in_use == ranges_table_allocated)
9691 ranges_table_allocated += RANGES_TABLE_INCREMENT;
9692 ranges_table = GGC_RESIZEVEC (struct dw_ranges_struct, ranges_table,
9693 ranges_table_allocated);
9694 memset (ranges_table + ranges_table_in_use, 0,
9695 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
9698 ranges_table[in_use].num = num;
9699 ranges_table_in_use = in_use + 1;
9701 return in_use * 2 * DWARF2_ADDR_SIZE;
9704 /* Add a new entry to .debug_ranges corresponding to a block, or a
9705 range terminator if BLOCK is NULL. */
9707 static unsigned int
9708 add_ranges (const_tree block)
9710 return add_ranges_num (block ? BLOCK_NUMBER (block) : 0);
9713 /* Add a new entry to .debug_ranges corresponding to a pair of labels.
9714 When using dwarf_split_debug_info, address attributes in dies destined
9715 for the final executable should be direct references--setting the
9716 parameter force_direct ensures this behavior. */
9718 static void
9719 add_ranges_by_labels (dw_die_ref die, const char *begin, const char *end,
9720 bool *added, bool force_direct)
9722 unsigned int in_use = ranges_by_label_in_use;
9723 unsigned int offset;
9725 if (in_use == ranges_by_label_allocated)
9727 ranges_by_label_allocated += RANGES_TABLE_INCREMENT;
9728 ranges_by_label = GGC_RESIZEVEC (struct dw_ranges_by_label_struct,
9729 ranges_by_label,
9730 ranges_by_label_allocated);
9731 memset (ranges_by_label + ranges_by_label_in_use, 0,
9732 RANGES_TABLE_INCREMENT
9733 * sizeof (struct dw_ranges_by_label_struct));
9736 ranges_by_label[in_use].begin = begin;
9737 ranges_by_label[in_use].end = end;
9738 ranges_by_label_in_use = in_use + 1;
9740 offset = add_ranges_num (-(int)in_use - 1);
9741 if (!*added)
9743 add_AT_range_list (die, DW_AT_ranges, offset, force_direct);
9744 *added = true;
9748 static void
9749 output_ranges (void)
9751 unsigned i;
9752 static const char *const start_fmt = "Offset %#x";
9753 const char *fmt = start_fmt;
9755 for (i = 0; i < ranges_table_in_use; i++)
9757 int block_num = ranges_table[i].num;
9759 if (block_num > 0)
9761 char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
9762 char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
9764 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
9765 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
9767 /* If all code is in the text section, then the compilation
9768 unit base address defaults to DW_AT_low_pc, which is the
9769 base of the text section. */
9770 if (!have_multiple_function_sections)
9772 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
9773 text_section_label,
9774 fmt, i * 2 * DWARF2_ADDR_SIZE);
9775 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
9776 text_section_label, NULL);
9779 /* Otherwise, the compilation unit base address is zero,
9780 which allows us to use absolute addresses, and not worry
9781 about whether the target supports cross-section
9782 arithmetic. */
9783 else
9785 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
9786 fmt, i * 2 * DWARF2_ADDR_SIZE);
9787 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
9790 fmt = NULL;
9793 /* Negative block_num stands for an index into ranges_by_label. */
9794 else if (block_num < 0)
9796 int lab_idx = - block_num - 1;
9798 if (!have_multiple_function_sections)
9800 gcc_unreachable ();
9801 #if 0
9802 /* If we ever use add_ranges_by_labels () for a single
9803 function section, all we have to do is to take out
9804 the #if 0 above. */
9805 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
9806 ranges_by_label[lab_idx].begin,
9807 text_section_label,
9808 fmt, i * 2 * DWARF2_ADDR_SIZE);
9809 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
9810 ranges_by_label[lab_idx].end,
9811 text_section_label, NULL);
9812 #endif
9814 else
9816 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
9817 ranges_by_label[lab_idx].begin,
9818 fmt, i * 2 * DWARF2_ADDR_SIZE);
9819 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
9820 ranges_by_label[lab_idx].end,
9821 NULL);
9824 else
9826 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
9827 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
9828 fmt = start_fmt;
9833 /* Data structure containing information about input files. */
9834 struct file_info
9836 const char *path; /* Complete file name. */
9837 const char *fname; /* File name part. */
9838 int length; /* Length of entire string. */
9839 struct dwarf_file_data * file_idx; /* Index in input file table. */
9840 int dir_idx; /* Index in directory table. */
9843 /* Data structure containing information about directories with source
9844 files. */
9845 struct dir_info
9847 const char *path; /* Path including directory name. */
9848 int length; /* Path length. */
9849 int prefix; /* Index of directory entry which is a prefix. */
9850 int count; /* Number of files in this directory. */
9851 int dir_idx; /* Index of directory used as base. */
9854 /* Callback function for file_info comparison. We sort by looking at
9855 the directories in the path. */
9857 static int
9858 file_info_cmp (const void *p1, const void *p2)
9860 const struct file_info *const s1 = (const struct file_info *) p1;
9861 const struct file_info *const s2 = (const struct file_info *) p2;
9862 const unsigned char *cp1;
9863 const unsigned char *cp2;
9865 /* Take care of file names without directories. We need to make sure that
9866 we return consistent values to qsort since some will get confused if
9867 we return the same value when identical operands are passed in opposite
9868 orders. So if neither has a directory, return 0 and otherwise return
9869 1 or -1 depending on which one has the directory. */
9870 if ((s1->path == s1->fname || s2->path == s2->fname))
9871 return (s2->path == s2->fname) - (s1->path == s1->fname);
9873 cp1 = (const unsigned char *) s1->path;
9874 cp2 = (const unsigned char *) s2->path;
9876 while (1)
9878 ++cp1;
9879 ++cp2;
9880 /* Reached the end of the first path? If so, handle like above. */
9881 if ((cp1 == (const unsigned char *) s1->fname)
9882 || (cp2 == (const unsigned char *) s2->fname))
9883 return ((cp2 == (const unsigned char *) s2->fname)
9884 - (cp1 == (const unsigned char *) s1->fname));
9886 /* Character of current path component the same? */
9887 else if (*cp1 != *cp2)
9888 return *cp1 - *cp2;
9892 struct file_name_acquire_data
9894 struct file_info *files;
9895 int used_files;
9896 int max_files;
9899 /* Traversal function for the hash table. */
9902 file_name_acquire (dwarf_file_data **slot, file_name_acquire_data *fnad)
9904 struct dwarf_file_data *d = *slot;
9905 struct file_info *fi;
9906 const char *f;
9908 gcc_assert (fnad->max_files >= d->emitted_number);
9910 if (! d->emitted_number)
9911 return 1;
9913 gcc_assert (fnad->max_files != fnad->used_files);
9915 fi = fnad->files + fnad->used_files++;
9917 /* Skip all leading "./". */
9918 f = d->filename;
9919 while (f[0] == '.' && IS_DIR_SEPARATOR (f[1]))
9920 f += 2;
9922 /* Create a new array entry. */
9923 fi->path = f;
9924 fi->length = strlen (f);
9925 fi->file_idx = d;
9927 /* Search for the file name part. */
9928 f = strrchr (f, DIR_SEPARATOR);
9929 #if defined (DIR_SEPARATOR_2)
9931 char *g = strrchr (fi->path, DIR_SEPARATOR_2);
9933 if (g != NULL)
9935 if (f == NULL || f < g)
9936 f = g;
9939 #endif
9941 fi->fname = f == NULL ? fi->path : f + 1;
9942 return 1;
9945 /* Output the directory table and the file name table. We try to minimize
9946 the total amount of memory needed. A heuristic is used to avoid large
9947 slowdowns with many input files. */
9949 static void
9950 output_file_names (void)
9952 struct file_name_acquire_data fnad;
9953 int numfiles;
9954 struct file_info *files;
9955 struct dir_info *dirs;
9956 int *saved;
9957 int *savehere;
9958 int *backmap;
9959 int ndirs;
9960 int idx_offset;
9961 int i;
9963 if (!last_emitted_file)
9965 dw2_asm_output_data (1, 0, "End directory table");
9966 dw2_asm_output_data (1, 0, "End file name table");
9967 return;
9970 numfiles = last_emitted_file->emitted_number;
9972 /* Allocate the various arrays we need. */
9973 files = XALLOCAVEC (struct file_info, numfiles);
9974 dirs = XALLOCAVEC (struct dir_info, numfiles);
9976 fnad.files = files;
9977 fnad.used_files = 0;
9978 fnad.max_files = numfiles;
9979 file_table->traverse<file_name_acquire_data *, file_name_acquire> (&fnad);
9980 gcc_assert (fnad.used_files == fnad.max_files);
9982 qsort (files, numfiles, sizeof (files[0]), file_info_cmp);
9984 /* Find all the different directories used. */
9985 dirs[0].path = files[0].path;
9986 dirs[0].length = files[0].fname - files[0].path;
9987 dirs[0].prefix = -1;
9988 dirs[0].count = 1;
9989 dirs[0].dir_idx = 0;
9990 files[0].dir_idx = 0;
9991 ndirs = 1;
9993 for (i = 1; i < numfiles; i++)
9994 if (files[i].fname - files[i].path == dirs[ndirs - 1].length
9995 && memcmp (dirs[ndirs - 1].path, files[i].path,
9996 dirs[ndirs - 1].length) == 0)
9998 /* Same directory as last entry. */
9999 files[i].dir_idx = ndirs - 1;
10000 ++dirs[ndirs - 1].count;
10002 else
10004 int j;
10006 /* This is a new directory. */
10007 dirs[ndirs].path = files[i].path;
10008 dirs[ndirs].length = files[i].fname - files[i].path;
10009 dirs[ndirs].count = 1;
10010 dirs[ndirs].dir_idx = ndirs;
10011 files[i].dir_idx = ndirs;
10013 /* Search for a prefix. */
10014 dirs[ndirs].prefix = -1;
10015 for (j = 0; j < ndirs; j++)
10016 if (dirs[j].length < dirs[ndirs].length
10017 && dirs[j].length > 1
10018 && (dirs[ndirs].prefix == -1
10019 || dirs[j].length > dirs[dirs[ndirs].prefix].length)
10020 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
10021 dirs[ndirs].prefix = j;
10023 ++ndirs;
10026 /* Now to the actual work. We have to find a subset of the directories which
10027 allow expressing the file name using references to the directory table
10028 with the least amount of characters. We do not do an exhaustive search
10029 where we would have to check out every combination of every single
10030 possible prefix. Instead we use a heuristic which provides nearly optimal
10031 results in most cases and never is much off. */
10032 saved = XALLOCAVEC (int, ndirs);
10033 savehere = XALLOCAVEC (int, ndirs);
10035 memset (saved, '\0', ndirs * sizeof (saved[0]));
10036 for (i = 0; i < ndirs; i++)
10038 int j;
10039 int total;
10041 /* We can always save some space for the current directory. But this
10042 does not mean it will be enough to justify adding the directory. */
10043 savehere[i] = dirs[i].length;
10044 total = (savehere[i] - saved[i]) * dirs[i].count;
10046 for (j = i + 1; j < ndirs; j++)
10048 savehere[j] = 0;
10049 if (saved[j] < dirs[i].length)
10051 /* Determine whether the dirs[i] path is a prefix of the
10052 dirs[j] path. */
10053 int k;
10055 k = dirs[j].prefix;
10056 while (k != -1 && k != (int) i)
10057 k = dirs[k].prefix;
10059 if (k == (int) i)
10061 /* Yes it is. We can possibly save some memory by
10062 writing the filenames in dirs[j] relative to
10063 dirs[i]. */
10064 savehere[j] = dirs[i].length;
10065 total += (savehere[j] - saved[j]) * dirs[j].count;
10070 /* Check whether we can save enough to justify adding the dirs[i]
10071 directory. */
10072 if (total > dirs[i].length + 1)
10074 /* It's worthwhile adding. */
10075 for (j = i; j < ndirs; j++)
10076 if (savehere[j] > 0)
10078 /* Remember how much we saved for this directory so far. */
10079 saved[j] = savehere[j];
10081 /* Remember the prefix directory. */
10082 dirs[j].dir_idx = i;
10087 /* Emit the directory name table. */
10088 idx_offset = dirs[0].length > 0 ? 1 : 0;
10089 for (i = 1 - idx_offset; i < ndirs; i++)
10090 dw2_asm_output_nstring (dirs[i].path,
10091 dirs[i].length
10092 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR,
10093 "Directory Entry: %#x", i + idx_offset);
10095 dw2_asm_output_data (1, 0, "End directory table");
10097 /* We have to emit them in the order of emitted_number since that's
10098 used in the debug info generation. To do this efficiently we
10099 generate a back-mapping of the indices first. */
10100 backmap = XALLOCAVEC (int, numfiles);
10101 for (i = 0; i < numfiles; i++)
10102 backmap[files[i].file_idx->emitted_number - 1] = i;
10104 /* Now write all the file names. */
10105 for (i = 0; i < numfiles; i++)
10107 int file_idx = backmap[i];
10108 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
10110 #ifdef VMS_DEBUGGING_INFO
10111 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
10113 /* Setting these fields can lead to debugger miscomparisons,
10114 but VMS Debug requires them to be set correctly. */
10116 int ver;
10117 long long cdt;
10118 long siz;
10119 int maxfilelen = strlen (files[file_idx].path)
10120 + dirs[dir_idx].length
10121 + MAX_VMS_VERSION_LEN + 1;
10122 char *filebuf = XALLOCAVEC (char, maxfilelen);
10124 vms_file_stats_name (files[file_idx].path, 0, 0, 0, &ver);
10125 snprintf (filebuf, maxfilelen, "%s;%d",
10126 files[file_idx].path + dirs[dir_idx].length, ver);
10128 dw2_asm_output_nstring
10129 (filebuf, -1, "File Entry: %#x", (unsigned) i + 1);
10131 /* Include directory index. */
10132 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
10134 /* Modification time. */
10135 dw2_asm_output_data_uleb128
10136 ((vms_file_stats_name (files[file_idx].path, &cdt, 0, 0, 0) == 0)
10137 ? cdt : 0,
10138 NULL);
10140 /* File length in bytes. */
10141 dw2_asm_output_data_uleb128
10142 ((vms_file_stats_name (files[file_idx].path, 0, &siz, 0, 0) == 0)
10143 ? siz : 0,
10144 NULL);
10145 #else
10146 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
10147 "File Entry: %#x", (unsigned) i + 1);
10149 /* Include directory index. */
10150 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
10152 /* Modification time. */
10153 dw2_asm_output_data_uleb128 (0, NULL);
10155 /* File length in bytes. */
10156 dw2_asm_output_data_uleb128 (0, NULL);
10157 #endif /* VMS_DEBUGGING_INFO */
10160 dw2_asm_output_data (1, 0, "End file name table");
10164 /* Output one line number table into the .debug_line section. */
10166 static void
10167 output_one_line_info_table (dw_line_info_table *table)
10169 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
10170 unsigned int current_line = 1;
10171 bool current_is_stmt = DWARF_LINE_DEFAULT_IS_STMT_START;
10172 dw_line_info_entry *ent;
10173 size_t i;
10175 FOR_EACH_VEC_SAFE_ELT (table->entries, i, ent)
10177 switch (ent->opcode)
10179 case LI_set_address:
10180 /* ??? Unfortunately, we have little choice here currently, and
10181 must always use the most general form. GCC does not know the
10182 address delta itself, so we can't use DW_LNS_advance_pc. Many
10183 ports do have length attributes which will give an upper bound
10184 on the address range. We could perhaps use length attributes
10185 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
10186 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, ent->val);
10188 /* This can handle any delta. This takes
10189 4+DWARF2_ADDR_SIZE bytes. */
10190 dw2_asm_output_data (1, 0, "set address %s", line_label);
10191 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
10192 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
10193 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
10194 break;
10196 case LI_set_line:
10197 if (ent->val == current_line)
10199 /* We still need to start a new row, so output a copy insn. */
10200 dw2_asm_output_data (1, DW_LNS_copy,
10201 "copy line %u", current_line);
10203 else
10205 int line_offset = ent->val - current_line;
10206 int line_delta = line_offset - DWARF_LINE_BASE;
10208 current_line = ent->val;
10209 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
10211 /* This can handle deltas from -10 to 234, using the current
10212 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.
10213 This takes 1 byte. */
10214 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
10215 "line %u", current_line);
10217 else
10219 /* This can handle any delta. This takes at least 4 bytes,
10220 depending on the value being encoded. */
10221 dw2_asm_output_data (1, DW_LNS_advance_line,
10222 "advance to line %u", current_line);
10223 dw2_asm_output_data_sleb128 (line_offset, NULL);
10224 dw2_asm_output_data (1, DW_LNS_copy, NULL);
10227 break;
10229 case LI_set_file:
10230 dw2_asm_output_data (1, DW_LNS_set_file, "set file %u", ent->val);
10231 dw2_asm_output_data_uleb128 (ent->val, "%u", ent->val);
10232 break;
10234 case LI_set_column:
10235 dw2_asm_output_data (1, DW_LNS_set_column, "column %u", ent->val);
10236 dw2_asm_output_data_uleb128 (ent->val, "%u", ent->val);
10237 break;
10239 case LI_negate_stmt:
10240 current_is_stmt = !current_is_stmt;
10241 dw2_asm_output_data (1, DW_LNS_negate_stmt,
10242 "is_stmt %d", current_is_stmt);
10243 break;
10245 case LI_set_prologue_end:
10246 dw2_asm_output_data (1, DW_LNS_set_prologue_end,
10247 "set prologue end");
10248 break;
10250 case LI_set_epilogue_begin:
10251 dw2_asm_output_data (1, DW_LNS_set_epilogue_begin,
10252 "set epilogue begin");
10253 break;
10255 case LI_set_discriminator:
10256 dw2_asm_output_data (1, 0, "discriminator %u", ent->val);
10257 dw2_asm_output_data_uleb128 (1 + size_of_uleb128 (ent->val), NULL);
10258 dw2_asm_output_data (1, DW_LNE_set_discriminator, NULL);
10259 dw2_asm_output_data_uleb128 (ent->val, NULL);
10260 break;
10264 /* Emit debug info for the address of the end of the table. */
10265 dw2_asm_output_data (1, 0, "set address %s", table->end_label);
10266 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
10267 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
10268 dw2_asm_output_addr (DWARF2_ADDR_SIZE, table->end_label, NULL);
10270 dw2_asm_output_data (1, 0, "end sequence");
10271 dw2_asm_output_data_uleb128 (1, NULL);
10272 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
10275 /* Output the source line number correspondence information. This
10276 information goes into the .debug_line section. */
10278 static void
10279 output_line_info (bool prologue_only)
10281 char l1[20], l2[20], p1[20], p2[20];
10282 /* We don't support DWARFv5 line tables yet. */
10283 int ver = dwarf_version < 5 ? dwarf_version : 4;
10284 bool saw_one = false;
10285 int opc;
10287 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
10288 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
10289 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
10290 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
10292 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
10293 dw2_asm_output_data (4, 0xffffffff,
10294 "Initial length escape value indicating 64-bit DWARF extension");
10295 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
10296 "Length of Source Line Info");
10297 ASM_OUTPUT_LABEL (asm_out_file, l1);
10299 dw2_asm_output_data (2, ver, "DWARF Version");
10300 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
10301 ASM_OUTPUT_LABEL (asm_out_file, p1);
10303 /* Define the architecture-dependent minimum instruction length (in bytes).
10304 In this implementation of DWARF, this field is used for information
10305 purposes only. Since GCC generates assembly language, we have no
10306 a priori knowledge of how many instruction bytes are generated for each
10307 source line, and therefore can use only the DW_LNE_set_address and
10308 DW_LNS_fixed_advance_pc line information commands. Accordingly, we fix
10309 this as '1', which is "correct enough" for all architectures,
10310 and don't let the target override. */
10311 dw2_asm_output_data (1, 1, "Minimum Instruction Length");
10313 if (ver >= 4)
10314 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN,
10315 "Maximum Operations Per Instruction");
10316 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
10317 "Default is_stmt_start flag");
10318 dw2_asm_output_data (1, DWARF_LINE_BASE,
10319 "Line Base Value (Special Opcodes)");
10320 dw2_asm_output_data (1, DWARF_LINE_RANGE,
10321 "Line Range Value (Special Opcodes)");
10322 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
10323 "Special Opcode Base");
10325 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
10327 int n_op_args;
10328 switch (opc)
10330 case DW_LNS_advance_pc:
10331 case DW_LNS_advance_line:
10332 case DW_LNS_set_file:
10333 case DW_LNS_set_column:
10334 case DW_LNS_fixed_advance_pc:
10335 case DW_LNS_set_isa:
10336 n_op_args = 1;
10337 break;
10338 default:
10339 n_op_args = 0;
10340 break;
10343 dw2_asm_output_data (1, n_op_args, "opcode: %#x has %d args",
10344 opc, n_op_args);
10347 /* Write out the information about the files we use. */
10348 output_file_names ();
10349 ASM_OUTPUT_LABEL (asm_out_file, p2);
10350 if (prologue_only)
10352 /* Output the marker for the end of the line number info. */
10353 ASM_OUTPUT_LABEL (asm_out_file, l2);
10354 return;
10357 if (separate_line_info)
10359 dw_line_info_table *table;
10360 size_t i;
10362 FOR_EACH_VEC_ELT (*separate_line_info, i, table)
10363 if (table->in_use)
10365 output_one_line_info_table (table);
10366 saw_one = true;
10369 if (cold_text_section_line_info && cold_text_section_line_info->in_use)
10371 output_one_line_info_table (cold_text_section_line_info);
10372 saw_one = true;
10375 /* ??? Some Darwin linkers crash on a .debug_line section with no
10376 sequences. Further, merely a DW_LNE_end_sequence entry is not
10377 sufficient -- the address column must also be initialized.
10378 Make sure to output at least one set_address/end_sequence pair,
10379 choosing .text since that section is always present. */
10380 if (text_section_line_info->in_use || !saw_one)
10381 output_one_line_info_table (text_section_line_info);
10383 /* Output the marker for the end of the line number info. */
10384 ASM_OUTPUT_LABEL (asm_out_file, l2);
10387 /* Given a pointer to a tree node for some base type, return a pointer to
10388 a DIE that describes the given type.
10390 This routine must only be called for GCC type nodes that correspond to
10391 Dwarf base (fundamental) types. */
10393 static dw_die_ref
10394 base_type_die (tree type)
10396 dw_die_ref base_type_result;
10397 enum dwarf_type encoding;
10399 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
10400 return 0;
10402 /* If this is a subtype that should not be emitted as a subrange type,
10403 use the base type. See subrange_type_for_debug_p. */
10404 if (TREE_CODE (type) == INTEGER_TYPE && TREE_TYPE (type) != NULL_TREE)
10405 type = TREE_TYPE (type);
10407 switch (TREE_CODE (type))
10409 case INTEGER_TYPE:
10410 if ((dwarf_version >= 4 || !dwarf_strict)
10411 && TYPE_NAME (type)
10412 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10413 && DECL_IS_BUILTIN (TYPE_NAME (type))
10414 && DECL_NAME (TYPE_NAME (type)))
10416 const char *name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
10417 if (strcmp (name, "char16_t") == 0
10418 || strcmp (name, "char32_t") == 0)
10420 encoding = DW_ATE_UTF;
10421 break;
10424 if (TYPE_STRING_FLAG (type))
10426 if (TYPE_UNSIGNED (type))
10427 encoding = DW_ATE_unsigned_char;
10428 else
10429 encoding = DW_ATE_signed_char;
10431 else if (TYPE_UNSIGNED (type))
10432 encoding = DW_ATE_unsigned;
10433 else
10434 encoding = DW_ATE_signed;
10435 break;
10437 case REAL_TYPE:
10438 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
10440 if (dwarf_version >= 3 || !dwarf_strict)
10441 encoding = DW_ATE_decimal_float;
10442 else
10443 encoding = DW_ATE_lo_user;
10445 else
10446 encoding = DW_ATE_float;
10447 break;
10449 case FIXED_POINT_TYPE:
10450 if (!(dwarf_version >= 3 || !dwarf_strict))
10451 encoding = DW_ATE_lo_user;
10452 else if (TYPE_UNSIGNED (type))
10453 encoding = DW_ATE_unsigned_fixed;
10454 else
10455 encoding = DW_ATE_signed_fixed;
10456 break;
10458 /* Dwarf2 doesn't know anything about complex ints, so use
10459 a user defined type for it. */
10460 case COMPLEX_TYPE:
10461 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
10462 encoding = DW_ATE_complex_float;
10463 else
10464 encoding = DW_ATE_lo_user;
10465 break;
10467 case BOOLEAN_TYPE:
10468 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
10469 encoding = DW_ATE_boolean;
10470 break;
10472 default:
10473 /* No other TREE_CODEs are Dwarf fundamental types. */
10474 gcc_unreachable ();
10477 base_type_result = new_die (DW_TAG_base_type, comp_unit_die (), type);
10479 add_AT_unsigned (base_type_result, DW_AT_byte_size,
10480 int_size_in_bytes (type));
10481 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
10482 add_pubtype (type, base_type_result);
10484 return base_type_result;
10487 /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
10488 named 'auto' in its type: return true for it, false otherwise. */
10490 static inline bool
10491 is_cxx_auto (tree type)
10493 if (is_cxx ())
10495 tree name = TYPE_IDENTIFIER (type);
10496 if (name == get_identifier ("auto")
10497 || name == get_identifier ("decltype(auto)"))
10498 return true;
10500 return false;
10503 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
10504 given input type is a Dwarf "fundamental" type. Otherwise return null. */
10506 static inline int
10507 is_base_type (tree type)
10509 switch (TREE_CODE (type))
10511 case ERROR_MARK:
10512 case VOID_TYPE:
10513 case INTEGER_TYPE:
10514 case REAL_TYPE:
10515 case FIXED_POINT_TYPE:
10516 case COMPLEX_TYPE:
10517 case BOOLEAN_TYPE:
10518 case POINTER_BOUNDS_TYPE:
10519 return 1;
10521 case ARRAY_TYPE:
10522 case RECORD_TYPE:
10523 case UNION_TYPE:
10524 case QUAL_UNION_TYPE:
10525 case ENUMERAL_TYPE:
10526 case FUNCTION_TYPE:
10527 case METHOD_TYPE:
10528 case POINTER_TYPE:
10529 case REFERENCE_TYPE:
10530 case NULLPTR_TYPE:
10531 case OFFSET_TYPE:
10532 case LANG_TYPE:
10533 case VECTOR_TYPE:
10534 return 0;
10536 default:
10537 if (is_cxx_auto (type))
10538 return 0;
10539 gcc_unreachable ();
10542 return 0;
10545 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
10546 node, return the size in bits for the type if it is a constant, or else
10547 return the alignment for the type if the type's size is not constant, or
10548 else return BITS_PER_WORD if the type actually turns out to be an
10549 ERROR_MARK node. */
10551 static inline unsigned HOST_WIDE_INT
10552 simple_type_size_in_bits (const_tree type)
10554 if (TREE_CODE (type) == ERROR_MARK)
10555 return BITS_PER_WORD;
10556 else if (TYPE_SIZE (type) == NULL_TREE)
10557 return 0;
10558 else if (tree_fits_uhwi_p (TYPE_SIZE (type)))
10559 return tree_to_uhwi (TYPE_SIZE (type));
10560 else
10561 return TYPE_ALIGN (type);
10564 /* Similarly, but return an offset_int instead of UHWI. */
10566 static inline offset_int
10567 offset_int_type_size_in_bits (const_tree type)
10569 if (TREE_CODE (type) == ERROR_MARK)
10570 return BITS_PER_WORD;
10571 else if (TYPE_SIZE (type) == NULL_TREE)
10572 return 0;
10573 else if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
10574 return wi::to_offset (TYPE_SIZE (type));
10575 else
10576 return TYPE_ALIGN (type);
10579 /* Given a pointer to a tree node for a subrange type, return a pointer
10580 to a DIE that describes the given type. */
10582 static dw_die_ref
10583 subrange_type_die (tree type, tree low, tree high, dw_die_ref context_die)
10585 dw_die_ref subrange_die;
10586 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
10588 if (context_die == NULL)
10589 context_die = comp_unit_die ();
10591 subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
10593 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
10595 /* The size of the subrange type and its base type do not match,
10596 so we need to generate a size attribute for the subrange type. */
10597 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
10600 if (low)
10601 add_bound_info (subrange_die, DW_AT_lower_bound, low, NULL);
10602 if (high)
10603 add_bound_info (subrange_die, DW_AT_upper_bound, high, NULL);
10605 return subrange_die;
10608 /* Returns the (const and/or volatile) cv_qualifiers associated with
10609 the decl node. This will normally be augmented with the
10610 cv_qualifiers of the underlying type in add_type_attribute. */
10612 static int
10613 decl_quals (const_tree decl)
10615 return ((TREE_READONLY (decl)
10616 ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED)
10617 | (TREE_THIS_VOLATILE (decl)
10618 ? TYPE_QUAL_VOLATILE : TYPE_UNQUALIFIED));
10621 /* Determine the TYPE whose qualifiers match the largest strict subset
10622 of the given TYPE_QUALS, and return its qualifiers. Ignore all
10623 qualifiers outside QUAL_MASK. */
10625 static int
10626 get_nearest_type_subqualifiers (tree type, int type_quals, int qual_mask)
10628 tree t;
10629 int best_rank = 0, best_qual = 0, max_rank;
10631 type_quals &= qual_mask;
10632 max_rank = popcount_hwi (type_quals) - 1;
10634 for (t = TYPE_MAIN_VARIANT (type); t && best_rank < max_rank;
10635 t = TYPE_NEXT_VARIANT (t))
10637 int q = TYPE_QUALS (t) & qual_mask;
10639 if ((q & type_quals) == q && q != type_quals
10640 && check_base_type (t, type))
10642 int rank = popcount_hwi (q);
10644 if (rank > best_rank)
10646 best_rank = rank;
10647 best_qual = q;
10652 return best_qual;
10655 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
10656 entry that chains various modifiers in front of the given type. */
10658 static dw_die_ref
10659 modified_type_die (tree type, int cv_quals, dw_die_ref context_die)
10661 enum tree_code code = TREE_CODE (type);
10662 dw_die_ref mod_type_die;
10663 dw_die_ref sub_die = NULL;
10664 tree item_type = NULL;
10665 tree qualified_type;
10666 tree name, low, high;
10667 dw_die_ref mod_scope;
10668 /* Only these cv-qualifiers are currently handled. */
10669 const int cv_qual_mask = (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE
10670 | TYPE_QUAL_RESTRICT | TYPE_QUAL_ATOMIC);
10672 if (code == ERROR_MARK)
10673 return NULL;
10675 cv_quals &= cv_qual_mask;
10677 /* Don't emit DW_TAG_restrict_type for DWARFv2, since it is a type
10678 tag modifier (and not an attribute) old consumers won't be able
10679 to handle it. */
10680 if (dwarf_version < 3)
10681 cv_quals &= ~TYPE_QUAL_RESTRICT;
10683 /* Likewise for DW_TAG_atomic_type for DWARFv5. */
10684 if (dwarf_version < 5)
10685 cv_quals &= ~TYPE_QUAL_ATOMIC;
10687 /* See if we already have the appropriately qualified variant of
10688 this type. */
10689 qualified_type = get_qualified_type (type, cv_quals);
10691 if (qualified_type == sizetype
10692 && TYPE_NAME (qualified_type)
10693 && TREE_CODE (TYPE_NAME (qualified_type)) == TYPE_DECL)
10695 tree t = TREE_TYPE (TYPE_NAME (qualified_type));
10697 gcc_checking_assert (TREE_CODE (t) == INTEGER_TYPE
10698 && TYPE_PRECISION (t)
10699 == TYPE_PRECISION (qualified_type)
10700 && TYPE_UNSIGNED (t)
10701 == TYPE_UNSIGNED (qualified_type));
10702 qualified_type = t;
10705 /* If we do, then we can just use its DIE, if it exists. */
10706 if (qualified_type)
10708 mod_type_die = lookup_type_die (qualified_type);
10709 if (mod_type_die)
10710 return mod_type_die;
10713 name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
10715 /* Handle C typedef types. */
10716 if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name)
10717 && !DECL_ARTIFICIAL (name))
10719 tree dtype = TREE_TYPE (name);
10721 if (qualified_type == dtype)
10723 /* For a named type, use the typedef. */
10724 gen_type_die (qualified_type, context_die);
10725 return lookup_type_die (qualified_type);
10727 else
10729 int dquals = TYPE_QUALS_NO_ADDR_SPACE (dtype);
10730 dquals &= cv_qual_mask;
10731 if ((dquals & ~cv_quals) != TYPE_UNQUALIFIED
10732 || (cv_quals == dquals && DECL_ORIGINAL_TYPE (name) != type))
10733 /* cv-unqualified version of named type. Just use
10734 the unnamed type to which it refers. */
10735 return modified_type_die (DECL_ORIGINAL_TYPE (name),
10736 cv_quals, context_die);
10737 /* Else cv-qualified version of named type; fall through. */
10741 mod_scope = scope_die_for (type, context_die);
10743 if (cv_quals)
10745 struct qual_info { int q; enum dwarf_tag t; };
10746 static const struct qual_info qual_info[] =
10748 { TYPE_QUAL_ATOMIC, DW_TAG_atomic_type },
10749 { TYPE_QUAL_RESTRICT, DW_TAG_restrict_type },
10750 { TYPE_QUAL_VOLATILE, DW_TAG_volatile_type },
10751 { TYPE_QUAL_CONST, DW_TAG_const_type },
10753 int sub_quals;
10754 unsigned i;
10756 /* Determine a lesser qualified type that most closely matches
10757 this one. Then generate DW_TAG_* entries for the remaining
10758 qualifiers. */
10759 sub_quals = get_nearest_type_subqualifiers (type, cv_quals,
10760 cv_qual_mask);
10761 mod_type_die = modified_type_die (type, sub_quals, context_die);
10763 for (i = 0; i < sizeof (qual_info) / sizeof (qual_info[0]); i++)
10764 if (qual_info[i].q & cv_quals & ~sub_quals)
10766 dw_die_ref d = new_die (qual_info[i].t, mod_scope, type);
10767 if (mod_type_die)
10768 add_AT_die_ref (d, DW_AT_type, mod_type_die);
10769 mod_type_die = d;
10772 else if (code == POINTER_TYPE)
10774 mod_type_die = new_die (DW_TAG_pointer_type, mod_scope, type);
10775 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
10776 simple_type_size_in_bits (type) / BITS_PER_UNIT);
10777 item_type = TREE_TYPE (type);
10778 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type)))
10779 add_AT_unsigned (mod_type_die, DW_AT_address_class,
10780 TYPE_ADDR_SPACE (item_type));
10782 else if (code == REFERENCE_TYPE)
10784 if (TYPE_REF_IS_RVALUE (type) && dwarf_version >= 4)
10785 mod_type_die = new_die (DW_TAG_rvalue_reference_type, mod_scope,
10786 type);
10787 else
10788 mod_type_die = new_die (DW_TAG_reference_type, mod_scope, type);
10789 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
10790 simple_type_size_in_bits (type) / BITS_PER_UNIT);
10791 item_type = TREE_TYPE (type);
10792 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type)))
10793 add_AT_unsigned (mod_type_die, DW_AT_address_class,
10794 TYPE_ADDR_SPACE (item_type));
10796 else if (code == INTEGER_TYPE
10797 && TREE_TYPE (type) != NULL_TREE
10798 && subrange_type_for_debug_p (type, &low, &high))
10800 mod_type_die = subrange_type_die (type, low, high, context_die);
10801 item_type = TREE_TYPE (type);
10803 else if (is_base_type (type))
10804 mod_type_die = base_type_die (type);
10805 else
10807 gen_type_die (type, context_die);
10809 /* We have to get the type_main_variant here (and pass that to the
10810 `lookup_type_die' routine) because the ..._TYPE node we have
10811 might simply be a *copy* of some original type node (where the
10812 copy was created to help us keep track of typedef names) and
10813 that copy might have a different TYPE_UID from the original
10814 ..._TYPE node. */
10815 if (TREE_CODE (type) != VECTOR_TYPE)
10816 return lookup_type_die (type_main_variant (type));
10817 else
10818 /* Vectors have the debugging information in the type,
10819 not the main variant. */
10820 return lookup_type_die (type);
10823 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
10824 don't output a DW_TAG_typedef, since there isn't one in the
10825 user's program; just attach a DW_AT_name to the type.
10826 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type
10827 if the base type already has the same name. */
10828 if (name
10829 && ((TREE_CODE (name) != TYPE_DECL
10830 && (qualified_type == TYPE_MAIN_VARIANT (type)
10831 || (cv_quals == TYPE_UNQUALIFIED)))
10832 || (TREE_CODE (name) == TYPE_DECL
10833 && TREE_TYPE (name) == qualified_type
10834 && DECL_NAME (name))))
10836 if (TREE_CODE (name) == TYPE_DECL)
10837 /* Could just call add_name_and_src_coords_attributes here,
10838 but since this is a builtin type it doesn't have any
10839 useful source coordinates anyway. */
10840 name = DECL_NAME (name);
10841 add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
10843 /* This probably indicates a bug. */
10844 else if (mod_type_die && mod_type_die->die_tag == DW_TAG_base_type)
10846 name = TYPE_IDENTIFIER (type);
10847 add_name_attribute (mod_type_die,
10848 name ? IDENTIFIER_POINTER (name) : "__unknown__");
10851 if (qualified_type)
10852 equate_type_number_to_die (qualified_type, mod_type_die);
10854 if (item_type)
10855 /* We must do this after the equate_type_number_to_die call, in case
10856 this is a recursive type. This ensures that the modified_type_die
10857 recursion will terminate even if the type is recursive. Recursive
10858 types are possible in Ada. */
10859 sub_die = modified_type_die (item_type,
10860 TYPE_QUALS_NO_ADDR_SPACE (item_type),
10861 context_die);
10863 if (sub_die != NULL)
10864 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
10866 add_gnat_descriptive_type_attribute (mod_type_die, type, context_die);
10867 if (TYPE_ARTIFICIAL (type))
10868 add_AT_flag (mod_type_die, DW_AT_artificial, 1);
10870 return mod_type_die;
10873 /* Generate DIEs for the generic parameters of T.
10874 T must be either a generic type or a generic function.
10875 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
10877 static void
10878 gen_generic_params_dies (tree t)
10880 tree parms, args;
10881 int parms_num, i;
10882 dw_die_ref die = NULL;
10883 int non_default;
10885 if (!t || (TYPE_P (t) && !COMPLETE_TYPE_P (t)))
10886 return;
10888 if (TYPE_P (t))
10889 die = lookup_type_die (t);
10890 else if (DECL_P (t))
10891 die = lookup_decl_die (t);
10893 gcc_assert (die);
10895 parms = lang_hooks.get_innermost_generic_parms (t);
10896 if (!parms)
10897 /* T has no generic parameter. It means T is neither a generic type
10898 or function. End of story. */
10899 return;
10901 parms_num = TREE_VEC_LENGTH (parms);
10902 args = lang_hooks.get_innermost_generic_args (t);
10903 if (TREE_CHAIN (args) && TREE_CODE (TREE_CHAIN (args)) == INTEGER_CST)
10904 non_default = int_cst_value (TREE_CHAIN (args));
10905 else
10906 non_default = TREE_VEC_LENGTH (args);
10907 for (i = 0; i < parms_num; i++)
10909 tree parm, arg, arg_pack_elems;
10910 dw_die_ref parm_die;
10912 parm = TREE_VEC_ELT (parms, i);
10913 arg = TREE_VEC_ELT (args, i);
10914 arg_pack_elems = lang_hooks.types.get_argument_pack_elems (arg);
10915 gcc_assert (parm && TREE_VALUE (parm) && arg);
10917 if (parm && TREE_VALUE (parm) && arg)
10919 /* If PARM represents a template parameter pack,
10920 emit a DW_TAG_GNU_template_parameter_pack DIE, followed
10921 by DW_TAG_template_*_parameter DIEs for the argument
10922 pack elements of ARG. Note that ARG would then be
10923 an argument pack. */
10924 if (arg_pack_elems)
10925 parm_die = template_parameter_pack_die (TREE_VALUE (parm),
10926 arg_pack_elems,
10927 die);
10928 else
10929 parm_die = generic_parameter_die (TREE_VALUE (parm), arg,
10930 true /* emit name */, die);
10931 if (i >= non_default)
10932 add_AT_flag (parm_die, DW_AT_default_value, 1);
10937 /* Create and return a DIE for PARM which should be
10938 the representation of a generic type parameter.
10939 For instance, in the C++ front end, PARM would be a template parameter.
10940 ARG is the argument to PARM.
10941 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the
10942 name of the PARM.
10943 PARENT_DIE is the parent DIE which the new created DIE should be added to,
10944 as a child node. */
10946 static dw_die_ref
10947 generic_parameter_die (tree parm, tree arg,
10948 bool emit_name_p,
10949 dw_die_ref parent_die)
10951 dw_die_ref tmpl_die = NULL;
10952 const char *name = NULL;
10954 if (!parm || !DECL_NAME (parm) || !arg)
10955 return NULL;
10957 /* We support non-type generic parameters and arguments,
10958 type generic parameters and arguments, as well as
10959 generic generic parameters (a.k.a. template template parameters in C++)
10960 and arguments. */
10961 if (TREE_CODE (parm) == PARM_DECL)
10962 /* PARM is a nontype generic parameter */
10963 tmpl_die = new_die (DW_TAG_template_value_param, parent_die, parm);
10964 else if (TREE_CODE (parm) == TYPE_DECL)
10965 /* PARM is a type generic parameter. */
10966 tmpl_die = new_die (DW_TAG_template_type_param, parent_die, parm);
10967 else if (lang_hooks.decls.generic_generic_parameter_decl_p (parm))
10968 /* PARM is a generic generic parameter.
10969 Its DIE is a GNU extension. It shall have a
10970 DW_AT_name attribute to represent the name of the template template
10971 parameter, and a DW_AT_GNU_template_name attribute to represent the
10972 name of the template template argument. */
10973 tmpl_die = new_die (DW_TAG_GNU_template_template_param,
10974 parent_die, parm);
10975 else
10976 gcc_unreachable ();
10978 if (tmpl_die)
10980 tree tmpl_type;
10982 /* If PARM is a generic parameter pack, it means we are
10983 emitting debug info for a template argument pack element.
10984 In other terms, ARG is a template argument pack element.
10985 In that case, we don't emit any DW_AT_name attribute for
10986 the die. */
10987 if (emit_name_p)
10989 name = IDENTIFIER_POINTER (DECL_NAME (parm));
10990 gcc_assert (name);
10991 add_AT_string (tmpl_die, DW_AT_name, name);
10994 if (!lang_hooks.decls.generic_generic_parameter_decl_p (parm))
10996 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
10997 TMPL_DIE should have a child DW_AT_type attribute that is set
10998 to the type of the argument to PARM, which is ARG.
10999 If PARM is a type generic parameter, TMPL_DIE should have a
11000 child DW_AT_type that is set to ARG. */
11001 tmpl_type = TYPE_P (arg) ? arg : TREE_TYPE (arg);
11002 add_type_attribute (tmpl_die, tmpl_type,
11003 (TREE_THIS_VOLATILE (tmpl_type)
11004 ? TYPE_QUAL_VOLATILE : TYPE_UNQUALIFIED),
11005 parent_die);
11007 else
11009 /* So TMPL_DIE is a DIE representing a
11010 a generic generic template parameter, a.k.a template template
11011 parameter in C++ and arg is a template. */
11013 /* The DW_AT_GNU_template_name attribute of the DIE must be set
11014 to the name of the argument. */
11015 name = dwarf2_name (TYPE_P (arg) ? TYPE_NAME (arg) : arg, 1);
11016 if (name)
11017 add_AT_string (tmpl_die, DW_AT_GNU_template_name, name);
11020 if (TREE_CODE (parm) == PARM_DECL)
11021 /* So PARM is a non-type generic parameter.
11022 DWARF3 5.6.8 says we must set a DW_AT_const_value child
11023 attribute of TMPL_DIE which value represents the value
11024 of ARG.
11025 We must be careful here:
11026 The value of ARG might reference some function decls.
11027 We might currently be emitting debug info for a generic
11028 type and types are emitted before function decls, we don't
11029 know if the function decls referenced by ARG will actually be
11030 emitted after cgraph computations.
11031 So must defer the generation of the DW_AT_const_value to
11032 after cgraph is ready. */
11033 append_entry_to_tmpl_value_parm_die_table (tmpl_die, arg);
11036 return tmpl_die;
11039 /* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing.
11040 PARM_PACK must be a template parameter pack. The returned DIE
11041 will be child DIE of PARENT_DIE. */
11043 static dw_die_ref
11044 template_parameter_pack_die (tree parm_pack,
11045 tree parm_pack_args,
11046 dw_die_ref parent_die)
11048 dw_die_ref die;
11049 int j;
11051 gcc_assert (parent_die && parm_pack);
11053 die = new_die (DW_TAG_GNU_template_parameter_pack, parent_die, parm_pack);
11054 add_name_and_src_coords_attributes (die, parm_pack);
11055 for (j = 0; j < TREE_VEC_LENGTH (parm_pack_args); j++)
11056 generic_parameter_die (parm_pack,
11057 TREE_VEC_ELT (parm_pack_args, j),
11058 false /* Don't emit DW_AT_name */,
11059 die);
11060 return die;
11063 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
11064 an enumerated type. */
11066 static inline int
11067 type_is_enum (const_tree type)
11069 return TREE_CODE (type) == ENUMERAL_TYPE;
11072 /* Return the DBX register number described by a given RTL node. */
11074 static unsigned int
11075 dbx_reg_number (const_rtx rtl)
11077 unsigned regno = REGNO (rtl);
11079 gcc_assert (regno < FIRST_PSEUDO_REGISTER);
11081 #ifdef LEAF_REG_REMAP
11082 if (crtl->uses_only_leaf_regs)
11084 int leaf_reg = LEAF_REG_REMAP (regno);
11085 if (leaf_reg != -1)
11086 regno = (unsigned) leaf_reg;
11088 #endif
11090 regno = DBX_REGISTER_NUMBER (regno);
11091 gcc_assert (regno != INVALID_REGNUM);
11092 return regno;
11095 /* Optionally add a DW_OP_piece term to a location description expression.
11096 DW_OP_piece is only added if the location description expression already
11097 doesn't end with DW_OP_piece. */
11099 static void
11100 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
11102 dw_loc_descr_ref loc;
11104 if (*list_head != NULL)
11106 /* Find the end of the chain. */
11107 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
11110 if (loc->dw_loc_opc != DW_OP_piece)
11111 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
11115 /* Return a location descriptor that designates a machine register or
11116 zero if there is none. */
11118 static dw_loc_descr_ref
11119 reg_loc_descriptor (rtx rtl, enum var_init_status initialized)
11121 rtx regs;
11123 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
11124 return 0;
11126 /* We only use "frame base" when we're sure we're talking about the
11127 post-prologue local stack frame. We do this by *not* running
11128 register elimination until this point, and recognizing the special
11129 argument pointer and soft frame pointer rtx's.
11130 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */
11131 if ((rtl == arg_pointer_rtx || rtl == frame_pointer_rtx)
11132 && eliminate_regs (rtl, VOIDmode, NULL_RTX) != rtl)
11134 dw_loc_descr_ref result = NULL;
11136 if (dwarf_version >= 4 || !dwarf_strict)
11138 result = mem_loc_descriptor (rtl, GET_MODE (rtl), VOIDmode,
11139 initialized);
11140 if (result)
11141 add_loc_descr (&result,
11142 new_loc_descr (DW_OP_stack_value, 0, 0));
11144 return result;
11147 regs = targetm.dwarf_register_span (rtl);
11149 if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
11150 return multiple_reg_loc_descriptor (rtl, regs, initialized);
11151 else
11153 unsigned int dbx_regnum = dbx_reg_number (rtl);
11154 if (dbx_regnum == IGNORED_DWARF_REGNUM)
11155 return 0;
11156 return one_reg_loc_descriptor (dbx_regnum, initialized);
11160 /* Return a location descriptor that designates a machine register for
11161 a given hard register number. */
11163 static dw_loc_descr_ref
11164 one_reg_loc_descriptor (unsigned int regno, enum var_init_status initialized)
11166 dw_loc_descr_ref reg_loc_descr;
11168 if (regno <= 31)
11169 reg_loc_descr
11170 = new_loc_descr ((enum dwarf_location_atom) (DW_OP_reg0 + regno), 0, 0);
11171 else
11172 reg_loc_descr = new_loc_descr (DW_OP_regx, regno, 0);
11174 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
11175 add_loc_descr (&reg_loc_descr, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
11177 return reg_loc_descr;
11180 /* Given an RTL of a register, return a location descriptor that
11181 designates a value that spans more than one register. */
11183 static dw_loc_descr_ref
11184 multiple_reg_loc_descriptor (rtx rtl, rtx regs,
11185 enum var_init_status initialized)
11187 int size, i;
11188 dw_loc_descr_ref loc_result = NULL;
11190 /* Simple, contiguous registers. */
11191 if (regs == NULL_RTX)
11193 unsigned reg = REGNO (rtl);
11194 int nregs;
11196 #ifdef LEAF_REG_REMAP
11197 if (crtl->uses_only_leaf_regs)
11199 int leaf_reg = LEAF_REG_REMAP (reg);
11200 if (leaf_reg != -1)
11201 reg = (unsigned) leaf_reg;
11203 #endif
11205 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
11206 nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
11208 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
11210 loc_result = NULL;
11211 while (nregs--)
11213 dw_loc_descr_ref t;
11215 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg),
11216 VAR_INIT_STATUS_INITIALIZED);
11217 add_loc_descr (&loc_result, t);
11218 add_loc_descr_op_piece (&loc_result, size);
11219 ++reg;
11221 return loc_result;
11224 /* Now onto stupid register sets in non contiguous locations. */
11226 gcc_assert (GET_CODE (regs) == PARALLEL);
11228 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
11229 loc_result = NULL;
11231 for (i = 0; i < XVECLEN (regs, 0); ++i)
11233 dw_loc_descr_ref t;
11235 t = one_reg_loc_descriptor (dbx_reg_number (XVECEXP (regs, 0, i)),
11236 VAR_INIT_STATUS_INITIALIZED);
11237 add_loc_descr (&loc_result, t);
11238 add_loc_descr_op_piece (&loc_result, size);
11241 if (loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
11242 add_loc_descr (&loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
11243 return loc_result;
11246 static unsigned long size_of_int_loc_descriptor (HOST_WIDE_INT);
11248 /* Return a location descriptor that designates a constant i,
11249 as a compound operation from constant (i >> shift), constant shift
11250 and DW_OP_shl. */
11252 static dw_loc_descr_ref
11253 int_shift_loc_descriptor (HOST_WIDE_INT i, int shift)
11255 dw_loc_descr_ref ret = int_loc_descriptor (i >> shift);
11256 add_loc_descr (&ret, int_loc_descriptor (shift));
11257 add_loc_descr (&ret, new_loc_descr (DW_OP_shl, 0, 0));
11258 return ret;
11261 /* Return a location descriptor that designates a constant. */
11263 static dw_loc_descr_ref
11264 int_loc_descriptor (HOST_WIDE_INT i)
11266 enum dwarf_location_atom op;
11268 /* Pick the smallest representation of a constant, rather than just
11269 defaulting to the LEB encoding. */
11270 if (i >= 0)
11272 int clz = clz_hwi (i);
11273 int ctz = ctz_hwi (i);
11274 if (i <= 31)
11275 op = (enum dwarf_location_atom) (DW_OP_lit0 + i);
11276 else if (i <= 0xff)
11277 op = DW_OP_const1u;
11278 else if (i <= 0xffff)
11279 op = DW_OP_const2u;
11280 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 5
11281 && clz + 5 + 255 >= HOST_BITS_PER_WIDE_INT)
11282 /* DW_OP_litX DW_OP_litY DW_OP_shl takes just 3 bytes and
11283 DW_OP_litX DW_OP_const1u Y DW_OP_shl takes just 4 bytes,
11284 while DW_OP_const4u is 5 bytes. */
11285 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 5);
11286 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 8
11287 && clz + 8 + 31 >= HOST_BITS_PER_WIDE_INT)
11288 /* DW_OP_const1u X DW_OP_litY DW_OP_shl takes just 4 bytes,
11289 while DW_OP_const4u is 5 bytes. */
11290 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 8);
11291 else if (HOST_BITS_PER_WIDE_INT == 32 || i <= 0xffffffff)
11292 op = DW_OP_const4u;
11293 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 8
11294 && clz + 8 + 255 >= HOST_BITS_PER_WIDE_INT)
11295 /* DW_OP_const1u X DW_OP_const1u Y DW_OP_shl takes just 5 bytes,
11296 while DW_OP_constu of constant >= 0x100000000 takes at least
11297 6 bytes. */
11298 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 8);
11299 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 16
11300 && clz + 16 + (size_of_uleb128 (i) > 5 ? 255 : 31)
11301 >= HOST_BITS_PER_WIDE_INT)
11302 /* DW_OP_const2u X DW_OP_litY DW_OP_shl takes just 5 bytes,
11303 DW_OP_const2u X DW_OP_const1u Y DW_OP_shl takes 6 bytes,
11304 while DW_OP_constu takes in this case at least 6 bytes. */
11305 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 16);
11306 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 32
11307 && clz + 32 + 31 >= HOST_BITS_PER_WIDE_INT
11308 && size_of_uleb128 (i) > 6)
11309 /* DW_OP_const4u X DW_OP_litY DW_OP_shl takes just 7 bytes. */
11310 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 32);
11311 else
11312 op = DW_OP_constu;
11314 else
11316 if (i >= -0x80)
11317 op = DW_OP_const1s;
11318 else if (i >= -0x8000)
11319 op = DW_OP_const2s;
11320 else if (HOST_BITS_PER_WIDE_INT == 32 || i >= -0x80000000)
11322 if (size_of_int_loc_descriptor (i) < 5)
11324 dw_loc_descr_ref ret = int_loc_descriptor (-i);
11325 add_loc_descr (&ret, new_loc_descr (DW_OP_neg, 0, 0));
11326 return ret;
11328 op = DW_OP_const4s;
11330 else
11332 if (size_of_int_loc_descriptor (i)
11333 < (unsigned long) 1 + size_of_sleb128 (i))
11335 dw_loc_descr_ref ret = int_loc_descriptor (-i);
11336 add_loc_descr (&ret, new_loc_descr (DW_OP_neg, 0, 0));
11337 return ret;
11339 op = DW_OP_consts;
11343 return new_loc_descr (op, i, 0);
11346 /* Return size_of_locs (int_shift_loc_descriptor (i, shift))
11347 without actually allocating it. */
11349 static unsigned long
11350 size_of_int_shift_loc_descriptor (HOST_WIDE_INT i, int shift)
11352 return size_of_int_loc_descriptor (i >> shift)
11353 + size_of_int_loc_descriptor (shift)
11354 + 1;
11357 /* Return size_of_locs (int_loc_descriptor (i)) without
11358 actually allocating it. */
11360 static unsigned long
11361 size_of_int_loc_descriptor (HOST_WIDE_INT i)
11363 unsigned long s;
11365 if (i >= 0)
11367 int clz, ctz;
11368 if (i <= 31)
11369 return 1;
11370 else if (i <= 0xff)
11371 return 2;
11372 else if (i <= 0xffff)
11373 return 3;
11374 clz = clz_hwi (i);
11375 ctz = ctz_hwi (i);
11376 if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 5
11377 && clz + 5 + 255 >= HOST_BITS_PER_WIDE_INT)
11378 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT
11379 - clz - 5);
11380 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 8
11381 && clz + 8 + 31 >= HOST_BITS_PER_WIDE_INT)
11382 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT
11383 - clz - 8);
11384 else if (HOST_BITS_PER_WIDE_INT == 32 || i <= 0xffffffff)
11385 return 5;
11386 s = size_of_uleb128 ((unsigned HOST_WIDE_INT) i);
11387 if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 8
11388 && clz + 8 + 255 >= HOST_BITS_PER_WIDE_INT)
11389 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT
11390 - clz - 8);
11391 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 16
11392 && clz + 16 + (s > 5 ? 255 : 31) >= HOST_BITS_PER_WIDE_INT)
11393 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT
11394 - clz - 16);
11395 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 32
11396 && clz + 32 + 31 >= HOST_BITS_PER_WIDE_INT
11397 && s > 6)
11398 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT
11399 - clz - 32);
11400 else
11401 return 1 + s;
11403 else
11405 if (i >= -0x80)
11406 return 2;
11407 else if (i >= -0x8000)
11408 return 3;
11409 else if (HOST_BITS_PER_WIDE_INT == 32 || i >= -0x80000000)
11411 if (-(unsigned HOST_WIDE_INT) i != (unsigned HOST_WIDE_INT) i)
11413 s = size_of_int_loc_descriptor (-i) + 1;
11414 if (s < 5)
11415 return s;
11417 return 5;
11419 else
11421 unsigned long r = 1 + size_of_sleb128 (i);
11422 if (-(unsigned HOST_WIDE_INT) i != (unsigned HOST_WIDE_INT) i)
11424 s = size_of_int_loc_descriptor (-i) + 1;
11425 if (s < r)
11426 return s;
11428 return r;
11433 /* Return loc description representing "address" of integer value.
11434 This can appear only as toplevel expression. */
11436 static dw_loc_descr_ref
11437 address_of_int_loc_descriptor (int size, HOST_WIDE_INT i)
11439 int litsize;
11440 dw_loc_descr_ref loc_result = NULL;
11442 if (!(dwarf_version >= 4 || !dwarf_strict))
11443 return NULL;
11445 litsize = size_of_int_loc_descriptor (i);
11446 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
11447 is more compact. For DW_OP_stack_value we need:
11448 litsize + 1 (DW_OP_stack_value)
11449 and for DW_OP_implicit_value:
11450 1 (DW_OP_implicit_value) + 1 (length) + size. */
11451 if ((int) DWARF2_ADDR_SIZE >= size && litsize + 1 <= 1 + 1 + size)
11453 loc_result = int_loc_descriptor (i);
11454 add_loc_descr (&loc_result,
11455 new_loc_descr (DW_OP_stack_value, 0, 0));
11456 return loc_result;
11459 loc_result = new_loc_descr (DW_OP_implicit_value,
11460 size, 0);
11461 loc_result->dw_loc_oprnd2.val_class = dw_val_class_const;
11462 loc_result->dw_loc_oprnd2.v.val_int = i;
11463 return loc_result;
11466 /* Return a location descriptor that designates a base+offset location. */
11468 static dw_loc_descr_ref
11469 based_loc_descr (rtx reg, HOST_WIDE_INT offset,
11470 enum var_init_status initialized)
11472 unsigned int regno;
11473 dw_loc_descr_ref result;
11474 dw_fde_ref fde = cfun->fde;
11476 /* We only use "frame base" when we're sure we're talking about the
11477 post-prologue local stack frame. We do this by *not* running
11478 register elimination until this point, and recognizing the special
11479 argument pointer and soft frame pointer rtx's. */
11480 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
11482 rtx elim = (ira_use_lra_p
11483 ? lra_eliminate_regs (reg, VOIDmode, NULL_RTX)
11484 : eliminate_regs (reg, VOIDmode, NULL_RTX));
11486 if (elim != reg)
11488 if (GET_CODE (elim) == PLUS)
11490 offset += INTVAL (XEXP (elim, 1));
11491 elim = XEXP (elim, 0);
11493 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
11494 && (elim == hard_frame_pointer_rtx
11495 || elim == stack_pointer_rtx))
11496 || elim == (frame_pointer_needed
11497 ? hard_frame_pointer_rtx
11498 : stack_pointer_rtx));
11500 /* If drap register is used to align stack, use frame
11501 pointer + offset to access stack variables. If stack
11502 is aligned without drap, use stack pointer + offset to
11503 access stack variables. */
11504 if (crtl->stack_realign_tried
11505 && reg == frame_pointer_rtx)
11507 int base_reg
11508 = DWARF_FRAME_REGNUM ((fde && fde->drap_reg != INVALID_REGNUM)
11509 ? HARD_FRAME_POINTER_REGNUM
11510 : REGNO (elim));
11511 return new_reg_loc_descr (base_reg, offset);
11514 gcc_assert (frame_pointer_fb_offset_valid);
11515 offset += frame_pointer_fb_offset;
11516 return new_loc_descr (DW_OP_fbreg, offset, 0);
11520 regno = REGNO (reg);
11521 #ifdef LEAF_REG_REMAP
11522 if (crtl->uses_only_leaf_regs)
11524 int leaf_reg = LEAF_REG_REMAP (regno);
11525 if (leaf_reg != -1)
11526 regno = (unsigned) leaf_reg;
11528 #endif
11529 regno = DWARF_FRAME_REGNUM (regno);
11531 if (!optimize && fde
11532 && (fde->drap_reg == regno || fde->vdrap_reg == regno))
11534 /* Use cfa+offset to represent the location of arguments passed
11535 on the stack when drap is used to align stack.
11536 Only do this when not optimizing, for optimized code var-tracking
11537 is supposed to track where the arguments live and the register
11538 used as vdrap or drap in some spot might be used for something
11539 else in other part of the routine. */
11540 return new_loc_descr (DW_OP_fbreg, offset, 0);
11543 if (regno <= 31)
11544 result = new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + regno),
11545 offset, 0);
11546 else
11547 result = new_loc_descr (DW_OP_bregx, regno, offset);
11549 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
11550 add_loc_descr (&result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
11552 return result;
11555 /* Return true if this RTL expression describes a base+offset calculation. */
11557 static inline int
11558 is_based_loc (const_rtx rtl)
11560 return (GET_CODE (rtl) == PLUS
11561 && ((REG_P (XEXP (rtl, 0))
11562 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
11563 && CONST_INT_P (XEXP (rtl, 1)))));
11566 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
11567 failed. */
11569 static dw_loc_descr_ref
11570 tls_mem_loc_descriptor (rtx mem)
11572 tree base;
11573 dw_loc_descr_ref loc_result;
11575 if (MEM_EXPR (mem) == NULL_TREE || !MEM_OFFSET_KNOWN_P (mem))
11576 return NULL;
11578 base = get_base_address (MEM_EXPR (mem));
11579 if (base == NULL
11580 || TREE_CODE (base) != VAR_DECL
11581 || !DECL_THREAD_LOCAL_P (base))
11582 return NULL;
11584 loc_result = loc_descriptor_from_tree (MEM_EXPR (mem), 1, NULL);
11585 if (loc_result == NULL)
11586 return NULL;
11588 if (MEM_OFFSET (mem))
11589 loc_descr_plus_const (&loc_result, MEM_OFFSET (mem));
11591 return loc_result;
11594 /* Output debug info about reason why we failed to expand expression as dwarf
11595 expression. */
11597 static void
11598 expansion_failed (tree expr, rtx rtl, char const *reason)
11600 if (dump_file && (dump_flags & TDF_DETAILS))
11602 fprintf (dump_file, "Failed to expand as dwarf: ");
11603 if (expr)
11604 print_generic_expr (dump_file, expr, dump_flags);
11605 if (rtl)
11607 fprintf (dump_file, "\n");
11608 print_rtl (dump_file, rtl);
11610 fprintf (dump_file, "\nReason: %s\n", reason);
11614 /* Helper function for const_ok_for_output. */
11616 static bool
11617 const_ok_for_output_1 (rtx rtl)
11619 if (GET_CODE (rtl) == UNSPEC)
11621 /* If delegitimize_address couldn't do anything with the UNSPEC, assume
11622 we can't express it in the debug info. */
11623 #ifdef ENABLE_CHECKING
11624 /* Don't complain about TLS UNSPECs, those are just too hard to
11625 delegitimize. Note this could be a non-decl SYMBOL_REF such as
11626 one in a constant pool entry, so testing SYMBOL_REF_TLS_MODEL
11627 rather than DECL_THREAD_LOCAL_P is not just an optimization. */
11628 if (XVECLEN (rtl, 0) == 0
11629 || GET_CODE (XVECEXP (rtl, 0, 0)) != SYMBOL_REF
11630 || SYMBOL_REF_TLS_MODEL (XVECEXP (rtl, 0, 0)) == TLS_MODEL_NONE)
11631 inform (current_function_decl
11632 ? DECL_SOURCE_LOCATION (current_function_decl)
11633 : UNKNOWN_LOCATION,
11634 #if NUM_UNSPEC_VALUES > 0
11635 "non-delegitimized UNSPEC %s (%d) found in variable location",
11636 ((XINT (rtl, 1) >= 0 && XINT (rtl, 1) < NUM_UNSPEC_VALUES)
11637 ? unspec_strings[XINT (rtl, 1)] : "unknown"),
11638 XINT (rtl, 1));
11639 #else
11640 "non-delegitimized UNSPEC %d found in variable location",
11641 XINT (rtl, 1));
11642 #endif
11643 #endif
11644 expansion_failed (NULL_TREE, rtl,
11645 "UNSPEC hasn't been delegitimized.\n");
11646 return false;
11649 if (targetm.const_not_ok_for_debug_p (rtl))
11651 expansion_failed (NULL_TREE, rtl,
11652 "Expression rejected for debug by the backend.\n");
11653 return false;
11656 /* FIXME: Refer to PR60655. It is possible for simplification
11657 of rtl expressions in var tracking to produce such expressions.
11658 We should really identify / validate expressions
11659 enclosed in CONST that can be handled by assemblers on various
11660 targets and only handle legitimate cases here. */
11661 if (GET_CODE (rtl) != SYMBOL_REF)
11663 if (GET_CODE (rtl) == NOT)
11664 return false;
11665 return true;
11668 if (CONSTANT_POOL_ADDRESS_P (rtl))
11670 bool marked;
11671 get_pool_constant_mark (rtl, &marked);
11672 /* If all references to this pool constant were optimized away,
11673 it was not output and thus we can't represent it. */
11674 if (!marked)
11676 expansion_failed (NULL_TREE, rtl,
11677 "Constant was removed from constant pool.\n");
11678 return false;
11682 if (SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE)
11683 return false;
11685 /* Avoid references to external symbols in debug info, on several targets
11686 the linker might even refuse to link when linking a shared library,
11687 and in many other cases the relocations for .debug_info/.debug_loc are
11688 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed
11689 to be defined within the same shared library or executable are fine. */
11690 if (SYMBOL_REF_EXTERNAL_P (rtl))
11692 tree decl = SYMBOL_REF_DECL (rtl);
11694 if (decl == NULL || !targetm.binds_local_p (decl))
11696 expansion_failed (NULL_TREE, rtl,
11697 "Symbol not defined in current TU.\n");
11698 return false;
11702 return true;
11705 /* Return true if constant RTL can be emitted in DW_OP_addr or
11706 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or
11707 non-marked constant pool SYMBOL_REFs can't be referenced in it. */
11709 static bool
11710 const_ok_for_output (rtx rtl)
11712 if (GET_CODE (rtl) == SYMBOL_REF)
11713 return const_ok_for_output_1 (rtl);
11715 if (GET_CODE (rtl) == CONST)
11717 subrtx_var_iterator::array_type array;
11718 FOR_EACH_SUBRTX_VAR (iter, array, XEXP (rtl, 0), ALL)
11719 if (!const_ok_for_output_1 (*iter))
11720 return false;
11721 return true;
11724 return true;
11727 /* Return a reference to DW_TAG_base_type corresponding to MODE and UNSIGNEDP
11728 if possible, NULL otherwise. */
11730 static dw_die_ref
11731 base_type_for_mode (machine_mode mode, bool unsignedp)
11733 dw_die_ref type_die;
11734 tree type = lang_hooks.types.type_for_mode (mode, unsignedp);
11736 if (type == NULL)
11737 return NULL;
11738 switch (TREE_CODE (type))
11740 case INTEGER_TYPE:
11741 case REAL_TYPE:
11742 break;
11743 default:
11744 return NULL;
11746 type_die = lookup_type_die (type);
11747 if (!type_die)
11748 type_die = modified_type_die (type, TYPE_UNQUALIFIED, comp_unit_die ());
11749 if (type_die == NULL || type_die->die_tag != DW_TAG_base_type)
11750 return NULL;
11751 return type_die;
11754 /* For OP descriptor assumed to be in unsigned MODE, convert it to a unsigned
11755 type matching MODE, or, if MODE is narrower than or as wide as
11756 DWARF2_ADDR_SIZE, untyped. Return NULL if the conversion is not
11757 possible. */
11759 static dw_loc_descr_ref
11760 convert_descriptor_to_mode (machine_mode mode, dw_loc_descr_ref op)
11762 machine_mode outer_mode = mode;
11763 dw_die_ref type_die;
11764 dw_loc_descr_ref cvt;
11766 if (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE)
11768 add_loc_descr (&op, new_loc_descr (DW_OP_GNU_convert, 0, 0));
11769 return op;
11771 type_die = base_type_for_mode (outer_mode, 1);
11772 if (type_die == NULL)
11773 return NULL;
11774 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
11775 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
11776 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
11777 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
11778 add_loc_descr (&op, cvt);
11779 return op;
11782 /* Return location descriptor for comparison OP with operands OP0 and OP1. */
11784 static dw_loc_descr_ref
11785 compare_loc_descriptor (enum dwarf_location_atom op, dw_loc_descr_ref op0,
11786 dw_loc_descr_ref op1)
11788 dw_loc_descr_ref ret = op0;
11789 add_loc_descr (&ret, op1);
11790 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
11791 if (STORE_FLAG_VALUE != 1)
11793 add_loc_descr (&ret, int_loc_descriptor (STORE_FLAG_VALUE));
11794 add_loc_descr (&ret, new_loc_descr (DW_OP_mul, 0, 0));
11796 return ret;
11799 /* Return location descriptor for signed comparison OP RTL. */
11801 static dw_loc_descr_ref
11802 scompare_loc_descriptor (enum dwarf_location_atom op, rtx rtl,
11803 machine_mode mem_mode)
11805 machine_mode op_mode = GET_MODE (XEXP (rtl, 0));
11806 dw_loc_descr_ref op0, op1;
11807 int shift;
11809 if (op_mode == VOIDmode)
11810 op_mode = GET_MODE (XEXP (rtl, 1));
11811 if (op_mode == VOIDmode)
11812 return NULL;
11814 if (dwarf_strict
11815 && (GET_MODE_CLASS (op_mode) != MODE_INT
11816 || GET_MODE_SIZE (op_mode) > DWARF2_ADDR_SIZE))
11817 return NULL;
11819 op0 = mem_loc_descriptor (XEXP (rtl, 0), op_mode, mem_mode,
11820 VAR_INIT_STATUS_INITIALIZED);
11821 op1 = mem_loc_descriptor (XEXP (rtl, 1), op_mode, mem_mode,
11822 VAR_INIT_STATUS_INITIALIZED);
11824 if (op0 == NULL || op1 == NULL)
11825 return NULL;
11827 if (GET_MODE_CLASS (op_mode) != MODE_INT
11828 || GET_MODE_SIZE (op_mode) == DWARF2_ADDR_SIZE)
11829 return compare_loc_descriptor (op, op0, op1);
11831 if (GET_MODE_SIZE (op_mode) > DWARF2_ADDR_SIZE)
11833 dw_die_ref type_die = base_type_for_mode (op_mode, 0);
11834 dw_loc_descr_ref cvt;
11836 if (type_die == NULL)
11837 return NULL;
11838 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
11839 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
11840 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
11841 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
11842 add_loc_descr (&op0, cvt);
11843 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
11844 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
11845 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
11846 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
11847 add_loc_descr (&op1, cvt);
11848 return compare_loc_descriptor (op, op0, op1);
11851 shift = (DWARF2_ADDR_SIZE - GET_MODE_SIZE (op_mode)) * BITS_PER_UNIT;
11852 /* For eq/ne, if the operands are known to be zero-extended,
11853 there is no need to do the fancy shifting up. */
11854 if (op == DW_OP_eq || op == DW_OP_ne)
11856 dw_loc_descr_ref last0, last1;
11857 for (last0 = op0; last0->dw_loc_next != NULL; last0 = last0->dw_loc_next)
11859 for (last1 = op1; last1->dw_loc_next != NULL; last1 = last1->dw_loc_next)
11861 /* deref_size zero extends, and for constants we can check
11862 whether they are zero extended or not. */
11863 if (((last0->dw_loc_opc == DW_OP_deref_size
11864 && last0->dw_loc_oprnd1.v.val_int <= GET_MODE_SIZE (op_mode))
11865 || (CONST_INT_P (XEXP (rtl, 0))
11866 && (unsigned HOST_WIDE_INT) INTVAL (XEXP (rtl, 0))
11867 == (INTVAL (XEXP (rtl, 0)) & GET_MODE_MASK (op_mode))))
11868 && ((last1->dw_loc_opc == DW_OP_deref_size
11869 && last1->dw_loc_oprnd1.v.val_int <= GET_MODE_SIZE (op_mode))
11870 || (CONST_INT_P (XEXP (rtl, 1))
11871 && (unsigned HOST_WIDE_INT) INTVAL (XEXP (rtl, 1))
11872 == (INTVAL (XEXP (rtl, 1)) & GET_MODE_MASK (op_mode)))))
11873 return compare_loc_descriptor (op, op0, op1);
11875 /* EQ/NE comparison against constant in narrower type than
11876 DWARF2_ADDR_SIZE can be performed either as
11877 DW_OP_const1u <shift> DW_OP_shl DW_OP_const* <cst << shift>
11878 DW_OP_{eq,ne}
11880 DW_OP_const*u <mode_mask> DW_OP_and DW_OP_const* <cst & mode_mask>
11881 DW_OP_{eq,ne}. Pick whatever is shorter. */
11882 if (CONST_INT_P (XEXP (rtl, 1))
11883 && GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT
11884 && (size_of_int_loc_descriptor (shift) + 1
11885 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl, 1)) << shift)
11886 >= size_of_int_loc_descriptor (GET_MODE_MASK (op_mode)) + 1
11887 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl, 1))
11888 & GET_MODE_MASK (op_mode))))
11890 add_loc_descr (&op0, int_loc_descriptor (GET_MODE_MASK (op_mode)));
11891 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
11892 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1))
11893 & GET_MODE_MASK (op_mode));
11894 return compare_loc_descriptor (op, op0, op1);
11897 add_loc_descr (&op0, int_loc_descriptor (shift));
11898 add_loc_descr (&op0, new_loc_descr (DW_OP_shl, 0, 0));
11899 if (CONST_INT_P (XEXP (rtl, 1)))
11900 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1)) << shift);
11901 else
11903 add_loc_descr (&op1, int_loc_descriptor (shift));
11904 add_loc_descr (&op1, new_loc_descr (DW_OP_shl, 0, 0));
11906 return compare_loc_descriptor (op, op0, op1);
11909 /* Return location descriptor for unsigned comparison OP RTL. */
11911 static dw_loc_descr_ref
11912 ucompare_loc_descriptor (enum dwarf_location_atom op, rtx rtl,
11913 machine_mode mem_mode)
11915 machine_mode op_mode = GET_MODE (XEXP (rtl, 0));
11916 dw_loc_descr_ref op0, op1;
11918 if (op_mode == VOIDmode)
11919 op_mode = GET_MODE (XEXP (rtl, 1));
11920 if (op_mode == VOIDmode)
11921 return NULL;
11922 if (GET_MODE_CLASS (op_mode) != MODE_INT)
11923 return NULL;
11925 if (dwarf_strict && GET_MODE_SIZE (op_mode) > DWARF2_ADDR_SIZE)
11926 return NULL;
11928 op0 = mem_loc_descriptor (XEXP (rtl, 0), op_mode, mem_mode,
11929 VAR_INIT_STATUS_INITIALIZED);
11930 op1 = mem_loc_descriptor (XEXP (rtl, 1), op_mode, mem_mode,
11931 VAR_INIT_STATUS_INITIALIZED);
11933 if (op0 == NULL || op1 == NULL)
11934 return NULL;
11936 if (GET_MODE_SIZE (op_mode) < DWARF2_ADDR_SIZE)
11938 HOST_WIDE_INT mask = GET_MODE_MASK (op_mode);
11939 dw_loc_descr_ref last0, last1;
11940 for (last0 = op0; last0->dw_loc_next != NULL; last0 = last0->dw_loc_next)
11942 for (last1 = op1; last1->dw_loc_next != NULL; last1 = last1->dw_loc_next)
11944 if (CONST_INT_P (XEXP (rtl, 0)))
11945 op0 = int_loc_descriptor (INTVAL (XEXP (rtl, 0)) & mask);
11946 /* deref_size zero extends, so no need to mask it again. */
11947 else if (last0->dw_loc_opc != DW_OP_deref_size
11948 || last0->dw_loc_oprnd1.v.val_int > GET_MODE_SIZE (op_mode))
11950 add_loc_descr (&op0, int_loc_descriptor (mask));
11951 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
11953 if (CONST_INT_P (XEXP (rtl, 1)))
11954 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1)) & mask);
11955 /* deref_size zero extends, so no need to mask it again. */
11956 else if (last1->dw_loc_opc != DW_OP_deref_size
11957 || last1->dw_loc_oprnd1.v.val_int > GET_MODE_SIZE (op_mode))
11959 add_loc_descr (&op1, int_loc_descriptor (mask));
11960 add_loc_descr (&op1, new_loc_descr (DW_OP_and, 0, 0));
11963 else if (GET_MODE_SIZE (op_mode) == DWARF2_ADDR_SIZE)
11965 HOST_WIDE_INT bias = 1;
11966 bias <<= (DWARF2_ADDR_SIZE * BITS_PER_UNIT - 1);
11967 add_loc_descr (&op0, new_loc_descr (DW_OP_plus_uconst, bias, 0));
11968 if (CONST_INT_P (XEXP (rtl, 1)))
11969 op1 = int_loc_descriptor ((unsigned HOST_WIDE_INT) bias
11970 + INTVAL (XEXP (rtl, 1)));
11971 else
11972 add_loc_descr (&op1, new_loc_descr (DW_OP_plus_uconst,
11973 bias, 0));
11975 return compare_loc_descriptor (op, op0, op1);
11978 /* Return location descriptor for {U,S}{MIN,MAX}. */
11980 static dw_loc_descr_ref
11981 minmax_loc_descriptor (rtx rtl, machine_mode mode,
11982 machine_mode mem_mode)
11984 enum dwarf_location_atom op;
11985 dw_loc_descr_ref op0, op1, ret;
11986 dw_loc_descr_ref bra_node, drop_node;
11988 if (dwarf_strict
11989 && (GET_MODE_CLASS (mode) != MODE_INT
11990 || GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE))
11991 return NULL;
11993 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
11994 VAR_INIT_STATUS_INITIALIZED);
11995 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
11996 VAR_INIT_STATUS_INITIALIZED);
11998 if (op0 == NULL || op1 == NULL)
11999 return NULL;
12001 add_loc_descr (&op0, new_loc_descr (DW_OP_dup, 0, 0));
12002 add_loc_descr (&op1, new_loc_descr (DW_OP_swap, 0, 0));
12003 add_loc_descr (&op1, new_loc_descr (DW_OP_over, 0, 0));
12004 if (GET_CODE (rtl) == UMIN || GET_CODE (rtl) == UMAX)
12006 if (GET_MODE_SIZE (mode) < DWARF2_ADDR_SIZE)
12008 HOST_WIDE_INT mask = GET_MODE_MASK (mode);
12009 add_loc_descr (&op0, int_loc_descriptor (mask));
12010 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
12011 add_loc_descr (&op1, int_loc_descriptor (mask));
12012 add_loc_descr (&op1, new_loc_descr (DW_OP_and, 0, 0));
12014 else if (GET_MODE_SIZE (mode) == DWARF2_ADDR_SIZE)
12016 HOST_WIDE_INT bias = 1;
12017 bias <<= (DWARF2_ADDR_SIZE * BITS_PER_UNIT - 1);
12018 add_loc_descr (&op0, new_loc_descr (DW_OP_plus_uconst, bias, 0));
12019 add_loc_descr (&op1, new_loc_descr (DW_OP_plus_uconst, bias, 0));
12022 else if (GET_MODE_CLASS (mode) == MODE_INT
12023 && GET_MODE_SIZE (mode) < DWARF2_ADDR_SIZE)
12025 int shift = (DWARF2_ADDR_SIZE - GET_MODE_SIZE (mode)) * BITS_PER_UNIT;
12026 add_loc_descr (&op0, int_loc_descriptor (shift));
12027 add_loc_descr (&op0, new_loc_descr (DW_OP_shl, 0, 0));
12028 add_loc_descr (&op1, int_loc_descriptor (shift));
12029 add_loc_descr (&op1, new_loc_descr (DW_OP_shl, 0, 0));
12031 else if (GET_MODE_CLASS (mode) == MODE_INT
12032 && GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE)
12034 dw_die_ref type_die = base_type_for_mode (mode, 0);
12035 dw_loc_descr_ref cvt;
12036 if (type_die == NULL)
12037 return NULL;
12038 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
12039 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12040 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
12041 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
12042 add_loc_descr (&op0, cvt);
12043 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
12044 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12045 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
12046 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
12047 add_loc_descr (&op1, cvt);
12050 if (GET_CODE (rtl) == SMIN || GET_CODE (rtl) == UMIN)
12051 op = DW_OP_lt;
12052 else
12053 op = DW_OP_gt;
12054 ret = op0;
12055 add_loc_descr (&ret, op1);
12056 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
12057 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
12058 add_loc_descr (&ret, bra_node);
12059 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12060 drop_node = new_loc_descr (DW_OP_drop, 0, 0);
12061 add_loc_descr (&ret, drop_node);
12062 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
12063 bra_node->dw_loc_oprnd1.v.val_loc = drop_node;
12064 if ((GET_CODE (rtl) == SMIN || GET_CODE (rtl) == SMAX)
12065 && GET_MODE_CLASS (mode) == MODE_INT
12066 && GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE)
12067 ret = convert_descriptor_to_mode (mode, ret);
12068 return ret;
12071 /* Helper function for mem_loc_descriptor. Perform OP binary op,
12072 but after converting arguments to type_die, afterwards
12073 convert back to unsigned. */
12075 static dw_loc_descr_ref
12076 typed_binop (enum dwarf_location_atom op, rtx rtl, dw_die_ref type_die,
12077 machine_mode mode, machine_mode mem_mode)
12079 dw_loc_descr_ref cvt, op0, op1;
12081 if (type_die == NULL)
12082 return NULL;
12083 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12084 VAR_INIT_STATUS_INITIALIZED);
12085 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
12086 VAR_INIT_STATUS_INITIALIZED);
12087 if (op0 == NULL || op1 == NULL)
12088 return NULL;
12089 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
12090 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12091 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
12092 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
12093 add_loc_descr (&op0, cvt);
12094 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
12095 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12096 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
12097 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
12098 add_loc_descr (&op1, cvt);
12099 add_loc_descr (&op0, op1);
12100 add_loc_descr (&op0, new_loc_descr (op, 0, 0));
12101 return convert_descriptor_to_mode (mode, op0);
12104 /* CLZ (where constV is CLZ_DEFINED_VALUE_AT_ZERO computed value,
12105 const0 is DW_OP_lit0 or corresponding typed constant,
12106 const1 is DW_OP_lit1 or corresponding typed constant
12107 and constMSB is constant with just the MSB bit set
12108 for the mode):
12109 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
12110 L1: const0 DW_OP_swap
12111 L2: DW_OP_dup constMSB DW_OP_and DW_OP_bra <L3> const1 DW_OP_shl
12112 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
12113 L3: DW_OP_drop
12114 L4: DW_OP_nop
12116 CTZ is similar:
12117 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
12118 L1: const0 DW_OP_swap
12119 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
12120 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
12121 L3: DW_OP_drop
12122 L4: DW_OP_nop
12124 FFS is similar:
12125 DW_OP_dup DW_OP_bra <L1> DW_OP_drop const0 DW_OP_skip <L4>
12126 L1: const1 DW_OP_swap
12127 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
12128 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
12129 L3: DW_OP_drop
12130 L4: DW_OP_nop */
12132 static dw_loc_descr_ref
12133 clz_loc_descriptor (rtx rtl, machine_mode mode,
12134 machine_mode mem_mode)
12136 dw_loc_descr_ref op0, ret, tmp;
12137 HOST_WIDE_INT valv;
12138 dw_loc_descr_ref l1jump, l1label;
12139 dw_loc_descr_ref l2jump, l2label;
12140 dw_loc_descr_ref l3jump, l3label;
12141 dw_loc_descr_ref l4jump, l4label;
12142 rtx msb;
12144 if (GET_MODE_CLASS (mode) != MODE_INT
12145 || GET_MODE (XEXP (rtl, 0)) != mode)
12146 return NULL;
12148 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12149 VAR_INIT_STATUS_INITIALIZED);
12150 if (op0 == NULL)
12151 return NULL;
12152 ret = op0;
12153 if (GET_CODE (rtl) == CLZ)
12155 if (!CLZ_DEFINED_VALUE_AT_ZERO (mode, valv))
12156 valv = GET_MODE_BITSIZE (mode);
12158 else if (GET_CODE (rtl) == FFS)
12159 valv = 0;
12160 else if (!CTZ_DEFINED_VALUE_AT_ZERO (mode, valv))
12161 valv = GET_MODE_BITSIZE (mode);
12162 add_loc_descr (&ret, new_loc_descr (DW_OP_dup, 0, 0));
12163 l1jump = new_loc_descr (DW_OP_bra, 0, 0);
12164 add_loc_descr (&ret, l1jump);
12165 add_loc_descr (&ret, new_loc_descr (DW_OP_drop, 0, 0));
12166 tmp = mem_loc_descriptor (GEN_INT (valv), mode, mem_mode,
12167 VAR_INIT_STATUS_INITIALIZED);
12168 if (tmp == NULL)
12169 return NULL;
12170 add_loc_descr (&ret, tmp);
12171 l4jump = new_loc_descr (DW_OP_skip, 0, 0);
12172 add_loc_descr (&ret, l4jump);
12173 l1label = mem_loc_descriptor (GET_CODE (rtl) == FFS
12174 ? const1_rtx : const0_rtx,
12175 mode, mem_mode,
12176 VAR_INIT_STATUS_INITIALIZED);
12177 if (l1label == NULL)
12178 return NULL;
12179 add_loc_descr (&ret, l1label);
12180 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12181 l2label = new_loc_descr (DW_OP_dup, 0, 0);
12182 add_loc_descr (&ret, l2label);
12183 if (GET_CODE (rtl) != CLZ)
12184 msb = const1_rtx;
12185 else if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
12186 msb = GEN_INT ((unsigned HOST_WIDE_INT) 1
12187 << (GET_MODE_BITSIZE (mode) - 1));
12188 else
12189 msb = immed_wide_int_const
12190 (wi::set_bit_in_zero (GET_MODE_PRECISION (mode) - 1,
12191 GET_MODE_PRECISION (mode)), mode);
12192 if (GET_CODE (msb) == CONST_INT && INTVAL (msb) < 0)
12193 tmp = new_loc_descr (HOST_BITS_PER_WIDE_INT == 32
12194 ? DW_OP_const4u : HOST_BITS_PER_WIDE_INT == 64
12195 ? DW_OP_const8u : DW_OP_constu, INTVAL (msb), 0);
12196 else
12197 tmp = mem_loc_descriptor (msb, mode, mem_mode,
12198 VAR_INIT_STATUS_INITIALIZED);
12199 if (tmp == NULL)
12200 return NULL;
12201 add_loc_descr (&ret, tmp);
12202 add_loc_descr (&ret, new_loc_descr (DW_OP_and, 0, 0));
12203 l3jump = new_loc_descr (DW_OP_bra, 0, 0);
12204 add_loc_descr (&ret, l3jump);
12205 tmp = mem_loc_descriptor (const1_rtx, mode, mem_mode,
12206 VAR_INIT_STATUS_INITIALIZED);
12207 if (tmp == NULL)
12208 return NULL;
12209 add_loc_descr (&ret, tmp);
12210 add_loc_descr (&ret, new_loc_descr (GET_CODE (rtl) == CLZ
12211 ? DW_OP_shl : DW_OP_shr, 0, 0));
12212 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12213 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, 1, 0));
12214 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12215 l2jump = new_loc_descr (DW_OP_skip, 0, 0);
12216 add_loc_descr (&ret, l2jump);
12217 l3label = new_loc_descr (DW_OP_drop, 0, 0);
12218 add_loc_descr (&ret, l3label);
12219 l4label = new_loc_descr (DW_OP_nop, 0, 0);
12220 add_loc_descr (&ret, l4label);
12221 l1jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
12222 l1jump->dw_loc_oprnd1.v.val_loc = l1label;
12223 l2jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
12224 l2jump->dw_loc_oprnd1.v.val_loc = l2label;
12225 l3jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
12226 l3jump->dw_loc_oprnd1.v.val_loc = l3label;
12227 l4jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
12228 l4jump->dw_loc_oprnd1.v.val_loc = l4label;
12229 return ret;
12232 /* POPCOUNT (const0 is DW_OP_lit0 or corresponding typed constant,
12233 const1 is DW_OP_lit1 or corresponding typed constant):
12234 const0 DW_OP_swap
12235 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
12236 DW_OP_plus DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
12237 L2: DW_OP_drop
12239 PARITY is similar:
12240 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
12241 DW_OP_xor DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
12242 L2: DW_OP_drop */
12244 static dw_loc_descr_ref
12245 popcount_loc_descriptor (rtx rtl, machine_mode mode,
12246 machine_mode mem_mode)
12248 dw_loc_descr_ref op0, ret, tmp;
12249 dw_loc_descr_ref l1jump, l1label;
12250 dw_loc_descr_ref l2jump, l2label;
12252 if (GET_MODE_CLASS (mode) != MODE_INT
12253 || GET_MODE (XEXP (rtl, 0)) != mode)
12254 return NULL;
12256 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12257 VAR_INIT_STATUS_INITIALIZED);
12258 if (op0 == NULL)
12259 return NULL;
12260 ret = op0;
12261 tmp = mem_loc_descriptor (const0_rtx, mode, mem_mode,
12262 VAR_INIT_STATUS_INITIALIZED);
12263 if (tmp == NULL)
12264 return NULL;
12265 add_loc_descr (&ret, tmp);
12266 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12267 l1label = new_loc_descr (DW_OP_dup, 0, 0);
12268 add_loc_descr (&ret, l1label);
12269 l2jump = new_loc_descr (DW_OP_bra, 0, 0);
12270 add_loc_descr (&ret, l2jump);
12271 add_loc_descr (&ret, new_loc_descr (DW_OP_dup, 0, 0));
12272 add_loc_descr (&ret, new_loc_descr (DW_OP_rot, 0, 0));
12273 tmp = mem_loc_descriptor (const1_rtx, mode, mem_mode,
12274 VAR_INIT_STATUS_INITIALIZED);
12275 if (tmp == NULL)
12276 return NULL;
12277 add_loc_descr (&ret, tmp);
12278 add_loc_descr (&ret, new_loc_descr (DW_OP_and, 0, 0));
12279 add_loc_descr (&ret, new_loc_descr (GET_CODE (rtl) == POPCOUNT
12280 ? DW_OP_plus : DW_OP_xor, 0, 0));
12281 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12282 tmp = mem_loc_descriptor (const1_rtx, mode, mem_mode,
12283 VAR_INIT_STATUS_INITIALIZED);
12284 add_loc_descr (&ret, tmp);
12285 add_loc_descr (&ret, new_loc_descr (DW_OP_shr, 0, 0));
12286 l1jump = new_loc_descr (DW_OP_skip, 0, 0);
12287 add_loc_descr (&ret, l1jump);
12288 l2label = new_loc_descr (DW_OP_drop, 0, 0);
12289 add_loc_descr (&ret, l2label);
12290 l1jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
12291 l1jump->dw_loc_oprnd1.v.val_loc = l1label;
12292 l2jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
12293 l2jump->dw_loc_oprnd1.v.val_loc = l2label;
12294 return ret;
12297 /* BSWAP (constS is initial shift count, either 56 or 24):
12298 constS const0
12299 L1: DW_OP_pick <2> constS DW_OP_pick <3> DW_OP_minus DW_OP_shr
12300 const255 DW_OP_and DW_OP_pick <2> DW_OP_shl DW_OP_or
12301 DW_OP_swap DW_OP_dup const0 DW_OP_eq DW_OP_bra <L2> const8
12302 DW_OP_minus DW_OP_swap DW_OP_skip <L1>
12303 L2: DW_OP_drop DW_OP_swap DW_OP_drop */
12305 static dw_loc_descr_ref
12306 bswap_loc_descriptor (rtx rtl, machine_mode mode,
12307 machine_mode mem_mode)
12309 dw_loc_descr_ref op0, ret, tmp;
12310 dw_loc_descr_ref l1jump, l1label;
12311 dw_loc_descr_ref l2jump, l2label;
12313 if (GET_MODE_CLASS (mode) != MODE_INT
12314 || BITS_PER_UNIT != 8
12315 || (GET_MODE_BITSIZE (mode) != 32
12316 && GET_MODE_BITSIZE (mode) != 64))
12317 return NULL;
12319 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12320 VAR_INIT_STATUS_INITIALIZED);
12321 if (op0 == NULL)
12322 return NULL;
12324 ret = op0;
12325 tmp = mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode) - 8),
12326 mode, mem_mode,
12327 VAR_INIT_STATUS_INITIALIZED);
12328 if (tmp == NULL)
12329 return NULL;
12330 add_loc_descr (&ret, tmp);
12331 tmp = mem_loc_descriptor (const0_rtx, mode, mem_mode,
12332 VAR_INIT_STATUS_INITIALIZED);
12333 if (tmp == NULL)
12334 return NULL;
12335 add_loc_descr (&ret, tmp);
12336 l1label = new_loc_descr (DW_OP_pick, 2, 0);
12337 add_loc_descr (&ret, l1label);
12338 tmp = mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode) - 8),
12339 mode, mem_mode,
12340 VAR_INIT_STATUS_INITIALIZED);
12341 add_loc_descr (&ret, tmp);
12342 add_loc_descr (&ret, new_loc_descr (DW_OP_pick, 3, 0));
12343 add_loc_descr (&ret, new_loc_descr (DW_OP_minus, 0, 0));
12344 add_loc_descr (&ret, new_loc_descr (DW_OP_shr, 0, 0));
12345 tmp = mem_loc_descriptor (GEN_INT (255), mode, mem_mode,
12346 VAR_INIT_STATUS_INITIALIZED);
12347 if (tmp == NULL)
12348 return NULL;
12349 add_loc_descr (&ret, tmp);
12350 add_loc_descr (&ret, new_loc_descr (DW_OP_and, 0, 0));
12351 add_loc_descr (&ret, new_loc_descr (DW_OP_pick, 2, 0));
12352 add_loc_descr (&ret, new_loc_descr (DW_OP_shl, 0, 0));
12353 add_loc_descr (&ret, new_loc_descr (DW_OP_or, 0, 0));
12354 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12355 add_loc_descr (&ret, new_loc_descr (DW_OP_dup, 0, 0));
12356 tmp = mem_loc_descriptor (const0_rtx, mode, mem_mode,
12357 VAR_INIT_STATUS_INITIALIZED);
12358 add_loc_descr (&ret, tmp);
12359 add_loc_descr (&ret, new_loc_descr (DW_OP_eq, 0, 0));
12360 l2jump = new_loc_descr (DW_OP_bra, 0, 0);
12361 add_loc_descr (&ret, l2jump);
12362 tmp = mem_loc_descriptor (GEN_INT (8), mode, mem_mode,
12363 VAR_INIT_STATUS_INITIALIZED);
12364 add_loc_descr (&ret, tmp);
12365 add_loc_descr (&ret, new_loc_descr (DW_OP_minus, 0, 0));
12366 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12367 l1jump = new_loc_descr (DW_OP_skip, 0, 0);
12368 add_loc_descr (&ret, l1jump);
12369 l2label = new_loc_descr (DW_OP_drop, 0, 0);
12370 add_loc_descr (&ret, l2label);
12371 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12372 add_loc_descr (&ret, new_loc_descr (DW_OP_drop, 0, 0));
12373 l1jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
12374 l1jump->dw_loc_oprnd1.v.val_loc = l1label;
12375 l2jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
12376 l2jump->dw_loc_oprnd1.v.val_loc = l2label;
12377 return ret;
12380 /* ROTATE (constMASK is mode mask, BITSIZE is bitsize of mode):
12381 DW_OP_over DW_OP_over DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
12382 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_neg
12383 DW_OP_plus_uconst <BITSIZE> DW_OP_shr DW_OP_or
12385 ROTATERT is similar:
12386 DW_OP_over DW_OP_over DW_OP_neg DW_OP_plus_uconst <BITSIZE>
12387 DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
12388 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_shr DW_OP_or */
12390 static dw_loc_descr_ref
12391 rotate_loc_descriptor (rtx rtl, machine_mode mode,
12392 machine_mode mem_mode)
12394 rtx rtlop1 = XEXP (rtl, 1);
12395 dw_loc_descr_ref op0, op1, ret, mask[2] = { NULL, NULL };
12396 int i;
12398 if (GET_MODE_CLASS (mode) != MODE_INT)
12399 return NULL;
12401 if (GET_MODE (rtlop1) != VOIDmode
12402 && GET_MODE_BITSIZE (GET_MODE (rtlop1)) < GET_MODE_BITSIZE (mode))
12403 rtlop1 = gen_rtx_ZERO_EXTEND (mode, rtlop1);
12404 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12405 VAR_INIT_STATUS_INITIALIZED);
12406 op1 = mem_loc_descriptor (rtlop1, mode, mem_mode,
12407 VAR_INIT_STATUS_INITIALIZED);
12408 if (op0 == NULL || op1 == NULL)
12409 return NULL;
12410 if (GET_MODE_SIZE (mode) < DWARF2_ADDR_SIZE)
12411 for (i = 0; i < 2; i++)
12413 if (GET_MODE_BITSIZE (mode) < HOST_BITS_PER_WIDE_INT)
12414 mask[i] = mem_loc_descriptor (GEN_INT (GET_MODE_MASK (mode)),
12415 mode, mem_mode,
12416 VAR_INIT_STATUS_INITIALIZED);
12417 else if (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT)
12418 mask[i] = new_loc_descr (HOST_BITS_PER_WIDE_INT == 32
12419 ? DW_OP_const4u
12420 : HOST_BITS_PER_WIDE_INT == 64
12421 ? DW_OP_const8u : DW_OP_constu,
12422 GET_MODE_MASK (mode), 0);
12423 else
12424 mask[i] = NULL;
12425 if (mask[i] == NULL)
12426 return NULL;
12427 add_loc_descr (&mask[i], new_loc_descr (DW_OP_and, 0, 0));
12429 ret = op0;
12430 add_loc_descr (&ret, op1);
12431 add_loc_descr (&ret, new_loc_descr (DW_OP_over, 0, 0));
12432 add_loc_descr (&ret, new_loc_descr (DW_OP_over, 0, 0));
12433 if (GET_CODE (rtl) == ROTATERT)
12435 add_loc_descr (&ret, new_loc_descr (DW_OP_neg, 0, 0));
12436 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst,
12437 GET_MODE_BITSIZE (mode), 0));
12439 add_loc_descr (&ret, new_loc_descr (DW_OP_shl, 0, 0));
12440 if (mask[0] != NULL)
12441 add_loc_descr (&ret, mask[0]);
12442 add_loc_descr (&ret, new_loc_descr (DW_OP_rot, 0, 0));
12443 if (mask[1] != NULL)
12445 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12446 add_loc_descr (&ret, mask[1]);
12447 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12449 if (GET_CODE (rtl) == ROTATE)
12451 add_loc_descr (&ret, new_loc_descr (DW_OP_neg, 0, 0));
12452 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst,
12453 GET_MODE_BITSIZE (mode), 0));
12455 add_loc_descr (&ret, new_loc_descr (DW_OP_shr, 0, 0));
12456 add_loc_descr (&ret, new_loc_descr (DW_OP_or, 0, 0));
12457 return ret;
12460 /* Helper function for mem_loc_descriptor. Return DW_OP_GNU_parameter_ref
12461 for DEBUG_PARAMETER_REF RTL. */
12463 static dw_loc_descr_ref
12464 parameter_ref_descriptor (rtx rtl)
12466 dw_loc_descr_ref ret;
12467 dw_die_ref ref;
12469 if (dwarf_strict)
12470 return NULL;
12471 gcc_assert (TREE_CODE (DEBUG_PARAMETER_REF_DECL (rtl)) == PARM_DECL);
12472 ref = lookup_decl_die (DEBUG_PARAMETER_REF_DECL (rtl));
12473 ret = new_loc_descr (DW_OP_GNU_parameter_ref, 0, 0);
12474 if (ref)
12476 ret->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12477 ret->dw_loc_oprnd1.v.val_die_ref.die = ref;
12478 ret->dw_loc_oprnd1.v.val_die_ref.external = 0;
12480 else
12482 ret->dw_loc_oprnd1.val_class = dw_val_class_decl_ref;
12483 ret->dw_loc_oprnd1.v.val_decl_ref = DEBUG_PARAMETER_REF_DECL (rtl);
12485 return ret;
12488 /* The following routine converts the RTL for a variable or parameter
12489 (resident in memory) into an equivalent Dwarf representation of a
12490 mechanism for getting the address of that same variable onto the top of a
12491 hypothetical "address evaluation" stack.
12493 When creating memory location descriptors, we are effectively transforming
12494 the RTL for a memory-resident object into its Dwarf postfix expression
12495 equivalent. This routine recursively descends an RTL tree, turning
12496 it into Dwarf postfix code as it goes.
12498 MODE is the mode that should be assumed for the rtl if it is VOIDmode.
12500 MEM_MODE is the mode of the memory reference, needed to handle some
12501 autoincrement addressing modes.
12503 Return 0 if we can't represent the location. */
12505 dw_loc_descr_ref
12506 mem_loc_descriptor (rtx rtl, machine_mode mode,
12507 machine_mode mem_mode,
12508 enum var_init_status initialized)
12510 dw_loc_descr_ref mem_loc_result = NULL;
12511 enum dwarf_location_atom op;
12512 dw_loc_descr_ref op0, op1;
12513 rtx inner = NULL_RTX;
12515 if (mode == VOIDmode)
12516 mode = GET_MODE (rtl);
12518 /* Note that for a dynamically sized array, the location we will generate a
12519 description of here will be the lowest numbered location which is
12520 actually within the array. That's *not* necessarily the same as the
12521 zeroth element of the array. */
12523 rtl = targetm.delegitimize_address (rtl);
12525 if (mode != GET_MODE (rtl) && GET_MODE (rtl) != VOIDmode)
12526 return NULL;
12528 switch (GET_CODE (rtl))
12530 case POST_INC:
12531 case POST_DEC:
12532 case POST_MODIFY:
12533 return mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode, initialized);
12535 case SUBREG:
12536 /* The case of a subreg may arise when we have a local (register)
12537 variable or a formal (register) parameter which doesn't quite fill
12538 up an entire register. For now, just assume that it is
12539 legitimate to make the Dwarf info refer to the whole register which
12540 contains the given subreg. */
12541 if (!subreg_lowpart_p (rtl))
12542 break;
12543 inner = SUBREG_REG (rtl);
12544 case TRUNCATE:
12545 if (inner == NULL_RTX)
12546 inner = XEXP (rtl, 0);
12547 if (GET_MODE_CLASS (mode) == MODE_INT
12548 && GET_MODE_CLASS (GET_MODE (inner)) == MODE_INT
12549 && (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE
12550 #ifdef POINTERS_EXTEND_UNSIGNED
12551 || (mode == Pmode && mem_mode != VOIDmode)
12552 #endif
12554 && GET_MODE_SIZE (GET_MODE (inner)) <= DWARF2_ADDR_SIZE)
12556 mem_loc_result = mem_loc_descriptor (inner,
12557 GET_MODE (inner),
12558 mem_mode, initialized);
12559 break;
12561 if (dwarf_strict)
12562 break;
12563 if (GET_MODE_SIZE (mode) > GET_MODE_SIZE (GET_MODE (inner)))
12564 break;
12565 if (GET_MODE_SIZE (mode) != GET_MODE_SIZE (GET_MODE (inner))
12566 && (GET_MODE_CLASS (mode) != MODE_INT
12567 || GET_MODE_CLASS (GET_MODE (inner)) != MODE_INT))
12568 break;
12569 else
12571 dw_die_ref type_die;
12572 dw_loc_descr_ref cvt;
12574 mem_loc_result = mem_loc_descriptor (inner,
12575 GET_MODE (inner),
12576 mem_mode, initialized);
12577 if (mem_loc_result == NULL)
12578 break;
12579 type_die = base_type_for_mode (mode,
12580 GET_MODE_CLASS (mode) == MODE_INT);
12581 if (type_die == NULL)
12583 mem_loc_result = NULL;
12584 break;
12586 if (GET_MODE_SIZE (mode)
12587 != GET_MODE_SIZE (GET_MODE (inner)))
12588 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
12589 else
12590 cvt = new_loc_descr (DW_OP_GNU_reinterpret, 0, 0);
12591 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12592 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
12593 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
12594 add_loc_descr (&mem_loc_result, cvt);
12596 break;
12598 case REG:
12599 if (GET_MODE_CLASS (mode) != MODE_INT
12600 || (GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE
12601 && rtl != arg_pointer_rtx
12602 && rtl != frame_pointer_rtx
12603 #ifdef POINTERS_EXTEND_UNSIGNED
12604 && (mode != Pmode || mem_mode == VOIDmode)
12605 #endif
12608 dw_die_ref type_die;
12609 unsigned int dbx_regnum;
12611 if (dwarf_strict)
12612 break;
12613 if (REGNO (rtl) > FIRST_PSEUDO_REGISTER)
12614 break;
12615 type_die = base_type_for_mode (mode,
12616 GET_MODE_CLASS (mode) == MODE_INT);
12617 if (type_die == NULL)
12618 break;
12620 dbx_regnum = dbx_reg_number (rtl);
12621 if (dbx_regnum == IGNORED_DWARF_REGNUM)
12622 break;
12623 mem_loc_result = new_loc_descr (DW_OP_GNU_regval_type,
12624 dbx_regnum, 0);
12625 mem_loc_result->dw_loc_oprnd2.val_class = dw_val_class_die_ref;
12626 mem_loc_result->dw_loc_oprnd2.v.val_die_ref.die = type_die;
12627 mem_loc_result->dw_loc_oprnd2.v.val_die_ref.external = 0;
12628 break;
12630 /* Whenever a register number forms a part of the description of the
12631 method for calculating the (dynamic) address of a memory resident
12632 object, DWARF rules require the register number be referred to as
12633 a "base register". This distinction is not based in any way upon
12634 what category of register the hardware believes the given register
12635 belongs to. This is strictly DWARF terminology we're dealing with
12636 here. Note that in cases where the location of a memory-resident
12637 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
12638 OP_CONST (0)) the actual DWARF location descriptor that we generate
12639 may just be OP_BASEREG (basereg). This may look deceptively like
12640 the object in question was allocated to a register (rather than in
12641 memory) so DWARF consumers need to be aware of the subtle
12642 distinction between OP_REG and OP_BASEREG. */
12643 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
12644 mem_loc_result = based_loc_descr (rtl, 0, VAR_INIT_STATUS_INITIALIZED);
12645 else if (stack_realign_drap
12646 && crtl->drap_reg
12647 && crtl->args.internal_arg_pointer == rtl
12648 && REGNO (crtl->drap_reg) < FIRST_PSEUDO_REGISTER)
12650 /* If RTL is internal_arg_pointer, which has been optimized
12651 out, use DRAP instead. */
12652 mem_loc_result = based_loc_descr (crtl->drap_reg, 0,
12653 VAR_INIT_STATUS_INITIALIZED);
12655 break;
12657 case SIGN_EXTEND:
12658 case ZERO_EXTEND:
12659 if (GET_MODE_CLASS (mode) != MODE_INT)
12660 break;
12661 op0 = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (XEXP (rtl, 0)),
12662 mem_mode, VAR_INIT_STATUS_INITIALIZED);
12663 if (op0 == 0)
12664 break;
12665 else if (GET_CODE (rtl) == ZERO_EXTEND
12666 && GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE
12667 && GET_MODE_BITSIZE (GET_MODE (XEXP (rtl, 0)))
12668 < HOST_BITS_PER_WIDE_INT
12669 /* If DW_OP_const{1,2,4}u won't be used, it is shorter
12670 to expand zero extend as two shifts instead of
12671 masking. */
12672 && GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) <= 4)
12674 machine_mode imode = GET_MODE (XEXP (rtl, 0));
12675 mem_loc_result = op0;
12676 add_loc_descr (&mem_loc_result,
12677 int_loc_descriptor (GET_MODE_MASK (imode)));
12678 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_and, 0, 0));
12680 else if (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE)
12682 int shift = DWARF2_ADDR_SIZE
12683 - GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0)));
12684 shift *= BITS_PER_UNIT;
12685 if (GET_CODE (rtl) == SIGN_EXTEND)
12686 op = DW_OP_shra;
12687 else
12688 op = DW_OP_shr;
12689 mem_loc_result = op0;
12690 add_loc_descr (&mem_loc_result, int_loc_descriptor (shift));
12691 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_shl, 0, 0));
12692 add_loc_descr (&mem_loc_result, int_loc_descriptor (shift));
12693 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
12695 else if (!dwarf_strict)
12697 dw_die_ref type_die1, type_die2;
12698 dw_loc_descr_ref cvt;
12700 type_die1 = base_type_for_mode (GET_MODE (XEXP (rtl, 0)),
12701 GET_CODE (rtl) == ZERO_EXTEND);
12702 if (type_die1 == NULL)
12703 break;
12704 type_die2 = base_type_for_mode (mode, 1);
12705 if (type_die2 == NULL)
12706 break;
12707 mem_loc_result = op0;
12708 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
12709 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12710 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die1;
12711 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
12712 add_loc_descr (&mem_loc_result, cvt);
12713 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
12714 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12715 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die2;
12716 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
12717 add_loc_descr (&mem_loc_result, cvt);
12719 break;
12721 case MEM:
12723 rtx new_rtl = avoid_constant_pool_reference (rtl);
12724 if (new_rtl != rtl)
12726 mem_loc_result = mem_loc_descriptor (new_rtl, mode, mem_mode,
12727 initialized);
12728 if (mem_loc_result != NULL)
12729 return mem_loc_result;
12732 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0),
12733 get_address_mode (rtl), mode,
12734 VAR_INIT_STATUS_INITIALIZED);
12735 if (mem_loc_result == NULL)
12736 mem_loc_result = tls_mem_loc_descriptor (rtl);
12737 if (mem_loc_result != NULL)
12739 if (GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE
12740 || GET_MODE_CLASS (mode) != MODE_INT)
12742 dw_die_ref type_die;
12743 dw_loc_descr_ref deref;
12745 if (dwarf_strict)
12746 return NULL;
12747 type_die
12748 = base_type_for_mode (mode, GET_MODE_CLASS (mode) == MODE_INT);
12749 if (type_die == NULL)
12750 return NULL;
12751 deref = new_loc_descr (DW_OP_GNU_deref_type,
12752 GET_MODE_SIZE (mode), 0);
12753 deref->dw_loc_oprnd2.val_class = dw_val_class_die_ref;
12754 deref->dw_loc_oprnd2.v.val_die_ref.die = type_die;
12755 deref->dw_loc_oprnd2.v.val_die_ref.external = 0;
12756 add_loc_descr (&mem_loc_result, deref);
12758 else if (GET_MODE_SIZE (mode) == DWARF2_ADDR_SIZE)
12759 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
12760 else
12761 add_loc_descr (&mem_loc_result,
12762 new_loc_descr (DW_OP_deref_size,
12763 GET_MODE_SIZE (mode), 0));
12765 break;
12767 case LO_SUM:
12768 return mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode, initialized);
12770 case LABEL_REF:
12771 /* Some ports can transform a symbol ref into a label ref, because
12772 the symbol ref is too far away and has to be dumped into a constant
12773 pool. */
12774 case CONST:
12775 case SYMBOL_REF:
12776 if ((GET_MODE_CLASS (mode) != MODE_INT
12777 && GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
12778 || (GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE
12779 #ifdef POINTERS_EXTEND_UNSIGNED
12780 && (mode != Pmode || mem_mode == VOIDmode)
12781 #endif
12783 break;
12784 if (GET_CODE (rtl) == SYMBOL_REF
12785 && SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE)
12787 dw_loc_descr_ref temp;
12789 /* If this is not defined, we have no way to emit the data. */
12790 if (!targetm.have_tls || !targetm.asm_out.output_dwarf_dtprel)
12791 break;
12793 temp = new_addr_loc_descr (rtl, dtprel_true);
12795 mem_loc_result = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
12796 add_loc_descr (&mem_loc_result, temp);
12798 break;
12801 if (!const_ok_for_output (rtl))
12802 break;
12804 symref:
12805 mem_loc_result = new_addr_loc_descr (rtl, dtprel_false);
12806 vec_safe_push (used_rtx_array, rtl);
12807 break;
12809 case CONCAT:
12810 case CONCATN:
12811 case VAR_LOCATION:
12812 case DEBUG_IMPLICIT_PTR:
12813 expansion_failed (NULL_TREE, rtl,
12814 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
12815 return 0;
12817 case ENTRY_VALUE:
12818 if (dwarf_strict)
12819 return NULL;
12820 if (REG_P (ENTRY_VALUE_EXP (rtl)))
12822 if (GET_MODE_CLASS (mode) != MODE_INT
12823 || GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE)
12824 op0 = mem_loc_descriptor (ENTRY_VALUE_EXP (rtl), mode,
12825 VOIDmode, VAR_INIT_STATUS_INITIALIZED);
12826 else
12828 unsigned int dbx_regnum = dbx_reg_number (ENTRY_VALUE_EXP (rtl));
12829 if (dbx_regnum == IGNORED_DWARF_REGNUM)
12830 return NULL;
12831 op0 = one_reg_loc_descriptor (dbx_regnum,
12832 VAR_INIT_STATUS_INITIALIZED);
12835 else if (MEM_P (ENTRY_VALUE_EXP (rtl))
12836 && REG_P (XEXP (ENTRY_VALUE_EXP (rtl), 0)))
12838 op0 = mem_loc_descriptor (ENTRY_VALUE_EXP (rtl), mode,
12839 VOIDmode, VAR_INIT_STATUS_INITIALIZED);
12840 if (op0 && op0->dw_loc_opc == DW_OP_fbreg)
12841 return NULL;
12843 else
12844 gcc_unreachable ();
12845 if (op0 == NULL)
12846 return NULL;
12847 mem_loc_result = new_loc_descr (DW_OP_GNU_entry_value, 0, 0);
12848 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_loc;
12849 mem_loc_result->dw_loc_oprnd1.v.val_loc = op0;
12850 break;
12852 case DEBUG_PARAMETER_REF:
12853 mem_loc_result = parameter_ref_descriptor (rtl);
12854 break;
12856 case PRE_MODIFY:
12857 /* Extract the PLUS expression nested inside and fall into
12858 PLUS code below. */
12859 rtl = XEXP (rtl, 1);
12860 goto plus;
12862 case PRE_INC:
12863 case PRE_DEC:
12864 /* Turn these into a PLUS expression and fall into the PLUS code
12865 below. */
12866 rtl = gen_rtx_PLUS (mode, XEXP (rtl, 0),
12867 gen_int_mode (GET_CODE (rtl) == PRE_INC
12868 ? GET_MODE_UNIT_SIZE (mem_mode)
12869 : -GET_MODE_UNIT_SIZE (mem_mode),
12870 mode));
12872 /* ... fall through ... */
12874 case PLUS:
12875 plus:
12876 if (is_based_loc (rtl)
12877 && (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE
12878 || XEXP (rtl, 0) == arg_pointer_rtx
12879 || XEXP (rtl, 0) == frame_pointer_rtx)
12880 && GET_MODE_CLASS (mode) == MODE_INT)
12881 mem_loc_result = based_loc_descr (XEXP (rtl, 0),
12882 INTVAL (XEXP (rtl, 1)),
12883 VAR_INIT_STATUS_INITIALIZED);
12884 else
12886 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12887 VAR_INIT_STATUS_INITIALIZED);
12888 if (mem_loc_result == 0)
12889 break;
12891 if (CONST_INT_P (XEXP (rtl, 1))
12892 && GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE)
12893 loc_descr_plus_const (&mem_loc_result, INTVAL (XEXP (rtl, 1)));
12894 else
12896 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
12897 VAR_INIT_STATUS_INITIALIZED);
12898 if (op1 == 0)
12899 return NULL;
12900 add_loc_descr (&mem_loc_result, op1);
12901 add_loc_descr (&mem_loc_result,
12902 new_loc_descr (DW_OP_plus, 0, 0));
12905 break;
12907 /* If a pseudo-reg is optimized away, it is possible for it to
12908 be replaced with a MEM containing a multiply or shift. */
12909 case MINUS:
12910 op = DW_OP_minus;
12911 goto do_binop;
12913 case MULT:
12914 op = DW_OP_mul;
12915 goto do_binop;
12917 case DIV:
12918 if (!dwarf_strict
12919 && GET_MODE_CLASS (mode) == MODE_INT
12920 && GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE)
12922 mem_loc_result = typed_binop (DW_OP_div, rtl,
12923 base_type_for_mode (mode, 0),
12924 mode, mem_mode);
12925 break;
12927 op = DW_OP_div;
12928 goto do_binop;
12930 case UMOD:
12931 op = DW_OP_mod;
12932 goto do_binop;
12934 case ASHIFT:
12935 op = DW_OP_shl;
12936 goto do_shift;
12938 case ASHIFTRT:
12939 op = DW_OP_shra;
12940 goto do_shift;
12942 case LSHIFTRT:
12943 op = DW_OP_shr;
12944 goto do_shift;
12946 do_shift:
12947 if (GET_MODE_CLASS (mode) != MODE_INT)
12948 break;
12949 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12950 VAR_INIT_STATUS_INITIALIZED);
12952 rtx rtlop1 = XEXP (rtl, 1);
12953 if (GET_MODE (rtlop1) != VOIDmode
12954 && GET_MODE_BITSIZE (GET_MODE (rtlop1))
12955 < GET_MODE_BITSIZE (mode))
12956 rtlop1 = gen_rtx_ZERO_EXTEND (mode, rtlop1);
12957 op1 = mem_loc_descriptor (rtlop1, mode, mem_mode,
12958 VAR_INIT_STATUS_INITIALIZED);
12961 if (op0 == 0 || op1 == 0)
12962 break;
12964 mem_loc_result = op0;
12965 add_loc_descr (&mem_loc_result, op1);
12966 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
12967 break;
12969 case AND:
12970 op = DW_OP_and;
12971 goto do_binop;
12973 case IOR:
12974 op = DW_OP_or;
12975 goto do_binop;
12977 case XOR:
12978 op = DW_OP_xor;
12979 goto do_binop;
12981 do_binop:
12982 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12983 VAR_INIT_STATUS_INITIALIZED);
12984 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
12985 VAR_INIT_STATUS_INITIALIZED);
12987 if (op0 == 0 || op1 == 0)
12988 break;
12990 mem_loc_result = op0;
12991 add_loc_descr (&mem_loc_result, op1);
12992 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
12993 break;
12995 case MOD:
12996 if (GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE && !dwarf_strict)
12998 mem_loc_result = typed_binop (DW_OP_mod, rtl,
12999 base_type_for_mode (mode, 0),
13000 mode, mem_mode);
13001 break;
13004 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
13005 VAR_INIT_STATUS_INITIALIZED);
13006 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
13007 VAR_INIT_STATUS_INITIALIZED);
13009 if (op0 == 0 || op1 == 0)
13010 break;
13012 mem_loc_result = op0;
13013 add_loc_descr (&mem_loc_result, op1);
13014 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_over, 0, 0));
13015 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_over, 0, 0));
13016 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_div, 0, 0));
13017 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
13018 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_minus, 0, 0));
13019 break;
13021 case UDIV:
13022 if (!dwarf_strict && GET_MODE_CLASS (mode) == MODE_INT)
13024 if (GET_MODE_CLASS (mode) > DWARF2_ADDR_SIZE)
13026 op = DW_OP_div;
13027 goto do_binop;
13029 mem_loc_result = typed_binop (DW_OP_div, rtl,
13030 base_type_for_mode (mode, 1),
13031 mode, mem_mode);
13033 break;
13035 case NOT:
13036 op = DW_OP_not;
13037 goto do_unop;
13039 case ABS:
13040 op = DW_OP_abs;
13041 goto do_unop;
13043 case NEG:
13044 op = DW_OP_neg;
13045 goto do_unop;
13047 do_unop:
13048 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
13049 VAR_INIT_STATUS_INITIALIZED);
13051 if (op0 == 0)
13052 break;
13054 mem_loc_result = op0;
13055 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
13056 break;
13058 case CONST_INT:
13059 if (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE
13060 #ifdef POINTERS_EXTEND_UNSIGNED
13061 || (mode == Pmode
13062 && mem_mode != VOIDmode
13063 && trunc_int_for_mode (INTVAL (rtl), ptr_mode) == INTVAL (rtl))
13064 #endif
13067 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
13068 break;
13070 if (!dwarf_strict
13071 && (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT
13072 || GET_MODE_BITSIZE (mode) == HOST_BITS_PER_DOUBLE_INT))
13074 dw_die_ref type_die = base_type_for_mode (mode, 1);
13075 machine_mode amode;
13076 if (type_die == NULL)
13077 return NULL;
13078 amode = mode_for_size (DWARF2_ADDR_SIZE * BITS_PER_UNIT,
13079 MODE_INT, 0);
13080 if (INTVAL (rtl) >= 0
13081 && amode != BLKmode
13082 && trunc_int_for_mode (INTVAL (rtl), amode) == INTVAL (rtl)
13083 /* const DW_OP_GNU_convert <XXX> vs.
13084 DW_OP_GNU_const_type <XXX, 1, const>. */
13085 && size_of_int_loc_descriptor (INTVAL (rtl)) + 1 + 1
13086 < (unsigned long) 1 + 1 + 1 + GET_MODE_SIZE (mode))
13088 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
13089 op0 = new_loc_descr (DW_OP_GNU_convert, 0, 0);
13090 op0->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
13091 op0->dw_loc_oprnd1.v.val_die_ref.die = type_die;
13092 op0->dw_loc_oprnd1.v.val_die_ref.external = 0;
13093 add_loc_descr (&mem_loc_result, op0);
13094 return mem_loc_result;
13096 mem_loc_result = new_loc_descr (DW_OP_GNU_const_type, 0,
13097 INTVAL (rtl));
13098 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
13099 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.die = type_die;
13100 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.external = 0;
13101 if (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT)
13102 mem_loc_result->dw_loc_oprnd2.val_class = dw_val_class_const;
13103 else
13105 mem_loc_result->dw_loc_oprnd2.val_class
13106 = dw_val_class_const_double;
13107 mem_loc_result->dw_loc_oprnd2.v.val_double
13108 = double_int::from_shwi (INTVAL (rtl));
13111 break;
13113 case CONST_DOUBLE:
13114 if (!dwarf_strict)
13116 dw_die_ref type_die;
13118 /* Note that if TARGET_SUPPORTS_WIDE_INT == 0, a
13119 CONST_DOUBLE rtx could represent either a large integer
13120 or a floating-point constant. If TARGET_SUPPORTS_WIDE_INT != 0,
13121 the value is always a floating point constant.
13123 When it is an integer, a CONST_DOUBLE is used whenever
13124 the constant requires 2 HWIs to be adequately represented.
13125 We output CONST_DOUBLEs as blocks. */
13126 if (mode == VOIDmode
13127 || (GET_MODE (rtl) == VOIDmode
13128 && GET_MODE_BITSIZE (mode) != HOST_BITS_PER_DOUBLE_INT))
13129 break;
13130 type_die = base_type_for_mode (mode,
13131 GET_MODE_CLASS (mode) == MODE_INT);
13132 if (type_die == NULL)
13133 return NULL;
13134 mem_loc_result = new_loc_descr (DW_OP_GNU_const_type, 0, 0);
13135 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
13136 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.die = type_die;
13137 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.external = 0;
13138 #if TARGET_SUPPORTS_WIDE_INT == 0
13139 if (!SCALAR_FLOAT_MODE_P (mode))
13141 mem_loc_result->dw_loc_oprnd2.val_class
13142 = dw_val_class_const_double;
13143 mem_loc_result->dw_loc_oprnd2.v.val_double
13144 = rtx_to_double_int (rtl);
13146 else
13147 #endif
13149 unsigned int length = GET_MODE_SIZE (mode);
13150 unsigned char *array = ggc_vec_alloc<unsigned char> (length);
13152 insert_float (rtl, array);
13153 mem_loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
13154 mem_loc_result->dw_loc_oprnd2.v.val_vec.length = length / 4;
13155 mem_loc_result->dw_loc_oprnd2.v.val_vec.elt_size = 4;
13156 mem_loc_result->dw_loc_oprnd2.v.val_vec.array = array;
13159 break;
13161 case CONST_WIDE_INT:
13162 if (!dwarf_strict)
13164 dw_die_ref type_die;
13166 type_die = base_type_for_mode (mode,
13167 GET_MODE_CLASS (mode) == MODE_INT);
13168 if (type_die == NULL)
13169 return NULL;
13170 mem_loc_result = new_loc_descr (DW_OP_GNU_const_type, 0, 0);
13171 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
13172 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.die = type_die;
13173 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.external = 0;
13174 mem_loc_result->dw_loc_oprnd2.val_class
13175 = dw_val_class_wide_int;
13176 mem_loc_result->dw_loc_oprnd2.v.val_wide = ggc_alloc<wide_int> ();
13177 *mem_loc_result->dw_loc_oprnd2.v.val_wide = std::make_pair (rtl, mode);
13179 break;
13181 case EQ:
13182 mem_loc_result = scompare_loc_descriptor (DW_OP_eq, rtl, mem_mode);
13183 break;
13185 case GE:
13186 mem_loc_result = scompare_loc_descriptor (DW_OP_ge, rtl, mem_mode);
13187 break;
13189 case GT:
13190 mem_loc_result = scompare_loc_descriptor (DW_OP_gt, rtl, mem_mode);
13191 break;
13193 case LE:
13194 mem_loc_result = scompare_loc_descriptor (DW_OP_le, rtl, mem_mode);
13195 break;
13197 case LT:
13198 mem_loc_result = scompare_loc_descriptor (DW_OP_lt, rtl, mem_mode);
13199 break;
13201 case NE:
13202 mem_loc_result = scompare_loc_descriptor (DW_OP_ne, rtl, mem_mode);
13203 break;
13205 case GEU:
13206 mem_loc_result = ucompare_loc_descriptor (DW_OP_ge, rtl, mem_mode);
13207 break;
13209 case GTU:
13210 mem_loc_result = ucompare_loc_descriptor (DW_OP_gt, rtl, mem_mode);
13211 break;
13213 case LEU:
13214 mem_loc_result = ucompare_loc_descriptor (DW_OP_le, rtl, mem_mode);
13215 break;
13217 case LTU:
13218 mem_loc_result = ucompare_loc_descriptor (DW_OP_lt, rtl, mem_mode);
13219 break;
13221 case UMIN:
13222 case UMAX:
13223 if (GET_MODE_CLASS (mode) != MODE_INT)
13224 break;
13225 /* FALLTHRU */
13226 case SMIN:
13227 case SMAX:
13228 mem_loc_result = minmax_loc_descriptor (rtl, mode, mem_mode);
13229 break;
13231 case ZERO_EXTRACT:
13232 case SIGN_EXTRACT:
13233 if (CONST_INT_P (XEXP (rtl, 1))
13234 && CONST_INT_P (XEXP (rtl, 2))
13235 && ((unsigned) INTVAL (XEXP (rtl, 1))
13236 + (unsigned) INTVAL (XEXP (rtl, 2))
13237 <= GET_MODE_BITSIZE (mode))
13238 && GET_MODE_CLASS (mode) == MODE_INT
13239 && GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE
13240 && GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) <= DWARF2_ADDR_SIZE)
13242 int shift, size;
13243 op0 = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (XEXP (rtl, 0)),
13244 mem_mode, VAR_INIT_STATUS_INITIALIZED);
13245 if (op0 == 0)
13246 break;
13247 if (GET_CODE (rtl) == SIGN_EXTRACT)
13248 op = DW_OP_shra;
13249 else
13250 op = DW_OP_shr;
13251 mem_loc_result = op0;
13252 size = INTVAL (XEXP (rtl, 1));
13253 shift = INTVAL (XEXP (rtl, 2));
13254 if (BITS_BIG_ENDIAN)
13255 shift = GET_MODE_BITSIZE (GET_MODE (XEXP (rtl, 0)))
13256 - shift - size;
13257 if (shift + size != (int) DWARF2_ADDR_SIZE)
13259 add_loc_descr (&mem_loc_result,
13260 int_loc_descriptor (DWARF2_ADDR_SIZE
13261 - shift - size));
13262 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_shl, 0, 0));
13264 if (size != (int) DWARF2_ADDR_SIZE)
13266 add_loc_descr (&mem_loc_result,
13267 int_loc_descriptor (DWARF2_ADDR_SIZE - size));
13268 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
13271 break;
13273 case IF_THEN_ELSE:
13275 dw_loc_descr_ref op2, bra_node, drop_node;
13276 op0 = mem_loc_descriptor (XEXP (rtl, 0),
13277 GET_MODE (XEXP (rtl, 0)) == VOIDmode
13278 ? word_mode : GET_MODE (XEXP (rtl, 0)),
13279 mem_mode, VAR_INIT_STATUS_INITIALIZED);
13280 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
13281 VAR_INIT_STATUS_INITIALIZED);
13282 op2 = mem_loc_descriptor (XEXP (rtl, 2), mode, mem_mode,
13283 VAR_INIT_STATUS_INITIALIZED);
13284 if (op0 == NULL || op1 == NULL || op2 == NULL)
13285 break;
13287 mem_loc_result = op1;
13288 add_loc_descr (&mem_loc_result, op2);
13289 add_loc_descr (&mem_loc_result, op0);
13290 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
13291 add_loc_descr (&mem_loc_result, bra_node);
13292 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_swap, 0, 0));
13293 drop_node = new_loc_descr (DW_OP_drop, 0, 0);
13294 add_loc_descr (&mem_loc_result, drop_node);
13295 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
13296 bra_node->dw_loc_oprnd1.v.val_loc = drop_node;
13298 break;
13300 case FLOAT_EXTEND:
13301 case FLOAT_TRUNCATE:
13302 case FLOAT:
13303 case UNSIGNED_FLOAT:
13304 case FIX:
13305 case UNSIGNED_FIX:
13306 if (!dwarf_strict)
13308 dw_die_ref type_die;
13309 dw_loc_descr_ref cvt;
13311 op0 = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (XEXP (rtl, 0)),
13312 mem_mode, VAR_INIT_STATUS_INITIALIZED);
13313 if (op0 == NULL)
13314 break;
13315 if (GET_MODE_CLASS (GET_MODE (XEXP (rtl, 0))) == MODE_INT
13316 && (GET_CODE (rtl) == FLOAT
13317 || GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0)))
13318 <= DWARF2_ADDR_SIZE))
13320 type_die = base_type_for_mode (GET_MODE (XEXP (rtl, 0)),
13321 GET_CODE (rtl) == UNSIGNED_FLOAT);
13322 if (type_die == NULL)
13323 break;
13324 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
13325 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
13326 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
13327 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
13328 add_loc_descr (&op0, cvt);
13330 type_die = base_type_for_mode (mode, GET_CODE (rtl) == UNSIGNED_FIX);
13331 if (type_die == NULL)
13332 break;
13333 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
13334 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
13335 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
13336 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
13337 add_loc_descr (&op0, cvt);
13338 if (GET_MODE_CLASS (mode) == MODE_INT
13339 && (GET_CODE (rtl) == FIX
13340 || GET_MODE_SIZE (mode) < DWARF2_ADDR_SIZE))
13342 op0 = convert_descriptor_to_mode (mode, op0);
13343 if (op0 == NULL)
13344 break;
13346 mem_loc_result = op0;
13348 break;
13350 case CLZ:
13351 case CTZ:
13352 case FFS:
13353 mem_loc_result = clz_loc_descriptor (rtl, mode, mem_mode);
13354 break;
13356 case POPCOUNT:
13357 case PARITY:
13358 mem_loc_result = popcount_loc_descriptor (rtl, mode, mem_mode);
13359 break;
13361 case BSWAP:
13362 mem_loc_result = bswap_loc_descriptor (rtl, mode, mem_mode);
13363 break;
13365 case ROTATE:
13366 case ROTATERT:
13367 mem_loc_result = rotate_loc_descriptor (rtl, mode, mem_mode);
13368 break;
13370 case COMPARE:
13371 /* In theory, we could implement the above. */
13372 /* DWARF cannot represent the unsigned compare operations
13373 natively. */
13374 case SS_MULT:
13375 case US_MULT:
13376 case SS_DIV:
13377 case US_DIV:
13378 case SS_PLUS:
13379 case US_PLUS:
13380 case SS_MINUS:
13381 case US_MINUS:
13382 case SS_NEG:
13383 case US_NEG:
13384 case SS_ABS:
13385 case SS_ASHIFT:
13386 case US_ASHIFT:
13387 case SS_TRUNCATE:
13388 case US_TRUNCATE:
13389 case UNORDERED:
13390 case ORDERED:
13391 case UNEQ:
13392 case UNGE:
13393 case UNGT:
13394 case UNLE:
13395 case UNLT:
13396 case LTGT:
13397 case FRACT_CONVERT:
13398 case UNSIGNED_FRACT_CONVERT:
13399 case SAT_FRACT:
13400 case UNSIGNED_SAT_FRACT:
13401 case SQRT:
13402 case ASM_OPERANDS:
13403 case VEC_MERGE:
13404 case VEC_SELECT:
13405 case VEC_CONCAT:
13406 case VEC_DUPLICATE:
13407 case UNSPEC:
13408 case HIGH:
13409 case FMA:
13410 case STRICT_LOW_PART:
13411 case CONST_VECTOR:
13412 case CONST_FIXED:
13413 case CLRSB:
13414 case CLOBBER:
13415 /* If delegitimize_address couldn't do anything with the UNSPEC, we
13416 can't express it in the debug info. This can happen e.g. with some
13417 TLS UNSPECs. */
13418 break;
13420 case CONST_STRING:
13421 resolve_one_addr (&rtl);
13422 goto symref;
13424 default:
13425 #ifdef ENABLE_CHECKING
13426 print_rtl (stderr, rtl);
13427 gcc_unreachable ();
13428 #else
13429 break;
13430 #endif
13433 if (mem_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
13434 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
13436 return mem_loc_result;
13439 /* Return a descriptor that describes the concatenation of two locations.
13440 This is typically a complex variable. */
13442 static dw_loc_descr_ref
13443 concat_loc_descriptor (rtx x0, rtx x1, enum var_init_status initialized)
13445 dw_loc_descr_ref cc_loc_result = NULL;
13446 dw_loc_descr_ref x0_ref
13447 = loc_descriptor (x0, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
13448 dw_loc_descr_ref x1_ref
13449 = loc_descriptor (x1, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
13451 if (x0_ref == 0 || x1_ref == 0)
13452 return 0;
13454 cc_loc_result = x0_ref;
13455 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
13457 add_loc_descr (&cc_loc_result, x1_ref);
13458 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
13460 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
13461 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
13463 return cc_loc_result;
13466 /* Return a descriptor that describes the concatenation of N
13467 locations. */
13469 static dw_loc_descr_ref
13470 concatn_loc_descriptor (rtx concatn, enum var_init_status initialized)
13472 unsigned int i;
13473 dw_loc_descr_ref cc_loc_result = NULL;
13474 unsigned int n = XVECLEN (concatn, 0);
13476 for (i = 0; i < n; ++i)
13478 dw_loc_descr_ref ref;
13479 rtx x = XVECEXP (concatn, 0, i);
13481 ref = loc_descriptor (x, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
13482 if (ref == NULL)
13483 return NULL;
13485 add_loc_descr (&cc_loc_result, ref);
13486 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x)));
13489 if (cc_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
13490 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
13492 return cc_loc_result;
13495 /* Helper function for loc_descriptor. Return DW_OP_GNU_implicit_pointer
13496 for DEBUG_IMPLICIT_PTR RTL. */
13498 static dw_loc_descr_ref
13499 implicit_ptr_descriptor (rtx rtl, HOST_WIDE_INT offset)
13501 dw_loc_descr_ref ret;
13502 dw_die_ref ref;
13504 if (dwarf_strict)
13505 return NULL;
13506 gcc_assert (TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == VAR_DECL
13507 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == PARM_DECL
13508 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == RESULT_DECL);
13509 ref = lookup_decl_die (DEBUG_IMPLICIT_PTR_DECL (rtl));
13510 ret = new_loc_descr (DW_OP_GNU_implicit_pointer, 0, offset);
13511 ret->dw_loc_oprnd2.val_class = dw_val_class_const;
13512 if (ref)
13514 ret->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
13515 ret->dw_loc_oprnd1.v.val_die_ref.die = ref;
13516 ret->dw_loc_oprnd1.v.val_die_ref.external = 0;
13518 else
13520 ret->dw_loc_oprnd1.val_class = dw_val_class_decl_ref;
13521 ret->dw_loc_oprnd1.v.val_decl_ref = DEBUG_IMPLICIT_PTR_DECL (rtl);
13523 return ret;
13526 /* Output a proper Dwarf location descriptor for a variable or parameter
13527 which is either allocated in a register or in a memory location. For a
13528 register, we just generate an OP_REG and the register number. For a
13529 memory location we provide a Dwarf postfix expression describing how to
13530 generate the (dynamic) address of the object onto the address stack.
13532 MODE is mode of the decl if this loc_descriptor is going to be used in
13533 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
13534 allowed, VOIDmode otherwise.
13536 If we don't know how to describe it, return 0. */
13538 static dw_loc_descr_ref
13539 loc_descriptor (rtx rtl, machine_mode mode,
13540 enum var_init_status initialized)
13542 dw_loc_descr_ref loc_result = NULL;
13544 switch (GET_CODE (rtl))
13546 case SUBREG:
13547 /* The case of a subreg may arise when we have a local (register)
13548 variable or a formal (register) parameter which doesn't quite fill
13549 up an entire register. For now, just assume that it is
13550 legitimate to make the Dwarf info refer to the whole register which
13551 contains the given subreg. */
13552 if (REG_P (SUBREG_REG (rtl)) && subreg_lowpart_p (rtl))
13553 loc_result = loc_descriptor (SUBREG_REG (rtl),
13554 GET_MODE (SUBREG_REG (rtl)), initialized);
13555 else
13556 goto do_default;
13557 break;
13559 case REG:
13560 loc_result = reg_loc_descriptor (rtl, initialized);
13561 break;
13563 case MEM:
13564 loc_result = mem_loc_descriptor (XEXP (rtl, 0), get_address_mode (rtl),
13565 GET_MODE (rtl), initialized);
13566 if (loc_result == NULL)
13567 loc_result = tls_mem_loc_descriptor (rtl);
13568 if (loc_result == NULL)
13570 rtx new_rtl = avoid_constant_pool_reference (rtl);
13571 if (new_rtl != rtl)
13572 loc_result = loc_descriptor (new_rtl, mode, initialized);
13574 break;
13576 case CONCAT:
13577 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1),
13578 initialized);
13579 break;
13581 case CONCATN:
13582 loc_result = concatn_loc_descriptor (rtl, initialized);
13583 break;
13585 case VAR_LOCATION:
13586 /* Single part. */
13587 if (GET_CODE (PAT_VAR_LOCATION_LOC (rtl)) != PARALLEL)
13589 rtx loc = PAT_VAR_LOCATION_LOC (rtl);
13590 if (GET_CODE (loc) == EXPR_LIST)
13591 loc = XEXP (loc, 0);
13592 loc_result = loc_descriptor (loc, mode, initialized);
13593 break;
13596 rtl = XEXP (rtl, 1);
13597 /* FALLTHRU */
13599 case PARALLEL:
13601 rtvec par_elems = XVEC (rtl, 0);
13602 int num_elem = GET_NUM_ELEM (par_elems);
13603 machine_mode mode;
13604 int i;
13606 /* Create the first one, so we have something to add to. */
13607 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0),
13608 VOIDmode, initialized);
13609 if (loc_result == NULL)
13610 return NULL;
13611 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
13612 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
13613 for (i = 1; i < num_elem; i++)
13615 dw_loc_descr_ref temp;
13617 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0),
13618 VOIDmode, initialized);
13619 if (temp == NULL)
13620 return NULL;
13621 add_loc_descr (&loc_result, temp);
13622 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
13623 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
13626 break;
13628 case CONST_INT:
13629 if (mode != VOIDmode && mode != BLKmode)
13630 loc_result = address_of_int_loc_descriptor (GET_MODE_SIZE (mode),
13631 INTVAL (rtl));
13632 break;
13634 case CONST_DOUBLE:
13635 if (mode == VOIDmode)
13636 mode = GET_MODE (rtl);
13638 if (mode != VOIDmode && (dwarf_version >= 4 || !dwarf_strict))
13640 gcc_assert (mode == GET_MODE (rtl) || VOIDmode == GET_MODE (rtl));
13642 /* Note that a CONST_DOUBLE rtx could represent either an integer
13643 or a floating-point constant. A CONST_DOUBLE is used whenever
13644 the constant requires more than one word in order to be
13645 adequately represented. We output CONST_DOUBLEs as blocks. */
13646 loc_result = new_loc_descr (DW_OP_implicit_value,
13647 GET_MODE_SIZE (mode), 0);
13648 #if TARGET_SUPPORTS_WIDE_INT == 0
13649 if (!SCALAR_FLOAT_MODE_P (mode))
13651 loc_result->dw_loc_oprnd2.val_class = dw_val_class_const_double;
13652 loc_result->dw_loc_oprnd2.v.val_double
13653 = rtx_to_double_int (rtl);
13655 else
13656 #endif
13658 unsigned int length = GET_MODE_SIZE (mode);
13659 unsigned char *array = ggc_vec_alloc<unsigned char> (length);
13661 insert_float (rtl, array);
13662 loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
13663 loc_result->dw_loc_oprnd2.v.val_vec.length = length / 4;
13664 loc_result->dw_loc_oprnd2.v.val_vec.elt_size = 4;
13665 loc_result->dw_loc_oprnd2.v.val_vec.array = array;
13668 break;
13670 case CONST_WIDE_INT:
13671 if (mode == VOIDmode)
13672 mode = GET_MODE (rtl);
13674 if (mode != VOIDmode && (dwarf_version >= 4 || !dwarf_strict))
13676 loc_result = new_loc_descr (DW_OP_implicit_value,
13677 GET_MODE_SIZE (mode), 0);
13678 loc_result->dw_loc_oprnd2.val_class = dw_val_class_wide_int;
13679 loc_result->dw_loc_oprnd2.v.val_wide = ggc_alloc<wide_int> ();
13680 *loc_result->dw_loc_oprnd2.v.val_wide = std::make_pair (rtl, mode);
13682 break;
13684 case CONST_VECTOR:
13685 if (mode == VOIDmode)
13686 mode = GET_MODE (rtl);
13688 if (mode != VOIDmode && (dwarf_version >= 4 || !dwarf_strict))
13690 unsigned int elt_size = GET_MODE_UNIT_SIZE (GET_MODE (rtl));
13691 unsigned int length = CONST_VECTOR_NUNITS (rtl);
13692 unsigned char *array
13693 = ggc_vec_alloc<unsigned char> (length * elt_size);
13694 unsigned int i;
13695 unsigned char *p;
13696 machine_mode imode = GET_MODE_INNER (mode);
13698 gcc_assert (mode == GET_MODE (rtl) || VOIDmode == GET_MODE (rtl));
13699 switch (GET_MODE_CLASS (mode))
13701 case MODE_VECTOR_INT:
13702 for (i = 0, p = array; i < length; i++, p += elt_size)
13704 rtx elt = CONST_VECTOR_ELT (rtl, i);
13705 insert_wide_int (std::make_pair (elt, imode), p, elt_size);
13707 break;
13709 case MODE_VECTOR_FLOAT:
13710 for (i = 0, p = array; i < length; i++, p += elt_size)
13712 rtx elt = CONST_VECTOR_ELT (rtl, i);
13713 insert_float (elt, p);
13715 break;
13717 default:
13718 gcc_unreachable ();
13721 loc_result = new_loc_descr (DW_OP_implicit_value,
13722 length * elt_size, 0);
13723 loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
13724 loc_result->dw_loc_oprnd2.v.val_vec.length = length;
13725 loc_result->dw_loc_oprnd2.v.val_vec.elt_size = elt_size;
13726 loc_result->dw_loc_oprnd2.v.val_vec.array = array;
13728 break;
13730 case CONST:
13731 if (mode == VOIDmode
13732 || CONST_SCALAR_INT_P (XEXP (rtl, 0))
13733 || CONST_DOUBLE_AS_FLOAT_P (XEXP (rtl, 0))
13734 || GET_CODE (XEXP (rtl, 0)) == CONST_VECTOR)
13736 loc_result = loc_descriptor (XEXP (rtl, 0), mode, initialized);
13737 break;
13739 /* FALLTHROUGH */
13740 case SYMBOL_REF:
13741 if (!const_ok_for_output (rtl))
13742 break;
13743 case LABEL_REF:
13744 if (mode != VOIDmode && GET_MODE_SIZE (mode) == DWARF2_ADDR_SIZE
13745 && (dwarf_version >= 4 || !dwarf_strict))
13747 loc_result = new_addr_loc_descr (rtl, dtprel_false);
13748 add_loc_descr (&loc_result, new_loc_descr (DW_OP_stack_value, 0, 0));
13749 vec_safe_push (used_rtx_array, rtl);
13751 break;
13753 case DEBUG_IMPLICIT_PTR:
13754 loc_result = implicit_ptr_descriptor (rtl, 0);
13755 break;
13757 case PLUS:
13758 if (GET_CODE (XEXP (rtl, 0)) == DEBUG_IMPLICIT_PTR
13759 && CONST_INT_P (XEXP (rtl, 1)))
13761 loc_result
13762 = implicit_ptr_descriptor (XEXP (rtl, 0), INTVAL (XEXP (rtl, 1)));
13763 break;
13765 /* FALLTHRU */
13766 do_default:
13767 default:
13768 if ((GET_MODE_CLASS (mode) == MODE_INT && GET_MODE (rtl) == mode
13769 && GET_MODE_SIZE (GET_MODE (rtl)) <= DWARF2_ADDR_SIZE
13770 && dwarf_version >= 4)
13771 || (!dwarf_strict && mode != VOIDmode && mode != BLKmode))
13773 /* Value expression. */
13774 loc_result = mem_loc_descriptor (rtl, mode, VOIDmode, initialized);
13775 if (loc_result)
13776 add_loc_descr (&loc_result,
13777 new_loc_descr (DW_OP_stack_value, 0, 0));
13779 break;
13782 return loc_result;
13785 /* We need to figure out what section we should use as the base for the
13786 address ranges where a given location is valid.
13787 1. If this particular DECL has a section associated with it, use that.
13788 2. If this function has a section associated with it, use that.
13789 3. Otherwise, use the text section.
13790 XXX: If you split a variable across multiple sections, we won't notice. */
13792 static const char *
13793 secname_for_decl (const_tree decl)
13795 const char *secname;
13797 if (VAR_OR_FUNCTION_DECL_P (decl)
13798 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl) || TREE_STATIC (decl))
13799 && DECL_SECTION_NAME (decl))
13800 secname = DECL_SECTION_NAME (decl);
13801 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
13802 secname = DECL_SECTION_NAME (current_function_decl);
13803 else if (cfun && in_cold_section_p)
13804 secname = crtl->subsections.cold_section_label;
13805 else
13806 secname = text_section_label;
13808 return secname;
13811 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
13813 static bool
13814 decl_by_reference_p (tree decl)
13816 return ((TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL
13817 || TREE_CODE (decl) == VAR_DECL)
13818 && DECL_BY_REFERENCE (decl));
13821 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
13822 for VARLOC. */
13824 static dw_loc_descr_ref
13825 dw_loc_list_1 (tree loc, rtx varloc, int want_address,
13826 enum var_init_status initialized)
13828 int have_address = 0;
13829 dw_loc_descr_ref descr;
13830 machine_mode mode;
13832 if (want_address != 2)
13834 gcc_assert (GET_CODE (varloc) == VAR_LOCATION);
13835 /* Single part. */
13836 if (GET_CODE (PAT_VAR_LOCATION_LOC (varloc)) != PARALLEL)
13838 varloc = PAT_VAR_LOCATION_LOC (varloc);
13839 if (GET_CODE (varloc) == EXPR_LIST)
13840 varloc = XEXP (varloc, 0);
13841 mode = GET_MODE (varloc);
13842 if (MEM_P (varloc))
13844 rtx addr = XEXP (varloc, 0);
13845 descr = mem_loc_descriptor (addr, get_address_mode (varloc),
13846 mode, initialized);
13847 if (descr)
13848 have_address = 1;
13849 else
13851 rtx x = avoid_constant_pool_reference (varloc);
13852 if (x != varloc)
13853 descr = mem_loc_descriptor (x, mode, VOIDmode,
13854 initialized);
13857 else
13858 descr = mem_loc_descriptor (varloc, mode, VOIDmode, initialized);
13860 else
13861 return 0;
13863 else
13865 if (GET_CODE (varloc) == VAR_LOCATION)
13866 mode = DECL_MODE (PAT_VAR_LOCATION_DECL (varloc));
13867 else
13868 mode = DECL_MODE (loc);
13869 descr = loc_descriptor (varloc, mode, initialized);
13870 have_address = 1;
13873 if (!descr)
13874 return 0;
13876 if (want_address == 2 && !have_address
13877 && (dwarf_version >= 4 || !dwarf_strict))
13879 if (int_size_in_bytes (TREE_TYPE (loc)) > DWARF2_ADDR_SIZE)
13881 expansion_failed (loc, NULL_RTX,
13882 "DWARF address size mismatch");
13883 return 0;
13885 add_loc_descr (&descr, new_loc_descr (DW_OP_stack_value, 0, 0));
13886 have_address = 1;
13888 /* Show if we can't fill the request for an address. */
13889 if (want_address && !have_address)
13891 expansion_failed (loc, NULL_RTX,
13892 "Want address and only have value");
13893 return 0;
13896 /* If we've got an address and don't want one, dereference. */
13897 if (!want_address && have_address)
13899 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
13900 enum dwarf_location_atom op;
13902 if (size > DWARF2_ADDR_SIZE || size == -1)
13904 expansion_failed (loc, NULL_RTX,
13905 "DWARF address size mismatch");
13906 return 0;
13908 else if (size == DWARF2_ADDR_SIZE)
13909 op = DW_OP_deref;
13910 else
13911 op = DW_OP_deref_size;
13913 add_loc_descr (&descr, new_loc_descr (op, size, 0));
13916 return descr;
13919 /* Create a DW_OP_piece or DW_OP_bit_piece for bitsize, or return NULL
13920 if it is not possible. */
13922 static dw_loc_descr_ref
13923 new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize, HOST_WIDE_INT offset)
13925 if ((bitsize % BITS_PER_UNIT) == 0 && offset == 0)
13926 return new_loc_descr (DW_OP_piece, bitsize / BITS_PER_UNIT, 0);
13927 else if (dwarf_version >= 3 || !dwarf_strict)
13928 return new_loc_descr (DW_OP_bit_piece, bitsize, offset);
13929 else
13930 return NULL;
13933 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
13934 for VAR_LOC_NOTE for variable DECL that has been optimized by SRA. */
13936 static dw_loc_descr_ref
13937 dw_sra_loc_expr (tree decl, rtx loc)
13939 rtx p;
13940 unsigned HOST_WIDE_INT padsize = 0;
13941 dw_loc_descr_ref descr, *descr_tail;
13942 unsigned HOST_WIDE_INT decl_size;
13943 rtx varloc;
13944 enum var_init_status initialized;
13946 if (DECL_SIZE (decl) == NULL
13947 || !tree_fits_uhwi_p (DECL_SIZE (decl)))
13948 return NULL;
13950 decl_size = tree_to_uhwi (DECL_SIZE (decl));
13951 descr = NULL;
13952 descr_tail = &descr;
13954 for (p = loc; p; p = XEXP (p, 1))
13956 unsigned HOST_WIDE_INT bitsize = decl_piece_bitsize (p);
13957 rtx loc_note = *decl_piece_varloc_ptr (p);
13958 dw_loc_descr_ref cur_descr;
13959 dw_loc_descr_ref *tail, last = NULL;
13960 unsigned HOST_WIDE_INT opsize = 0;
13962 if (loc_note == NULL_RTX
13963 || NOTE_VAR_LOCATION_LOC (loc_note) == NULL_RTX)
13965 padsize += bitsize;
13966 continue;
13968 initialized = NOTE_VAR_LOCATION_STATUS (loc_note);
13969 varloc = NOTE_VAR_LOCATION (loc_note);
13970 cur_descr = dw_loc_list_1 (decl, varloc, 2, initialized);
13971 if (cur_descr == NULL)
13973 padsize += bitsize;
13974 continue;
13977 /* Check that cur_descr either doesn't use
13978 DW_OP_*piece operations, or their sum is equal
13979 to bitsize. Otherwise we can't embed it. */
13980 for (tail = &cur_descr; *tail != NULL;
13981 tail = &(*tail)->dw_loc_next)
13982 if ((*tail)->dw_loc_opc == DW_OP_piece)
13984 opsize += (*tail)->dw_loc_oprnd1.v.val_unsigned
13985 * BITS_PER_UNIT;
13986 last = *tail;
13988 else if ((*tail)->dw_loc_opc == DW_OP_bit_piece)
13990 opsize += (*tail)->dw_loc_oprnd1.v.val_unsigned;
13991 last = *tail;
13994 if (last != NULL && opsize != bitsize)
13996 padsize += bitsize;
13997 /* Discard the current piece of the descriptor and release any
13998 addr_table entries it uses. */
13999 remove_loc_list_addr_table_entries (cur_descr);
14000 continue;
14003 /* If there is a hole, add DW_OP_*piece after empty DWARF
14004 expression, which means that those bits are optimized out. */
14005 if (padsize)
14007 if (padsize > decl_size)
14009 remove_loc_list_addr_table_entries (cur_descr);
14010 goto discard_descr;
14012 decl_size -= padsize;
14013 *descr_tail = new_loc_descr_op_bit_piece (padsize, 0);
14014 if (*descr_tail == NULL)
14016 remove_loc_list_addr_table_entries (cur_descr);
14017 goto discard_descr;
14019 descr_tail = &(*descr_tail)->dw_loc_next;
14020 padsize = 0;
14022 *descr_tail = cur_descr;
14023 descr_tail = tail;
14024 if (bitsize > decl_size)
14025 goto discard_descr;
14026 decl_size -= bitsize;
14027 if (last == NULL)
14029 HOST_WIDE_INT offset = 0;
14030 if (GET_CODE (varloc) == VAR_LOCATION
14031 && GET_CODE (PAT_VAR_LOCATION_LOC (varloc)) != PARALLEL)
14033 varloc = PAT_VAR_LOCATION_LOC (varloc);
14034 if (GET_CODE (varloc) == EXPR_LIST)
14035 varloc = XEXP (varloc, 0);
14039 if (GET_CODE (varloc) == CONST
14040 || GET_CODE (varloc) == SIGN_EXTEND
14041 || GET_CODE (varloc) == ZERO_EXTEND)
14042 varloc = XEXP (varloc, 0);
14043 else if (GET_CODE (varloc) == SUBREG)
14044 varloc = SUBREG_REG (varloc);
14045 else
14046 break;
14048 while (1);
14049 /* DW_OP_bit_size offset should be zero for register
14050 or implicit location descriptions and empty location
14051 descriptions, but for memory addresses needs big endian
14052 adjustment. */
14053 if (MEM_P (varloc))
14055 unsigned HOST_WIDE_INT memsize
14056 = MEM_SIZE (varloc) * BITS_PER_UNIT;
14057 if (memsize != bitsize)
14059 if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
14060 && (memsize > BITS_PER_WORD || bitsize > BITS_PER_WORD))
14061 goto discard_descr;
14062 if (memsize < bitsize)
14063 goto discard_descr;
14064 if (BITS_BIG_ENDIAN)
14065 offset = memsize - bitsize;
14069 *descr_tail = new_loc_descr_op_bit_piece (bitsize, offset);
14070 if (*descr_tail == NULL)
14071 goto discard_descr;
14072 descr_tail = &(*descr_tail)->dw_loc_next;
14076 /* If there were any non-empty expressions, add padding till the end of
14077 the decl. */
14078 if (descr != NULL && decl_size != 0)
14080 *descr_tail = new_loc_descr_op_bit_piece (decl_size, 0);
14081 if (*descr_tail == NULL)
14082 goto discard_descr;
14084 return descr;
14086 discard_descr:
14087 /* Discard the descriptor and release any addr_table entries it uses. */
14088 remove_loc_list_addr_table_entries (descr);
14089 return NULL;
14092 /* Return the dwarf representation of the location list LOC_LIST of
14093 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree
14094 function. */
14096 static dw_loc_list_ref
14097 dw_loc_list (var_loc_list *loc_list, tree decl, int want_address)
14099 const char *endname, *secname;
14100 rtx varloc;
14101 enum var_init_status initialized;
14102 struct var_loc_node *node;
14103 dw_loc_descr_ref descr;
14104 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
14105 dw_loc_list_ref list = NULL;
14106 dw_loc_list_ref *listp = &list;
14108 /* Now that we know what section we are using for a base,
14109 actually construct the list of locations.
14110 The first location information is what is passed to the
14111 function that creates the location list, and the remaining
14112 locations just get added on to that list.
14113 Note that we only know the start address for a location
14114 (IE location changes), so to build the range, we use
14115 the range [current location start, next location start].
14116 This means we have to special case the last node, and generate
14117 a range of [last location start, end of function label]. */
14119 secname = secname_for_decl (decl);
14121 for (node = loc_list->first; node; node = node->next)
14122 if (GET_CODE (node->loc) == EXPR_LIST
14123 || NOTE_VAR_LOCATION_LOC (node->loc) != NULL_RTX)
14125 if (GET_CODE (node->loc) == EXPR_LIST)
14127 /* This requires DW_OP_{,bit_}piece, which is not usable
14128 inside DWARF expressions. */
14129 if (want_address != 2)
14130 continue;
14131 descr = dw_sra_loc_expr (decl, node->loc);
14132 if (descr == NULL)
14133 continue;
14135 else
14137 initialized = NOTE_VAR_LOCATION_STATUS (node->loc);
14138 varloc = NOTE_VAR_LOCATION (node->loc);
14139 descr = dw_loc_list_1 (decl, varloc, want_address, initialized);
14141 if (descr)
14143 bool range_across_switch = false;
14144 /* If section switch happens in between node->label
14145 and node->next->label (or end of function) and
14146 we can't emit it as a single entry list,
14147 emit two ranges, first one ending at the end
14148 of first partition and second one starting at the
14149 beginning of second partition. */
14150 if (node == loc_list->last_before_switch
14151 && (node != loc_list->first || loc_list->first->next)
14152 && current_function_decl)
14154 endname = cfun->fde->dw_fde_end;
14155 range_across_switch = true;
14157 /* The variable has a location between NODE->LABEL and
14158 NODE->NEXT->LABEL. */
14159 else if (node->next)
14160 endname = node->next->label;
14161 /* If the variable has a location at the last label
14162 it keeps its location until the end of function. */
14163 else if (!current_function_decl)
14164 endname = text_end_label;
14165 else
14167 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
14168 current_function_funcdef_no);
14169 endname = ggc_strdup (label_id);
14172 *listp = new_loc_list (descr, node->label, endname, secname);
14173 if (TREE_CODE (decl) == PARM_DECL
14174 && node == loc_list->first
14175 && NOTE_P (node->loc)
14176 && strcmp (node->label, endname) == 0)
14177 (*listp)->force = true;
14178 listp = &(*listp)->dw_loc_next;
14180 if (range_across_switch)
14182 if (GET_CODE (node->loc) == EXPR_LIST)
14183 descr = dw_sra_loc_expr (decl, node->loc);
14184 else
14186 initialized = NOTE_VAR_LOCATION_STATUS (node->loc);
14187 varloc = NOTE_VAR_LOCATION (node->loc);
14188 descr = dw_loc_list_1 (decl, varloc, want_address,
14189 initialized);
14191 gcc_assert (descr);
14192 /* The variable has a location between NODE->LABEL and
14193 NODE->NEXT->LABEL. */
14194 if (node->next)
14195 endname = node->next->label;
14196 else
14197 endname = cfun->fde->dw_fde_second_end;
14198 *listp = new_loc_list (descr,
14199 cfun->fde->dw_fde_second_begin,
14200 endname, secname);
14201 listp = &(*listp)->dw_loc_next;
14206 /* Try to avoid the overhead of a location list emitting a location
14207 expression instead, but only if we didn't have more than one
14208 location entry in the first place. If some entries were not
14209 representable, we don't want to pretend a single entry that was
14210 applies to the entire scope in which the variable is
14211 available. */
14212 if (list && loc_list->first->next)
14213 gen_llsym (list);
14215 return list;
14218 /* Return if the loc_list has only single element and thus can be represented
14219 as location description. */
14221 static bool
14222 single_element_loc_list_p (dw_loc_list_ref list)
14224 gcc_assert (!list->dw_loc_next || list->ll_symbol);
14225 return !list->ll_symbol;
14228 /* To each location in list LIST add loc descr REF. */
14230 static void
14231 add_loc_descr_to_each (dw_loc_list_ref list, dw_loc_descr_ref ref)
14233 dw_loc_descr_ref copy;
14234 add_loc_descr (&list->expr, ref);
14235 list = list->dw_loc_next;
14236 while (list)
14238 copy = ggc_alloc<dw_loc_descr_node> ();
14239 memcpy (copy, ref, sizeof (dw_loc_descr_node));
14240 add_loc_descr (&list->expr, copy);
14241 while (copy->dw_loc_next)
14243 dw_loc_descr_ref new_copy = ggc_alloc<dw_loc_descr_node> ();
14244 memcpy (new_copy, copy->dw_loc_next, sizeof (dw_loc_descr_node));
14245 copy->dw_loc_next = new_copy;
14246 copy = new_copy;
14248 list = list->dw_loc_next;
14252 /* Given two lists RET and LIST
14253 produce location list that is result of adding expression in LIST
14254 to expression in RET on each position in program.
14255 Might be destructive on both RET and LIST.
14257 TODO: We handle only simple cases of RET or LIST having at most one
14258 element. General case would inolve sorting the lists in program order
14259 and merging them that will need some additional work.
14260 Adding that will improve quality of debug info especially for SRA-ed
14261 structures. */
14263 static void
14264 add_loc_list (dw_loc_list_ref *ret, dw_loc_list_ref list)
14266 if (!list)
14267 return;
14268 if (!*ret)
14270 *ret = list;
14271 return;
14273 if (!list->dw_loc_next)
14275 add_loc_descr_to_each (*ret, list->expr);
14276 return;
14278 if (!(*ret)->dw_loc_next)
14280 add_loc_descr_to_each (list, (*ret)->expr);
14281 *ret = list;
14282 return;
14284 expansion_failed (NULL_TREE, NULL_RTX,
14285 "Don't know how to merge two non-trivial"
14286 " location lists.\n");
14287 *ret = NULL;
14288 return;
14291 /* LOC is constant expression. Try a luck, look it up in constant
14292 pool and return its loc_descr of its address. */
14294 static dw_loc_descr_ref
14295 cst_pool_loc_descr (tree loc)
14297 /* Get an RTL for this, if something has been emitted. */
14298 rtx rtl = lookup_constant_def (loc);
14300 if (!rtl || !MEM_P (rtl))
14302 gcc_assert (!rtl);
14303 return 0;
14305 gcc_assert (GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF);
14307 /* TODO: We might get more coverage if we was actually delaying expansion
14308 of all expressions till end of compilation when constant pools are fully
14309 populated. */
14310 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl, 0))))
14312 expansion_failed (loc, NULL_RTX,
14313 "CST value in contant pool but not marked.");
14314 return 0;
14316 return mem_loc_descriptor (XEXP (rtl, 0), get_address_mode (rtl),
14317 GET_MODE (rtl), VAR_INIT_STATUS_INITIALIZED);
14320 /* Return dw_loc_list representing address of addr_expr LOC
14321 by looking for inner INDIRECT_REF expression and turning
14322 it into simple arithmetics.
14324 See loc_list_from_tree for the meaning of CONTEXT. */
14326 static dw_loc_list_ref
14327 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc, bool toplev,
14328 const loc_descr_context *context)
14330 tree obj, offset;
14331 HOST_WIDE_INT bitsize, bitpos, bytepos;
14332 machine_mode mode;
14333 int unsignedp, volatilep = 0;
14334 dw_loc_list_ref list_ret = NULL, list_ret1 = NULL;
14336 obj = get_inner_reference (TREE_OPERAND (loc, 0),
14337 &bitsize, &bitpos, &offset, &mode,
14338 &unsignedp, &volatilep, false);
14339 STRIP_NOPS (obj);
14340 if (bitpos % BITS_PER_UNIT)
14342 expansion_failed (loc, NULL_RTX, "bitfield access");
14343 return 0;
14345 if (!INDIRECT_REF_P (obj))
14347 expansion_failed (obj,
14348 NULL_RTX, "no indirect ref in inner refrence");
14349 return 0;
14351 if (!offset && !bitpos)
14352 list_ret = loc_list_from_tree (TREE_OPERAND (obj, 0), toplev ? 2 : 1,
14353 context);
14354 else if (toplev
14355 && int_size_in_bytes (TREE_TYPE (loc)) <= DWARF2_ADDR_SIZE
14356 && (dwarf_version >= 4 || !dwarf_strict))
14358 list_ret = loc_list_from_tree (TREE_OPERAND (obj, 0), 0, context);
14359 if (!list_ret)
14360 return 0;
14361 if (offset)
14363 /* Variable offset. */
14364 list_ret1 = loc_list_from_tree (offset, 0, context);
14365 if (list_ret1 == 0)
14366 return 0;
14367 add_loc_list (&list_ret, list_ret1);
14368 if (!list_ret)
14369 return 0;
14370 add_loc_descr_to_each (list_ret,
14371 new_loc_descr (DW_OP_plus, 0, 0));
14373 bytepos = bitpos / BITS_PER_UNIT;
14374 if (bytepos > 0)
14375 add_loc_descr_to_each (list_ret,
14376 new_loc_descr (DW_OP_plus_uconst,
14377 bytepos, 0));
14378 else if (bytepos < 0)
14379 loc_list_plus_const (list_ret, bytepos);
14380 add_loc_descr_to_each (list_ret,
14381 new_loc_descr (DW_OP_stack_value, 0, 0));
14383 return list_ret;
14387 /* Helper structure for location descriptions generation. */
14388 struct loc_descr_context
14390 /* The type that is implicitly referenced by DW_OP_push_object_address, or
14391 NULL_TREE if DW_OP_push_object_address in invalid for this location
14392 description. This is used when processing PLACEHOLDER_EXPR nodes. */
14393 tree context_type;
14394 /* The ..._DECL node that should be translated as a
14395 DW_OP_push_object_address operation. */
14396 tree base_decl;
14399 /* Generate Dwarf location list representing LOC.
14400 If WANT_ADDRESS is false, expression computing LOC will be computed
14401 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
14402 if WANT_ADDRESS is 2, expression computing address useable in location
14403 will be returned (i.e. DW_OP_reg can be used
14404 to refer to register values).
14406 CONTEXT provides information to customize the location descriptions
14407 generation. Its context_type field specifies what type is implicitly
14408 referenced by DW_OP_push_object_address. If it is NULL_TREE, this operation
14409 will not be generated.
14411 If CONTEXT is NULL, the behavior is the same as if both context_type and
14412 base_decl fields were NULL_TREE. */
14414 static dw_loc_list_ref
14415 loc_list_from_tree (tree loc, int want_address,
14416 const struct loc_descr_context *context)
14418 dw_loc_descr_ref ret = NULL, ret1 = NULL;
14419 dw_loc_list_ref list_ret = NULL, list_ret1 = NULL;
14420 int have_address = 0;
14421 enum dwarf_location_atom op;
14423 /* ??? Most of the time we do not take proper care for sign/zero
14424 extending the values properly. Hopefully this won't be a real
14425 problem... */
14427 if (context != NULL
14428 && context->base_decl == loc
14429 && want_address == 0)
14431 if (dwarf_version >= 3 || !dwarf_strict)
14432 return new_loc_list (new_loc_descr (DW_OP_push_object_address, 0, 0),
14433 NULL, NULL, NULL);
14434 else
14435 return NULL;
14438 switch (TREE_CODE (loc))
14440 case ERROR_MARK:
14441 expansion_failed (loc, NULL_RTX, "ERROR_MARK");
14442 return 0;
14444 case PLACEHOLDER_EXPR:
14445 /* This case involves extracting fields from an object to determine the
14446 position of other fields. It is supposed to appear only as the first
14447 operand of COMPONENT_REF nodes and to reference precisely the type
14448 that the context allows. */
14449 if (context != NULL
14450 && TREE_TYPE (loc) == context->context_type
14451 && want_address >= 1)
14453 if (dwarf_version >= 3 || !dwarf_strict)
14455 ret = new_loc_descr (DW_OP_push_object_address, 0, 0);
14456 have_address = 1;
14457 break;
14459 else
14460 return NULL;
14462 else
14463 expansion_failed (loc, NULL_RTX,
14464 "PLACEHOLDER_EXPR for an unexpected type");
14465 break;
14467 case CALL_EXPR:
14468 expansion_failed (loc, NULL_RTX, "CALL_EXPR");
14469 /* There are no opcodes for these operations. */
14470 return 0;
14472 case PREINCREMENT_EXPR:
14473 case PREDECREMENT_EXPR:
14474 case POSTINCREMENT_EXPR:
14475 case POSTDECREMENT_EXPR:
14476 expansion_failed (loc, NULL_RTX, "PRE/POST INDCREMENT/DECREMENT");
14477 /* There are no opcodes for these operations. */
14478 return 0;
14480 case ADDR_EXPR:
14481 /* If we already want an address, see if there is INDIRECT_REF inside
14482 e.g. for &this->field. */
14483 if (want_address)
14485 list_ret = loc_list_for_address_of_addr_expr_of_indirect_ref
14486 (loc, want_address == 2, context);
14487 if (list_ret)
14488 have_address = 1;
14489 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc, 0))
14490 && (ret = cst_pool_loc_descr (loc)))
14491 have_address = 1;
14493 /* Otherwise, process the argument and look for the address. */
14494 if (!list_ret && !ret)
14495 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 1, context);
14496 else
14498 if (want_address)
14499 expansion_failed (loc, NULL_RTX, "need address of ADDR_EXPR");
14500 return NULL;
14502 break;
14504 case VAR_DECL:
14505 if (DECL_THREAD_LOCAL_P (loc))
14507 rtx rtl;
14508 enum dwarf_location_atom tls_op;
14509 enum dtprel_bool dtprel = dtprel_false;
14511 if (targetm.have_tls)
14513 /* If this is not defined, we have no way to emit the
14514 data. */
14515 if (!targetm.asm_out.output_dwarf_dtprel)
14516 return 0;
14518 /* The way DW_OP_GNU_push_tls_address is specified, we
14519 can only look up addresses of objects in the current
14520 module. We used DW_OP_addr as first op, but that's
14521 wrong, because DW_OP_addr is relocated by the debug
14522 info consumer, while DW_OP_GNU_push_tls_address
14523 operand shouldn't be. */
14524 if (DECL_EXTERNAL (loc) && !targetm.binds_local_p (loc))
14525 return 0;
14526 dtprel = dtprel_true;
14527 tls_op = DW_OP_GNU_push_tls_address;
14529 else
14531 if (!targetm.emutls.debug_form_tls_address
14532 || !(dwarf_version >= 3 || !dwarf_strict))
14533 return 0;
14534 /* We stuffed the control variable into the DECL_VALUE_EXPR
14535 to signal (via DECL_HAS_VALUE_EXPR_P) that the decl should
14536 no longer appear in gimple code. We used the control
14537 variable in specific so that we could pick it up here. */
14538 loc = DECL_VALUE_EXPR (loc);
14539 tls_op = DW_OP_form_tls_address;
14542 rtl = rtl_for_decl_location (loc);
14543 if (rtl == NULL_RTX)
14544 return 0;
14546 if (!MEM_P (rtl))
14547 return 0;
14548 rtl = XEXP (rtl, 0);
14549 if (! CONSTANT_P (rtl))
14550 return 0;
14552 ret = new_addr_loc_descr (rtl, dtprel);
14553 ret1 = new_loc_descr (tls_op, 0, 0);
14554 add_loc_descr (&ret, ret1);
14556 have_address = 1;
14557 break;
14559 /* FALLTHRU */
14561 case PARM_DECL:
14562 case RESULT_DECL:
14563 if (DECL_HAS_VALUE_EXPR_P (loc))
14564 return loc_list_from_tree (DECL_VALUE_EXPR (loc),
14565 want_address, context);
14566 /* FALLTHRU */
14568 case FUNCTION_DECL:
14570 rtx rtl;
14571 var_loc_list *loc_list = lookup_decl_loc (loc);
14573 if (loc_list && loc_list->first)
14575 list_ret = dw_loc_list (loc_list, loc, want_address);
14576 have_address = want_address != 0;
14577 break;
14579 rtl = rtl_for_decl_location (loc);
14580 if (rtl == NULL_RTX)
14582 expansion_failed (loc, NULL_RTX, "DECL has no RTL");
14583 return 0;
14585 else if (CONST_INT_P (rtl))
14587 HOST_WIDE_INT val = INTVAL (rtl);
14588 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
14589 val &= GET_MODE_MASK (DECL_MODE (loc));
14590 ret = int_loc_descriptor (val);
14592 else if (GET_CODE (rtl) == CONST_STRING)
14594 expansion_failed (loc, NULL_RTX, "CONST_STRING");
14595 return 0;
14597 else if (CONSTANT_P (rtl) && const_ok_for_output (rtl))
14598 ret = new_addr_loc_descr (rtl, dtprel_false);
14599 else
14601 machine_mode mode, mem_mode;
14603 /* Certain constructs can only be represented at top-level. */
14604 if (want_address == 2)
14606 ret = loc_descriptor (rtl, VOIDmode,
14607 VAR_INIT_STATUS_INITIALIZED);
14608 have_address = 1;
14610 else
14612 mode = GET_MODE (rtl);
14613 mem_mode = VOIDmode;
14614 if (MEM_P (rtl))
14616 mem_mode = mode;
14617 mode = get_address_mode (rtl);
14618 rtl = XEXP (rtl, 0);
14619 have_address = 1;
14621 ret = mem_loc_descriptor (rtl, mode, mem_mode,
14622 VAR_INIT_STATUS_INITIALIZED);
14624 if (!ret)
14625 expansion_failed (loc, rtl,
14626 "failed to produce loc descriptor for rtl");
14629 break;
14631 case MEM_REF:
14632 if (!integer_zerop (TREE_OPERAND (loc, 1)))
14634 have_address = 1;
14635 goto do_plus;
14637 /* Fallthru. */
14638 case INDIRECT_REF:
14639 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0, context);
14640 have_address = 1;
14641 break;
14643 case TARGET_MEM_REF:
14644 case SSA_NAME:
14645 return NULL;
14647 case COMPOUND_EXPR:
14648 return loc_list_from_tree (TREE_OPERAND (loc, 1), want_address, context);
14650 CASE_CONVERT:
14651 case VIEW_CONVERT_EXPR:
14652 case SAVE_EXPR:
14653 case MODIFY_EXPR:
14654 return loc_list_from_tree (TREE_OPERAND (loc, 0), want_address, context);
14656 case COMPONENT_REF:
14657 case BIT_FIELD_REF:
14658 case ARRAY_REF:
14659 case ARRAY_RANGE_REF:
14660 case REALPART_EXPR:
14661 case IMAGPART_EXPR:
14663 tree obj, offset;
14664 HOST_WIDE_INT bitsize, bitpos, bytepos;
14665 machine_mode mode;
14666 int unsignedp, volatilep = 0;
14668 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
14669 &unsignedp, &volatilep, false);
14671 gcc_assert (obj != loc);
14673 list_ret = loc_list_from_tree (obj,
14674 want_address == 2
14675 && !bitpos && !offset ? 2 : 1,
14676 context);
14677 /* TODO: We can extract value of the small expression via shifting even
14678 for nonzero bitpos. */
14679 if (list_ret == 0)
14680 return 0;
14681 if (bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
14683 expansion_failed (loc, NULL_RTX,
14684 "bitfield access");
14685 return 0;
14688 if (offset != NULL_TREE)
14690 /* Variable offset. */
14691 list_ret1 = loc_list_from_tree (offset, 0, context);
14692 if (list_ret1 == 0)
14693 return 0;
14694 add_loc_list (&list_ret, list_ret1);
14695 if (!list_ret)
14696 return 0;
14697 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_plus, 0, 0));
14700 bytepos = bitpos / BITS_PER_UNIT;
14701 if (bytepos > 0)
14702 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
14703 else if (bytepos < 0)
14704 loc_list_plus_const (list_ret, bytepos);
14706 have_address = 1;
14707 break;
14710 case INTEGER_CST:
14711 if ((want_address || !tree_fits_shwi_p (loc))
14712 && (ret = cst_pool_loc_descr (loc)))
14713 have_address = 1;
14714 else if (want_address == 2
14715 && tree_fits_shwi_p (loc)
14716 && (ret = address_of_int_loc_descriptor
14717 (int_size_in_bytes (TREE_TYPE (loc)),
14718 tree_to_shwi (loc))))
14719 have_address = 1;
14720 else if (tree_fits_shwi_p (loc))
14721 ret = int_loc_descriptor (tree_to_shwi (loc));
14722 else
14724 expansion_failed (loc, NULL_RTX,
14725 "Integer operand is not host integer");
14726 return 0;
14728 break;
14730 case CONSTRUCTOR:
14731 case REAL_CST:
14732 case STRING_CST:
14733 case COMPLEX_CST:
14734 if ((ret = cst_pool_loc_descr (loc)))
14735 have_address = 1;
14736 else
14737 /* We can construct small constants here using int_loc_descriptor. */
14738 expansion_failed (loc, NULL_RTX,
14739 "constructor or constant not in constant pool");
14740 break;
14742 case TRUTH_AND_EXPR:
14743 case TRUTH_ANDIF_EXPR:
14744 case BIT_AND_EXPR:
14745 op = DW_OP_and;
14746 goto do_binop;
14748 case TRUTH_XOR_EXPR:
14749 case BIT_XOR_EXPR:
14750 op = DW_OP_xor;
14751 goto do_binop;
14753 case TRUTH_OR_EXPR:
14754 case TRUTH_ORIF_EXPR:
14755 case BIT_IOR_EXPR:
14756 op = DW_OP_or;
14757 goto do_binop;
14759 case FLOOR_DIV_EXPR:
14760 case CEIL_DIV_EXPR:
14761 case ROUND_DIV_EXPR:
14762 case TRUNC_DIV_EXPR:
14763 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
14764 return 0;
14765 op = DW_OP_div;
14766 goto do_binop;
14768 case MINUS_EXPR:
14769 op = DW_OP_minus;
14770 goto do_binop;
14772 case FLOOR_MOD_EXPR:
14773 case CEIL_MOD_EXPR:
14774 case ROUND_MOD_EXPR:
14775 case TRUNC_MOD_EXPR:
14776 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
14778 op = DW_OP_mod;
14779 goto do_binop;
14781 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0, context);
14782 list_ret1 = loc_list_from_tree (TREE_OPERAND (loc, 1), 0, context);
14783 if (list_ret == 0 || list_ret1 == 0)
14784 return 0;
14786 add_loc_list (&list_ret, list_ret1);
14787 if (list_ret == 0)
14788 return 0;
14789 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_over, 0, 0));
14790 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_over, 0, 0));
14791 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_div, 0, 0));
14792 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_mul, 0, 0));
14793 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_minus, 0, 0));
14794 break;
14796 case MULT_EXPR:
14797 op = DW_OP_mul;
14798 goto do_binop;
14800 case LSHIFT_EXPR:
14801 op = DW_OP_shl;
14802 goto do_binop;
14804 case RSHIFT_EXPR:
14805 op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
14806 goto do_binop;
14808 case POINTER_PLUS_EXPR:
14809 case PLUS_EXPR:
14810 do_plus:
14811 if (tree_fits_shwi_p (TREE_OPERAND (loc, 1)))
14813 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0, context);
14814 if (list_ret == 0)
14815 return 0;
14817 loc_list_plus_const (list_ret, tree_to_shwi (TREE_OPERAND (loc, 1)));
14818 break;
14821 op = DW_OP_plus;
14822 goto do_binop;
14824 case LE_EXPR:
14825 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
14826 return 0;
14828 op = DW_OP_le;
14829 goto do_binop;
14831 case GE_EXPR:
14832 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
14833 return 0;
14835 op = DW_OP_ge;
14836 goto do_binop;
14838 case LT_EXPR:
14839 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
14840 return 0;
14842 op = DW_OP_lt;
14843 goto do_binop;
14845 case GT_EXPR:
14846 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
14847 return 0;
14849 op = DW_OP_gt;
14850 goto do_binop;
14852 case EQ_EXPR:
14853 op = DW_OP_eq;
14854 goto do_binop;
14856 case NE_EXPR:
14857 op = DW_OP_ne;
14858 goto do_binop;
14860 do_binop:
14861 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0, context);
14862 list_ret1 = loc_list_from_tree (TREE_OPERAND (loc, 1), 0, context);
14863 if (list_ret == 0 || list_ret1 == 0)
14864 return 0;
14866 add_loc_list (&list_ret, list_ret1);
14867 if (list_ret == 0)
14868 return 0;
14869 add_loc_descr_to_each (list_ret, new_loc_descr (op, 0, 0));
14870 break;
14872 case TRUTH_NOT_EXPR:
14873 case BIT_NOT_EXPR:
14874 op = DW_OP_not;
14875 goto do_unop;
14877 case ABS_EXPR:
14878 op = DW_OP_abs;
14879 goto do_unop;
14881 case NEGATE_EXPR:
14882 op = DW_OP_neg;
14883 goto do_unop;
14885 do_unop:
14886 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0, context);
14887 if (list_ret == 0)
14888 return 0;
14890 add_loc_descr_to_each (list_ret, new_loc_descr (op, 0, 0));
14891 break;
14893 case MIN_EXPR:
14894 case MAX_EXPR:
14896 const enum tree_code code =
14897 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
14899 loc = build3 (COND_EXPR, TREE_TYPE (loc),
14900 build2 (code, integer_type_node,
14901 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
14902 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
14905 /* ... fall through ... */
14907 case COND_EXPR:
14909 dw_loc_descr_ref lhs
14910 = loc_descriptor_from_tree (TREE_OPERAND (loc, 1), 0, context);
14911 dw_loc_list_ref rhs
14912 = loc_list_from_tree (TREE_OPERAND (loc, 2), 0, context);
14913 dw_loc_descr_ref bra_node, jump_node, tmp;
14915 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0, context);
14916 if (list_ret == 0 || lhs == 0 || rhs == 0)
14917 return 0;
14919 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
14920 add_loc_descr_to_each (list_ret, bra_node);
14922 add_loc_list (&list_ret, rhs);
14923 jump_node = new_loc_descr (DW_OP_skip, 0, 0);
14924 add_loc_descr_to_each (list_ret, jump_node);
14926 add_loc_descr_to_each (list_ret, lhs);
14927 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
14928 bra_node->dw_loc_oprnd1.v.val_loc = lhs;
14930 /* ??? Need a node to point the skip at. Use a nop. */
14931 tmp = new_loc_descr (DW_OP_nop, 0, 0);
14932 add_loc_descr_to_each (list_ret, tmp);
14933 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
14934 jump_node->dw_loc_oprnd1.v.val_loc = tmp;
14936 break;
14938 case FIX_TRUNC_EXPR:
14939 return 0;
14941 default:
14942 /* Leave front-end specific codes as simply unknown. This comes
14943 up, for instance, with the C STMT_EXPR. */
14944 if ((unsigned int) TREE_CODE (loc)
14945 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
14947 expansion_failed (loc, NULL_RTX,
14948 "language specific tree node");
14949 return 0;
14952 #ifdef ENABLE_CHECKING
14953 /* Otherwise this is a generic code; we should just lists all of
14954 these explicitly. We forgot one. */
14955 gcc_unreachable ();
14956 #else
14957 /* In a release build, we want to degrade gracefully: better to
14958 generate incomplete debugging information than to crash. */
14959 return NULL;
14960 #endif
14963 if (!ret && !list_ret)
14964 return 0;
14966 if (want_address == 2 && !have_address
14967 && (dwarf_version >= 4 || !dwarf_strict))
14969 if (int_size_in_bytes (TREE_TYPE (loc)) > DWARF2_ADDR_SIZE)
14971 expansion_failed (loc, NULL_RTX,
14972 "DWARF address size mismatch");
14973 return 0;
14975 if (ret)
14976 add_loc_descr (&ret, new_loc_descr (DW_OP_stack_value, 0, 0));
14977 else
14978 add_loc_descr_to_each (list_ret,
14979 new_loc_descr (DW_OP_stack_value, 0, 0));
14980 have_address = 1;
14982 /* Show if we can't fill the request for an address. */
14983 if (want_address && !have_address)
14985 expansion_failed (loc, NULL_RTX,
14986 "Want address and only have value");
14987 return 0;
14990 gcc_assert (!ret || !list_ret);
14992 /* If we've got an address and don't want one, dereference. */
14993 if (!want_address && have_address)
14995 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
14997 if (size > DWARF2_ADDR_SIZE || size == -1)
14999 expansion_failed (loc, NULL_RTX,
15000 "DWARF address size mismatch");
15001 return 0;
15003 else if (size == DWARF2_ADDR_SIZE)
15004 op = DW_OP_deref;
15005 else
15006 op = DW_OP_deref_size;
15008 if (ret)
15009 add_loc_descr (&ret, new_loc_descr (op, size, 0));
15010 else
15011 add_loc_descr_to_each (list_ret, new_loc_descr (op, size, 0));
15013 if (ret)
15014 list_ret = new_loc_list (ret, NULL, NULL, NULL);
15016 return list_ret;
15019 /* Same as above but return only single location expression. */
15020 static dw_loc_descr_ref
15021 loc_descriptor_from_tree (tree loc, int want_address,
15022 const struct loc_descr_context *context)
15024 dw_loc_list_ref ret = loc_list_from_tree (loc, want_address, context);
15025 if (!ret)
15026 return NULL;
15027 if (ret->dw_loc_next)
15029 expansion_failed (loc, NULL_RTX,
15030 "Location list where only loc descriptor needed");
15031 return NULL;
15033 return ret->expr;
15036 /* Given a value, round it up to the lowest multiple of `boundary'
15037 which is not less than the value itself. */
15039 static inline HOST_WIDE_INT
15040 ceiling (HOST_WIDE_INT value, unsigned int boundary)
15042 return (((value + boundary - 1) / boundary) * boundary);
15045 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
15046 pointer to the declared type for the relevant field variable, or return
15047 `integer_type_node' if the given node turns out to be an
15048 ERROR_MARK node. */
15050 static inline tree
15051 field_type (const_tree decl)
15053 tree type;
15055 if (TREE_CODE (decl) == ERROR_MARK)
15056 return integer_type_node;
15058 type = DECL_BIT_FIELD_TYPE (decl);
15059 if (type == NULL_TREE)
15060 type = TREE_TYPE (decl);
15062 return type;
15065 /* Given a pointer to a tree node, return the alignment in bits for
15066 it, or else return BITS_PER_WORD if the node actually turns out to
15067 be an ERROR_MARK node. */
15069 static inline unsigned
15070 simple_type_align_in_bits (const_tree type)
15072 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
15075 static inline unsigned
15076 simple_decl_align_in_bits (const_tree decl)
15078 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
15081 /* Return the result of rounding T up to ALIGN. */
15083 static inline offset_int
15084 round_up_to_align (const offset_int &t, unsigned int align)
15086 return wi::udiv_trunc (t + align - 1, align) * align;
15089 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
15090 lowest addressed byte of the "containing object" for the given FIELD_DECL,
15091 or return 0 if we are unable to determine what that offset is, either
15092 because the argument turns out to be a pointer to an ERROR_MARK node, or
15093 because the offset is actually variable. (We can't handle the latter case
15094 just yet). */
15096 static HOST_WIDE_INT
15097 field_byte_offset (const_tree decl)
15099 offset_int object_offset_in_bits;
15100 offset_int object_offset_in_bytes;
15101 offset_int bitpos_int;
15103 if (TREE_CODE (decl) == ERROR_MARK)
15104 return 0;
15106 gcc_assert (TREE_CODE (decl) == FIELD_DECL);
15108 /* We cannot yet cope with fields whose positions are variable, so
15109 for now, when we see such things, we simply return 0. Someday, we may
15110 be able to handle such cases, but it will be damn difficult. */
15111 if (TREE_CODE (bit_position (decl)) != INTEGER_CST)
15112 return 0;
15114 bitpos_int = wi::to_offset (bit_position (decl));
15116 #ifdef PCC_BITFIELD_TYPE_MATTERS
15117 if (PCC_BITFIELD_TYPE_MATTERS)
15119 tree type;
15120 tree field_size_tree;
15121 offset_int deepest_bitpos;
15122 offset_int field_size_in_bits;
15123 unsigned int type_align_in_bits;
15124 unsigned int decl_align_in_bits;
15125 offset_int type_size_in_bits;
15127 type = field_type (decl);
15128 type_size_in_bits = offset_int_type_size_in_bits (type);
15129 type_align_in_bits = simple_type_align_in_bits (type);
15131 field_size_tree = DECL_SIZE (decl);
15133 /* The size could be unspecified if there was an error, or for
15134 a flexible array member. */
15135 if (!field_size_tree)
15136 field_size_tree = bitsize_zero_node;
15138 /* If the size of the field is not constant, use the type size. */
15139 if (TREE_CODE (field_size_tree) == INTEGER_CST)
15140 field_size_in_bits = wi::to_offset (field_size_tree);
15141 else
15142 field_size_in_bits = type_size_in_bits;
15144 decl_align_in_bits = simple_decl_align_in_bits (decl);
15146 /* The GCC front-end doesn't make any attempt to keep track of the
15147 starting bit offset (relative to the start of the containing
15148 structure type) of the hypothetical "containing object" for a
15149 bit-field. Thus, when computing the byte offset value for the
15150 start of the "containing object" of a bit-field, we must deduce
15151 this information on our own. This can be rather tricky to do in
15152 some cases. For example, handling the following structure type
15153 definition when compiling for an i386/i486 target (which only
15154 aligns long long's to 32-bit boundaries) can be very tricky:
15156 struct S { int field1; long long field2:31; };
15158 Fortunately, there is a simple rule-of-thumb which can be used
15159 in such cases. When compiling for an i386/i486, GCC will
15160 allocate 8 bytes for the structure shown above. It decides to
15161 do this based upon one simple rule for bit-field allocation.
15162 GCC allocates each "containing object" for each bit-field at
15163 the first (i.e. lowest addressed) legitimate alignment boundary
15164 (based upon the required minimum alignment for the declared
15165 type of the field) which it can possibly use, subject to the
15166 condition that there is still enough available space remaining
15167 in the containing object (when allocated at the selected point)
15168 to fully accommodate all of the bits of the bit-field itself.
15170 This simple rule makes it obvious why GCC allocates 8 bytes for
15171 each object of the structure type shown above. When looking
15172 for a place to allocate the "containing object" for `field2',
15173 the compiler simply tries to allocate a 64-bit "containing
15174 object" at each successive 32-bit boundary (starting at zero)
15175 until it finds a place to allocate that 64- bit field such that
15176 at least 31 contiguous (and previously unallocated) bits remain
15177 within that selected 64 bit field. (As it turns out, for the
15178 example above, the compiler finds it is OK to allocate the
15179 "containing object" 64-bit field at bit-offset zero within the
15180 structure type.)
15182 Here we attempt to work backwards from the limited set of facts
15183 we're given, and we try to deduce from those facts, where GCC
15184 must have believed that the containing object started (within
15185 the structure type). The value we deduce is then used (by the
15186 callers of this routine) to generate DW_AT_location and
15187 DW_AT_bit_offset attributes for fields (both bit-fields and, in
15188 the case of DW_AT_location, regular fields as well). */
15190 /* Figure out the bit-distance from the start of the structure to
15191 the "deepest" bit of the bit-field. */
15192 deepest_bitpos = bitpos_int + field_size_in_bits;
15194 /* This is the tricky part. Use some fancy footwork to deduce
15195 where the lowest addressed bit of the containing object must
15196 be. */
15197 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
15199 /* Round up to type_align by default. This works best for
15200 bitfields. */
15201 object_offset_in_bits
15202 = round_up_to_align (object_offset_in_bits, type_align_in_bits);
15204 if (wi::gtu_p (object_offset_in_bits, bitpos_int))
15206 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
15208 /* Round up to decl_align instead. */
15209 object_offset_in_bits
15210 = round_up_to_align (object_offset_in_bits, decl_align_in_bits);
15213 else
15214 #endif /* PCC_BITFIELD_TYPE_MATTERS */
15215 object_offset_in_bits = bitpos_int;
15217 object_offset_in_bytes
15218 = wi::lrshift (object_offset_in_bits, LOG2_BITS_PER_UNIT);
15219 return object_offset_in_bytes.to_shwi ();
15222 /* The following routines define various Dwarf attributes and any data
15223 associated with them. */
15225 /* Add a location description attribute value to a DIE.
15227 This emits location attributes suitable for whole variables and
15228 whole parameters. Note that the location attributes for struct fields are
15229 generated by the routine `data_member_location_attribute' below. */
15231 static inline void
15232 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
15233 dw_loc_list_ref descr)
15235 if (descr == 0)
15236 return;
15237 if (single_element_loc_list_p (descr))
15238 add_AT_loc (die, attr_kind, descr->expr);
15239 else
15240 add_AT_loc_list (die, attr_kind, descr);
15243 /* Add DW_AT_accessibility attribute to DIE if needed. */
15245 static void
15246 add_accessibility_attribute (dw_die_ref die, tree decl)
15248 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
15249 children, otherwise the default is DW_ACCESS_public. In DWARF2
15250 the default has always been DW_ACCESS_public. */
15251 if (TREE_PROTECTED (decl))
15252 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
15253 else if (TREE_PRIVATE (decl))
15255 if (dwarf_version == 2
15256 || die->die_parent == NULL
15257 || die->die_parent->die_tag != DW_TAG_class_type)
15258 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_private);
15260 else if (dwarf_version > 2
15261 && die->die_parent
15262 && die->die_parent->die_tag == DW_TAG_class_type)
15263 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
15266 /* Attach the specialized form of location attribute used for data members of
15267 struct and union types. In the special case of a FIELD_DECL node which
15268 represents a bit-field, the "offset" part of this special location
15269 descriptor must indicate the distance in bytes from the lowest-addressed
15270 byte of the containing struct or union type to the lowest-addressed byte of
15271 the "containing object" for the bit-field. (See the `field_byte_offset'
15272 function above).
15274 For any given bit-field, the "containing object" is a hypothetical object
15275 (of some integral or enum type) within which the given bit-field lives. The
15276 type of this hypothetical "containing object" is always the same as the
15277 declared type of the individual bit-field itself (for GCC anyway... the
15278 DWARF spec doesn't actually mandate this). Note that it is the size (in
15279 bytes) of the hypothetical "containing object" which will be given in the
15280 DW_AT_byte_size attribute for this bit-field. (See the
15281 `byte_size_attribute' function below.) It is also used when calculating the
15282 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
15283 function below.) */
15285 static void
15286 add_data_member_location_attribute (dw_die_ref die, tree decl)
15288 HOST_WIDE_INT offset;
15289 dw_loc_descr_ref loc_descr = 0;
15291 if (TREE_CODE (decl) == TREE_BINFO)
15293 /* We're working on the TAG_inheritance for a base class. */
15294 if (BINFO_VIRTUAL_P (decl) && is_cxx ())
15296 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
15297 aren't at a fixed offset from all (sub)objects of the same
15298 type. We need to extract the appropriate offset from our
15299 vtable. The following dwarf expression means
15301 BaseAddr = ObAddr + *((*ObAddr) - Offset)
15303 This is specific to the V3 ABI, of course. */
15305 dw_loc_descr_ref tmp;
15307 /* Make a copy of the object address. */
15308 tmp = new_loc_descr (DW_OP_dup, 0, 0);
15309 add_loc_descr (&loc_descr, tmp);
15311 /* Extract the vtable address. */
15312 tmp = new_loc_descr (DW_OP_deref, 0, 0);
15313 add_loc_descr (&loc_descr, tmp);
15315 /* Calculate the address of the offset. */
15316 offset = tree_to_shwi (BINFO_VPTR_FIELD (decl));
15317 gcc_assert (offset < 0);
15319 tmp = int_loc_descriptor (-offset);
15320 add_loc_descr (&loc_descr, tmp);
15321 tmp = new_loc_descr (DW_OP_minus, 0, 0);
15322 add_loc_descr (&loc_descr, tmp);
15324 /* Extract the offset. */
15325 tmp = new_loc_descr (DW_OP_deref, 0, 0);
15326 add_loc_descr (&loc_descr, tmp);
15328 /* Add it to the object address. */
15329 tmp = new_loc_descr (DW_OP_plus, 0, 0);
15330 add_loc_descr (&loc_descr, tmp);
15332 else
15333 offset = tree_to_shwi (BINFO_OFFSET (decl));
15335 else
15336 offset = field_byte_offset (decl);
15338 if (! loc_descr)
15340 if (dwarf_version > 2)
15342 /* Don't need to output a location expression, just the constant. */
15343 if (offset < 0)
15344 add_AT_int (die, DW_AT_data_member_location, offset);
15345 else
15346 add_AT_unsigned (die, DW_AT_data_member_location, offset);
15347 return;
15349 else
15351 enum dwarf_location_atom op;
15353 /* The DWARF2 standard says that we should assume that the structure
15354 address is already on the stack, so we can specify a structure
15355 field address by using DW_OP_plus_uconst. */
15356 op = DW_OP_plus_uconst;
15357 loc_descr = new_loc_descr (op, offset, 0);
15361 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
15364 /* Writes integer values to dw_vec_const array. */
15366 static void
15367 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
15369 while (size != 0)
15371 *dest++ = val & 0xff;
15372 val >>= 8;
15373 --size;
15377 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
15379 static HOST_WIDE_INT
15380 extract_int (const unsigned char *src, unsigned int size)
15382 HOST_WIDE_INT val = 0;
15384 src += size;
15385 while (size != 0)
15387 val <<= 8;
15388 val |= *--src & 0xff;
15389 --size;
15391 return val;
15394 /* Writes wide_int values to dw_vec_const array. */
15396 static void
15397 insert_wide_int (const wide_int &val, unsigned char *dest, int elt_size)
15399 int i;
15401 if (elt_size <= HOST_BITS_PER_WIDE_INT/BITS_PER_UNIT)
15403 insert_int ((HOST_WIDE_INT) val.elt (0), elt_size, dest);
15404 return;
15407 /* We'd have to extend this code to support odd sizes. */
15408 gcc_assert (elt_size % (HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT) == 0);
15410 int n = elt_size / (HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT);
15412 if (WORDS_BIG_ENDIAN)
15413 for (i = n - 1; i >= 0; i--)
15415 insert_int ((HOST_WIDE_INT) val.elt (i), sizeof (HOST_WIDE_INT), dest);
15416 dest += sizeof (HOST_WIDE_INT);
15418 else
15419 for (i = 0; i < n; i++)
15421 insert_int ((HOST_WIDE_INT) val.elt (i), sizeof (HOST_WIDE_INT), dest);
15422 dest += sizeof (HOST_WIDE_INT);
15426 /* Writes floating point values to dw_vec_const array. */
15428 static void
15429 insert_float (const_rtx rtl, unsigned char *array)
15431 REAL_VALUE_TYPE rv;
15432 long val[4];
15433 int i;
15435 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
15436 real_to_target (val, &rv, GET_MODE (rtl));
15438 /* real_to_target puts 32-bit pieces in each long. Pack them. */
15439 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
15441 insert_int (val[i], 4, array);
15442 array += 4;
15446 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
15447 does not have a "location" either in memory or in a register. These
15448 things can arise in GNU C when a constant is passed as an actual parameter
15449 to an inlined function. They can also arise in C++ where declared
15450 constants do not necessarily get memory "homes". */
15452 static bool
15453 add_const_value_attribute (dw_die_ref die, rtx rtl)
15455 switch (GET_CODE (rtl))
15457 case CONST_INT:
15459 HOST_WIDE_INT val = INTVAL (rtl);
15461 if (val < 0)
15462 add_AT_int (die, DW_AT_const_value, val);
15463 else
15464 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
15466 return true;
15468 case CONST_WIDE_INT:
15469 add_AT_wide (die, DW_AT_const_value,
15470 std::make_pair (rtl, GET_MODE (rtl)));
15471 return true;
15473 case CONST_DOUBLE:
15474 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
15475 floating-point constant. A CONST_DOUBLE is used whenever the
15476 constant requires more than one word in order to be adequately
15477 represented. */
15479 machine_mode mode = GET_MODE (rtl);
15481 if (TARGET_SUPPORTS_WIDE_INT == 0 && !SCALAR_FLOAT_MODE_P (mode))
15482 add_AT_double (die, DW_AT_const_value,
15483 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
15484 else
15486 unsigned int length = GET_MODE_SIZE (mode);
15487 unsigned char *array = ggc_vec_alloc<unsigned char> (length);
15489 insert_float (rtl, array);
15490 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
15493 return true;
15495 case CONST_VECTOR:
15497 machine_mode mode = GET_MODE (rtl);
15498 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
15499 unsigned int length = CONST_VECTOR_NUNITS (rtl);
15500 unsigned char *array
15501 = ggc_vec_alloc<unsigned char> (length * elt_size);
15502 unsigned int i;
15503 unsigned char *p;
15504 machine_mode imode = GET_MODE_INNER (mode);
15506 switch (GET_MODE_CLASS (mode))
15508 case MODE_VECTOR_INT:
15509 for (i = 0, p = array; i < length; i++, p += elt_size)
15511 rtx elt = CONST_VECTOR_ELT (rtl, i);
15512 insert_wide_int (std::make_pair (elt, imode), p, elt_size);
15514 break;
15516 case MODE_VECTOR_FLOAT:
15517 for (i = 0, p = array; i < length; i++, p += elt_size)
15519 rtx elt = CONST_VECTOR_ELT (rtl, i);
15520 insert_float (elt, p);
15522 break;
15524 default:
15525 gcc_unreachable ();
15528 add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
15530 return true;
15532 case CONST_STRING:
15533 if (dwarf_version >= 4 || !dwarf_strict)
15535 dw_loc_descr_ref loc_result;
15536 resolve_one_addr (&rtl);
15537 rtl_addr:
15538 loc_result = new_addr_loc_descr (rtl, dtprel_false);
15539 add_loc_descr (&loc_result, new_loc_descr (DW_OP_stack_value, 0, 0));
15540 add_AT_loc (die, DW_AT_location, loc_result);
15541 vec_safe_push (used_rtx_array, rtl);
15542 return true;
15544 return false;
15546 case CONST:
15547 if (CONSTANT_P (XEXP (rtl, 0)))
15548 return add_const_value_attribute (die, XEXP (rtl, 0));
15549 /* FALLTHROUGH */
15550 case SYMBOL_REF:
15551 if (!const_ok_for_output (rtl))
15552 return false;
15553 case LABEL_REF:
15554 if (dwarf_version >= 4 || !dwarf_strict)
15555 goto rtl_addr;
15556 return false;
15558 case PLUS:
15559 /* In cases where an inlined instance of an inline function is passed
15560 the address of an `auto' variable (which is local to the caller) we
15561 can get a situation where the DECL_RTL of the artificial local
15562 variable (for the inlining) which acts as a stand-in for the
15563 corresponding formal parameter (of the inline function) will look
15564 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
15565 exactly a compile-time constant expression, but it isn't the address
15566 of the (artificial) local variable either. Rather, it represents the
15567 *value* which the artificial local variable always has during its
15568 lifetime. We currently have no way to represent such quasi-constant
15569 values in Dwarf, so for now we just punt and generate nothing. */
15570 return false;
15572 case HIGH:
15573 case CONST_FIXED:
15574 return false;
15576 case MEM:
15577 if (GET_CODE (XEXP (rtl, 0)) == CONST_STRING
15578 && MEM_READONLY_P (rtl)
15579 && GET_MODE (rtl) == BLKmode)
15581 add_AT_string (die, DW_AT_const_value, XSTR (XEXP (rtl, 0), 0));
15582 return true;
15584 return false;
15586 default:
15587 /* No other kinds of rtx should be possible here. */
15588 gcc_unreachable ();
15590 return false;
15593 /* Determine whether the evaluation of EXPR references any variables
15594 or functions which aren't otherwise used (and therefore may not be
15595 output). */
15596 static tree
15597 reference_to_unused (tree * tp, int * walk_subtrees,
15598 void * data ATTRIBUTE_UNUSED)
15600 if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp))
15601 *walk_subtrees = 0;
15603 if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
15604 && ! TREE_ASM_WRITTEN (*tp))
15605 return *tp;
15606 /* ??? The C++ FE emits debug information for using decls, so
15607 putting gcc_unreachable here falls over. See PR31899. For now
15608 be conservative. */
15609 else if (!symtab->global_info_ready
15610 && (TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == FUNCTION_DECL))
15611 return *tp;
15612 else if (TREE_CODE (*tp) == VAR_DECL)
15614 varpool_node *node = varpool_node::get (*tp);
15615 if (!node || !node->definition)
15616 return *tp;
15618 else if (TREE_CODE (*tp) == FUNCTION_DECL
15619 && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp)))
15621 /* The call graph machinery must have finished analyzing,
15622 optimizing and gimplifying the CU by now.
15623 So if *TP has no call graph node associated
15624 to it, it means *TP will not be emitted. */
15625 if (!cgraph_node::get (*tp))
15626 return *tp;
15628 else if (TREE_CODE (*tp) == STRING_CST && !TREE_ASM_WRITTEN (*tp))
15629 return *tp;
15631 return NULL_TREE;
15634 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
15635 for use in a later add_const_value_attribute call. */
15637 static rtx
15638 rtl_for_decl_init (tree init, tree type)
15640 rtx rtl = NULL_RTX;
15642 STRIP_NOPS (init);
15644 /* If a variable is initialized with a string constant without embedded
15645 zeros, build CONST_STRING. */
15646 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
15648 tree enttype = TREE_TYPE (type);
15649 tree domain = TYPE_DOMAIN (type);
15650 machine_mode mode = TYPE_MODE (enttype);
15652 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
15653 && domain
15654 && integer_zerop (TYPE_MIN_VALUE (domain))
15655 && compare_tree_int (TYPE_MAX_VALUE (domain),
15656 TREE_STRING_LENGTH (init) - 1) == 0
15657 && ((size_t) TREE_STRING_LENGTH (init)
15658 == strlen (TREE_STRING_POINTER (init)) + 1))
15660 rtl = gen_rtx_CONST_STRING (VOIDmode,
15661 ggc_strdup (TREE_STRING_POINTER (init)));
15662 rtl = gen_rtx_MEM (BLKmode, rtl);
15663 MEM_READONLY_P (rtl) = 1;
15666 /* Other aggregates, and complex values, could be represented using
15667 CONCAT: FIXME! */
15668 else if (AGGREGATE_TYPE_P (type)
15669 || (TREE_CODE (init) == VIEW_CONVERT_EXPR
15670 && AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (init, 0))))
15671 || TREE_CODE (type) == COMPLEX_TYPE)
15673 /* Vectors only work if their mode is supported by the target.
15674 FIXME: generic vectors ought to work too. */
15675 else if (TREE_CODE (type) == VECTOR_TYPE
15676 && !VECTOR_MODE_P (TYPE_MODE (type)))
15678 /* If the initializer is something that we know will expand into an
15679 immediate RTL constant, expand it now. We must be careful not to
15680 reference variables which won't be output. */
15681 else if (initializer_constant_valid_p (init, type)
15682 && ! walk_tree (&init, reference_to_unused, NULL, NULL))
15684 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
15685 possible. */
15686 if (TREE_CODE (type) == VECTOR_TYPE)
15687 switch (TREE_CODE (init))
15689 case VECTOR_CST:
15690 break;
15691 case CONSTRUCTOR:
15692 if (TREE_CONSTANT (init))
15694 vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (init);
15695 bool constant_p = true;
15696 tree value;
15697 unsigned HOST_WIDE_INT ix;
15699 /* Even when ctor is constant, it might contain non-*_CST
15700 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
15701 belong into VECTOR_CST nodes. */
15702 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
15703 if (!CONSTANT_CLASS_P (value))
15705 constant_p = false;
15706 break;
15709 if (constant_p)
15711 init = build_vector_from_ctor (type, elts);
15712 break;
15715 /* FALLTHRU */
15717 default:
15718 return NULL;
15721 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
15723 /* If expand_expr returns a MEM, it wasn't immediate. */
15724 gcc_assert (!rtl || !MEM_P (rtl));
15727 return rtl;
15730 /* Generate RTL for the variable DECL to represent its location. */
15732 static rtx
15733 rtl_for_decl_location (tree decl)
15735 rtx rtl;
15737 /* Here we have to decide where we are going to say the parameter "lives"
15738 (as far as the debugger is concerned). We only have a couple of
15739 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
15741 DECL_RTL normally indicates where the parameter lives during most of the
15742 activation of the function. If optimization is enabled however, this
15743 could be either NULL or else a pseudo-reg. Both of those cases indicate
15744 that the parameter doesn't really live anywhere (as far as the code
15745 generation parts of GCC are concerned) during most of the function's
15746 activation. That will happen (for example) if the parameter is never
15747 referenced within the function.
15749 We could just generate a location descriptor here for all non-NULL
15750 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
15751 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
15752 where DECL_RTL is NULL or is a pseudo-reg.
15754 Note however that we can only get away with using DECL_INCOMING_RTL as
15755 a backup substitute for DECL_RTL in certain limited cases. In cases
15756 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
15757 we can be sure that the parameter was passed using the same type as it is
15758 declared to have within the function, and that its DECL_INCOMING_RTL
15759 points us to a place where a value of that type is passed.
15761 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
15762 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
15763 because in these cases DECL_INCOMING_RTL points us to a value of some
15764 type which is *different* from the type of the parameter itself. Thus,
15765 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
15766 such cases, the debugger would end up (for example) trying to fetch a
15767 `float' from a place which actually contains the first part of a
15768 `double'. That would lead to really incorrect and confusing
15769 output at debug-time.
15771 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
15772 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
15773 are a couple of exceptions however. On little-endian machines we can
15774 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
15775 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
15776 an integral type that is smaller than TREE_TYPE (decl). These cases arise
15777 when (on a little-endian machine) a non-prototyped function has a
15778 parameter declared to be of type `short' or `char'. In such cases,
15779 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
15780 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
15781 passed `int' value. If the debugger then uses that address to fetch
15782 a `short' or a `char' (on a little-endian machine) the result will be
15783 the correct data, so we allow for such exceptional cases below.
15785 Note that our goal here is to describe the place where the given formal
15786 parameter lives during most of the function's activation (i.e. between the
15787 end of the prologue and the start of the epilogue). We'll do that as best
15788 as we can. Note however that if the given formal parameter is modified
15789 sometime during the execution of the function, then a stack backtrace (at
15790 debug-time) will show the function as having been called with the *new*
15791 value rather than the value which was originally passed in. This happens
15792 rarely enough that it is not a major problem, but it *is* a problem, and
15793 I'd like to fix it.
15795 A future version of dwarf2out.c may generate two additional attributes for
15796 any given DW_TAG_formal_parameter DIE which will describe the "passed
15797 type" and the "passed location" for the given formal parameter in addition
15798 to the attributes we now generate to indicate the "declared type" and the
15799 "active location" for each parameter. This additional set of attributes
15800 could be used by debuggers for stack backtraces. Separately, note that
15801 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
15802 This happens (for example) for inlined-instances of inline function formal
15803 parameters which are never referenced. This really shouldn't be
15804 happening. All PARM_DECL nodes should get valid non-NULL
15805 DECL_INCOMING_RTL values. FIXME. */
15807 /* Use DECL_RTL as the "location" unless we find something better. */
15808 rtl = DECL_RTL_IF_SET (decl);
15810 /* When generating abstract instances, ignore everything except
15811 constants, symbols living in memory, and symbols living in
15812 fixed registers. */
15813 if (! reload_completed)
15815 if (rtl
15816 && (CONSTANT_P (rtl)
15817 || (MEM_P (rtl)
15818 && CONSTANT_P (XEXP (rtl, 0)))
15819 || (REG_P (rtl)
15820 && TREE_CODE (decl) == VAR_DECL
15821 && TREE_STATIC (decl))))
15823 rtl = targetm.delegitimize_address (rtl);
15824 return rtl;
15826 rtl = NULL_RTX;
15828 else if (TREE_CODE (decl) == PARM_DECL)
15830 if (rtl == NULL_RTX
15831 || is_pseudo_reg (rtl)
15832 || (MEM_P (rtl)
15833 && is_pseudo_reg (XEXP (rtl, 0))
15834 && DECL_INCOMING_RTL (decl)
15835 && MEM_P (DECL_INCOMING_RTL (decl))
15836 && GET_MODE (rtl) == GET_MODE (DECL_INCOMING_RTL (decl))))
15838 tree declared_type = TREE_TYPE (decl);
15839 tree passed_type = DECL_ARG_TYPE (decl);
15840 machine_mode dmode = TYPE_MODE (declared_type);
15841 machine_mode pmode = TYPE_MODE (passed_type);
15843 /* This decl represents a formal parameter which was optimized out.
15844 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
15845 all cases where (rtl == NULL_RTX) just below. */
15846 if (dmode == pmode)
15847 rtl = DECL_INCOMING_RTL (decl);
15848 else if ((rtl == NULL_RTX || is_pseudo_reg (rtl))
15849 && SCALAR_INT_MODE_P (dmode)
15850 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
15851 && DECL_INCOMING_RTL (decl))
15853 rtx inc = DECL_INCOMING_RTL (decl);
15854 if (REG_P (inc))
15855 rtl = inc;
15856 else if (MEM_P (inc))
15858 if (BYTES_BIG_ENDIAN)
15859 rtl = adjust_address_nv (inc, dmode,
15860 GET_MODE_SIZE (pmode)
15861 - GET_MODE_SIZE (dmode));
15862 else
15863 rtl = inc;
15868 /* If the parm was passed in registers, but lives on the stack, then
15869 make a big endian correction if the mode of the type of the
15870 parameter is not the same as the mode of the rtl. */
15871 /* ??? This is the same series of checks that are made in dbxout.c before
15872 we reach the big endian correction code there. It isn't clear if all
15873 of these checks are necessary here, but keeping them all is the safe
15874 thing to do. */
15875 else if (MEM_P (rtl)
15876 && XEXP (rtl, 0) != const0_rtx
15877 && ! CONSTANT_P (XEXP (rtl, 0))
15878 /* Not passed in memory. */
15879 && !MEM_P (DECL_INCOMING_RTL (decl))
15880 /* Not passed by invisible reference. */
15881 && (!REG_P (XEXP (rtl, 0))
15882 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
15883 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
15884 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
15885 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
15886 #endif
15888 /* Big endian correction check. */
15889 && BYTES_BIG_ENDIAN
15890 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
15891 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
15892 < UNITS_PER_WORD))
15894 machine_mode addr_mode = get_address_mode (rtl);
15895 int offset = (UNITS_PER_WORD
15896 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
15898 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
15899 plus_constant (addr_mode, XEXP (rtl, 0), offset));
15902 else if (TREE_CODE (decl) == VAR_DECL
15903 && rtl
15904 && MEM_P (rtl)
15905 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
15906 && BYTES_BIG_ENDIAN)
15908 machine_mode addr_mode = get_address_mode (rtl);
15909 int rsize = GET_MODE_SIZE (GET_MODE (rtl));
15910 int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
15912 /* If a variable is declared "register" yet is smaller than
15913 a register, then if we store the variable to memory, it
15914 looks like we're storing a register-sized value, when in
15915 fact we are not. We need to adjust the offset of the
15916 storage location to reflect the actual value's bytes,
15917 else gdb will not be able to display it. */
15918 if (rsize > dsize)
15919 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
15920 plus_constant (addr_mode, XEXP (rtl, 0),
15921 rsize - dsize));
15924 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
15925 and will have been substituted directly into all expressions that use it.
15926 C does not have such a concept, but C++ and other languages do. */
15927 if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
15928 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
15930 if (rtl)
15931 rtl = targetm.delegitimize_address (rtl);
15933 /* If we don't look past the constant pool, we risk emitting a
15934 reference to a constant pool entry that isn't referenced from
15935 code, and thus is not emitted. */
15936 if (rtl)
15937 rtl = avoid_constant_pool_reference (rtl);
15939 /* Try harder to get a rtl. If this symbol ends up not being emitted
15940 in the current CU, resolve_addr will remove the expression referencing
15941 it. */
15942 if (rtl == NULL_RTX
15943 && TREE_CODE (decl) == VAR_DECL
15944 && !DECL_EXTERNAL (decl)
15945 && TREE_STATIC (decl)
15946 && DECL_NAME (decl)
15947 && !DECL_HARD_REGISTER (decl)
15948 && DECL_MODE (decl) != VOIDmode)
15950 rtl = make_decl_rtl_for_debug (decl);
15951 if (!MEM_P (rtl)
15952 || GET_CODE (XEXP (rtl, 0)) != SYMBOL_REF
15953 || SYMBOL_REF_DECL (XEXP (rtl, 0)) != decl)
15954 rtl = NULL_RTX;
15957 return rtl;
15960 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
15961 returned. If so, the decl for the COMMON block is returned, and the
15962 value is the offset into the common block for the symbol. */
15964 static tree
15965 fortran_common (tree decl, HOST_WIDE_INT *value)
15967 tree val_expr, cvar;
15968 machine_mode mode;
15969 HOST_WIDE_INT bitsize, bitpos;
15970 tree offset;
15971 int unsignedp, volatilep = 0;
15973 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
15974 it does not have a value (the offset into the common area), or if it
15975 is thread local (as opposed to global) then it isn't common, and shouldn't
15976 be handled as such. */
15977 if (TREE_CODE (decl) != VAR_DECL
15978 || !TREE_STATIC (decl)
15979 || !DECL_HAS_VALUE_EXPR_P (decl)
15980 || !is_fortran ())
15981 return NULL_TREE;
15983 val_expr = DECL_VALUE_EXPR (decl);
15984 if (TREE_CODE (val_expr) != COMPONENT_REF)
15985 return NULL_TREE;
15987 cvar = get_inner_reference (val_expr, &bitsize, &bitpos, &offset,
15988 &mode, &unsignedp, &volatilep, true);
15990 if (cvar == NULL_TREE
15991 || TREE_CODE (cvar) != VAR_DECL
15992 || DECL_ARTIFICIAL (cvar)
15993 || !TREE_PUBLIC (cvar))
15994 return NULL_TREE;
15996 *value = 0;
15997 if (offset != NULL)
15999 if (!tree_fits_shwi_p (offset))
16000 return NULL_TREE;
16001 *value = tree_to_shwi (offset);
16003 if (bitpos != 0)
16004 *value += bitpos / BITS_PER_UNIT;
16006 return cvar;
16009 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
16010 data attribute for a variable or a parameter. We generate the
16011 DW_AT_const_value attribute only in those cases where the given variable
16012 or parameter does not have a true "location" either in memory or in a
16013 register. This can happen (for example) when a constant is passed as an
16014 actual argument in a call to an inline function. (It's possible that
16015 these things can crop up in other ways also.) Note that one type of
16016 constant value which can be passed into an inlined function is a constant
16017 pointer. This can happen for example if an actual argument in an inlined
16018 function call evaluates to a compile-time constant address.
16020 CACHE_P is true if it is worth caching the location list for DECL,
16021 so that future calls can reuse it rather than regenerate it from scratch.
16022 This is true for BLOCK_NONLOCALIZED_VARS in inlined subroutines,
16023 since we will need to refer to them each time the function is inlined. */
16025 static bool
16026 add_location_or_const_value_attribute (dw_die_ref die, tree decl, bool cache_p,
16027 enum dwarf_attribute attr)
16029 rtx rtl;
16030 dw_loc_list_ref list;
16031 var_loc_list *loc_list;
16032 cached_dw_loc_list *cache;
16034 if (TREE_CODE (decl) == ERROR_MARK)
16035 return false;
16037 gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
16038 || TREE_CODE (decl) == RESULT_DECL);
16040 /* Try to get some constant RTL for this decl, and use that as the value of
16041 the location. */
16043 rtl = rtl_for_decl_location (decl);
16044 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING)
16045 && add_const_value_attribute (die, rtl))
16046 return true;
16048 /* See if we have single element location list that is equivalent to
16049 a constant value. That way we are better to use add_const_value_attribute
16050 rather than expanding constant value equivalent. */
16051 loc_list = lookup_decl_loc (decl);
16052 if (loc_list
16053 && loc_list->first
16054 && loc_list->first->next == NULL
16055 && NOTE_P (loc_list->first->loc)
16056 && NOTE_VAR_LOCATION (loc_list->first->loc)
16057 && NOTE_VAR_LOCATION_LOC (loc_list->first->loc))
16059 struct var_loc_node *node;
16061 node = loc_list->first;
16062 rtl = NOTE_VAR_LOCATION_LOC (node->loc);
16063 if (GET_CODE (rtl) == EXPR_LIST)
16064 rtl = XEXP (rtl, 0);
16065 if ((CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING)
16066 && add_const_value_attribute (die, rtl))
16067 return true;
16069 /* If this decl is from BLOCK_NONLOCALIZED_VARS, we might need its
16070 list several times. See if we've already cached the contents. */
16071 list = NULL;
16072 if (loc_list == NULL || cached_dw_loc_list_table == NULL)
16073 cache_p = false;
16074 if (cache_p)
16076 cache = cached_dw_loc_list_table->find_with_hash (decl, DECL_UID (decl));
16077 if (cache)
16078 list = cache->loc_list;
16080 if (list == NULL)
16082 list = loc_list_from_tree (decl, decl_by_reference_p (decl) ? 0 : 2,
16083 NULL);
16084 /* It is usually worth caching this result if the decl is from
16085 BLOCK_NONLOCALIZED_VARS and if the list has at least two elements. */
16086 if (cache_p && list && list->dw_loc_next)
16088 cached_dw_loc_list **slot
16089 = cached_dw_loc_list_table->find_slot_with_hash (decl,
16090 DECL_UID (decl),
16091 INSERT);
16092 cache = ggc_cleared_alloc<cached_dw_loc_list> ();
16093 cache->decl_id = DECL_UID (decl);
16094 cache->loc_list = list;
16095 *slot = cache;
16098 if (list)
16100 add_AT_location_description (die, attr, list);
16101 return true;
16103 /* None of that worked, so it must not really have a location;
16104 try adding a constant value attribute from the DECL_INITIAL. */
16105 return tree_add_const_value_attribute_for_decl (die, decl);
16108 /* Add VARIABLE and DIE into deferred locations list. */
16110 static void
16111 defer_location (tree variable, dw_die_ref die)
16113 deferred_locations entry;
16114 entry.variable = variable;
16115 entry.die = die;
16116 vec_safe_push (deferred_locations_list, entry);
16119 /* Helper function for tree_add_const_value_attribute. Natively encode
16120 initializer INIT into an array. Return true if successful. */
16122 static bool
16123 native_encode_initializer (tree init, unsigned char *array, int size)
16125 tree type;
16127 if (init == NULL_TREE)
16128 return false;
16130 STRIP_NOPS (init);
16131 switch (TREE_CODE (init))
16133 case STRING_CST:
16134 type = TREE_TYPE (init);
16135 if (TREE_CODE (type) == ARRAY_TYPE)
16137 tree enttype = TREE_TYPE (type);
16138 machine_mode mode = TYPE_MODE (enttype);
16140 if (GET_MODE_CLASS (mode) != MODE_INT || GET_MODE_SIZE (mode) != 1)
16141 return false;
16142 if (int_size_in_bytes (type) != size)
16143 return false;
16144 if (size > TREE_STRING_LENGTH (init))
16146 memcpy (array, TREE_STRING_POINTER (init),
16147 TREE_STRING_LENGTH (init));
16148 memset (array + TREE_STRING_LENGTH (init),
16149 '\0', size - TREE_STRING_LENGTH (init));
16151 else
16152 memcpy (array, TREE_STRING_POINTER (init), size);
16153 return true;
16155 return false;
16156 case CONSTRUCTOR:
16157 type = TREE_TYPE (init);
16158 if (int_size_in_bytes (type) != size)
16159 return false;
16160 if (TREE_CODE (type) == ARRAY_TYPE)
16162 HOST_WIDE_INT min_index;
16163 unsigned HOST_WIDE_INT cnt;
16164 int curpos = 0, fieldsize;
16165 constructor_elt *ce;
16167 if (TYPE_DOMAIN (type) == NULL_TREE
16168 || !tree_fits_shwi_p (TYPE_MIN_VALUE (TYPE_DOMAIN (type))))
16169 return false;
16171 fieldsize = int_size_in_bytes (TREE_TYPE (type));
16172 if (fieldsize <= 0)
16173 return false;
16175 min_index = tree_to_shwi (TYPE_MIN_VALUE (TYPE_DOMAIN (type)));
16176 memset (array, '\0', size);
16177 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init), cnt, ce)
16179 tree val = ce->value;
16180 tree index = ce->index;
16181 int pos = curpos;
16182 if (index && TREE_CODE (index) == RANGE_EXPR)
16183 pos = (tree_to_shwi (TREE_OPERAND (index, 0)) - min_index)
16184 * fieldsize;
16185 else if (index)
16186 pos = (tree_to_shwi (index) - min_index) * fieldsize;
16188 if (val)
16190 STRIP_NOPS (val);
16191 if (!native_encode_initializer (val, array + pos, fieldsize))
16192 return false;
16194 curpos = pos + fieldsize;
16195 if (index && TREE_CODE (index) == RANGE_EXPR)
16197 int count = tree_to_shwi (TREE_OPERAND (index, 1))
16198 - tree_to_shwi (TREE_OPERAND (index, 0));
16199 while (count-- > 0)
16201 if (val)
16202 memcpy (array + curpos, array + pos, fieldsize);
16203 curpos += fieldsize;
16206 gcc_assert (curpos <= size);
16208 return true;
16210 else if (TREE_CODE (type) == RECORD_TYPE
16211 || TREE_CODE (type) == UNION_TYPE)
16213 tree field = NULL_TREE;
16214 unsigned HOST_WIDE_INT cnt;
16215 constructor_elt *ce;
16217 if (int_size_in_bytes (type) != size)
16218 return false;
16220 if (TREE_CODE (type) == RECORD_TYPE)
16221 field = TYPE_FIELDS (type);
16223 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init), cnt, ce)
16225 tree val = ce->value;
16226 int pos, fieldsize;
16228 if (ce->index != 0)
16229 field = ce->index;
16231 if (val)
16232 STRIP_NOPS (val);
16234 if (field == NULL_TREE || DECL_BIT_FIELD (field))
16235 return false;
16237 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
16238 && TYPE_DOMAIN (TREE_TYPE (field))
16239 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
16240 return false;
16241 else if (DECL_SIZE_UNIT (field) == NULL_TREE
16242 || !tree_fits_shwi_p (DECL_SIZE_UNIT (field)))
16243 return false;
16244 fieldsize = tree_to_shwi (DECL_SIZE_UNIT (field));
16245 pos = int_byte_position (field);
16246 gcc_assert (pos + fieldsize <= size);
16247 if (val
16248 && !native_encode_initializer (val, array + pos, fieldsize))
16249 return false;
16251 return true;
16253 return false;
16254 case VIEW_CONVERT_EXPR:
16255 case NON_LVALUE_EXPR:
16256 return native_encode_initializer (TREE_OPERAND (init, 0), array, size);
16257 default:
16258 return native_encode_expr (init, array, size) == size;
16262 /* Attach a DW_AT_const_value attribute to DIE. The value of the
16263 attribute is the const value T. */
16265 static bool
16266 tree_add_const_value_attribute (dw_die_ref die, tree t)
16268 tree init;
16269 tree type = TREE_TYPE (t);
16270 rtx rtl;
16272 if (!t || !TREE_TYPE (t) || TREE_TYPE (t) == error_mark_node)
16273 return false;
16275 init = t;
16276 gcc_assert (!DECL_P (init));
16278 rtl = rtl_for_decl_init (init, type);
16279 if (rtl)
16280 return add_const_value_attribute (die, rtl);
16281 /* If the host and target are sane, try harder. */
16282 else if (CHAR_BIT == 8 && BITS_PER_UNIT == 8
16283 && initializer_constant_valid_p (init, type))
16285 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (init));
16286 if (size > 0 && (int) size == size)
16288 unsigned char *array = ggc_cleared_vec_alloc<unsigned char> (size);
16290 if (native_encode_initializer (init, array, size))
16292 add_AT_vec (die, DW_AT_const_value, size, 1, array);
16293 return true;
16295 ggc_free (array);
16298 return false;
16301 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
16302 attribute is the const value of T, where T is an integral constant
16303 variable with static storage duration
16304 (so it can't be a PARM_DECL or a RESULT_DECL). */
16306 static bool
16307 tree_add_const_value_attribute_for_decl (dw_die_ref var_die, tree decl)
16310 if (!decl
16311 || (TREE_CODE (decl) != VAR_DECL
16312 && TREE_CODE (decl) != CONST_DECL)
16313 || (TREE_CODE (decl) == VAR_DECL
16314 && !TREE_STATIC (decl)))
16315 return false;
16317 if (TREE_READONLY (decl)
16318 && ! TREE_THIS_VOLATILE (decl)
16319 && DECL_INITIAL (decl))
16320 /* OK */;
16321 else
16322 return false;
16324 /* Don't add DW_AT_const_value if abstract origin already has one. */
16325 if (get_AT (var_die, DW_AT_const_value))
16326 return false;
16328 return tree_add_const_value_attribute (var_die, DECL_INITIAL (decl));
16331 /* Convert the CFI instructions for the current function into a
16332 location list. This is used for DW_AT_frame_base when we targeting
16333 a dwarf2 consumer that does not support the dwarf3
16334 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
16335 expressions. */
16337 static dw_loc_list_ref
16338 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
16340 int ix;
16341 dw_fde_ref fde;
16342 dw_loc_list_ref list, *list_tail;
16343 dw_cfi_ref cfi;
16344 dw_cfa_location last_cfa, next_cfa;
16345 const char *start_label, *last_label, *section;
16346 dw_cfa_location remember;
16348 fde = cfun->fde;
16349 gcc_assert (fde != NULL);
16351 section = secname_for_decl (current_function_decl);
16352 list_tail = &list;
16353 list = NULL;
16355 memset (&next_cfa, 0, sizeof (next_cfa));
16356 next_cfa.reg = INVALID_REGNUM;
16357 remember = next_cfa;
16359 start_label = fde->dw_fde_begin;
16361 /* ??? Bald assumption that the CIE opcode list does not contain
16362 advance opcodes. */
16363 FOR_EACH_VEC_ELT (*cie_cfi_vec, ix, cfi)
16364 lookup_cfa_1 (cfi, &next_cfa, &remember);
16366 last_cfa = next_cfa;
16367 last_label = start_label;
16369 if (fde->dw_fde_second_begin && fde->dw_fde_switch_cfi_index == 0)
16371 /* If the first partition contained no CFI adjustments, the
16372 CIE opcodes apply to the whole first partition. */
16373 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
16374 fde->dw_fde_begin, fde->dw_fde_end, section);
16375 list_tail =&(*list_tail)->dw_loc_next;
16376 start_label = last_label = fde->dw_fde_second_begin;
16379 FOR_EACH_VEC_SAFE_ELT (fde->dw_fde_cfi, ix, cfi)
16381 switch (cfi->dw_cfi_opc)
16383 case DW_CFA_set_loc:
16384 case DW_CFA_advance_loc1:
16385 case DW_CFA_advance_loc2:
16386 case DW_CFA_advance_loc4:
16387 if (!cfa_equal_p (&last_cfa, &next_cfa))
16389 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
16390 start_label, last_label, section);
16392 list_tail = &(*list_tail)->dw_loc_next;
16393 last_cfa = next_cfa;
16394 start_label = last_label;
16396 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
16397 break;
16399 case DW_CFA_advance_loc:
16400 /* The encoding is complex enough that we should never emit this. */
16401 gcc_unreachable ();
16403 default:
16404 lookup_cfa_1 (cfi, &next_cfa, &remember);
16405 break;
16407 if (ix + 1 == fde->dw_fde_switch_cfi_index)
16409 if (!cfa_equal_p (&last_cfa, &next_cfa))
16411 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
16412 start_label, last_label, section);
16414 list_tail = &(*list_tail)->dw_loc_next;
16415 last_cfa = next_cfa;
16416 start_label = last_label;
16418 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
16419 start_label, fde->dw_fde_end, section);
16420 list_tail = &(*list_tail)->dw_loc_next;
16421 start_label = last_label = fde->dw_fde_second_begin;
16425 if (!cfa_equal_p (&last_cfa, &next_cfa))
16427 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
16428 start_label, last_label, section);
16429 list_tail = &(*list_tail)->dw_loc_next;
16430 start_label = last_label;
16433 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
16434 start_label,
16435 fde->dw_fde_second_begin
16436 ? fde->dw_fde_second_end : fde->dw_fde_end,
16437 section);
16439 if (list && list->dw_loc_next)
16440 gen_llsym (list);
16442 return list;
16445 /* Compute a displacement from the "steady-state frame pointer" to the
16446 frame base (often the same as the CFA), and store it in
16447 frame_pointer_fb_offset. OFFSET is added to the displacement
16448 before the latter is negated. */
16450 static void
16451 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset)
16453 rtx reg, elim;
16455 #ifdef FRAME_POINTER_CFA_OFFSET
16456 reg = frame_pointer_rtx;
16457 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
16458 #else
16459 reg = arg_pointer_rtx;
16460 offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
16461 #endif
16463 elim = (ira_use_lra_p
16464 ? lra_eliminate_regs (reg, VOIDmode, NULL_RTX)
16465 : eliminate_regs (reg, VOIDmode, NULL_RTX));
16466 if (GET_CODE (elim) == PLUS)
16468 offset += INTVAL (XEXP (elim, 1));
16469 elim = XEXP (elim, 0);
16472 frame_pointer_fb_offset = -offset;
16474 /* ??? AVR doesn't set up valid eliminations when there is no stack frame
16475 in which to eliminate. This is because it's stack pointer isn't
16476 directly accessible as a register within the ISA. To work around
16477 this, assume that while we cannot provide a proper value for
16478 frame_pointer_fb_offset, we won't need one either. */
16479 frame_pointer_fb_offset_valid
16480 = ((SUPPORTS_STACK_ALIGNMENT
16481 && (elim == hard_frame_pointer_rtx
16482 || elim == stack_pointer_rtx))
16483 || elim == (frame_pointer_needed
16484 ? hard_frame_pointer_rtx
16485 : stack_pointer_rtx));
16488 /* Generate a DW_AT_name attribute given some string value to be included as
16489 the value of the attribute. */
16491 static void
16492 add_name_attribute (dw_die_ref die, const char *name_string)
16494 if (name_string != NULL && *name_string != 0)
16496 if (demangle_name_func)
16497 name_string = (*demangle_name_func) (name_string);
16499 add_AT_string (die, DW_AT_name, name_string);
16503 /* Retrieve the descriptive type of TYPE, if any, make sure it has a
16504 DIE and attach a DW_AT_GNAT_descriptive_type attribute to the DIE
16505 of TYPE accordingly.
16507 ??? This is a temporary measure until after we're able to generate
16508 regular DWARF for the complex Ada type system. */
16510 static void
16511 add_gnat_descriptive_type_attribute (dw_die_ref die, tree type,
16512 dw_die_ref context_die)
16514 tree dtype;
16515 dw_die_ref dtype_die;
16517 if (!lang_hooks.types.descriptive_type)
16518 return;
16520 dtype = lang_hooks.types.descriptive_type (type);
16521 if (!dtype)
16522 return;
16524 dtype_die = lookup_type_die (dtype);
16525 if (!dtype_die)
16527 gen_type_die (dtype, context_die);
16528 dtype_die = lookup_type_die (dtype);
16529 gcc_assert (dtype_die);
16532 add_AT_die_ref (die, DW_AT_GNAT_descriptive_type, dtype_die);
16535 /* Retrieve the comp_dir string suitable for use with DW_AT_comp_dir. */
16537 static const char *
16538 comp_dir_string (void)
16540 const char *wd;
16541 char *wd1;
16542 static const char *cached_wd = NULL;
16544 if (cached_wd != NULL)
16545 return cached_wd;
16547 wd = get_src_pwd ();
16548 if (wd == NULL)
16549 return NULL;
16551 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR)
16553 int wdlen;
16555 wdlen = strlen (wd);
16556 wd1 = ggc_vec_alloc<char> (wdlen + 2);
16557 strcpy (wd1, wd);
16558 wd1 [wdlen] = DIR_SEPARATOR;
16559 wd1 [wdlen + 1] = 0;
16560 wd = wd1;
16563 cached_wd = remap_debug_filename (wd);
16564 return cached_wd;
16567 /* Generate a DW_AT_comp_dir attribute for DIE. */
16569 static void
16570 add_comp_dir_attribute (dw_die_ref die)
16572 const char * wd = comp_dir_string ();
16573 if (wd != NULL)
16574 add_AT_string (die, DW_AT_comp_dir, wd);
16577 /* Given a tree node VALUE describing a scalar attribute ATTR (i.e. a bound, a
16578 pointer computation, ...), output a representation for that bound according
16579 to the accepted FORMS (see enum dw_scalar_form) and add it to DIE. See
16580 loc_list_from_tree for the meaning of CONTEXT. */
16582 static void
16583 add_scalar_info (dw_die_ref die, enum dwarf_attribute attr, tree value,
16584 int forms, const struct loc_descr_context *context)
16586 dw_die_ref ctx, decl_die;
16587 dw_loc_list_ref list;
16589 bool strip_conversions = true;
16591 while (strip_conversions)
16592 switch (TREE_CODE (value))
16594 case ERROR_MARK:
16595 case SAVE_EXPR:
16596 return;
16598 CASE_CONVERT:
16599 case VIEW_CONVERT_EXPR:
16600 value = TREE_OPERAND (value, 0);
16601 break;
16603 default:
16604 strip_conversions = false;
16605 break;
16608 /* If possible and permitted, output the attribute as a constant. */
16609 if ((forms & dw_scalar_form_constant) != 0
16610 && TREE_CODE (value) == INTEGER_CST)
16612 unsigned int prec = simple_type_size_in_bits (TREE_TYPE (value));
16614 /* If HOST_WIDE_INT is big enough then represent the bound as
16615 a constant value. We need to choose a form based on
16616 whether the type is signed or unsigned. We cannot just
16617 call add_AT_unsigned if the value itself is positive
16618 (add_AT_unsigned might add the unsigned value encoded as
16619 DW_FORM_data[1248]). Some DWARF consumers will lookup the
16620 bounds type and then sign extend any unsigned values found
16621 for signed types. This is needed only for
16622 DW_AT_{lower,upper}_bound, since for most other attributes,
16623 consumers will treat DW_FORM_data[1248] as unsigned values,
16624 regardless of the underlying type. */
16625 if (prec <= HOST_BITS_PER_WIDE_INT
16626 || tree_fits_uhwi_p (value))
16628 if (TYPE_UNSIGNED (TREE_TYPE (value)))
16629 add_AT_unsigned (die, attr, TREE_INT_CST_LOW (value));
16630 else
16631 add_AT_int (die, attr, TREE_INT_CST_LOW (value));
16633 else
16634 /* Otherwise represent the bound as an unsigned value with
16635 the precision of its type. The precision and signedness
16636 of the type will be necessary to re-interpret it
16637 unambiguously. */
16638 add_AT_wide (die, attr, value);
16639 return;
16642 /* Otherwise, if it's possible and permitted too, output a reference to
16643 another DIE. */
16644 if ((forms & dw_scalar_form_reference) != 0)
16646 tree decl = NULL_TREE;
16648 /* Some type attributes reference an outer type. For instance, the upper
16649 bound of an array may reference an embedding record (this happens in
16650 Ada). */
16651 if (TREE_CODE (value) == COMPONENT_REF
16652 && TREE_CODE (TREE_OPERAND (value, 0)) == PLACEHOLDER_EXPR
16653 && TREE_CODE (TREE_OPERAND (value, 1)) == FIELD_DECL)
16654 decl = TREE_OPERAND (value, 1);
16656 else if (TREE_CODE (value) == VAR_DECL
16657 || TREE_CODE (value) == PARM_DECL
16658 || TREE_CODE (value) == RESULT_DECL)
16659 decl = value;
16661 if (decl != NULL_TREE)
16663 dw_die_ref decl_die = lookup_decl_die (decl);
16665 /* ??? Can this happen, or should the variable have been bound
16666 first? Probably it can, since I imagine that we try to create
16667 the types of parameters in the order in which they exist in
16668 the list, and won't have created a forward reference to a
16669 later parameter. */
16670 if (decl_die != NULL)
16672 add_AT_die_ref (die, attr, decl_die);
16673 return;
16678 /* Last chance: try to create a stack operation procedure to evaluate the
16679 value. Do nothing if even that is not possible or permitted. */
16680 if ((forms & dw_scalar_form_exprloc) == 0)
16681 return;
16683 list = loc_list_from_tree (value, 2, context);
16684 if (list == NULL || single_element_loc_list_p (list))
16686 /* If this attribute is not a reference nor constant, it is
16687 a DWARF expression rather than location description. For that
16688 loc_list_from_tree (value, 0, &context) is needed. */
16689 dw_loc_list_ref list2 = loc_list_from_tree (value, 0, context);
16690 if (list2 && single_element_loc_list_p (list2))
16692 add_AT_loc (die, attr, list2->expr);
16693 return;
16697 /* If that failed to give a single element location list, fall back to
16698 outputting this as a reference... still if permitted. */
16699 if (list == NULL || (forms & dw_scalar_form_reference) == 0)
16700 return;
16702 if (current_function_decl == 0)
16703 ctx = comp_unit_die ();
16704 else
16705 ctx = lookup_decl_die (current_function_decl);
16707 decl_die = new_die (DW_TAG_variable, ctx, value);
16708 add_AT_flag (decl_die, DW_AT_artificial, 1);
16709 add_type_attribute (decl_die, TREE_TYPE (value), TYPE_QUAL_CONST, ctx);
16710 add_AT_location_description (decl_die, DW_AT_location, list);
16711 add_AT_die_ref (die, attr, decl_die);
16714 /* Return the default for DW_AT_lower_bound, or -1 if there is not any
16715 default. */
16717 static int
16718 lower_bound_default (void)
16720 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language))
16722 case DW_LANG_C:
16723 case DW_LANG_C89:
16724 case DW_LANG_C99:
16725 case DW_LANG_C11:
16726 case DW_LANG_C_plus_plus:
16727 case DW_LANG_C_plus_plus_11:
16728 case DW_LANG_C_plus_plus_14:
16729 case DW_LANG_ObjC:
16730 case DW_LANG_ObjC_plus_plus:
16731 case DW_LANG_Java:
16732 return 0;
16733 case DW_LANG_Fortran77:
16734 case DW_LANG_Fortran90:
16735 case DW_LANG_Fortran95:
16736 case DW_LANG_Fortran03:
16737 case DW_LANG_Fortran08:
16738 return 1;
16739 case DW_LANG_UPC:
16740 case DW_LANG_D:
16741 case DW_LANG_Python:
16742 return dwarf_version >= 4 ? 0 : -1;
16743 case DW_LANG_Ada95:
16744 case DW_LANG_Ada83:
16745 case DW_LANG_Cobol74:
16746 case DW_LANG_Cobol85:
16747 case DW_LANG_Pascal83:
16748 case DW_LANG_Modula2:
16749 case DW_LANG_PLI:
16750 return dwarf_version >= 4 ? 1 : -1;
16751 default:
16752 return -1;
16756 /* Given a tree node describing an array bound (either lower or upper) output
16757 a representation for that bound. */
16759 static void
16760 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr,
16761 tree bound, const struct loc_descr_context *context)
16763 int dflt;
16765 while (1)
16766 switch (TREE_CODE (bound))
16768 /* Strip all conversions. */
16769 CASE_CONVERT:
16770 case VIEW_CONVERT_EXPR:
16771 bound = TREE_OPERAND (bound, 0);
16772 break;
16774 /* All fixed-bounds are represented by INTEGER_CST nodes. Lower bounds
16775 are even omitted when they are the default. */
16776 case INTEGER_CST:
16777 /* If the value for this bound is the default one, we can even omit the
16778 attribute. */
16779 if (bound_attr == DW_AT_lower_bound
16780 && tree_fits_shwi_p (bound)
16781 && (dflt = lower_bound_default ()) != -1
16782 && tree_to_shwi (bound) == dflt)
16783 return;
16785 /* FALLTHRU */
16787 default:
16788 add_scalar_info (subrange_die, bound_attr, bound,
16789 dw_scalar_form_constant
16790 | dw_scalar_form_exprloc
16791 | dw_scalar_form_reference,
16792 context);
16793 return;
16797 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
16798 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
16799 Note that the block of subscript information for an array type also
16800 includes information about the element type of the given array type. */
16802 static void
16803 add_subscript_info (dw_die_ref type_die, tree type, bool collapse_p)
16805 unsigned dimension_number;
16806 tree lower, upper;
16807 dw_die_ref subrange_die;
16809 for (dimension_number = 0;
16810 TREE_CODE (type) == ARRAY_TYPE && (dimension_number == 0 || collapse_p);
16811 type = TREE_TYPE (type), dimension_number++)
16813 tree domain = TYPE_DOMAIN (type);
16815 if (TYPE_STRING_FLAG (type) && is_fortran () && dimension_number > 0)
16816 break;
16818 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
16819 and (in GNU C only) variable bounds. Handle all three forms
16820 here. */
16821 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
16822 if (domain)
16824 /* We have an array type with specified bounds. */
16825 lower = TYPE_MIN_VALUE (domain);
16826 upper = TYPE_MAX_VALUE (domain);
16828 /* Define the index type. */
16829 if (TREE_TYPE (domain))
16831 /* ??? This is probably an Ada unnamed subrange type. Ignore the
16832 TREE_TYPE field. We can't emit debug info for this
16833 because it is an unnamed integral type. */
16834 if (TREE_CODE (domain) == INTEGER_TYPE
16835 && TYPE_NAME (domain) == NULL_TREE
16836 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
16837 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
16839 else
16840 add_type_attribute (subrange_die, TREE_TYPE (domain),
16841 TYPE_UNQUALIFIED, type_die);
16844 /* ??? If upper is NULL, the array has unspecified length,
16845 but it does have a lower bound. This happens with Fortran
16846 dimension arr(N:*)
16847 Since the debugger is definitely going to need to know N
16848 to produce useful results, go ahead and output the lower
16849 bound solo, and hope the debugger can cope. */
16851 add_bound_info (subrange_die, DW_AT_lower_bound, lower, NULL);
16852 if (upper)
16853 add_bound_info (subrange_die, DW_AT_upper_bound, upper, NULL);
16856 /* Otherwise we have an array type with an unspecified length. The
16857 DWARF-2 spec does not say how to handle this; let's just leave out the
16858 bounds. */
16862 /* Add a DW_AT_byte_size attribute to DIE with TREE_NODE's size. */
16864 static void
16865 add_byte_size_attribute (dw_die_ref die, tree tree_node)
16867 dw_die_ref decl_die;
16868 HOST_WIDE_INT size;
16870 switch (TREE_CODE (tree_node))
16872 case ERROR_MARK:
16873 size = 0;
16874 break;
16875 case ENUMERAL_TYPE:
16876 case RECORD_TYPE:
16877 case UNION_TYPE:
16878 case QUAL_UNION_TYPE:
16879 if (TREE_CODE (TYPE_SIZE_UNIT (tree_node)) == VAR_DECL
16880 && (decl_die = lookup_decl_die (TYPE_SIZE_UNIT (tree_node))))
16882 add_AT_die_ref (die, DW_AT_byte_size, decl_die);
16883 return;
16885 size = int_size_in_bytes (tree_node);
16886 break;
16887 case FIELD_DECL:
16888 /* For a data member of a struct or union, the DW_AT_byte_size is
16889 generally given as the number of bytes normally allocated for an
16890 object of the *declared* type of the member itself. This is true
16891 even for bit-fields. */
16892 size = int_size_in_bytes (field_type (tree_node));
16893 break;
16894 default:
16895 gcc_unreachable ();
16898 /* Note that `size' might be -1 when we get to this point. If it is, that
16899 indicates that the byte size of the entity in question is variable. We
16900 have no good way of expressing this fact in Dwarf at the present time,
16901 when location description was not used by the caller code instead. */
16902 if (size >= 0)
16903 add_AT_unsigned (die, DW_AT_byte_size, size);
16906 /* For a FIELD_DECL node which represents a bit-field, output an attribute
16907 which specifies the distance in bits from the highest order bit of the
16908 "containing object" for the bit-field to the highest order bit of the
16909 bit-field itself.
16911 For any given bit-field, the "containing object" is a hypothetical object
16912 (of some integral or enum type) within which the given bit-field lives. The
16913 type of this hypothetical "containing object" is always the same as the
16914 declared type of the individual bit-field itself. The determination of the
16915 exact location of the "containing object" for a bit-field is rather
16916 complicated. It's handled by the `field_byte_offset' function (above).
16918 Note that it is the size (in bytes) of the hypothetical "containing object"
16919 which will be given in the DW_AT_byte_size attribute for this bit-field.
16920 (See `byte_size_attribute' above). */
16922 static inline void
16923 add_bit_offset_attribute (dw_die_ref die, tree decl)
16925 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
16926 tree type = DECL_BIT_FIELD_TYPE (decl);
16927 HOST_WIDE_INT bitpos_int;
16928 HOST_WIDE_INT highest_order_object_bit_offset;
16929 HOST_WIDE_INT highest_order_field_bit_offset;
16930 HOST_WIDE_INT bit_offset;
16932 /* Must be a field and a bit field. */
16933 gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
16935 /* We can't yet handle bit-fields whose offsets are variable, so if we
16936 encounter such things, just return without generating any attribute
16937 whatsoever. Likewise for variable or too large size. */
16938 if (! tree_fits_shwi_p (bit_position (decl))
16939 || ! tree_fits_uhwi_p (DECL_SIZE (decl)))
16940 return;
16942 bitpos_int = int_bit_position (decl);
16944 /* Note that the bit offset is always the distance (in bits) from the
16945 highest-order bit of the "containing object" to the highest-order bit of
16946 the bit-field itself. Since the "high-order end" of any object or field
16947 is different on big-endian and little-endian machines, the computation
16948 below must take account of these differences. */
16949 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
16950 highest_order_field_bit_offset = bitpos_int;
16952 if (! BYTES_BIG_ENDIAN)
16954 highest_order_field_bit_offset += tree_to_shwi (DECL_SIZE (decl));
16955 highest_order_object_bit_offset += simple_type_size_in_bits (type);
16958 bit_offset
16959 = (! BYTES_BIG_ENDIAN
16960 ? highest_order_object_bit_offset - highest_order_field_bit_offset
16961 : highest_order_field_bit_offset - highest_order_object_bit_offset);
16963 if (bit_offset < 0)
16964 add_AT_int (die, DW_AT_bit_offset, bit_offset);
16965 else
16966 add_AT_unsigned (die, DW_AT_bit_offset, (unsigned HOST_WIDE_INT) bit_offset);
16969 /* For a FIELD_DECL node which represents a bit field, output an attribute
16970 which specifies the length in bits of the given field. */
16972 static inline void
16973 add_bit_size_attribute (dw_die_ref die, tree decl)
16975 /* Must be a field and a bit field. */
16976 gcc_assert (TREE_CODE (decl) == FIELD_DECL
16977 && DECL_BIT_FIELD_TYPE (decl));
16979 if (tree_fits_uhwi_p (DECL_SIZE (decl)))
16980 add_AT_unsigned (die, DW_AT_bit_size, tree_to_uhwi (DECL_SIZE (decl)));
16983 /* If the compiled language is ANSI C, then add a 'prototyped'
16984 attribute, if arg types are given for the parameters of a function. */
16986 static inline void
16987 add_prototyped_attribute (dw_die_ref die, tree func_type)
16989 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language))
16991 case DW_LANG_C:
16992 case DW_LANG_C89:
16993 case DW_LANG_C99:
16994 case DW_LANG_C11:
16995 case DW_LANG_ObjC:
16996 if (prototype_p (func_type))
16997 add_AT_flag (die, DW_AT_prototyped, 1);
16998 break;
16999 default:
17000 break;
17004 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
17005 by looking in either the type declaration or object declaration
17006 equate table. */
17008 static inline dw_die_ref
17009 add_abstract_origin_attribute (dw_die_ref die, tree origin)
17011 dw_die_ref origin_die = NULL;
17013 if (TREE_CODE (origin) != FUNCTION_DECL)
17015 /* We may have gotten separated from the block for the inlined
17016 function, if we're in an exception handler or some such; make
17017 sure that the abstract function has been written out.
17019 Doing this for nested functions is wrong, however; functions are
17020 distinct units, and our context might not even be inline. */
17021 tree fn = origin;
17023 if (TYPE_P (fn))
17024 fn = TYPE_STUB_DECL (fn);
17026 fn = decl_function_context (fn);
17027 if (fn)
17028 dwarf2out_abstract_function (fn);
17031 if (DECL_P (origin))
17032 origin_die = lookup_decl_die (origin);
17033 else if (TYPE_P (origin))
17034 origin_die = lookup_type_die (origin);
17036 /* XXX: Functions that are never lowered don't always have correct block
17037 trees (in the case of java, they simply have no block tree, in some other
17038 languages). For these functions, there is nothing we can really do to
17039 output correct debug info for inlined functions in all cases. Rather
17040 than die, we'll just produce deficient debug info now, in that we will
17041 have variables without a proper abstract origin. In the future, when all
17042 functions are lowered, we should re-add a gcc_assert (origin_die)
17043 here. */
17045 if (origin_die)
17046 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
17047 return origin_die;
17050 /* We do not currently support the pure_virtual attribute. */
17052 static inline void
17053 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
17055 if (DECL_VINDEX (func_decl))
17057 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
17059 if (tree_fits_shwi_p (DECL_VINDEX (func_decl)))
17060 add_AT_loc (die, DW_AT_vtable_elem_location,
17061 new_loc_descr (DW_OP_constu,
17062 tree_to_shwi (DECL_VINDEX (func_decl)),
17063 0));
17065 /* GNU extension: Record what type this method came from originally. */
17066 if (debug_info_level > DINFO_LEVEL_TERSE
17067 && DECL_CONTEXT (func_decl))
17068 add_AT_die_ref (die, DW_AT_containing_type,
17069 lookup_type_die (DECL_CONTEXT (func_decl)));
17073 /* Add a DW_AT_linkage_name or DW_AT_MIPS_linkage_name attribute for the
17074 given decl. This used to be a vendor extension until after DWARF 4
17075 standardized it. */
17077 static void
17078 add_linkage_attr (dw_die_ref die, tree decl)
17080 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
17082 /* Mimic what assemble_name_raw does with a leading '*'. */
17083 if (name[0] == '*')
17084 name = &name[1];
17086 if (dwarf_version >= 4)
17087 add_AT_string (die, DW_AT_linkage_name, name);
17088 else
17089 add_AT_string (die, DW_AT_MIPS_linkage_name, name);
17092 /* Add source coordinate attributes for the given decl. */
17094 static void
17095 add_src_coords_attributes (dw_die_ref die, tree decl)
17097 expanded_location s;
17099 if (LOCATION_LOCUS (DECL_SOURCE_LOCATION (decl)) == UNKNOWN_LOCATION)
17100 return;
17101 s = expand_location (DECL_SOURCE_LOCATION (decl));
17102 add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file));
17103 add_AT_unsigned (die, DW_AT_decl_line, s.line);
17106 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl. */
17108 static void
17109 add_linkage_name (dw_die_ref die, tree decl)
17111 if (debug_info_level > DINFO_LEVEL_NONE
17112 && (TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
17113 && TREE_PUBLIC (decl)
17114 && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
17115 && die->die_tag != DW_TAG_member)
17117 /* Defer until we have an assembler name set. */
17118 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
17120 limbo_die_node *asm_name;
17122 asm_name = ggc_cleared_alloc<limbo_die_node> ();
17123 asm_name->die = die;
17124 asm_name->created_for = decl;
17125 asm_name->next = deferred_asm_name;
17126 deferred_asm_name = asm_name;
17128 else if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
17129 add_linkage_attr (die, decl);
17133 /* Add a DW_AT_name attribute and source coordinate attribute for the
17134 given decl, but only if it actually has a name. */
17136 static void
17137 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
17139 tree decl_name;
17141 decl_name = DECL_NAME (decl);
17142 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
17144 const char *name = dwarf2_name (decl, 0);
17145 if (name)
17146 add_name_attribute (die, name);
17147 if (! DECL_ARTIFICIAL (decl))
17148 add_src_coords_attributes (die, decl);
17150 add_linkage_name (die, decl);
17153 #ifdef VMS_DEBUGGING_INFO
17154 /* Get the function's name, as described by its RTL. This may be different
17155 from the DECL_NAME name used in the source file. */
17156 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
17158 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
17159 XEXP (DECL_RTL (decl), 0), false);
17160 vec_safe_push (used_rtx_array, XEXP (DECL_RTL (decl), 0));
17162 #endif /* VMS_DEBUGGING_INFO */
17165 #ifdef VMS_DEBUGGING_INFO
17166 /* Output the debug main pointer die for VMS */
17168 void
17169 dwarf2out_vms_debug_main_pointer (void)
17171 char label[MAX_ARTIFICIAL_LABEL_BYTES];
17172 dw_die_ref die;
17174 /* Allocate the VMS debug main subprogram die. */
17175 die = ggc_cleared_alloc<die_node> ();
17176 die->die_tag = DW_TAG_subprogram;
17177 add_name_attribute (die, VMS_DEBUG_MAIN_POINTER);
17178 ASM_GENERATE_INTERNAL_LABEL (label, PROLOGUE_END_LABEL,
17179 current_function_funcdef_no);
17180 add_AT_lbl_id (die, DW_AT_entry_pc, label);
17182 /* Make it the first child of comp_unit_die (). */
17183 die->die_parent = comp_unit_die ();
17184 if (comp_unit_die ()->die_child)
17186 die->die_sib = comp_unit_die ()->die_child->die_sib;
17187 comp_unit_die ()->die_child->die_sib = die;
17189 else
17191 die->die_sib = die;
17192 comp_unit_die ()->die_child = die;
17195 #endif /* VMS_DEBUGGING_INFO */
17197 /* Push a new declaration scope. */
17199 static void
17200 push_decl_scope (tree scope)
17202 vec_safe_push (decl_scope_table, scope);
17205 /* Pop a declaration scope. */
17207 static inline void
17208 pop_decl_scope (void)
17210 decl_scope_table->pop ();
17213 /* walk_tree helper function for uses_local_type, below. */
17215 static tree
17216 uses_local_type_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
17218 if (!TYPE_P (*tp))
17219 *walk_subtrees = 0;
17220 else
17222 tree name = TYPE_NAME (*tp);
17223 if (name && DECL_P (name) && decl_function_context (name))
17224 return *tp;
17226 return NULL_TREE;
17229 /* If TYPE involves a function-local type (including a local typedef to a
17230 non-local type), returns that type; otherwise returns NULL_TREE. */
17232 static tree
17233 uses_local_type (tree type)
17235 tree used = walk_tree_without_duplicates (&type, uses_local_type_r, NULL);
17236 return used;
17239 /* Return the DIE for the scope that immediately contains this type.
17240 Non-named types that do not involve a function-local type get global
17241 scope. Named types nested in namespaces or other types get their
17242 containing scope. All other types (i.e. function-local named types) get
17243 the current active scope. */
17245 static dw_die_ref
17246 scope_die_for (tree t, dw_die_ref context_die)
17248 dw_die_ref scope_die = NULL;
17249 tree containing_scope;
17251 /* Non-types always go in the current scope. */
17252 gcc_assert (TYPE_P (t));
17254 /* Use the scope of the typedef, rather than the scope of the type
17255 it refers to. */
17256 if (TYPE_NAME (t) && DECL_P (TYPE_NAME (t)))
17257 containing_scope = DECL_CONTEXT (TYPE_NAME (t));
17258 else
17259 containing_scope = TYPE_CONTEXT (t);
17261 /* Use the containing namespace if there is one. */
17262 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
17264 if (context_die == lookup_decl_die (containing_scope))
17265 /* OK */;
17266 else if (debug_info_level > DINFO_LEVEL_TERSE)
17267 context_die = get_context_die (containing_scope);
17268 else
17269 containing_scope = NULL_TREE;
17272 /* Ignore function type "scopes" from the C frontend. They mean that
17273 a tagged type is local to a parmlist of a function declarator, but
17274 that isn't useful to DWARF. */
17275 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
17276 containing_scope = NULL_TREE;
17278 if (SCOPE_FILE_SCOPE_P (containing_scope))
17280 /* If T uses a local type keep it local as well, to avoid references
17281 to function-local DIEs from outside the function. */
17282 if (current_function_decl && uses_local_type (t))
17283 scope_die = context_die;
17284 else
17285 scope_die = comp_unit_die ();
17287 else if (TYPE_P (containing_scope))
17289 /* For types, we can just look up the appropriate DIE. */
17290 if (debug_info_level > DINFO_LEVEL_TERSE)
17291 scope_die = get_context_die (containing_scope);
17292 else
17294 scope_die = lookup_type_die_strip_naming_typedef (containing_scope);
17295 if (scope_die == NULL)
17296 scope_die = comp_unit_die ();
17299 else
17300 scope_die = context_die;
17302 return scope_die;
17305 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
17307 static inline int
17308 local_scope_p (dw_die_ref context_die)
17310 for (; context_die; context_die = context_die->die_parent)
17311 if (context_die->die_tag == DW_TAG_inlined_subroutine
17312 || context_die->die_tag == DW_TAG_subprogram)
17313 return 1;
17315 return 0;
17318 /* Returns nonzero if CONTEXT_DIE is a class. */
17320 static inline int
17321 class_scope_p (dw_die_ref context_die)
17323 return (context_die
17324 && (context_die->die_tag == DW_TAG_structure_type
17325 || context_die->die_tag == DW_TAG_class_type
17326 || context_die->die_tag == DW_TAG_interface_type
17327 || context_die->die_tag == DW_TAG_union_type));
17330 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
17331 whether or not to treat a DIE in this context as a declaration. */
17333 static inline int
17334 class_or_namespace_scope_p (dw_die_ref context_die)
17336 return (class_scope_p (context_die)
17337 || (context_die && context_die->die_tag == DW_TAG_namespace));
17340 /* Many forms of DIEs require a "type description" attribute. This
17341 routine locates the proper "type descriptor" die for the type given
17342 by 'type' plus any additional qualifiers given by 'cv_quals', and
17343 adds a DW_AT_type attribute below the given die. */
17345 static void
17346 add_type_attribute (dw_die_ref object_die, tree type, int cv_quals,
17347 dw_die_ref context_die)
17349 enum tree_code code = TREE_CODE (type);
17350 dw_die_ref type_die = NULL;
17352 /* ??? If this type is an unnamed subrange type of an integral, floating-point
17353 or fixed-point type, use the inner type. This is because we have no
17354 support for unnamed types in base_type_die. This can happen if this is
17355 an Ada subrange type. Correct solution is emit a subrange type die. */
17356 if ((code == INTEGER_TYPE || code == REAL_TYPE || code == FIXED_POINT_TYPE)
17357 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
17358 type = TREE_TYPE (type), code = TREE_CODE (type);
17360 if (code == ERROR_MARK
17361 /* Handle a special case. For functions whose return type is void, we
17362 generate *no* type attribute. (Note that no object may have type
17363 `void', so this only applies to function return types). */
17364 || code == VOID_TYPE)
17365 return;
17367 type_die = modified_type_die (type,
17368 cv_quals | TYPE_QUALS_NO_ADDR_SPACE (type),
17369 context_die);
17371 if (type_die != NULL)
17372 add_AT_die_ref (object_die, DW_AT_type, type_die);
17375 /* Given an object die, add the calling convention attribute for the
17376 function call type. */
17377 static void
17378 add_calling_convention_attribute (dw_die_ref subr_die, tree decl)
17380 enum dwarf_calling_convention value = DW_CC_normal;
17382 value = ((enum dwarf_calling_convention)
17383 targetm.dwarf_calling_convention (TREE_TYPE (decl)));
17385 if (is_fortran ()
17386 && !strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), "MAIN__"))
17388 /* DWARF 2 doesn't provide a way to identify a program's source-level
17389 entry point. DW_AT_calling_convention attributes are only meant
17390 to describe functions' calling conventions. However, lacking a
17391 better way to signal the Fortran main program, we used this for
17392 a long time, following existing custom. Now, DWARF 4 has
17393 DW_AT_main_subprogram, which we add below, but some tools still
17394 rely on the old way, which we thus keep. */
17395 value = DW_CC_program;
17397 if (dwarf_version >= 4 || !dwarf_strict)
17398 add_AT_flag (subr_die, DW_AT_main_subprogram, 1);
17401 /* Only add the attribute if the backend requests it, and
17402 is not DW_CC_normal. */
17403 if (value && (value != DW_CC_normal))
17404 add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
17407 /* Given a tree pointer to a struct, class, union, or enum type node, return
17408 a pointer to the (string) tag name for the given type, or zero if the type
17409 was declared without a tag. */
17411 static const char *
17412 type_tag (const_tree type)
17414 const char *name = 0;
17416 if (TYPE_NAME (type) != 0)
17418 tree t = 0;
17420 /* Find the IDENTIFIER_NODE for the type name. */
17421 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
17422 && !TYPE_NAMELESS (type))
17423 t = TYPE_NAME (type);
17425 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
17426 a TYPE_DECL node, regardless of whether or not a `typedef' was
17427 involved. */
17428 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
17429 && ! DECL_IGNORED_P (TYPE_NAME (type)))
17431 /* We want to be extra verbose. Don't call dwarf_name if
17432 DECL_NAME isn't set. The default hook for decl_printable_name
17433 doesn't like that, and in this context it's correct to return
17434 0, instead of "<anonymous>" or the like. */
17435 if (DECL_NAME (TYPE_NAME (type))
17436 && !DECL_NAMELESS (TYPE_NAME (type)))
17437 name = lang_hooks.dwarf_name (TYPE_NAME (type), 2);
17440 /* Now get the name as a string, or invent one. */
17441 if (!name && t != 0)
17442 name = IDENTIFIER_POINTER (t);
17445 return (name == 0 || *name == '\0') ? 0 : name;
17448 /* Return the type associated with a data member, make a special check
17449 for bit field types. */
17451 static inline tree
17452 member_declared_type (const_tree member)
17454 return (DECL_BIT_FIELD_TYPE (member)
17455 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
17458 /* Get the decl's label, as described by its RTL. This may be different
17459 from the DECL_NAME name used in the source file. */
17461 #if 0
17462 static const char *
17463 decl_start_label (tree decl)
17465 rtx x;
17466 const char *fnname;
17468 x = DECL_RTL (decl);
17469 gcc_assert (MEM_P (x));
17471 x = XEXP (x, 0);
17472 gcc_assert (GET_CODE (x) == SYMBOL_REF);
17474 fnname = XSTR (x, 0);
17475 return fnname;
17477 #endif
17479 /* These routines generate the internal representation of the DIE's for
17480 the compilation unit. Debugging information is collected by walking
17481 the declaration trees passed in from dwarf2out_decl(). */
17483 static void
17484 gen_array_type_die (tree type, dw_die_ref context_die)
17486 dw_die_ref scope_die = scope_die_for (type, context_die);
17487 dw_die_ref array_die;
17489 /* GNU compilers represent multidimensional array types as sequences of one
17490 dimensional array types whose element types are themselves array types.
17491 We sometimes squish that down to a single array_type DIE with multiple
17492 subscripts in the Dwarf debugging info. The draft Dwarf specification
17493 say that we are allowed to do this kind of compression in C, because
17494 there is no difference between an array of arrays and a multidimensional
17495 array. We don't do this for Ada to remain as close as possible to the
17496 actual representation, which is especially important against the language
17497 flexibilty wrt arrays of variable size. */
17499 bool collapse_nested_arrays = !is_ada ();
17500 tree element_type;
17502 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
17503 DW_TAG_string_type doesn't have DW_AT_type attribute). */
17504 if (TYPE_STRING_FLAG (type)
17505 && TREE_CODE (type) == ARRAY_TYPE
17506 && is_fortran ()
17507 && TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (char_type_node))
17509 HOST_WIDE_INT size;
17511 array_die = new_die (DW_TAG_string_type, scope_die, type);
17512 add_name_attribute (array_die, type_tag (type));
17513 equate_type_number_to_die (type, array_die);
17514 size = int_size_in_bytes (type);
17515 if (size >= 0)
17516 add_AT_unsigned (array_die, DW_AT_byte_size, size);
17517 else if (TYPE_DOMAIN (type) != NULL_TREE
17518 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != NULL_TREE
17519 && DECL_P (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
17521 tree szdecl = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
17522 dw_loc_list_ref loc = loc_list_from_tree (szdecl, 2, NULL);
17524 size = int_size_in_bytes (TREE_TYPE (szdecl));
17525 if (loc && size > 0)
17527 add_AT_location_description (array_die, DW_AT_string_length, loc);
17528 if (size != DWARF2_ADDR_SIZE)
17529 add_AT_unsigned (array_die, DW_AT_byte_size, size);
17532 return;
17535 array_die = new_die (DW_TAG_array_type, scope_die, type);
17536 add_name_attribute (array_die, type_tag (type));
17537 equate_type_number_to_die (type, array_die);
17539 if (TREE_CODE (type) == VECTOR_TYPE)
17540 add_AT_flag (array_die, DW_AT_GNU_vector, 1);
17542 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
17543 if (is_fortran ()
17544 && TREE_CODE (type) == ARRAY_TYPE
17545 && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE
17546 && !TYPE_STRING_FLAG (TREE_TYPE (type)))
17547 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
17549 #if 0
17550 /* We default the array ordering. SDB will probably do
17551 the right things even if DW_AT_ordering is not present. It's not even
17552 an issue until we start to get into multidimensional arrays anyway. If
17553 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
17554 then we'll have to put the DW_AT_ordering attribute back in. (But if
17555 and when we find out that we need to put these in, we will only do so
17556 for multidimensional arrays. */
17557 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
17558 #endif
17560 if (TREE_CODE (type) == VECTOR_TYPE)
17562 /* For VECTOR_TYPEs we use an array die with appropriate bounds. */
17563 dw_die_ref subrange_die = new_die (DW_TAG_subrange_type, array_die, NULL);
17564 add_bound_info (subrange_die, DW_AT_lower_bound, size_zero_node, NULL);
17565 add_bound_info (subrange_die, DW_AT_upper_bound,
17566 size_int (TYPE_VECTOR_SUBPARTS (type) - 1), NULL);
17568 else
17569 add_subscript_info (array_die, type, collapse_nested_arrays);
17571 /* Add representation of the type of the elements of this array type and
17572 emit the corresponding DIE if we haven't done it already. */
17573 element_type = TREE_TYPE (type);
17574 if (collapse_nested_arrays)
17575 while (TREE_CODE (element_type) == ARRAY_TYPE)
17577 if (TYPE_STRING_FLAG (element_type) && is_fortran ())
17578 break;
17579 element_type = TREE_TYPE (element_type);
17582 add_type_attribute (array_die, element_type, TYPE_UNQUALIFIED, context_die);
17584 add_gnat_descriptive_type_attribute (array_die, type, context_die);
17585 if (TYPE_ARTIFICIAL (type))
17586 add_AT_flag (array_die, DW_AT_artificial, 1);
17588 if (get_AT (array_die, DW_AT_name))
17589 add_pubtype (type, array_die);
17592 /* This routine generates DIE for array with hidden descriptor, details
17593 are filled into *info by a langhook. */
17595 static void
17596 gen_descr_array_type_die (tree type, struct array_descr_info *info,
17597 dw_die_ref context_die)
17599 const dw_die_ref scope_die = scope_die_for (type, context_die);
17600 const dw_die_ref array_die = new_die (DW_TAG_array_type, scope_die, type);
17601 const struct loc_descr_context context = { type, info->base_decl };
17602 int dim;
17604 add_name_attribute (array_die, type_tag (type));
17605 equate_type_number_to_die (type, array_die);
17607 if (info->ndimensions > 1)
17608 switch (info->ordering)
17610 case array_descr_ordering_row_major:
17611 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
17612 break;
17613 case array_descr_ordering_column_major:
17614 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
17615 break;
17616 default:
17617 break;
17620 if (dwarf_version >= 3 || !dwarf_strict)
17622 if (info->data_location)
17623 add_scalar_info (array_die, DW_AT_data_location, info->data_location,
17624 dw_scalar_form_exprloc, &context);
17625 if (info->associated)
17626 add_scalar_info (array_die, DW_AT_associated, info->associated,
17627 dw_scalar_form_constant
17628 | dw_scalar_form_exprloc
17629 | dw_scalar_form_reference, &context);
17630 if (info->allocated)
17631 add_scalar_info (array_die, DW_AT_allocated, info->allocated,
17632 dw_scalar_form_constant
17633 | dw_scalar_form_exprloc
17634 | dw_scalar_form_reference, &context);
17637 add_gnat_descriptive_type_attribute (array_die, type, context_die);
17639 for (dim = 0; dim < info->ndimensions; dim++)
17641 dw_die_ref subrange_die
17642 = new_die (DW_TAG_subrange_type, array_die, NULL);
17644 if (info->dimen[dim].bounds_type)
17645 add_type_attribute (subrange_die,
17646 info->dimen[dim].bounds_type, 0,
17647 context_die);
17648 if (info->dimen[dim].lower_bound)
17649 add_bound_info (subrange_die, DW_AT_lower_bound,
17650 info->dimen[dim].lower_bound, &context);
17651 if (info->dimen[dim].upper_bound)
17652 add_bound_info (subrange_die, DW_AT_upper_bound,
17653 info->dimen[dim].upper_bound, &context);
17654 if ((dwarf_version >= 3 || !dwarf_strict) && info->dimen[dim].stride)
17655 add_scalar_info (subrange_die, DW_AT_byte_stride,
17656 info->dimen[dim].stride,
17657 dw_scalar_form_constant
17658 | dw_scalar_form_exprloc
17659 | dw_scalar_form_reference,
17660 &context);
17663 gen_type_die (info->element_type, context_die);
17664 add_type_attribute (array_die, info->element_type, TYPE_UNQUALIFIED,
17665 context_die);
17667 if (get_AT (array_die, DW_AT_name))
17668 add_pubtype (type, array_die);
17671 #if 0
17672 static void
17673 gen_entry_point_die (tree decl, dw_die_ref context_die)
17675 tree origin = decl_ultimate_origin (decl);
17676 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
17678 if (origin != NULL)
17679 add_abstract_origin_attribute (decl_die, origin);
17680 else
17682 add_name_and_src_coords_attributes (decl_die, decl);
17683 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
17684 TYPE_UNQUALIFIED, context_die);
17687 if (DECL_ABSTRACT_P (decl))
17688 equate_decl_number_to_die (decl, decl_die);
17689 else
17690 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
17692 #endif
17694 /* Walk through the list of incomplete types again, trying once more to
17695 emit full debugging info for them. */
17697 static void
17698 retry_incomplete_types (void)
17700 int i;
17702 for (i = vec_safe_length (incomplete_types) - 1; i >= 0; i--)
17703 if (should_emit_struct_debug ((*incomplete_types)[i], DINFO_USAGE_DIR_USE))
17704 gen_type_die ((*incomplete_types)[i], comp_unit_die ());
17707 /* Determine what tag to use for a record type. */
17709 static enum dwarf_tag
17710 record_type_tag (tree type)
17712 if (! lang_hooks.types.classify_record)
17713 return DW_TAG_structure_type;
17715 switch (lang_hooks.types.classify_record (type))
17717 case RECORD_IS_STRUCT:
17718 return DW_TAG_structure_type;
17720 case RECORD_IS_CLASS:
17721 return DW_TAG_class_type;
17723 case RECORD_IS_INTERFACE:
17724 if (dwarf_version >= 3 || !dwarf_strict)
17725 return DW_TAG_interface_type;
17726 return DW_TAG_structure_type;
17728 default:
17729 gcc_unreachable ();
17733 /* Generate a DIE to represent an enumeration type. Note that these DIEs
17734 include all of the information about the enumeration values also. Each
17735 enumerated type name/value is listed as a child of the enumerated type
17736 DIE. */
17738 static dw_die_ref
17739 gen_enumeration_type_die (tree type, dw_die_ref context_die)
17741 dw_die_ref type_die = lookup_type_die (type);
17743 if (type_die == NULL)
17745 type_die = new_die (DW_TAG_enumeration_type,
17746 scope_die_for (type, context_die), type);
17747 equate_type_number_to_die (type, type_die);
17748 add_name_attribute (type_die, type_tag (type));
17749 if (dwarf_version >= 4 || !dwarf_strict)
17751 if (ENUM_IS_SCOPED (type))
17752 add_AT_flag (type_die, DW_AT_enum_class, 1);
17753 if (ENUM_IS_OPAQUE (type))
17754 add_AT_flag (type_die, DW_AT_declaration, 1);
17757 else if (! TYPE_SIZE (type))
17758 return type_die;
17759 else
17760 remove_AT (type_die, DW_AT_declaration);
17762 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
17763 given enum type is incomplete, do not generate the DW_AT_byte_size
17764 attribute or the DW_AT_element_list attribute. */
17765 if (TYPE_SIZE (type))
17767 tree link;
17769 TREE_ASM_WRITTEN (type) = 1;
17770 add_byte_size_attribute (type_die, type);
17771 if (dwarf_version >= 3 || !dwarf_strict)
17773 tree underlying = lang_hooks.types.enum_underlying_base_type (type);
17774 add_type_attribute (type_die, underlying, TYPE_UNQUALIFIED,
17775 context_die);
17777 if (TYPE_STUB_DECL (type) != NULL_TREE)
17779 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
17780 add_accessibility_attribute (type_die, TYPE_STUB_DECL (type));
17783 /* If the first reference to this type was as the return type of an
17784 inline function, then it may not have a parent. Fix this now. */
17785 if (type_die->die_parent == NULL)
17786 add_child_die (scope_die_for (type, context_die), type_die);
17788 for (link = TYPE_VALUES (type);
17789 link != NULL; link = TREE_CHAIN (link))
17791 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
17792 tree value = TREE_VALUE (link);
17794 add_name_attribute (enum_die,
17795 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
17797 if (TREE_CODE (value) == CONST_DECL)
17798 value = DECL_INITIAL (value);
17800 if (simple_type_size_in_bits (TREE_TYPE (value))
17801 <= HOST_BITS_PER_WIDE_INT || tree_fits_shwi_p (value))
17803 /* For constant forms created by add_AT_unsigned DWARF
17804 consumers (GDB, elfutils, etc.) always zero extend
17805 the value. Only when the actual value is negative
17806 do we need to use add_AT_int to generate a constant
17807 form that can represent negative values. */
17808 HOST_WIDE_INT val = TREE_INT_CST_LOW (value);
17809 if (TYPE_UNSIGNED (TREE_TYPE (value)) || val >= 0)
17810 add_AT_unsigned (enum_die, DW_AT_const_value,
17811 (unsigned HOST_WIDE_INT) val);
17812 else
17813 add_AT_int (enum_die, DW_AT_const_value, val);
17815 else
17816 /* Enumeration constants may be wider than HOST_WIDE_INT. Handle
17817 that here. TODO: This should be re-worked to use correct
17818 signed/unsigned double tags for all cases. */
17819 add_AT_wide (enum_die, DW_AT_const_value, value);
17822 add_gnat_descriptive_type_attribute (type_die, type, context_die);
17823 if (TYPE_ARTIFICIAL (type))
17824 add_AT_flag (type_die, DW_AT_artificial, 1);
17826 else
17827 add_AT_flag (type_die, DW_AT_declaration, 1);
17829 add_pubtype (type, type_die);
17831 return type_die;
17834 /* Generate a DIE to represent either a real live formal parameter decl or to
17835 represent just the type of some formal parameter position in some function
17836 type.
17838 Note that this routine is a bit unusual because its argument may be a
17839 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
17840 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
17841 node. If it's the former then this function is being called to output a
17842 DIE to represent a formal parameter object (or some inlining thereof). If
17843 it's the latter, then this function is only being called to output a
17844 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
17845 argument type of some subprogram type.
17846 If EMIT_NAME_P is true, name and source coordinate attributes
17847 are emitted. */
17849 static dw_die_ref
17850 gen_formal_parameter_die (tree node, tree origin, bool emit_name_p,
17851 dw_die_ref context_die)
17853 tree node_or_origin = node ? node : origin;
17854 tree ultimate_origin;
17855 dw_die_ref parm_die
17856 = new_die (DW_TAG_formal_parameter, context_die, node);
17858 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin)))
17860 case tcc_declaration:
17861 ultimate_origin = decl_ultimate_origin (node_or_origin);
17862 if (node || ultimate_origin)
17863 origin = ultimate_origin;
17864 if (origin != NULL)
17865 add_abstract_origin_attribute (parm_die, origin);
17866 else if (emit_name_p)
17867 add_name_and_src_coords_attributes (parm_die, node);
17868 if (origin == NULL
17869 || (! DECL_ABSTRACT_P (node_or_origin)
17870 && variably_modified_type_p (TREE_TYPE (node_or_origin),
17871 decl_function_context
17872 (node_or_origin))))
17874 tree type = TREE_TYPE (node_or_origin);
17875 if (decl_by_reference_p (node_or_origin))
17876 add_type_attribute (parm_die, TREE_TYPE (type),
17877 TYPE_UNQUALIFIED, context_die);
17878 else
17879 add_type_attribute (parm_die, type,
17880 decl_quals (node_or_origin),
17881 context_die);
17883 if (origin == NULL && DECL_ARTIFICIAL (node))
17884 add_AT_flag (parm_die, DW_AT_artificial, 1);
17886 if (node && node != origin)
17887 equate_decl_number_to_die (node, parm_die);
17888 if (! DECL_ABSTRACT_P (node_or_origin))
17889 add_location_or_const_value_attribute (parm_die, node_or_origin,
17890 node == NULL, DW_AT_location);
17892 break;
17894 case tcc_type:
17895 /* We were called with some kind of a ..._TYPE node. */
17896 add_type_attribute (parm_die, node_or_origin, TYPE_UNQUALIFIED,
17897 context_die);
17898 break;
17900 default:
17901 gcc_unreachable ();
17904 return parm_die;
17907 /* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate
17908 children DW_TAG_formal_parameter DIEs representing the arguments of the
17909 parameter pack.
17911 PARM_PACK must be a function parameter pack.
17912 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN
17913 must point to the subsequent arguments of the function PACK_ARG belongs to.
17914 SUBR_DIE is the DIE of the function PACK_ARG belongs to.
17915 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument
17916 following the last one for which a DIE was generated. */
17918 static dw_die_ref
17919 gen_formal_parameter_pack_die (tree parm_pack,
17920 tree pack_arg,
17921 dw_die_ref subr_die,
17922 tree *next_arg)
17924 tree arg;
17925 dw_die_ref parm_pack_die;
17927 gcc_assert (parm_pack
17928 && lang_hooks.function_parameter_pack_p (parm_pack)
17929 && subr_die);
17931 parm_pack_die = new_die (DW_TAG_GNU_formal_parameter_pack, subr_die, parm_pack);
17932 add_src_coords_attributes (parm_pack_die, parm_pack);
17934 for (arg = pack_arg; arg; arg = DECL_CHAIN (arg))
17936 if (! lang_hooks.decls.function_parm_expanded_from_pack_p (arg,
17937 parm_pack))
17938 break;
17939 gen_formal_parameter_die (arg, NULL,
17940 false /* Don't emit name attribute. */,
17941 parm_pack_die);
17943 if (next_arg)
17944 *next_arg = arg;
17945 return parm_pack_die;
17948 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
17949 at the end of an (ANSI prototyped) formal parameters list. */
17951 static void
17952 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
17954 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
17957 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
17958 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
17959 parameters as specified in some function type specification (except for
17960 those which appear as part of a function *definition*). */
17962 static void
17963 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
17965 tree link;
17966 tree formal_type = NULL;
17967 tree first_parm_type;
17968 tree arg;
17970 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
17972 arg = DECL_ARGUMENTS (function_or_method_type);
17973 function_or_method_type = TREE_TYPE (function_or_method_type);
17975 else
17976 arg = NULL_TREE;
17978 first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
17980 /* Make our first pass over the list of formal parameter types and output a
17981 DW_TAG_formal_parameter DIE for each one. */
17982 for (link = first_parm_type; link; )
17984 dw_die_ref parm_die;
17986 formal_type = TREE_VALUE (link);
17987 if (formal_type == void_type_node)
17988 break;
17990 /* Output a (nameless) DIE to represent the formal parameter itself. */
17991 if (!POINTER_BOUNDS_TYPE_P (formal_type))
17993 parm_die = gen_formal_parameter_die (formal_type, NULL,
17994 true /* Emit name attribute. */,
17995 context_die);
17996 if (TREE_CODE (function_or_method_type) == METHOD_TYPE
17997 && link == first_parm_type)
17999 add_AT_flag (parm_die, DW_AT_artificial, 1);
18000 if (dwarf_version >= 3 || !dwarf_strict)
18001 add_AT_die_ref (context_die, DW_AT_object_pointer, parm_die);
18003 else if (arg && DECL_ARTIFICIAL (arg))
18004 add_AT_flag (parm_die, DW_AT_artificial, 1);
18007 link = TREE_CHAIN (link);
18008 if (arg)
18009 arg = DECL_CHAIN (arg);
18012 /* If this function type has an ellipsis, add a
18013 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
18014 if (formal_type != void_type_node)
18015 gen_unspecified_parameters_die (function_or_method_type, context_die);
18017 /* Make our second (and final) pass over the list of formal parameter types
18018 and output DIEs to represent those types (as necessary). */
18019 for (link = TYPE_ARG_TYPES (function_or_method_type);
18020 link && TREE_VALUE (link);
18021 link = TREE_CHAIN (link))
18022 gen_type_die (TREE_VALUE (link), context_die);
18025 /* We want to generate the DIE for TYPE so that we can generate the
18026 die for MEMBER, which has been defined; we will need to refer back
18027 to the member declaration nested within TYPE. If we're trying to
18028 generate minimal debug info for TYPE, processing TYPE won't do the
18029 trick; we need to attach the member declaration by hand. */
18031 static void
18032 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
18034 gen_type_die (type, context_die);
18036 /* If we're trying to avoid duplicate debug info, we may not have
18037 emitted the member decl for this function. Emit it now. */
18038 if (TYPE_STUB_DECL (type)
18039 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
18040 && ! lookup_decl_die (member))
18042 dw_die_ref type_die;
18043 gcc_assert (!decl_ultimate_origin (member));
18045 push_decl_scope (type);
18046 type_die = lookup_type_die_strip_naming_typedef (type);
18047 if (TREE_CODE (member) == FUNCTION_DECL)
18048 gen_subprogram_die (member, type_die);
18049 else if (TREE_CODE (member) == FIELD_DECL)
18051 /* Ignore the nameless fields that are used to skip bits but handle
18052 C++ anonymous unions and structs. */
18053 if (DECL_NAME (member) != NULL_TREE
18054 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
18055 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
18057 gen_type_die (member_declared_type (member), type_die);
18058 gen_field_die (member, type_die);
18061 else
18062 gen_variable_die (member, NULL_TREE, type_die);
18064 pop_decl_scope ();
18068 /* Forward declare these functions, because they are mutually recursive
18069 with their set_block_* pairing functions. */
18070 static void set_decl_origin_self (tree);
18071 static void set_decl_abstract_flags (tree, vec<tree> &);
18073 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
18074 given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
18075 that it points to the node itself, thus indicating that the node is its
18076 own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for
18077 the given node is NULL, recursively descend the decl/block tree which
18078 it is the root of, and for each other ..._DECL or BLOCK node contained
18079 therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
18080 still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
18081 values to point to themselves. */
18083 static void
18084 set_block_origin_self (tree stmt)
18086 if (BLOCK_ABSTRACT_ORIGIN (stmt) == NULL_TREE)
18088 BLOCK_ABSTRACT_ORIGIN (stmt) = stmt;
18091 tree local_decl;
18093 for (local_decl = BLOCK_VARS (stmt);
18094 local_decl != NULL_TREE;
18095 local_decl = DECL_CHAIN (local_decl))
18096 /* Do not recurse on nested functions since the inlining status
18097 of parent and child can be different as per the DWARF spec. */
18098 if (TREE_CODE (local_decl) != FUNCTION_DECL
18099 && !DECL_EXTERNAL (local_decl))
18100 set_decl_origin_self (local_decl);
18104 tree subblock;
18106 for (subblock = BLOCK_SUBBLOCKS (stmt);
18107 subblock != NULL_TREE;
18108 subblock = BLOCK_CHAIN (subblock))
18109 set_block_origin_self (subblock); /* Recurse. */
18114 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
18115 the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
18116 node to so that it points to the node itself, thus indicating that the
18117 node represents its own (abstract) origin. Additionally, if the
18118 DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
18119 the decl/block tree of which the given node is the root of, and for
18120 each other ..._DECL or BLOCK node contained therein whose
18121 DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
18122 set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
18123 point to themselves. */
18125 static void
18126 set_decl_origin_self (tree decl)
18128 if (DECL_ABSTRACT_ORIGIN (decl) == NULL_TREE)
18130 DECL_ABSTRACT_ORIGIN (decl) = decl;
18131 if (TREE_CODE (decl) == FUNCTION_DECL)
18133 tree arg;
18135 for (arg = DECL_ARGUMENTS (decl); arg; arg = DECL_CHAIN (arg))
18136 DECL_ABSTRACT_ORIGIN (arg) = arg;
18137 if (DECL_INITIAL (decl) != NULL_TREE
18138 && DECL_INITIAL (decl) != error_mark_node)
18139 set_block_origin_self (DECL_INITIAL (decl));
18144 /* Given a pointer to some BLOCK node, set the BLOCK_ABSTRACT flag to 1
18145 and if it wasn't 1 before, push it to abstract_vec vector.
18146 For all local decls and all local sub-blocks (recursively) do it
18147 too. */
18149 static void
18150 set_block_abstract_flags (tree stmt, vec<tree> &abstract_vec)
18152 tree local_decl;
18153 tree subblock;
18154 unsigned int i;
18156 if (!BLOCK_ABSTRACT (stmt))
18158 abstract_vec.safe_push (stmt);
18159 BLOCK_ABSTRACT (stmt) = 1;
18162 for (local_decl = BLOCK_VARS (stmt);
18163 local_decl != NULL_TREE;
18164 local_decl = DECL_CHAIN (local_decl))
18165 if (! DECL_EXTERNAL (local_decl))
18166 set_decl_abstract_flags (local_decl, abstract_vec);
18168 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (stmt); i++)
18170 local_decl = BLOCK_NONLOCALIZED_VAR (stmt, i);
18171 if ((TREE_CODE (local_decl) == VAR_DECL && !TREE_STATIC (local_decl))
18172 || TREE_CODE (local_decl) == PARM_DECL)
18173 set_decl_abstract_flags (local_decl, abstract_vec);
18176 for (subblock = BLOCK_SUBBLOCKS (stmt);
18177 subblock != NULL_TREE;
18178 subblock = BLOCK_CHAIN (subblock))
18179 set_block_abstract_flags (subblock, abstract_vec);
18182 /* Given a pointer to some ..._DECL node, set DECL_ABSTRACT_P flag on it
18183 to 1 and if it wasn't 1 before, push to abstract_vec vector.
18184 In the case where the decl is a FUNCTION_DECL also set the abstract
18185 flags for all of the parameters, local vars, local
18186 blocks and sub-blocks (recursively). */
18188 static void
18189 set_decl_abstract_flags (tree decl, vec<tree> &abstract_vec)
18191 if (!DECL_ABSTRACT_P (decl))
18193 abstract_vec.safe_push (decl);
18194 DECL_ABSTRACT_P (decl) = 1;
18197 if (TREE_CODE (decl) == FUNCTION_DECL)
18199 tree arg;
18201 for (arg = DECL_ARGUMENTS (decl); arg; arg = DECL_CHAIN (arg))
18202 if (!DECL_ABSTRACT_P (arg))
18204 abstract_vec.safe_push (arg);
18205 DECL_ABSTRACT_P (arg) = 1;
18207 if (DECL_INITIAL (decl) != NULL_TREE
18208 && DECL_INITIAL (decl) != error_mark_node)
18209 set_block_abstract_flags (DECL_INITIAL (decl), abstract_vec);
18213 /* Generate the DWARF2 info for the "abstract" instance of a function which we
18214 may later generate inlined and/or out-of-line instances of. */
18216 static void
18217 dwarf2out_abstract_function (tree decl)
18219 dw_die_ref old_die;
18220 tree save_fn;
18221 tree context;
18222 hash_table<decl_loc_hasher> *old_decl_loc_table;
18223 hash_table<dw_loc_list_hasher> *old_cached_dw_loc_list_table;
18224 int old_call_site_count, old_tail_call_site_count;
18225 struct call_arg_loc_node *old_call_arg_locations;
18227 /* Make sure we have the actual abstract inline, not a clone. */
18228 decl = DECL_ORIGIN (decl);
18230 old_die = lookup_decl_die (decl);
18231 if (old_die && get_AT (old_die, DW_AT_inline))
18232 /* We've already generated the abstract instance. */
18233 return;
18235 /* We can be called while recursively when seeing block defining inlined subroutine
18236 DIE. Be sure to not clobber the outer location table nor use it or we would
18237 get locations in abstract instantces. */
18238 old_decl_loc_table = decl_loc_table;
18239 decl_loc_table = NULL;
18240 old_cached_dw_loc_list_table = cached_dw_loc_list_table;
18241 cached_dw_loc_list_table = NULL;
18242 old_call_arg_locations = call_arg_locations;
18243 call_arg_locations = NULL;
18244 old_call_site_count = call_site_count;
18245 call_site_count = -1;
18246 old_tail_call_site_count = tail_call_site_count;
18247 tail_call_site_count = -1;
18249 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
18250 we don't get confused by DECL_ABSTRACT_P. */
18251 if (debug_info_level > DINFO_LEVEL_TERSE)
18253 context = decl_class_context (decl);
18254 if (context)
18255 gen_type_die_for_member
18256 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die ());
18259 /* Pretend we've just finished compiling this function. */
18260 save_fn = current_function_decl;
18261 current_function_decl = decl;
18263 auto_vec<tree, 64> abstract_vec;
18264 set_decl_abstract_flags (decl, abstract_vec);
18265 dwarf2out_decl (decl);
18266 unsigned int i;
18267 tree t;
18268 FOR_EACH_VEC_ELT (abstract_vec, i, t)
18269 if (TREE_CODE (t) == BLOCK)
18270 BLOCK_ABSTRACT (t) = 0;
18271 else
18272 DECL_ABSTRACT_P (t) = 0;
18274 current_function_decl = save_fn;
18275 decl_loc_table = old_decl_loc_table;
18276 cached_dw_loc_list_table = old_cached_dw_loc_list_table;
18277 call_arg_locations = old_call_arg_locations;
18278 call_site_count = old_call_site_count;
18279 tail_call_site_count = old_tail_call_site_count;
18282 /* Helper function of premark_used_types() which gets called through
18283 htab_traverse.
18285 Marks the DIE of a given type in *SLOT as perennial, so it never gets
18286 marked as unused by prune_unused_types. */
18288 bool
18289 premark_used_types_helper (tree const &type, void *)
18291 dw_die_ref die;
18293 die = lookup_type_die (type);
18294 if (die != NULL)
18295 die->die_perennial_p = 1;
18296 return true;
18299 /* Helper function of premark_types_used_by_global_vars which gets called
18300 through htab_traverse.
18302 Marks the DIE of a given type in *SLOT as perennial, so it never gets
18303 marked as unused by prune_unused_types. The DIE of the type is marked
18304 only if the global variable using the type will actually be emitted. */
18307 premark_types_used_by_global_vars_helper (types_used_by_vars_entry **slot,
18308 void *)
18310 struct types_used_by_vars_entry *entry;
18311 dw_die_ref die;
18313 entry = (struct types_used_by_vars_entry *) *slot;
18314 gcc_assert (entry->type != NULL
18315 && entry->var_decl != NULL);
18316 die = lookup_type_die (entry->type);
18317 if (die)
18319 /* Ask cgraph if the global variable really is to be emitted.
18320 If yes, then we'll keep the DIE of ENTRY->TYPE. */
18321 varpool_node *node = varpool_node::get (entry->var_decl);
18322 if (node && node->definition)
18324 die->die_perennial_p = 1;
18325 /* Keep the parent DIEs as well. */
18326 while ((die = die->die_parent) && die->die_perennial_p == 0)
18327 die->die_perennial_p = 1;
18330 return 1;
18333 /* Mark all members of used_types_hash as perennial. */
18335 static void
18336 premark_used_types (struct function *fun)
18338 if (fun && fun->used_types_hash)
18339 fun->used_types_hash->traverse<void *, premark_used_types_helper> (NULL);
18342 /* Mark all members of types_used_by_vars_entry as perennial. */
18344 static void
18345 premark_types_used_by_global_vars (void)
18347 if (types_used_by_vars_hash)
18348 types_used_by_vars_hash
18349 ->traverse<void *, premark_types_used_by_global_vars_helper> (NULL);
18352 /* Generate a DW_TAG_GNU_call_site DIE in function DECL under SUBR_DIE
18353 for CA_LOC call arg loc node. */
18355 static dw_die_ref
18356 gen_call_site_die (tree decl, dw_die_ref subr_die,
18357 struct call_arg_loc_node *ca_loc)
18359 dw_die_ref stmt_die = NULL, die;
18360 tree block = ca_loc->block;
18362 while (block
18363 && block != DECL_INITIAL (decl)
18364 && TREE_CODE (block) == BLOCK)
18366 if (block_map.length () > BLOCK_NUMBER (block))
18367 stmt_die = block_map[BLOCK_NUMBER (block)];
18368 if (stmt_die)
18369 break;
18370 block = BLOCK_SUPERCONTEXT (block);
18372 if (stmt_die == NULL)
18373 stmt_die = subr_die;
18374 die = new_die (DW_TAG_GNU_call_site, stmt_die, NULL_TREE);
18375 add_AT_lbl_id (die, DW_AT_low_pc, ca_loc->label);
18376 if (ca_loc->tail_call_p)
18377 add_AT_flag (die, DW_AT_GNU_tail_call, 1);
18378 if (ca_loc->symbol_ref)
18380 dw_die_ref tdie = lookup_decl_die (SYMBOL_REF_DECL (ca_loc->symbol_ref));
18381 if (tdie)
18382 add_AT_die_ref (die, DW_AT_abstract_origin, tdie);
18383 else
18384 add_AT_addr (die, DW_AT_abstract_origin, ca_loc->symbol_ref, false);
18386 return die;
18389 /* Generate a DIE to represent a declared function (either file-scope or
18390 block-local). */
18392 static void
18393 gen_subprogram_die (tree decl, dw_die_ref context_die)
18395 tree origin = decl_ultimate_origin (decl);
18396 dw_die_ref subr_die;
18397 tree outer_scope;
18398 dw_die_ref old_die = lookup_decl_die (decl);
18399 int declaration = (current_function_decl != decl
18400 || class_or_namespace_scope_p (context_die));
18402 premark_used_types (DECL_STRUCT_FUNCTION (decl));
18404 /* It is possible to have both DECL_ABSTRACT_P and DECLARATION be true if we
18405 started to generate the abstract instance of an inline, decided to output
18406 its containing class, and proceeded to emit the declaration of the inline
18407 from the member list for the class. If so, DECLARATION takes priority;
18408 we'll get back to the abstract instance when done with the class. */
18410 /* The class-scope declaration DIE must be the primary DIE. */
18411 if (origin && declaration && class_or_namespace_scope_p (context_die))
18413 origin = NULL;
18414 gcc_assert (!old_die);
18417 /* Now that the C++ front end lazily declares artificial member fns, we
18418 might need to retrofit the declaration into its class. */
18419 if (!declaration && !origin && !old_die
18420 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
18421 && !class_or_namespace_scope_p (context_die)
18422 && debug_info_level > DINFO_LEVEL_TERSE)
18423 old_die = force_decl_die (decl);
18425 if (origin != NULL)
18427 gcc_assert (!declaration || local_scope_p (context_die));
18429 /* Fixup die_parent for the abstract instance of a nested
18430 inline function. */
18431 if (old_die && old_die->die_parent == NULL)
18432 add_child_die (context_die, old_die);
18434 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
18435 add_abstract_origin_attribute (subr_die, origin);
18436 /* This is where the actual code for a cloned function is.
18437 Let's emit linkage name attribute for it. This helps
18438 debuggers to e.g, set breakpoints into
18439 constructors/destructors when the user asks "break
18440 K::K". */
18441 add_linkage_name (subr_die, decl);
18443 else if (old_die)
18445 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
18446 struct dwarf_file_data * file_index = lookup_filename (s.file);
18448 if (!get_AT_flag (old_die, DW_AT_declaration)
18449 /* We can have a normal definition following an inline one in the
18450 case of redefinition of GNU C extern inlines.
18451 It seems reasonable to use AT_specification in this case. */
18452 && !get_AT (old_die, DW_AT_inline))
18454 /* Detect and ignore this case, where we are trying to output
18455 something we have already output. */
18456 return;
18459 /* If the definition comes from the same place as the declaration,
18460 maybe use the old DIE. We always want the DIE for this function
18461 that has the *_pc attributes to be under comp_unit_die so the
18462 debugger can find it. We also need to do this for abstract
18463 instances of inlines, since the spec requires the out-of-line copy
18464 to have the same parent. For local class methods, this doesn't
18465 apply; we just use the old DIE. */
18466 if ((is_cu_die (old_die->die_parent) || context_die == NULL)
18467 && (DECL_ARTIFICIAL (decl)
18468 || (get_AT_file (old_die, DW_AT_decl_file) == file_index
18469 && (get_AT_unsigned (old_die, DW_AT_decl_line)
18470 == (unsigned) s.line))))
18472 subr_die = old_die;
18474 /* Clear out the declaration attribute and the formal parameters.
18475 Do not remove all children, because it is possible that this
18476 declaration die was forced using force_decl_die(). In such
18477 cases die that forced declaration die (e.g. TAG_imported_module)
18478 is one of the children that we do not want to remove. */
18479 remove_AT (subr_die, DW_AT_declaration);
18480 remove_AT (subr_die, DW_AT_object_pointer);
18481 remove_child_TAG (subr_die, DW_TAG_formal_parameter);
18483 else
18485 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
18486 add_AT_specification (subr_die, old_die);
18487 add_pubname (decl, subr_die);
18488 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
18489 add_AT_file (subr_die, DW_AT_decl_file, file_index);
18490 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
18491 add_AT_unsigned (subr_die, DW_AT_decl_line, s.line);
18493 /* If the prototype had an 'auto' or 'decltype(auto)' return type,
18494 emit the real type on the definition die. */
18495 if (is_cxx() && debug_info_level > DINFO_LEVEL_TERSE)
18497 dw_die_ref die = get_AT_ref (old_die, DW_AT_type);
18498 if (die == auto_die || die == decltype_auto_die)
18499 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
18500 TYPE_UNQUALIFIED, context_die);
18504 else
18506 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
18508 if (TREE_PUBLIC (decl))
18509 add_AT_flag (subr_die, DW_AT_external, 1);
18511 add_name_and_src_coords_attributes (subr_die, decl);
18512 add_pubname (decl, subr_die);
18513 if (debug_info_level > DINFO_LEVEL_TERSE)
18515 add_prototyped_attribute (subr_die, TREE_TYPE (decl));
18516 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
18517 TYPE_UNQUALIFIED, context_die);
18520 add_pure_or_virtual_attribute (subr_die, decl);
18521 if (DECL_ARTIFICIAL (decl))
18522 add_AT_flag (subr_die, DW_AT_artificial, 1);
18524 if (TREE_THIS_VOLATILE (decl) && (dwarf_version >= 5 || !dwarf_strict))
18525 add_AT_flag (subr_die, DW_AT_noreturn, 1);
18527 add_accessibility_attribute (subr_die, decl);
18530 if (declaration)
18532 if (!old_die || !get_AT (old_die, DW_AT_inline))
18534 add_AT_flag (subr_die, DW_AT_declaration, 1);
18536 /* If this is an explicit function declaration then generate
18537 a DW_AT_explicit attribute. */
18538 if (lang_hooks.decls.function_decl_explicit_p (decl)
18539 && (dwarf_version >= 3 || !dwarf_strict))
18540 add_AT_flag (subr_die, DW_AT_explicit, 1);
18542 /* If this is a C++11 deleted special function member then generate
18543 a DW_AT_GNU_deleted attribute. */
18544 if (lang_hooks.decls.function_decl_deleted_p (decl)
18545 && (! dwarf_strict))
18546 add_AT_flag (subr_die, DW_AT_GNU_deleted, 1);
18548 /* The first time we see a member function, it is in the context of
18549 the class to which it belongs. We make sure of this by emitting
18550 the class first. The next time is the definition, which is
18551 handled above. The two may come from the same source text.
18553 Note that force_decl_die() forces function declaration die. It is
18554 later reused to represent definition. */
18555 equate_decl_number_to_die (decl, subr_die);
18558 else if (DECL_ABSTRACT_P (decl))
18560 if (DECL_DECLARED_INLINE_P (decl))
18562 if (cgraph_function_possibly_inlined_p (decl))
18563 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
18564 else
18565 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
18567 else
18569 if (cgraph_function_possibly_inlined_p (decl))
18570 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
18571 else
18572 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
18575 if (DECL_DECLARED_INLINE_P (decl)
18576 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl)))
18577 add_AT_flag (subr_die, DW_AT_artificial, 1);
18579 equate_decl_number_to_die (decl, subr_die);
18581 else if (!DECL_EXTERNAL (decl))
18583 HOST_WIDE_INT cfa_fb_offset;
18584 struct function *fun = DECL_STRUCT_FUNCTION (decl);
18586 if (!old_die || !get_AT (old_die, DW_AT_inline))
18587 equate_decl_number_to_die (decl, subr_die);
18589 gcc_checking_assert (fun);
18590 if (!flag_reorder_blocks_and_partition)
18592 dw_fde_ref fde = fun->fde;
18593 if (fde->dw_fde_begin)
18595 /* We have already generated the labels. */
18596 add_AT_low_high_pc (subr_die, fde->dw_fde_begin,
18597 fde->dw_fde_end, false);
18599 else
18601 /* Create start/end labels and add the range. */
18602 char label_id_low[MAX_ARTIFICIAL_LABEL_BYTES];
18603 char label_id_high[MAX_ARTIFICIAL_LABEL_BYTES];
18604 ASM_GENERATE_INTERNAL_LABEL (label_id_low, FUNC_BEGIN_LABEL,
18605 current_function_funcdef_no);
18606 ASM_GENERATE_INTERNAL_LABEL (label_id_high, FUNC_END_LABEL,
18607 current_function_funcdef_no);
18608 add_AT_low_high_pc (subr_die, label_id_low, label_id_high,
18609 false);
18612 #if VMS_DEBUGGING_INFO
18613 /* HP OpenVMS Industry Standard 64: DWARF Extensions
18614 Section 2.3 Prologue and Epilogue Attributes:
18615 When a breakpoint is set on entry to a function, it is generally
18616 desirable for execution to be suspended, not on the very first
18617 instruction of the function, but rather at a point after the
18618 function's frame has been set up, after any language defined local
18619 declaration processing has been completed, and before execution of
18620 the first statement of the function begins. Debuggers generally
18621 cannot properly determine where this point is. Similarly for a
18622 breakpoint set on exit from a function. The prologue and epilogue
18623 attributes allow a compiler to communicate the location(s) to use. */
18626 if (fde->dw_fde_vms_end_prologue)
18627 add_AT_vms_delta (subr_die, DW_AT_HP_prologue,
18628 fde->dw_fde_begin, fde->dw_fde_vms_end_prologue);
18630 if (fde->dw_fde_vms_begin_epilogue)
18631 add_AT_vms_delta (subr_die, DW_AT_HP_epilogue,
18632 fde->dw_fde_begin, fde->dw_fde_vms_begin_epilogue);
18634 #endif
18637 else
18639 /* Generate pubnames entries for the split function code ranges. */
18640 dw_fde_ref fde = fun->fde;
18642 if (fde->dw_fde_second_begin)
18644 if (dwarf_version >= 3 || !dwarf_strict)
18646 /* We should use ranges for non-contiguous code section
18647 addresses. Use the actual code range for the initial
18648 section, since the HOT/COLD labels might precede an
18649 alignment offset. */
18650 bool range_list_added = false;
18651 add_ranges_by_labels (subr_die, fde->dw_fde_begin,
18652 fde->dw_fde_end, &range_list_added,
18653 false);
18654 add_ranges_by_labels (subr_die, fde->dw_fde_second_begin,
18655 fde->dw_fde_second_end,
18656 &range_list_added, false);
18657 if (range_list_added)
18658 add_ranges (NULL);
18660 else
18662 /* There is no real support in DW2 for this .. so we make
18663 a work-around. First, emit the pub name for the segment
18664 containing the function label. Then make and emit a
18665 simplified subprogram DIE for the second segment with the
18666 name pre-fixed by __hot/cold_sect_of_. We use the same
18667 linkage name for the second die so that gdb will find both
18668 sections when given "b foo". */
18669 const char *name = NULL;
18670 tree decl_name = DECL_NAME (decl);
18671 dw_die_ref seg_die;
18673 /* Do the 'primary' section. */
18674 add_AT_low_high_pc (subr_die, fde->dw_fde_begin,
18675 fde->dw_fde_end, false);
18677 /* Build a minimal DIE for the secondary section. */
18678 seg_die = new_die (DW_TAG_subprogram,
18679 subr_die->die_parent, decl);
18681 if (TREE_PUBLIC (decl))
18682 add_AT_flag (seg_die, DW_AT_external, 1);
18684 if (decl_name != NULL
18685 && IDENTIFIER_POINTER (decl_name) != NULL)
18687 name = dwarf2_name (decl, 1);
18688 if (! DECL_ARTIFICIAL (decl))
18689 add_src_coords_attributes (seg_die, decl);
18691 add_linkage_name (seg_die, decl);
18693 gcc_assert (name != NULL);
18694 add_pure_or_virtual_attribute (seg_die, decl);
18695 if (DECL_ARTIFICIAL (decl))
18696 add_AT_flag (seg_die, DW_AT_artificial, 1);
18698 name = concat ("__second_sect_of_", name, NULL);
18699 add_AT_low_high_pc (seg_die, fde->dw_fde_second_begin,
18700 fde->dw_fde_second_end, false);
18701 add_name_attribute (seg_die, name);
18702 if (want_pubnames ())
18703 add_pubname_string (name, seg_die);
18706 else
18707 add_AT_low_high_pc (subr_die, fde->dw_fde_begin, fde->dw_fde_end,
18708 false);
18711 cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl);
18713 /* We define the "frame base" as the function's CFA. This is more
18714 convenient for several reasons: (1) It's stable across the prologue
18715 and epilogue, which makes it better than just a frame pointer,
18716 (2) With dwarf3, there exists a one-byte encoding that allows us
18717 to reference the .debug_frame data by proxy, but failing that,
18718 (3) We can at least reuse the code inspection and interpretation
18719 code that determines the CFA position at various points in the
18720 function. */
18721 if (dwarf_version >= 3 && targetm.debug_unwind_info () == UI_DWARF2)
18723 dw_loc_descr_ref op = new_loc_descr (DW_OP_call_frame_cfa, 0, 0);
18724 add_AT_loc (subr_die, DW_AT_frame_base, op);
18726 else
18728 dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset);
18729 if (list->dw_loc_next)
18730 add_AT_loc_list (subr_die, DW_AT_frame_base, list);
18731 else
18732 add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
18735 /* Compute a displacement from the "steady-state frame pointer" to
18736 the CFA. The former is what all stack slots and argument slots
18737 will reference in the rtl; the latter is what we've told the
18738 debugger about. We'll need to adjust all frame_base references
18739 by this displacement. */
18740 compute_frame_pointer_to_fb_displacement (cfa_fb_offset);
18742 if (fun->static_chain_decl)
18743 add_AT_location_description (subr_die, DW_AT_static_link,
18744 loc_list_from_tree (fun->static_chain_decl, 2, NULL));
18747 /* Generate child dies for template paramaters. */
18748 if (debug_info_level > DINFO_LEVEL_TERSE)
18749 gen_generic_params_dies (decl);
18751 /* Now output descriptions of the arguments for this function. This gets
18752 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
18753 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
18754 `...' at the end of the formal parameter list. In order to find out if
18755 there was a trailing ellipsis or not, we must instead look at the type
18756 associated with the FUNCTION_DECL. This will be a node of type
18757 FUNCTION_TYPE. If the chain of type nodes hanging off of this
18758 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
18759 an ellipsis at the end. */
18761 /* In the case where we are describing a mere function declaration, all we
18762 need to do here (and all we *can* do here) is to describe the *types* of
18763 its formal parameters. */
18764 if (debug_info_level <= DINFO_LEVEL_TERSE)
18766 else if (declaration)
18767 gen_formal_types_die (decl, subr_die);
18768 else
18770 /* Generate DIEs to represent all known formal parameters. */
18771 tree parm = DECL_ARGUMENTS (decl);
18772 tree generic_decl = lang_hooks.decls.get_generic_function_decl (decl);
18773 tree generic_decl_parm = generic_decl
18774 ? DECL_ARGUMENTS (generic_decl)
18775 : NULL;
18777 /* Now we want to walk the list of parameters of the function and
18778 emit their relevant DIEs.
18780 We consider the case of DECL being an instance of a generic function
18781 as well as it being a normal function.
18783 If DECL is an instance of a generic function we walk the
18784 parameters of the generic function declaration _and_ the parameters of
18785 DECL itself. This is useful because we want to emit specific DIEs for
18786 function parameter packs and those are declared as part of the
18787 generic function declaration. In that particular case,
18788 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE.
18789 That DIE has children DIEs representing the set of arguments
18790 of the pack. Note that the set of pack arguments can be empty.
18791 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any
18792 children DIE.
18794 Otherwise, we just consider the parameters of DECL. */
18795 while (generic_decl_parm || parm)
18797 if (generic_decl_parm
18798 && lang_hooks.function_parameter_pack_p (generic_decl_parm))
18799 gen_formal_parameter_pack_die (generic_decl_parm,
18800 parm, subr_die,
18801 &parm);
18802 else if (parm && !POINTER_BOUNDS_P (parm))
18804 dw_die_ref parm_die = gen_decl_die (parm, NULL, subr_die);
18806 if (parm == DECL_ARGUMENTS (decl)
18807 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE
18808 && parm_die
18809 && (dwarf_version >= 3 || !dwarf_strict))
18810 add_AT_die_ref (subr_die, DW_AT_object_pointer, parm_die);
18812 parm = DECL_CHAIN (parm);
18814 else if (parm)
18815 parm = DECL_CHAIN (parm);
18817 if (generic_decl_parm)
18818 generic_decl_parm = DECL_CHAIN (generic_decl_parm);
18821 /* Decide whether we need an unspecified_parameters DIE at the end.
18822 There are 2 more cases to do this for: 1) the ansi ... declaration -
18823 this is detectable when the end of the arg list is not a
18824 void_type_node 2) an unprototyped function declaration (not a
18825 definition). This just means that we have no info about the
18826 parameters at all. */
18827 if (prototype_p (TREE_TYPE (decl)))
18829 /* This is the prototyped case, check for.... */
18830 if (stdarg_p (TREE_TYPE (decl)))
18831 gen_unspecified_parameters_die (decl, subr_die);
18833 else if (DECL_INITIAL (decl) == NULL_TREE)
18834 gen_unspecified_parameters_die (decl, subr_die);
18837 /* Output Dwarf info for all of the stuff within the body of the function
18838 (if it has one - it may be just a declaration). */
18839 outer_scope = DECL_INITIAL (decl);
18841 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
18842 a function. This BLOCK actually represents the outermost binding contour
18843 for the function, i.e. the contour in which the function's formal
18844 parameters and labels get declared. Curiously, it appears that the front
18845 end doesn't actually put the PARM_DECL nodes for the current function onto
18846 the BLOCK_VARS list for this outer scope, but are strung off of the
18847 DECL_ARGUMENTS list for the function instead.
18849 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
18850 the LABEL_DECL nodes for the function however, and we output DWARF info
18851 for those in decls_for_scope. Just within the `outer_scope' there will be
18852 a BLOCK node representing the function's outermost pair of curly braces,
18853 and any blocks used for the base and member initializers of a C++
18854 constructor function. */
18855 if (! declaration && outer_scope && TREE_CODE (outer_scope) != ERROR_MARK)
18857 int call_site_note_count = 0;
18858 int tail_call_site_note_count = 0;
18860 /* Emit a DW_TAG_variable DIE for a named return value. */
18861 if (DECL_NAME (DECL_RESULT (decl)))
18862 gen_decl_die (DECL_RESULT (decl), NULL, subr_die);
18864 decls_for_scope (outer_scope, subr_die);
18866 if (call_arg_locations && !dwarf_strict)
18868 struct call_arg_loc_node *ca_loc;
18869 for (ca_loc = call_arg_locations; ca_loc; ca_loc = ca_loc->next)
18871 dw_die_ref die = NULL;
18872 rtx tloc = NULL_RTX, tlocc = NULL_RTX;
18873 rtx arg, next_arg;
18875 for (arg = NOTE_VAR_LOCATION (ca_loc->call_arg_loc_note);
18876 arg; arg = next_arg)
18878 dw_loc_descr_ref reg, val;
18879 machine_mode mode = GET_MODE (XEXP (XEXP (arg, 0), 1));
18880 dw_die_ref cdie, tdie = NULL;
18882 next_arg = XEXP (arg, 1);
18883 if (REG_P (XEXP (XEXP (arg, 0), 0))
18884 && next_arg
18885 && MEM_P (XEXP (XEXP (next_arg, 0), 0))
18886 && REG_P (XEXP (XEXP (XEXP (next_arg, 0), 0), 0))
18887 && REGNO (XEXP (XEXP (arg, 0), 0))
18888 == REGNO (XEXP (XEXP (XEXP (next_arg, 0), 0), 0)))
18889 next_arg = XEXP (next_arg, 1);
18890 if (mode == VOIDmode)
18892 mode = GET_MODE (XEXP (XEXP (arg, 0), 0));
18893 if (mode == VOIDmode)
18894 mode = GET_MODE (XEXP (arg, 0));
18896 if (mode == VOIDmode || mode == BLKmode)
18897 continue;
18898 if (XEXP (XEXP (arg, 0), 0) == pc_rtx)
18900 gcc_assert (ca_loc->symbol_ref == NULL_RTX);
18901 tloc = XEXP (XEXP (arg, 0), 1);
18902 continue;
18904 else if (GET_CODE (XEXP (XEXP (arg, 0), 0)) == CLOBBER
18905 && XEXP (XEXP (XEXP (arg, 0), 0), 0) == pc_rtx)
18907 gcc_assert (ca_loc->symbol_ref == NULL_RTX);
18908 tlocc = XEXP (XEXP (arg, 0), 1);
18909 continue;
18911 reg = NULL;
18912 if (REG_P (XEXP (XEXP (arg, 0), 0)))
18913 reg = reg_loc_descriptor (XEXP (XEXP (arg, 0), 0),
18914 VAR_INIT_STATUS_INITIALIZED);
18915 else if (MEM_P (XEXP (XEXP (arg, 0), 0)))
18917 rtx mem = XEXP (XEXP (arg, 0), 0);
18918 reg = mem_loc_descriptor (XEXP (mem, 0),
18919 get_address_mode (mem),
18920 GET_MODE (mem),
18921 VAR_INIT_STATUS_INITIALIZED);
18923 else if (GET_CODE (XEXP (XEXP (arg, 0), 0))
18924 == DEBUG_PARAMETER_REF)
18926 tree tdecl
18927 = DEBUG_PARAMETER_REF_DECL (XEXP (XEXP (arg, 0), 0));
18928 tdie = lookup_decl_die (tdecl);
18929 if (tdie == NULL)
18930 continue;
18932 else
18933 continue;
18934 if (reg == NULL
18935 && GET_CODE (XEXP (XEXP (arg, 0), 0))
18936 != DEBUG_PARAMETER_REF)
18937 continue;
18938 val = mem_loc_descriptor (XEXP (XEXP (arg, 0), 1), mode,
18939 VOIDmode,
18940 VAR_INIT_STATUS_INITIALIZED);
18941 if (val == NULL)
18942 continue;
18943 if (die == NULL)
18944 die = gen_call_site_die (decl, subr_die, ca_loc);
18945 cdie = new_die (DW_TAG_GNU_call_site_parameter, die,
18946 NULL_TREE);
18947 if (reg != NULL)
18948 add_AT_loc (cdie, DW_AT_location, reg);
18949 else if (tdie != NULL)
18950 add_AT_die_ref (cdie, DW_AT_abstract_origin, tdie);
18951 add_AT_loc (cdie, DW_AT_GNU_call_site_value, val);
18952 if (next_arg != XEXP (arg, 1))
18954 mode = GET_MODE (XEXP (XEXP (XEXP (arg, 1), 0), 1));
18955 if (mode == VOIDmode)
18956 mode = GET_MODE (XEXP (XEXP (XEXP (arg, 1), 0), 0));
18957 val = mem_loc_descriptor (XEXP (XEXP (XEXP (arg, 1),
18958 0), 1),
18959 mode, VOIDmode,
18960 VAR_INIT_STATUS_INITIALIZED);
18961 if (val != NULL)
18962 add_AT_loc (cdie, DW_AT_GNU_call_site_data_value, val);
18965 if (die == NULL
18966 && (ca_loc->symbol_ref || tloc))
18967 die = gen_call_site_die (decl, subr_die, ca_loc);
18968 if (die != NULL && (tloc != NULL_RTX || tlocc != NULL_RTX))
18970 dw_loc_descr_ref tval = NULL;
18972 if (tloc != NULL_RTX)
18973 tval = mem_loc_descriptor (tloc,
18974 GET_MODE (tloc) == VOIDmode
18975 ? Pmode : GET_MODE (tloc),
18976 VOIDmode,
18977 VAR_INIT_STATUS_INITIALIZED);
18978 if (tval)
18979 add_AT_loc (die, DW_AT_GNU_call_site_target, tval);
18980 else if (tlocc != NULL_RTX)
18982 tval = mem_loc_descriptor (tlocc,
18983 GET_MODE (tlocc) == VOIDmode
18984 ? Pmode : GET_MODE (tlocc),
18985 VOIDmode,
18986 VAR_INIT_STATUS_INITIALIZED);
18987 if (tval)
18988 add_AT_loc (die, DW_AT_GNU_call_site_target_clobbered,
18989 tval);
18992 if (die != NULL)
18994 call_site_note_count++;
18995 if (ca_loc->tail_call_p)
18996 tail_call_site_note_count++;
19000 call_arg_locations = NULL;
19001 call_arg_loc_last = NULL;
19002 if (tail_call_site_count >= 0
19003 && tail_call_site_count == tail_call_site_note_count
19004 && !dwarf_strict)
19006 if (call_site_count >= 0
19007 && call_site_count == call_site_note_count)
19008 add_AT_flag (subr_die, DW_AT_GNU_all_call_sites, 1);
19009 else
19010 add_AT_flag (subr_die, DW_AT_GNU_all_tail_call_sites, 1);
19012 call_site_count = -1;
19013 tail_call_site_count = -1;
19016 if (subr_die != old_die)
19017 /* Add the calling convention attribute if requested. */
19018 add_calling_convention_attribute (subr_die, decl);
19021 /* Returns a hash value for X (which really is a die_struct). */
19023 hashval_t
19024 block_die_hasher::hash (die_struct *d)
19026 return (hashval_t) d->decl_id ^ htab_hash_pointer (d->die_parent);
19029 /* Return nonzero if decl_id and die_parent of die_struct X is the same
19030 as decl_id and die_parent of die_struct Y. */
19032 bool
19033 block_die_hasher::equal (die_struct *x, die_struct *y)
19035 return x->decl_id == y->decl_id && x->die_parent == y->die_parent;
19038 /* Generate a DIE to represent a declared data object.
19039 Either DECL or ORIGIN must be non-null. */
19041 static void
19042 gen_variable_die (tree decl, tree origin, dw_die_ref context_die)
19044 HOST_WIDE_INT off = 0;
19045 tree com_decl;
19046 tree decl_or_origin = decl ? decl : origin;
19047 tree ultimate_origin;
19048 dw_die_ref var_die;
19049 dw_die_ref old_die = decl ? lookup_decl_die (decl) : NULL;
19050 dw_die_ref origin_die;
19051 bool declaration = (DECL_EXTERNAL (decl_or_origin)
19052 || class_or_namespace_scope_p (context_die));
19053 bool specialization_p = false;
19055 ultimate_origin = decl_ultimate_origin (decl_or_origin);
19056 if (decl || ultimate_origin)
19057 origin = ultimate_origin;
19058 com_decl = fortran_common (decl_or_origin, &off);
19060 /* Symbol in common gets emitted as a child of the common block, in the form
19061 of a data member. */
19062 if (com_decl)
19064 dw_die_ref com_die;
19065 dw_loc_list_ref loc;
19066 die_node com_die_arg;
19068 var_die = lookup_decl_die (decl_or_origin);
19069 if (var_die)
19071 if (get_AT (var_die, DW_AT_location) == NULL)
19073 loc = loc_list_from_tree (com_decl, off ? 1 : 2, NULL);
19074 if (loc)
19076 if (off)
19078 /* Optimize the common case. */
19079 if (single_element_loc_list_p (loc)
19080 && loc->expr->dw_loc_opc == DW_OP_addr
19081 && loc->expr->dw_loc_next == NULL
19082 && GET_CODE (loc->expr->dw_loc_oprnd1.v.val_addr)
19083 == SYMBOL_REF)
19085 rtx x = loc->expr->dw_loc_oprnd1.v.val_addr;
19086 loc->expr->dw_loc_oprnd1.v.val_addr
19087 = plus_constant (GET_MODE (x), x , off);
19089 else
19090 loc_list_plus_const (loc, off);
19092 add_AT_location_description (var_die, DW_AT_location, loc);
19093 remove_AT (var_die, DW_AT_declaration);
19096 return;
19099 if (common_block_die_table == NULL)
19100 common_block_die_table = hash_table<block_die_hasher>::create_ggc (10);
19102 com_die_arg.decl_id = DECL_UID (com_decl);
19103 com_die_arg.die_parent = context_die;
19104 com_die = common_block_die_table->find (&com_die_arg);
19105 loc = loc_list_from_tree (com_decl, 2, NULL);
19106 if (com_die == NULL)
19108 const char *cnam
19109 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl));
19110 die_node **slot;
19112 com_die = new_die (DW_TAG_common_block, context_die, decl);
19113 add_name_and_src_coords_attributes (com_die, com_decl);
19114 if (loc)
19116 add_AT_location_description (com_die, DW_AT_location, loc);
19117 /* Avoid sharing the same loc descriptor between
19118 DW_TAG_common_block and DW_TAG_variable. */
19119 loc = loc_list_from_tree (com_decl, 2, NULL);
19121 else if (DECL_EXTERNAL (decl))
19122 add_AT_flag (com_die, DW_AT_declaration, 1);
19123 if (want_pubnames ())
19124 add_pubname_string (cnam, com_die); /* ??? needed? */
19125 com_die->decl_id = DECL_UID (com_decl);
19126 slot = common_block_die_table->find_slot (com_die, INSERT);
19127 *slot = com_die;
19129 else if (get_AT (com_die, DW_AT_location) == NULL && loc)
19131 add_AT_location_description (com_die, DW_AT_location, loc);
19132 loc = loc_list_from_tree (com_decl, 2, NULL);
19133 remove_AT (com_die, DW_AT_declaration);
19135 var_die = new_die (DW_TAG_variable, com_die, decl);
19136 add_name_and_src_coords_attributes (var_die, decl);
19137 add_type_attribute (var_die, TREE_TYPE (decl), decl_quals (decl),
19138 context_die);
19139 add_AT_flag (var_die, DW_AT_external, 1);
19140 if (loc)
19142 if (off)
19144 /* Optimize the common case. */
19145 if (single_element_loc_list_p (loc)
19146 && loc->expr->dw_loc_opc == DW_OP_addr
19147 && loc->expr->dw_loc_next == NULL
19148 && GET_CODE (loc->expr->dw_loc_oprnd1.v.val_addr) == SYMBOL_REF)
19150 rtx x = loc->expr->dw_loc_oprnd1.v.val_addr;
19151 loc->expr->dw_loc_oprnd1.v.val_addr
19152 = plus_constant (GET_MODE (x), x, off);
19154 else
19155 loc_list_plus_const (loc, off);
19157 add_AT_location_description (var_die, DW_AT_location, loc);
19159 else if (DECL_EXTERNAL (decl))
19160 add_AT_flag (var_die, DW_AT_declaration, 1);
19161 equate_decl_number_to_die (decl, var_die);
19162 return;
19165 /* If the compiler emitted a definition for the DECL declaration
19166 and if we already emitted a DIE for it, don't emit a second
19167 DIE for it again. Allow re-declarations of DECLs that are
19168 inside functions, though. */
19169 if (old_die && declaration && !local_scope_p (context_die))
19170 return;
19172 /* For static data members, the declaration in the class is supposed
19173 to have DW_TAG_member tag; the specification should still be
19174 DW_TAG_variable referencing the DW_TAG_member DIE. */
19175 if (declaration && class_scope_p (context_die))
19176 var_die = new_die (DW_TAG_member, context_die, decl);
19177 else
19178 var_die = new_die (DW_TAG_variable, context_die, decl);
19180 origin_die = NULL;
19181 if (origin != NULL)
19182 origin_die = add_abstract_origin_attribute (var_die, origin);
19184 /* Loop unrolling can create multiple blocks that refer to the same
19185 static variable, so we must test for the DW_AT_declaration flag.
19187 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
19188 copy decls and set the DECL_ABSTRACT_P flag on them instead of
19189 sharing them.
19191 ??? Duplicated blocks have been rewritten to use .debug_ranges.
19193 ??? The declare_in_namespace support causes us to get two DIEs for one
19194 variable, both of which are declarations. We want to avoid considering
19195 one to be a specification, so we must test that this DIE is not a
19196 declaration. */
19197 else if (old_die && TREE_STATIC (decl) && ! declaration
19198 && get_AT_flag (old_die, DW_AT_declaration) == 1)
19200 /* This is a definition of a C++ class level static. */
19201 add_AT_specification (var_die, old_die);
19202 specialization_p = true;
19203 if (DECL_NAME (decl))
19205 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
19206 struct dwarf_file_data * file_index = lookup_filename (s.file);
19208 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
19209 add_AT_file (var_die, DW_AT_decl_file, file_index);
19211 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
19212 add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
19214 if (old_die->die_tag == DW_TAG_member)
19215 add_linkage_name (var_die, decl);
19218 else
19219 add_name_and_src_coords_attributes (var_die, decl);
19221 if ((origin == NULL && !specialization_p)
19222 || (origin != NULL
19223 && !DECL_ABSTRACT_P (decl_or_origin)
19224 && variably_modified_type_p (TREE_TYPE (decl_or_origin),
19225 decl_function_context
19226 (decl_or_origin))))
19228 tree type = TREE_TYPE (decl_or_origin);
19230 if (decl_by_reference_p (decl_or_origin))
19231 add_type_attribute (var_die, TREE_TYPE (type), TYPE_UNQUALIFIED,
19232 context_die);
19233 else
19234 add_type_attribute (var_die, type, decl_quals (decl_or_origin),
19235 context_die);
19238 if (origin == NULL && !specialization_p)
19240 if (TREE_PUBLIC (decl))
19241 add_AT_flag (var_die, DW_AT_external, 1);
19243 if (DECL_ARTIFICIAL (decl))
19244 add_AT_flag (var_die, DW_AT_artificial, 1);
19246 add_accessibility_attribute (var_die, decl);
19249 if (declaration)
19250 add_AT_flag (var_die, DW_AT_declaration, 1);
19252 if (decl && (DECL_ABSTRACT_P (decl) || declaration || old_die == NULL))
19253 equate_decl_number_to_die (decl, var_die);
19255 if (! declaration
19256 && (! DECL_ABSTRACT_P (decl_or_origin)
19257 /* Local static vars are shared between all clones/inlines,
19258 so emit DW_AT_location on the abstract DIE if DECL_RTL is
19259 already set. */
19260 || (TREE_CODE (decl_or_origin) == VAR_DECL
19261 && TREE_STATIC (decl_or_origin)
19262 && DECL_RTL_SET_P (decl_or_origin)))
19263 /* When abstract origin already has DW_AT_location attribute, no need
19264 to add it again. */
19265 && (origin_die == NULL || get_AT (origin_die, DW_AT_location) == NULL))
19267 if (TREE_CODE (decl_or_origin) == VAR_DECL && TREE_STATIC (decl_or_origin)
19268 && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl_or_origin)))
19269 defer_location (decl_or_origin, var_die);
19270 else
19271 add_location_or_const_value_attribute (var_die, decl_or_origin,
19272 decl == NULL, DW_AT_location);
19273 add_pubname (decl_or_origin, var_die);
19275 else
19276 tree_add_const_value_attribute_for_decl (var_die, decl_or_origin);
19279 /* Generate a DIE to represent a named constant. */
19281 static void
19282 gen_const_die (tree decl, dw_die_ref context_die)
19284 dw_die_ref const_die;
19285 tree type = TREE_TYPE (decl);
19287 const_die = new_die (DW_TAG_constant, context_die, decl);
19288 add_name_and_src_coords_attributes (const_die, decl);
19289 add_type_attribute (const_die, type, TYPE_QUAL_CONST, context_die);
19290 if (TREE_PUBLIC (decl))
19291 add_AT_flag (const_die, DW_AT_external, 1);
19292 if (DECL_ARTIFICIAL (decl))
19293 add_AT_flag (const_die, DW_AT_artificial, 1);
19294 tree_add_const_value_attribute_for_decl (const_die, decl);
19297 /* Generate a DIE to represent a label identifier. */
19299 static void
19300 gen_label_die (tree decl, dw_die_ref context_die)
19302 tree origin = decl_ultimate_origin (decl);
19303 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
19304 rtx insn;
19305 char label[MAX_ARTIFICIAL_LABEL_BYTES];
19307 if (origin != NULL)
19308 add_abstract_origin_attribute (lbl_die, origin);
19309 else
19310 add_name_and_src_coords_attributes (lbl_die, decl);
19312 if (DECL_ABSTRACT_P (decl))
19313 equate_decl_number_to_die (decl, lbl_die);
19314 else
19316 insn = DECL_RTL_IF_SET (decl);
19318 /* Deleted labels are programmer specified labels which have been
19319 eliminated because of various optimizations. We still emit them
19320 here so that it is possible to put breakpoints on them. */
19321 if (insn
19322 && (LABEL_P (insn)
19323 || ((NOTE_P (insn)
19324 && NOTE_KIND (insn) == NOTE_INSN_DELETED_LABEL))))
19326 /* When optimization is enabled (via -O) some parts of the compiler
19327 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
19328 represent source-level labels which were explicitly declared by
19329 the user. This really shouldn't be happening though, so catch
19330 it if it ever does happen. */
19331 gcc_assert (!as_a<rtx_insn *> (insn)->deleted ());
19333 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
19334 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
19336 else if (insn
19337 && NOTE_P (insn)
19338 && NOTE_KIND (insn) == NOTE_INSN_DELETED_DEBUG_LABEL
19339 && CODE_LABEL_NUMBER (insn) != -1)
19341 ASM_GENERATE_INTERNAL_LABEL (label, "LDL", CODE_LABEL_NUMBER (insn));
19342 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
19347 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
19348 attributes to the DIE for a block STMT, to describe where the inlined
19349 function was called from. This is similar to add_src_coords_attributes. */
19351 static inline void
19352 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
19354 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
19356 if (dwarf_version >= 3 || !dwarf_strict)
19358 add_AT_file (die, DW_AT_call_file, lookup_filename (s.file));
19359 add_AT_unsigned (die, DW_AT_call_line, s.line);
19364 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
19365 Add low_pc and high_pc attributes to the DIE for a block STMT. */
19367 static inline void
19368 add_high_low_attributes (tree stmt, dw_die_ref die)
19370 char label[MAX_ARTIFICIAL_LABEL_BYTES];
19372 if (BLOCK_FRAGMENT_CHAIN (stmt)
19373 && (dwarf_version >= 3 || !dwarf_strict))
19375 tree chain, superblock = NULL_TREE;
19376 dw_die_ref pdie;
19377 dw_attr_ref attr = NULL;
19379 if (inlined_function_outer_scope_p (stmt))
19381 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
19382 BLOCK_NUMBER (stmt));
19383 add_AT_lbl_id (die, DW_AT_entry_pc, label);
19386 /* Optimize duplicate .debug_ranges lists or even tails of
19387 lists. If this BLOCK has same ranges as its supercontext,
19388 lookup DW_AT_ranges attribute in the supercontext (and
19389 recursively so), verify that the ranges_table contains the
19390 right values and use it instead of adding a new .debug_range. */
19391 for (chain = stmt, pdie = die;
19392 BLOCK_SAME_RANGE (chain);
19393 chain = BLOCK_SUPERCONTEXT (chain))
19395 dw_attr_ref new_attr;
19397 pdie = pdie->die_parent;
19398 if (pdie == NULL)
19399 break;
19400 if (BLOCK_SUPERCONTEXT (chain) == NULL_TREE)
19401 break;
19402 new_attr = get_AT (pdie, DW_AT_ranges);
19403 if (new_attr == NULL
19404 || new_attr->dw_attr_val.val_class != dw_val_class_range_list)
19405 break;
19406 attr = new_attr;
19407 superblock = BLOCK_SUPERCONTEXT (chain);
19409 if (attr != NULL
19410 && (ranges_table[attr->dw_attr_val.v.val_offset
19411 / 2 / DWARF2_ADDR_SIZE].num
19412 == BLOCK_NUMBER (superblock))
19413 && BLOCK_FRAGMENT_CHAIN (superblock))
19415 unsigned long off = attr->dw_attr_val.v.val_offset
19416 / 2 / DWARF2_ADDR_SIZE;
19417 unsigned long supercnt = 0, thiscnt = 0;
19418 for (chain = BLOCK_FRAGMENT_CHAIN (superblock);
19419 chain; chain = BLOCK_FRAGMENT_CHAIN (chain))
19421 ++supercnt;
19422 gcc_checking_assert (ranges_table[off + supercnt].num
19423 == BLOCK_NUMBER (chain));
19425 gcc_checking_assert (ranges_table[off + supercnt + 1].num == 0);
19426 for (chain = BLOCK_FRAGMENT_CHAIN (stmt);
19427 chain; chain = BLOCK_FRAGMENT_CHAIN (chain))
19428 ++thiscnt;
19429 gcc_assert (supercnt >= thiscnt);
19430 add_AT_range_list (die, DW_AT_ranges,
19431 ((off + supercnt - thiscnt)
19432 * 2 * DWARF2_ADDR_SIZE),
19433 false);
19434 return;
19437 add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt), false);
19439 chain = BLOCK_FRAGMENT_CHAIN (stmt);
19442 add_ranges (chain);
19443 chain = BLOCK_FRAGMENT_CHAIN (chain);
19445 while (chain);
19446 add_ranges (NULL);
19448 else
19450 char label_high[MAX_ARTIFICIAL_LABEL_BYTES];
19451 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
19452 BLOCK_NUMBER (stmt));
19453 ASM_GENERATE_INTERNAL_LABEL (label_high, BLOCK_END_LABEL,
19454 BLOCK_NUMBER (stmt));
19455 add_AT_low_high_pc (die, label, label_high, false);
19459 /* Generate a DIE for a lexical block. */
19461 static void
19462 gen_lexical_block_die (tree stmt, dw_die_ref context_die)
19464 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
19466 if (call_arg_locations)
19468 if (block_map.length () <= BLOCK_NUMBER (stmt))
19469 block_map.safe_grow_cleared (BLOCK_NUMBER (stmt) + 1);
19470 block_map[BLOCK_NUMBER (stmt)] = stmt_die;
19473 if (! BLOCK_ABSTRACT (stmt) && TREE_ASM_WRITTEN (stmt))
19474 add_high_low_attributes (stmt, stmt_die);
19476 decls_for_scope (stmt, stmt_die);
19479 /* Generate a DIE for an inlined subprogram. */
19481 static void
19482 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die)
19484 tree decl;
19486 /* The instance of function that is effectively being inlined shall not
19487 be abstract. */
19488 gcc_assert (! BLOCK_ABSTRACT (stmt));
19490 decl = block_ultimate_origin (stmt);
19492 /* Emit info for the abstract instance first, if we haven't yet. We
19493 must emit this even if the block is abstract, otherwise when we
19494 emit the block below (or elsewhere), we may end up trying to emit
19495 a die whose origin die hasn't been emitted, and crashing. */
19496 dwarf2out_abstract_function (decl);
19498 if (! BLOCK_ABSTRACT (stmt))
19500 dw_die_ref subr_die
19501 = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
19503 if (call_arg_locations)
19505 if (block_map.length () <= BLOCK_NUMBER (stmt))
19506 block_map.safe_grow_cleared (BLOCK_NUMBER (stmt) + 1);
19507 block_map[BLOCK_NUMBER (stmt)] = subr_die;
19509 add_abstract_origin_attribute (subr_die, decl);
19510 if (TREE_ASM_WRITTEN (stmt))
19511 add_high_low_attributes (stmt, subr_die);
19512 add_call_src_coords_attributes (stmt, subr_die);
19514 decls_for_scope (stmt, subr_die);
19518 /* Generate a DIE for a field in a record, or structure. */
19520 static void
19521 gen_field_die (tree decl, dw_die_ref context_die)
19523 dw_die_ref decl_die;
19525 if (TREE_TYPE (decl) == error_mark_node)
19526 return;
19528 decl_die = new_die (DW_TAG_member, context_die, decl);
19529 add_name_and_src_coords_attributes (decl_die, decl);
19530 add_type_attribute (decl_die, member_declared_type (decl),
19531 decl_quals (decl), context_die);
19533 if (DECL_BIT_FIELD_TYPE (decl))
19535 add_byte_size_attribute (decl_die, decl);
19536 add_bit_size_attribute (decl_die, decl);
19537 add_bit_offset_attribute (decl_die, decl);
19540 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
19541 add_data_member_location_attribute (decl_die, decl);
19543 if (DECL_ARTIFICIAL (decl))
19544 add_AT_flag (decl_die, DW_AT_artificial, 1);
19546 add_accessibility_attribute (decl_die, decl);
19548 /* Equate decl number to die, so that we can look up this decl later on. */
19549 equate_decl_number_to_die (decl, decl_die);
19552 #if 0
19553 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
19554 Use modified_type_die instead.
19555 We keep this code here just in case these types of DIEs may be needed to
19556 represent certain things in other languages (e.g. Pascal) someday. */
19558 static void
19559 gen_pointer_type_die (tree type, dw_die_ref context_die)
19561 dw_die_ref ptr_die
19562 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
19564 equate_type_number_to_die (type, ptr_die);
19565 add_type_attribute (ptr_die, TREE_TYPE (type), TYPE_UNQUALIFIED,
19566 context_die);
19567 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
19570 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
19571 Use modified_type_die instead.
19572 We keep this code here just in case these types of DIEs may be needed to
19573 represent certain things in other languages (e.g. Pascal) someday. */
19575 static void
19576 gen_reference_type_die (tree type, dw_die_ref context_die)
19578 dw_die_ref ref_die, scope_die = scope_die_for (type, context_die);
19580 if (TYPE_REF_IS_RVALUE (type) && dwarf_version >= 4)
19581 ref_die = new_die (DW_TAG_rvalue_reference_type, scope_die, type);
19582 else
19583 ref_die = new_die (DW_TAG_reference_type, scope_die, type);
19585 equate_type_number_to_die (type, ref_die);
19586 add_type_attribute (ref_die, TREE_TYPE (type), TYPE_UNQUALIFIED,
19587 context_die);
19588 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
19590 #endif
19592 /* Generate a DIE for a pointer to a member type. */
19594 static void
19595 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
19597 dw_die_ref ptr_die
19598 = new_die (DW_TAG_ptr_to_member_type,
19599 scope_die_for (type, context_die), type);
19601 equate_type_number_to_die (type, ptr_die);
19602 add_AT_die_ref (ptr_die, DW_AT_containing_type,
19603 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
19604 add_type_attribute (ptr_die, TREE_TYPE (type), TYPE_UNQUALIFIED,
19605 context_die);
19608 typedef const char *dchar_p; /* For DEF_VEC_P. */
19610 static char *producer_string;
19612 /* Return a heap allocated producer string including command line options
19613 if -grecord-gcc-switches. */
19615 static char *
19616 gen_producer_string (void)
19618 size_t j;
19619 auto_vec<dchar_p> switches;
19620 const char *language_string = lang_hooks.name;
19621 char *producer, *tail;
19622 const char *p;
19623 size_t len = dwarf_record_gcc_switches ? 0 : 3;
19624 size_t plen = strlen (language_string) + 1 + strlen (version_string);
19626 for (j = 1; dwarf_record_gcc_switches && j < save_decoded_options_count; j++)
19627 switch (save_decoded_options[j].opt_index)
19629 case OPT_o:
19630 case OPT_d:
19631 case OPT_dumpbase:
19632 case OPT_dumpdir:
19633 case OPT_auxbase:
19634 case OPT_auxbase_strip:
19635 case OPT_quiet:
19636 case OPT_version:
19637 case OPT_v:
19638 case OPT_w:
19639 case OPT_L:
19640 case OPT_D:
19641 case OPT_I:
19642 case OPT_U:
19643 case OPT_SPECIAL_unknown:
19644 case OPT_SPECIAL_ignore:
19645 case OPT_SPECIAL_program_name:
19646 case OPT_SPECIAL_input_file:
19647 case OPT_grecord_gcc_switches:
19648 case OPT_gno_record_gcc_switches:
19649 case OPT__output_pch_:
19650 case OPT_fdiagnostics_show_location_:
19651 case OPT_fdiagnostics_show_option:
19652 case OPT_fdiagnostics_show_caret:
19653 case OPT_fdiagnostics_color_:
19654 case OPT_fverbose_asm:
19655 case OPT____:
19656 case OPT__sysroot_:
19657 case OPT_nostdinc:
19658 case OPT_nostdinc__:
19659 case OPT_fpreprocessed:
19660 case OPT_fltrans_output_list_:
19661 case OPT_fresolution_:
19662 /* Ignore these. */
19663 continue;
19664 default:
19665 if (cl_options[save_decoded_options[j].opt_index].flags
19666 & CL_NO_DWARF_RECORD)
19667 continue;
19668 gcc_checking_assert (save_decoded_options[j].canonical_option[0][0]
19669 == '-');
19670 switch (save_decoded_options[j].canonical_option[0][1])
19672 case 'M':
19673 case 'i':
19674 case 'W':
19675 continue;
19676 case 'f':
19677 if (strncmp (save_decoded_options[j].canonical_option[0] + 2,
19678 "dump", 4) == 0)
19679 continue;
19680 break;
19681 default:
19682 break;
19684 switches.safe_push (save_decoded_options[j].orig_option_with_args_text);
19685 len += strlen (save_decoded_options[j].orig_option_with_args_text) + 1;
19686 break;
19689 producer = XNEWVEC (char, plen + 1 + len + 1);
19690 tail = producer;
19691 sprintf (tail, "%s %s", language_string, version_string);
19692 tail += plen;
19694 FOR_EACH_VEC_ELT (switches, j, p)
19696 len = strlen (p);
19697 *tail = ' ';
19698 memcpy (tail + 1, p, len);
19699 tail += len + 1;
19702 *tail = '\0';
19703 return producer;
19706 /* Given a C and/or C++ language/version string return the "highest".
19707 C++ is assumed to be "higher" than C in this case. Used for merging
19708 LTO translation unit languages. */
19709 static const char *
19710 highest_c_language (const char *lang1, const char *lang2)
19712 if (strcmp ("GNU C++14", lang1) == 0 || strcmp ("GNU C++14", lang2) == 0)
19713 return "GNU C++14";
19714 if (strcmp ("GNU C++11", lang1) == 0 || strcmp ("GNU C++11", lang2) == 0)
19715 return "GNU C++11";
19716 if (strcmp ("GNU C++98", lang1) == 0 || strcmp ("GNU C++98", lang2) == 0)
19717 return "GNU C++98";
19719 if (strcmp ("GNU C11", lang1) == 0 || strcmp ("GNU C11", lang2) == 0)
19720 return "GNU C11";
19721 if (strcmp ("GNU C99", lang1) == 0 || strcmp ("GNU C99", lang2) == 0)
19722 return "GNU C99";
19723 if (strcmp ("GNU C89", lang1) == 0 || strcmp ("GNU C89", lang2) == 0)
19724 return "GNU C89";
19726 gcc_unreachable ();
19730 /* Generate the DIE for the compilation unit. */
19732 static dw_die_ref
19733 gen_compile_unit_die (const char *filename)
19735 dw_die_ref die;
19736 const char *language_string = lang_hooks.name;
19737 int language;
19739 die = new_die (DW_TAG_compile_unit, NULL, NULL);
19741 if (filename)
19743 add_name_attribute (die, filename);
19744 /* Don't add cwd for <built-in>. */
19745 if (!IS_ABSOLUTE_PATH (filename) && filename[0] != '<')
19746 add_comp_dir_attribute (die);
19749 add_AT_string (die, DW_AT_producer, producer_string ? producer_string : "");
19751 /* If our producer is LTO try to figure out a common language to use
19752 from the global list of translation units. */
19753 if (strcmp (language_string, "GNU GIMPLE") == 0)
19755 unsigned i;
19756 tree t;
19757 const char *common_lang = NULL;
19759 FOR_EACH_VEC_SAFE_ELT (all_translation_units, i, t)
19761 if (!TRANSLATION_UNIT_LANGUAGE (t))
19762 continue;
19763 if (!common_lang)
19764 common_lang = TRANSLATION_UNIT_LANGUAGE (t);
19765 else if (strcmp (common_lang, TRANSLATION_UNIT_LANGUAGE (t)) == 0)
19767 else if (strncmp (common_lang, "GNU C", 5) == 0
19768 && strncmp (TRANSLATION_UNIT_LANGUAGE (t), "GNU C", 5) == 0)
19769 /* Mixing C and C++ is ok, use C++ in that case. */
19770 common_lang = highest_c_language (common_lang,
19771 TRANSLATION_UNIT_LANGUAGE (t));
19772 else
19774 /* Fall back to C. */
19775 common_lang = NULL;
19776 break;
19780 if (common_lang)
19781 language_string = common_lang;
19784 language = DW_LANG_C;
19785 if (strncmp (language_string, "GNU C", 5) == 0
19786 && ISDIGIT (language_string[5]))
19788 language = DW_LANG_C89;
19789 if (dwarf_version >= 3 || !dwarf_strict)
19791 if (strcmp (language_string, "GNU C89") != 0)
19792 language = DW_LANG_C99;
19794 if (dwarf_version >= 5 /* || !dwarf_strict */)
19795 if (strcmp (language_string, "GNU C11") == 0)
19796 language = DW_LANG_C11;
19799 else if (strncmp (language_string, "GNU C++", 7) == 0)
19801 language = DW_LANG_C_plus_plus;
19802 if (dwarf_version >= 5 /* || !dwarf_strict */)
19804 if (strcmp (language_string, "GNU C++11") == 0)
19805 language = DW_LANG_C_plus_plus_11;
19806 else if (strcmp (language_string, "GNU C++14") == 0)
19807 language = DW_LANG_C_plus_plus_14;
19810 else if (strcmp (language_string, "GNU F77") == 0)
19811 language = DW_LANG_Fortran77;
19812 else if (strcmp (language_string, "GNU Pascal") == 0)
19813 language = DW_LANG_Pascal83;
19814 else if (dwarf_version >= 3 || !dwarf_strict)
19816 if (strcmp (language_string, "GNU Ada") == 0)
19817 language = DW_LANG_Ada95;
19818 else if (strncmp (language_string, "GNU Fortran", 11) == 0)
19820 language = DW_LANG_Fortran95;
19821 if (dwarf_version >= 5 /* || !dwarf_strict */)
19823 if (strcmp (language_string, "GNU Fortran2003") == 0)
19824 language = DW_LANG_Fortran03;
19825 else if (strcmp (language_string, "GNU Fortran2008") == 0)
19826 language = DW_LANG_Fortran08;
19829 else if (strcmp (language_string, "GNU Java") == 0)
19830 language = DW_LANG_Java;
19831 else if (strcmp (language_string, "GNU Objective-C") == 0)
19832 language = DW_LANG_ObjC;
19833 else if (strcmp (language_string, "GNU Objective-C++") == 0)
19834 language = DW_LANG_ObjC_plus_plus;
19835 else if (dwarf_version >= 5 || !dwarf_strict)
19837 if (strcmp (language_string, "GNU Go") == 0)
19838 language = DW_LANG_Go;
19841 /* Use a degraded Fortran setting in strict DWARF2 so is_fortran works. */
19842 else if (strncmp (language_string, "GNU Fortran", 11) == 0)
19843 language = DW_LANG_Fortran90;
19845 add_AT_unsigned (die, DW_AT_language, language);
19847 switch (language)
19849 case DW_LANG_Fortran77:
19850 case DW_LANG_Fortran90:
19851 case DW_LANG_Fortran95:
19852 case DW_LANG_Fortran03:
19853 case DW_LANG_Fortran08:
19854 /* Fortran has case insensitive identifiers and the front-end
19855 lowercases everything. */
19856 add_AT_unsigned (die, DW_AT_identifier_case, DW_ID_down_case);
19857 break;
19858 default:
19859 /* The default DW_ID_case_sensitive doesn't need to be specified. */
19860 break;
19862 return die;
19865 /* Generate the DIE for a base class. */
19867 static void
19868 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
19870 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
19872 add_type_attribute (die, BINFO_TYPE (binfo), TYPE_UNQUALIFIED, context_die);
19873 add_data_member_location_attribute (die, binfo);
19875 if (BINFO_VIRTUAL_P (binfo))
19876 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
19878 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
19879 children, otherwise the default is DW_ACCESS_public. In DWARF2
19880 the default has always been DW_ACCESS_private. */
19881 if (access == access_public_node)
19883 if (dwarf_version == 2
19884 || context_die->die_tag == DW_TAG_class_type)
19885 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
19887 else if (access == access_protected_node)
19888 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
19889 else if (dwarf_version > 2
19890 && context_die->die_tag != DW_TAG_class_type)
19891 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_private);
19894 /* Generate a DIE for a class member. */
19896 static void
19897 gen_member_die (tree type, dw_die_ref context_die)
19899 tree member;
19900 tree binfo = TYPE_BINFO (type);
19901 dw_die_ref child;
19903 /* If this is not an incomplete type, output descriptions of each of its
19904 members. Note that as we output the DIEs necessary to represent the
19905 members of this record or union type, we will also be trying to output
19906 DIEs to represent the *types* of those members. However the `type'
19907 function (above) will specifically avoid generating type DIEs for member
19908 types *within* the list of member DIEs for this (containing) type except
19909 for those types (of members) which are explicitly marked as also being
19910 members of this (containing) type themselves. The g++ front- end can
19911 force any given type to be treated as a member of some other (containing)
19912 type by setting the TYPE_CONTEXT of the given (member) type to point to
19913 the TREE node representing the appropriate (containing) type. */
19915 /* First output info about the base classes. */
19916 if (binfo)
19918 vec<tree, va_gc> *accesses = BINFO_BASE_ACCESSES (binfo);
19919 int i;
19920 tree base;
19922 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
19923 gen_inheritance_die (base,
19924 (accesses ? (*accesses)[i] : access_public_node),
19925 context_die);
19928 /* Now output info about the data members and type members. */
19929 for (member = TYPE_FIELDS (type); member; member = DECL_CHAIN (member))
19931 /* If we thought we were generating minimal debug info for TYPE
19932 and then changed our minds, some of the member declarations
19933 may have already been defined. Don't define them again, but
19934 do put them in the right order. */
19936 child = lookup_decl_die (member);
19937 if (child)
19938 splice_child_die (context_die, child);
19939 else
19940 gen_decl_die (member, NULL, context_die);
19943 /* Now output info about the function members (if any). */
19944 for (member = TYPE_METHODS (type); member; member = DECL_CHAIN (member))
19946 /* Don't include clones in the member list. */
19947 if (DECL_ABSTRACT_ORIGIN (member))
19948 continue;
19950 child = lookup_decl_die (member);
19951 if (child)
19952 splice_child_die (context_die, child);
19953 else
19954 gen_decl_die (member, NULL, context_die);
19958 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
19959 is set, we pretend that the type was never defined, so we only get the
19960 member DIEs needed by later specification DIEs. */
19962 static void
19963 gen_struct_or_union_type_die (tree type, dw_die_ref context_die,
19964 enum debug_info_usage usage)
19966 dw_die_ref type_die = lookup_type_die (type);
19967 dw_die_ref scope_die = 0;
19968 int nested = 0;
19969 int complete = (TYPE_SIZE (type)
19970 && (! TYPE_STUB_DECL (type)
19971 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
19972 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
19973 complete = complete && should_emit_struct_debug (type, usage);
19975 if (type_die && ! complete)
19976 return;
19978 if (TYPE_CONTEXT (type) != NULL_TREE
19979 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
19980 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
19981 nested = 1;
19983 scope_die = scope_die_for (type, context_die);
19985 /* Generate child dies for template paramaters. */
19986 if (!type_die && debug_info_level > DINFO_LEVEL_TERSE)
19987 schedule_generic_params_dies_gen (type);
19989 if (! type_die || (nested && is_cu_die (scope_die)))
19990 /* First occurrence of type or toplevel definition of nested class. */
19992 dw_die_ref old_die = type_die;
19994 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
19995 ? record_type_tag (type) : DW_TAG_union_type,
19996 scope_die, type);
19997 equate_type_number_to_die (type, type_die);
19998 if (old_die)
19999 add_AT_specification (type_die, old_die);
20000 else
20001 add_name_attribute (type_die, type_tag (type));
20003 else
20004 remove_AT (type_die, DW_AT_declaration);
20006 /* If this type has been completed, then give it a byte_size attribute and
20007 then give a list of members. */
20008 if (complete && !ns_decl)
20010 /* Prevent infinite recursion in cases where the type of some member of
20011 this type is expressed in terms of this type itself. */
20012 TREE_ASM_WRITTEN (type) = 1;
20013 add_byte_size_attribute (type_die, type);
20014 if (TYPE_STUB_DECL (type) != NULL_TREE)
20016 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
20017 add_accessibility_attribute (type_die, TYPE_STUB_DECL (type));
20020 /* If the first reference to this type was as the return type of an
20021 inline function, then it may not have a parent. Fix this now. */
20022 if (type_die->die_parent == NULL)
20023 add_child_die (scope_die, type_die);
20025 push_decl_scope (type);
20026 gen_member_die (type, type_die);
20027 pop_decl_scope ();
20029 add_gnat_descriptive_type_attribute (type_die, type, context_die);
20030 if (TYPE_ARTIFICIAL (type))
20031 add_AT_flag (type_die, DW_AT_artificial, 1);
20033 /* GNU extension: Record what type our vtable lives in. */
20034 if (TYPE_VFIELD (type))
20036 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
20038 gen_type_die (vtype, context_die);
20039 add_AT_die_ref (type_die, DW_AT_containing_type,
20040 lookup_type_die (vtype));
20043 else
20045 add_AT_flag (type_die, DW_AT_declaration, 1);
20047 /* We don't need to do this for function-local types. */
20048 if (TYPE_STUB_DECL (type)
20049 && ! decl_function_context (TYPE_STUB_DECL (type)))
20050 vec_safe_push (incomplete_types, type);
20053 if (get_AT (type_die, DW_AT_name))
20054 add_pubtype (type, type_die);
20057 /* Generate a DIE for a subroutine _type_. */
20059 static void
20060 gen_subroutine_type_die (tree type, dw_die_ref context_die)
20062 tree return_type = TREE_TYPE (type);
20063 dw_die_ref subr_die
20064 = new_die (DW_TAG_subroutine_type,
20065 scope_die_for (type, context_die), type);
20067 equate_type_number_to_die (type, subr_die);
20068 add_prototyped_attribute (subr_die, type);
20069 add_type_attribute (subr_die, return_type, TYPE_UNQUALIFIED, context_die);
20070 gen_formal_types_die (type, subr_die);
20072 if (get_AT (subr_die, DW_AT_name))
20073 add_pubtype (type, subr_die);
20076 /* Generate a DIE for a type definition. */
20078 static void
20079 gen_typedef_die (tree decl, dw_die_ref context_die)
20081 dw_die_ref type_die;
20082 tree origin;
20084 if (TREE_ASM_WRITTEN (decl))
20085 return;
20087 TREE_ASM_WRITTEN (decl) = 1;
20088 type_die = new_die (DW_TAG_typedef, context_die, decl);
20089 origin = decl_ultimate_origin (decl);
20090 if (origin != NULL)
20091 add_abstract_origin_attribute (type_die, origin);
20092 else
20094 tree type;
20096 add_name_and_src_coords_attributes (type_die, decl);
20097 if (DECL_ORIGINAL_TYPE (decl))
20099 type = DECL_ORIGINAL_TYPE (decl);
20101 gcc_assert (type != TREE_TYPE (decl));
20102 equate_type_number_to_die (TREE_TYPE (decl), type_die);
20104 else
20106 type = TREE_TYPE (decl);
20108 if (is_naming_typedef_decl (TYPE_NAME (type)))
20110 /* Here, we are in the case of decl being a typedef naming
20111 an anonymous type, e.g:
20112 typedef struct {...} foo;
20113 In that case TREE_TYPE (decl) is not a typedef variant
20114 type and TYPE_NAME of the anonymous type is set to the
20115 TYPE_DECL of the typedef. This construct is emitted by
20116 the C++ FE.
20118 TYPE is the anonymous struct named by the typedef
20119 DECL. As we need the DW_AT_type attribute of the
20120 DW_TAG_typedef to point to the DIE of TYPE, let's
20121 generate that DIE right away. add_type_attribute
20122 called below will then pick (via lookup_type_die) that
20123 anonymous struct DIE. */
20124 if (!TREE_ASM_WRITTEN (type))
20125 gen_tagged_type_die (type, context_die, DINFO_USAGE_DIR_USE);
20127 /* This is a GNU Extension. We are adding a
20128 DW_AT_linkage_name attribute to the DIE of the
20129 anonymous struct TYPE. The value of that attribute
20130 is the name of the typedef decl naming the anonymous
20131 struct. This greatly eases the work of consumers of
20132 this debug info. */
20133 add_linkage_attr (lookup_type_die (type), decl);
20137 add_type_attribute (type_die, type, decl_quals (decl), context_die);
20139 if (is_naming_typedef_decl (decl))
20140 /* We want that all subsequent calls to lookup_type_die with
20141 TYPE in argument yield the DW_TAG_typedef we have just
20142 created. */
20143 equate_type_number_to_die (type, type_die);
20145 add_accessibility_attribute (type_die, decl);
20148 if (DECL_ABSTRACT_P (decl))
20149 equate_decl_number_to_die (decl, type_die);
20151 if (get_AT (type_die, DW_AT_name))
20152 add_pubtype (decl, type_die);
20155 /* Generate a DIE for a struct, class, enum or union type. */
20157 static void
20158 gen_tagged_type_die (tree type,
20159 dw_die_ref context_die,
20160 enum debug_info_usage usage)
20162 int need_pop;
20164 if (type == NULL_TREE
20165 || !is_tagged_type (type))
20166 return;
20168 /* If this is a nested type whose containing class hasn't been written
20169 out yet, writing it out will cover this one, too. This does not apply
20170 to instantiations of member class templates; they need to be added to
20171 the containing class as they are generated. FIXME: This hurts the
20172 idea of combining type decls from multiple TUs, since we can't predict
20173 what set of template instantiations we'll get. */
20174 if (TYPE_CONTEXT (type)
20175 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
20176 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
20178 gen_type_die_with_usage (TYPE_CONTEXT (type), context_die, usage);
20180 if (TREE_ASM_WRITTEN (type))
20181 return;
20183 /* If that failed, attach ourselves to the stub. */
20184 push_decl_scope (TYPE_CONTEXT (type));
20185 context_die = lookup_type_die (TYPE_CONTEXT (type));
20186 need_pop = 1;
20188 else if (TYPE_CONTEXT (type) != NULL_TREE
20189 && (TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL))
20191 /* If this type is local to a function that hasn't been written
20192 out yet, use a NULL context for now; it will be fixed up in
20193 decls_for_scope. */
20194 context_die = lookup_decl_die (TYPE_CONTEXT (type));
20195 /* A declaration DIE doesn't count; nested types need to go in the
20196 specification. */
20197 if (context_die && is_declaration_die (context_die))
20198 context_die = NULL;
20199 need_pop = 0;
20201 else
20203 context_die = declare_in_namespace (type, context_die);
20204 need_pop = 0;
20207 if (TREE_CODE (type) == ENUMERAL_TYPE)
20209 /* This might have been written out by the call to
20210 declare_in_namespace. */
20211 if (!TREE_ASM_WRITTEN (type))
20212 gen_enumeration_type_die (type, context_die);
20214 else
20215 gen_struct_or_union_type_die (type, context_die, usage);
20217 if (need_pop)
20218 pop_decl_scope ();
20220 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
20221 it up if it is ever completed. gen_*_type_die will set it for us
20222 when appropriate. */
20225 /* Generate a type description DIE. */
20227 static void
20228 gen_type_die_with_usage (tree type, dw_die_ref context_die,
20229 enum debug_info_usage usage)
20231 struct array_descr_info info;
20233 if (type == NULL_TREE || type == error_mark_node)
20234 return;
20236 if (TYPE_NAME (type) != NULL_TREE
20237 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
20238 && is_redundant_typedef (TYPE_NAME (type))
20239 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
20240 /* The DECL of this type is a typedef we don't want to emit debug
20241 info for but we want debug info for its underlying typedef.
20242 This can happen for e.g, the injected-class-name of a C++
20243 type. */
20244 type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
20246 /* If TYPE is a typedef type variant, let's generate debug info
20247 for the parent typedef which TYPE is a type of. */
20248 if (typedef_variant_p (type))
20250 if (TREE_ASM_WRITTEN (type))
20251 return;
20253 /* Prevent broken recursion; we can't hand off to the same type. */
20254 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
20256 /* Give typedefs the right scope. */
20257 context_die = scope_die_for (type, context_die);
20259 TREE_ASM_WRITTEN (type) = 1;
20261 gen_decl_die (TYPE_NAME (type), NULL, context_die);
20262 return;
20265 /* If type is an anonymous tagged type named by a typedef, let's
20266 generate debug info for the typedef. */
20267 if (is_naming_typedef_decl (TYPE_NAME (type)))
20269 /* Use the DIE of the containing namespace as the parent DIE of
20270 the type description DIE we want to generate. */
20271 if (DECL_CONTEXT (TYPE_NAME (type))
20272 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type))) == NAMESPACE_DECL)
20273 context_die = get_context_die (DECL_CONTEXT (TYPE_NAME (type)));
20275 gen_decl_die (TYPE_NAME (type), NULL, context_die);
20276 return;
20279 /* We are going to output a DIE to represent the unqualified version
20280 of this type (i.e. without any const or volatile qualifiers) so
20281 get the main variant (i.e. the unqualified version) of this type
20282 now. (Vectors are special because the debugging info is in the
20283 cloned type itself). */
20284 if (TREE_CODE (type) != VECTOR_TYPE)
20285 type = type_main_variant (type);
20287 /* If this is an array type with hidden descriptor, handle it first. */
20288 if (!TREE_ASM_WRITTEN (type)
20289 && lang_hooks.types.get_array_descr_info)
20291 memset (&info, 0, sizeof (info));
20292 if (lang_hooks.types.get_array_descr_info (type, &info))
20294 gen_descr_array_type_die (type, &info, context_die);
20295 TREE_ASM_WRITTEN (type) = 1;
20296 return;
20300 if (TREE_ASM_WRITTEN (type))
20301 return;
20303 switch (TREE_CODE (type))
20305 case ERROR_MARK:
20306 break;
20308 case POINTER_TYPE:
20309 case REFERENCE_TYPE:
20310 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
20311 ensures that the gen_type_die recursion will terminate even if the
20312 type is recursive. Recursive types are possible in Ada. */
20313 /* ??? We could perhaps do this for all types before the switch
20314 statement. */
20315 TREE_ASM_WRITTEN (type) = 1;
20317 /* For these types, all that is required is that we output a DIE (or a
20318 set of DIEs) to represent the "basis" type. */
20319 gen_type_die_with_usage (TREE_TYPE (type), context_die,
20320 DINFO_USAGE_IND_USE);
20321 break;
20323 case OFFSET_TYPE:
20324 /* This code is used for C++ pointer-to-data-member types.
20325 Output a description of the relevant class type. */
20326 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type), context_die,
20327 DINFO_USAGE_IND_USE);
20329 /* Output a description of the type of the object pointed to. */
20330 gen_type_die_with_usage (TREE_TYPE (type), context_die,
20331 DINFO_USAGE_IND_USE);
20333 /* Now output a DIE to represent this pointer-to-data-member type
20334 itself. */
20335 gen_ptr_to_mbr_type_die (type, context_die);
20336 break;
20338 case FUNCTION_TYPE:
20339 /* Force out return type (in case it wasn't forced out already). */
20340 gen_type_die_with_usage (TREE_TYPE (type), context_die,
20341 DINFO_USAGE_DIR_USE);
20342 gen_subroutine_type_die (type, context_die);
20343 break;
20345 case METHOD_TYPE:
20346 /* Force out return type (in case it wasn't forced out already). */
20347 gen_type_die_with_usage (TREE_TYPE (type), context_die,
20348 DINFO_USAGE_DIR_USE);
20349 gen_subroutine_type_die (type, context_die);
20350 break;
20352 case ARRAY_TYPE:
20353 gen_array_type_die (type, context_die);
20354 break;
20356 case VECTOR_TYPE:
20357 gen_array_type_die (type, context_die);
20358 break;
20360 case ENUMERAL_TYPE:
20361 case RECORD_TYPE:
20362 case UNION_TYPE:
20363 case QUAL_UNION_TYPE:
20364 gen_tagged_type_die (type, context_die, usage);
20365 return;
20367 case VOID_TYPE:
20368 case INTEGER_TYPE:
20369 case REAL_TYPE:
20370 case FIXED_POINT_TYPE:
20371 case COMPLEX_TYPE:
20372 case BOOLEAN_TYPE:
20373 case POINTER_BOUNDS_TYPE:
20374 /* No DIEs needed for fundamental types. */
20375 break;
20377 case NULLPTR_TYPE:
20378 case LANG_TYPE:
20379 /* Just use DW_TAG_unspecified_type. */
20381 dw_die_ref type_die = lookup_type_die (type);
20382 if (type_die == NULL)
20384 tree name = TYPE_IDENTIFIER (type);
20385 type_die = new_die (DW_TAG_unspecified_type, comp_unit_die (),
20386 type);
20387 add_name_attribute (type_die, IDENTIFIER_POINTER (name));
20388 equate_type_number_to_die (type, type_die);
20391 break;
20393 default:
20394 if (is_cxx_auto (type))
20396 tree name = TYPE_IDENTIFIER (type);
20397 dw_die_ref *die = (name == get_identifier ("auto")
20398 ? &auto_die : &decltype_auto_die);
20399 if (!*die)
20401 *die = new_die (DW_TAG_unspecified_type,
20402 comp_unit_die (), NULL_TREE);
20403 add_name_attribute (*die, IDENTIFIER_POINTER (name));
20405 equate_type_number_to_die (type, *die);
20406 break;
20408 gcc_unreachable ();
20411 TREE_ASM_WRITTEN (type) = 1;
20414 static void
20415 gen_type_die (tree type, dw_die_ref context_die)
20417 gen_type_die_with_usage (type, context_die, DINFO_USAGE_DIR_USE);
20420 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
20421 things which are local to the given block. */
20423 static void
20424 gen_block_die (tree stmt, dw_die_ref context_die)
20426 int must_output_die = 0;
20427 bool inlined_func;
20429 /* Ignore blocks that are NULL. */
20430 if (stmt == NULL_TREE)
20431 return;
20433 inlined_func = inlined_function_outer_scope_p (stmt);
20435 /* If the block is one fragment of a non-contiguous block, do not
20436 process the variables, since they will have been done by the
20437 origin block. Do process subblocks. */
20438 if (BLOCK_FRAGMENT_ORIGIN (stmt))
20440 tree sub;
20442 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
20443 gen_block_die (sub, context_die);
20445 return;
20448 /* Determine if we need to output any Dwarf DIEs at all to represent this
20449 block. */
20450 if (inlined_func)
20451 /* The outer scopes for inlinings *must* always be represented. We
20452 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
20453 must_output_die = 1;
20454 else
20456 /* Determine if this block directly contains any "significant"
20457 local declarations which we will need to output DIEs for. */
20458 if (debug_info_level > DINFO_LEVEL_TERSE)
20459 /* We are not in terse mode so *any* local declaration counts
20460 as being a "significant" one. */
20461 must_output_die = ((BLOCK_VARS (stmt) != NULL
20462 || BLOCK_NUM_NONLOCALIZED_VARS (stmt))
20463 && (TREE_USED (stmt)
20464 || TREE_ASM_WRITTEN (stmt)
20465 || BLOCK_ABSTRACT (stmt)));
20466 else if ((TREE_USED (stmt)
20467 || TREE_ASM_WRITTEN (stmt)
20468 || BLOCK_ABSTRACT (stmt))
20469 && !dwarf2out_ignore_block (stmt))
20470 must_output_die = 1;
20473 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
20474 DIE for any block which contains no significant local declarations at
20475 all. Rather, in such cases we just call `decls_for_scope' so that any
20476 needed Dwarf info for any sub-blocks will get properly generated. Note
20477 that in terse mode, our definition of what constitutes a "significant"
20478 local declaration gets restricted to include only inlined function
20479 instances and local (nested) function definitions. */
20480 if (must_output_die)
20482 if (inlined_func)
20484 /* If STMT block is abstract, that means we have been called
20485 indirectly from dwarf2out_abstract_function.
20486 That function rightfully marks the descendent blocks (of
20487 the abstract function it is dealing with) as being abstract,
20488 precisely to prevent us from emitting any
20489 DW_TAG_inlined_subroutine DIE as a descendent
20490 of an abstract function instance. So in that case, we should
20491 not call gen_inlined_subroutine_die.
20493 Later though, when cgraph asks dwarf2out to emit info
20494 for the concrete instance of the function decl into which
20495 the concrete instance of STMT got inlined, the later will lead
20496 to the generation of a DW_TAG_inlined_subroutine DIE. */
20497 if (! BLOCK_ABSTRACT (stmt))
20498 gen_inlined_subroutine_die (stmt, context_die);
20500 else
20501 gen_lexical_block_die (stmt, context_die);
20503 else
20504 decls_for_scope (stmt, context_die);
20507 /* Process variable DECL (or variable with origin ORIGIN) within
20508 block STMT and add it to CONTEXT_DIE. */
20509 static void
20510 process_scope_var (tree stmt, tree decl, tree origin, dw_die_ref context_die)
20512 dw_die_ref die;
20513 tree decl_or_origin = decl ? decl : origin;
20515 if (TREE_CODE (decl_or_origin) == FUNCTION_DECL)
20516 die = lookup_decl_die (decl_or_origin);
20517 else if (TREE_CODE (decl_or_origin) == TYPE_DECL
20518 && TYPE_DECL_IS_STUB (decl_or_origin))
20519 die = lookup_type_die (TREE_TYPE (decl_or_origin));
20520 else
20521 die = NULL;
20523 if (die != NULL && die->die_parent == NULL)
20524 add_child_die (context_die, die);
20525 else if (TREE_CODE (decl_or_origin) == IMPORTED_DECL)
20526 dwarf2out_imported_module_or_decl_1 (decl_or_origin, DECL_NAME (decl_or_origin),
20527 stmt, context_die);
20528 else
20529 gen_decl_die (decl, origin, context_die);
20532 /* Generate all of the decls declared within a given scope and (recursively)
20533 all of its sub-blocks. */
20535 static void
20536 decls_for_scope (tree stmt, dw_die_ref context_die)
20538 tree decl;
20539 unsigned int i;
20540 tree subblocks;
20542 /* Ignore NULL blocks. */
20543 if (stmt == NULL_TREE)
20544 return;
20546 /* Output the DIEs to represent all of the data objects and typedefs
20547 declared directly within this block but not within any nested
20548 sub-blocks. Also, nested function and tag DIEs have been
20549 generated with a parent of NULL; fix that up now. We don't
20550 have to do this if we're at -g1. */
20551 if (debug_info_level > DINFO_LEVEL_TERSE)
20553 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = DECL_CHAIN (decl))
20554 process_scope_var (stmt, decl, NULL_TREE, context_die);
20555 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (stmt); i++)
20556 process_scope_var (stmt, NULL, BLOCK_NONLOCALIZED_VAR (stmt, i),
20557 context_die);
20560 /* Even if we're at -g1, we need to process the subblocks in order to get
20561 inlined call information. */
20563 /* Output the DIEs to represent all sub-blocks (and the items declared
20564 therein) of this block. */
20565 for (subblocks = BLOCK_SUBBLOCKS (stmt);
20566 subblocks != NULL;
20567 subblocks = BLOCK_CHAIN (subblocks))
20568 gen_block_die (subblocks, context_die);
20571 /* Is this a typedef we can avoid emitting? */
20573 static inline int
20574 is_redundant_typedef (const_tree decl)
20576 if (TYPE_DECL_IS_STUB (decl))
20577 return 1;
20579 if (DECL_ARTIFICIAL (decl)
20580 && DECL_CONTEXT (decl)
20581 && is_tagged_type (DECL_CONTEXT (decl))
20582 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
20583 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
20584 /* Also ignore the artificial member typedef for the class name. */
20585 return 1;
20587 return 0;
20590 /* Return TRUE if TYPE is a typedef that names a type for linkage
20591 purposes. This kind of typedefs is produced by the C++ FE for
20592 constructs like:
20594 typedef struct {...} foo;
20596 In that case, there is no typedef variant type produced for foo.
20597 Rather, the TREE_TYPE of the TYPE_DECL of foo is the anonymous
20598 struct type. */
20600 static bool
20601 is_naming_typedef_decl (const_tree decl)
20603 if (decl == NULL_TREE
20604 || TREE_CODE (decl) != TYPE_DECL
20605 || !is_tagged_type (TREE_TYPE (decl))
20606 || DECL_IS_BUILTIN (decl)
20607 || is_redundant_typedef (decl)
20608 /* It looks like Ada produces TYPE_DECLs that are very similar
20609 to C++ naming typedefs but that have different
20610 semantics. Let's be specific to c++ for now. */
20611 || !is_cxx ())
20612 return FALSE;
20614 return (DECL_ORIGINAL_TYPE (decl) == NULL_TREE
20615 && TYPE_NAME (TREE_TYPE (decl)) == decl
20616 && (TYPE_STUB_DECL (TREE_TYPE (decl))
20617 != TYPE_NAME (TREE_TYPE (decl))));
20620 /* Returns the DIE for a context. */
20622 static inline dw_die_ref
20623 get_context_die (tree context)
20625 if (context)
20627 /* Find die that represents this context. */
20628 if (TYPE_P (context))
20630 context = TYPE_MAIN_VARIANT (context);
20631 return strip_naming_typedef (context, force_type_die (context));
20633 else
20634 return force_decl_die (context);
20636 return comp_unit_die ();
20639 /* Returns the DIE for decl. A DIE will always be returned. */
20641 static dw_die_ref
20642 force_decl_die (tree decl)
20644 dw_die_ref decl_die;
20645 unsigned saved_external_flag;
20646 tree save_fn = NULL_TREE;
20647 decl_die = lookup_decl_die (decl);
20648 if (!decl_die)
20650 dw_die_ref context_die = get_context_die (DECL_CONTEXT (decl));
20652 decl_die = lookup_decl_die (decl);
20653 if (decl_die)
20654 return decl_die;
20656 switch (TREE_CODE (decl))
20658 case FUNCTION_DECL:
20659 /* Clear current_function_decl, so that gen_subprogram_die thinks
20660 that this is a declaration. At this point, we just want to force
20661 declaration die. */
20662 save_fn = current_function_decl;
20663 current_function_decl = NULL_TREE;
20664 gen_subprogram_die (decl, context_die);
20665 current_function_decl = save_fn;
20666 break;
20668 case VAR_DECL:
20669 /* Set external flag to force declaration die. Restore it after
20670 gen_decl_die() call. */
20671 saved_external_flag = DECL_EXTERNAL (decl);
20672 DECL_EXTERNAL (decl) = 1;
20673 gen_decl_die (decl, NULL, context_die);
20674 DECL_EXTERNAL (decl) = saved_external_flag;
20675 break;
20677 case NAMESPACE_DECL:
20678 if (dwarf_version >= 3 || !dwarf_strict)
20679 dwarf2out_decl (decl);
20680 else
20681 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */
20682 decl_die = comp_unit_die ();
20683 break;
20685 case TRANSLATION_UNIT_DECL:
20686 decl_die = comp_unit_die ();
20687 break;
20689 default:
20690 gcc_unreachable ();
20693 /* We should be able to find the DIE now. */
20694 if (!decl_die)
20695 decl_die = lookup_decl_die (decl);
20696 gcc_assert (decl_die);
20699 return decl_die;
20702 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
20703 always returned. */
20705 static dw_die_ref
20706 force_type_die (tree type)
20708 dw_die_ref type_die;
20710 type_die = lookup_type_die (type);
20711 if (!type_die)
20713 dw_die_ref context_die = get_context_die (TYPE_CONTEXT (type));
20715 type_die = modified_type_die (type, TYPE_QUALS_NO_ADDR_SPACE (type),
20716 context_die);
20717 gcc_assert (type_die);
20719 return type_die;
20722 /* Force out any required namespaces to be able to output DECL,
20723 and return the new context_die for it, if it's changed. */
20725 static dw_die_ref
20726 setup_namespace_context (tree thing, dw_die_ref context_die)
20728 tree context = (DECL_P (thing)
20729 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
20730 if (context && TREE_CODE (context) == NAMESPACE_DECL)
20731 /* Force out the namespace. */
20732 context_die = force_decl_die (context);
20734 return context_die;
20737 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
20738 type) within its namespace, if appropriate.
20740 For compatibility with older debuggers, namespace DIEs only contain
20741 declarations; all definitions are emitted at CU scope. */
20743 static dw_die_ref
20744 declare_in_namespace (tree thing, dw_die_ref context_die)
20746 dw_die_ref ns_context;
20748 if (debug_info_level <= DINFO_LEVEL_TERSE)
20749 return context_die;
20751 /* External declarations in the local scope only need to be emitted
20752 once, not once in the namespace and once in the scope.
20754 This avoids declaring the `extern' below in the
20755 namespace DIE as well as in the innermost scope:
20757 namespace S
20759 int i=5;
20760 int foo()
20762 int i=8;
20763 extern int i;
20764 return i;
20768 if (DECL_P (thing) && DECL_EXTERNAL (thing) && local_scope_p (context_die))
20769 return context_die;
20771 /* If this decl is from an inlined function, then don't try to emit it in its
20772 namespace, as we will get confused. It would have already been emitted
20773 when the abstract instance of the inline function was emitted anyways. */
20774 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
20775 return context_die;
20777 ns_context = setup_namespace_context (thing, context_die);
20779 if (ns_context != context_die)
20781 if (is_fortran ())
20782 return ns_context;
20783 if (DECL_P (thing))
20784 gen_decl_die (thing, NULL, ns_context);
20785 else
20786 gen_type_die (thing, ns_context);
20788 return context_die;
20791 /* Generate a DIE for a namespace or namespace alias. */
20793 static void
20794 gen_namespace_die (tree decl, dw_die_ref context_die)
20796 dw_die_ref namespace_die;
20798 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
20799 they are an alias of. */
20800 if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
20802 /* Output a real namespace or module. */
20803 context_die = setup_namespace_context (decl, comp_unit_die ());
20804 namespace_die = new_die (is_fortran ()
20805 ? DW_TAG_module : DW_TAG_namespace,
20806 context_die, decl);
20807 /* For Fortran modules defined in different CU don't add src coords. */
20808 if (namespace_die->die_tag == DW_TAG_module && DECL_EXTERNAL (decl))
20810 const char *name = dwarf2_name (decl, 0);
20811 if (name)
20812 add_name_attribute (namespace_die, name);
20814 else
20815 add_name_and_src_coords_attributes (namespace_die, decl);
20816 if (DECL_EXTERNAL (decl))
20817 add_AT_flag (namespace_die, DW_AT_declaration, 1);
20818 equate_decl_number_to_die (decl, namespace_die);
20820 else
20822 /* Output a namespace alias. */
20824 /* Force out the namespace we are an alias of, if necessary. */
20825 dw_die_ref origin_die
20826 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
20828 if (DECL_FILE_SCOPE_P (decl)
20829 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
20830 context_die = setup_namespace_context (decl, comp_unit_die ());
20831 /* Now create the namespace alias DIE. */
20832 namespace_die = new_die (DW_TAG_imported_declaration, context_die, decl);
20833 add_name_and_src_coords_attributes (namespace_die, decl);
20834 add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
20835 equate_decl_number_to_die (decl, namespace_die);
20837 /* Bypass dwarf2_name's check for DECL_NAMELESS. */
20838 if (want_pubnames ())
20839 add_pubname_string (lang_hooks.dwarf_name (decl, 1), namespace_die);
20842 /* Generate Dwarf debug information for a decl described by DECL.
20843 The return value is currently only meaningful for PARM_DECLs,
20844 for all other decls it returns NULL. */
20846 static dw_die_ref
20847 gen_decl_die (tree decl, tree origin, dw_die_ref context_die)
20849 tree decl_or_origin = decl ? decl : origin;
20850 tree class_origin = NULL, ultimate_origin;
20852 if (DECL_P (decl_or_origin) && DECL_IGNORED_P (decl_or_origin))
20853 return NULL;
20855 /* Ignore pointer bounds decls. */
20856 if (DECL_P (decl_or_origin)
20857 && TREE_TYPE (decl_or_origin)
20858 && POINTER_BOUNDS_P (decl_or_origin))
20859 return NULL;
20861 switch (TREE_CODE (decl_or_origin))
20863 case ERROR_MARK:
20864 break;
20866 case CONST_DECL:
20867 if (!is_fortran () && !is_ada ())
20869 /* The individual enumerators of an enum type get output when we output
20870 the Dwarf representation of the relevant enum type itself. */
20871 break;
20874 /* Emit its type. */
20875 gen_type_die (TREE_TYPE (decl), context_die);
20877 /* And its containing namespace. */
20878 context_die = declare_in_namespace (decl, context_die);
20880 gen_const_die (decl, context_die);
20881 break;
20883 case FUNCTION_DECL:
20884 /* Don't output any DIEs to represent mere function declarations,
20885 unless they are class members or explicit block externs. */
20886 if (DECL_INITIAL (decl_or_origin) == NULL_TREE
20887 && DECL_FILE_SCOPE_P (decl_or_origin)
20888 && (current_function_decl == NULL_TREE
20889 || DECL_ARTIFICIAL (decl_or_origin)))
20890 break;
20892 #if 0
20893 /* FIXME */
20894 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
20895 on local redeclarations of global functions. That seems broken. */
20896 if (current_function_decl != decl)
20897 /* This is only a declaration. */;
20898 #endif
20900 /* If we're emitting a clone, emit info for the abstract instance. */
20901 if (origin || DECL_ORIGIN (decl) != decl)
20902 dwarf2out_abstract_function (origin
20903 ? DECL_ORIGIN (origin)
20904 : DECL_ABSTRACT_ORIGIN (decl));
20906 /* If we're emitting an out-of-line copy of an inline function,
20907 emit info for the abstract instance and set up to refer to it. */
20908 else if (cgraph_function_possibly_inlined_p (decl)
20909 && ! DECL_ABSTRACT_P (decl)
20910 && ! class_or_namespace_scope_p (context_die)
20911 /* dwarf2out_abstract_function won't emit a die if this is just
20912 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
20913 that case, because that works only if we have a die. */
20914 && DECL_INITIAL (decl) != NULL_TREE)
20916 dwarf2out_abstract_function (decl);
20917 set_decl_origin_self (decl);
20920 /* Otherwise we're emitting the primary DIE for this decl. */
20921 else if (debug_info_level > DINFO_LEVEL_TERSE)
20923 /* Before we describe the FUNCTION_DECL itself, make sure that we
20924 have its containing type. */
20925 if (!origin)
20926 origin = decl_class_context (decl);
20927 if (origin != NULL_TREE)
20928 gen_type_die (origin, context_die);
20930 /* And its return type. */
20931 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
20933 /* And its virtual context. */
20934 if (DECL_VINDEX (decl) != NULL_TREE)
20935 gen_type_die (DECL_CONTEXT (decl), context_die);
20937 /* Make sure we have a member DIE for decl. */
20938 if (origin != NULL_TREE)
20939 gen_type_die_for_member (origin, decl, context_die);
20941 /* And its containing namespace. */
20942 context_die = declare_in_namespace (decl, context_die);
20945 /* Now output a DIE to represent the function itself. */
20946 if (decl)
20947 gen_subprogram_die (decl, context_die);
20948 break;
20950 case TYPE_DECL:
20951 /* If we are in terse mode, don't generate any DIEs to represent any
20952 actual typedefs. */
20953 if (debug_info_level <= DINFO_LEVEL_TERSE)
20954 break;
20956 /* In the special case of a TYPE_DECL node representing the declaration
20957 of some type tag, if the given TYPE_DECL is marked as having been
20958 instantiated from some other (original) TYPE_DECL node (e.g. one which
20959 was generated within the original definition of an inline function) we
20960 used to generate a special (abbreviated) DW_TAG_structure_type,
20961 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
20962 should be actually referencing those DIEs, as variable DIEs with that
20963 type would be emitted already in the abstract origin, so it was always
20964 removed during unused type prunning. Don't add anything in this
20965 case. */
20966 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
20967 break;
20969 if (is_redundant_typedef (decl))
20970 gen_type_die (TREE_TYPE (decl), context_die);
20971 else
20972 /* Output a DIE to represent the typedef itself. */
20973 gen_typedef_die (decl, context_die);
20974 break;
20976 case LABEL_DECL:
20977 if (debug_info_level >= DINFO_LEVEL_NORMAL)
20978 gen_label_die (decl, context_die);
20979 break;
20981 case VAR_DECL:
20982 case RESULT_DECL:
20983 /* If we are in terse mode, don't generate any DIEs to represent any
20984 variable declarations or definitions. */
20985 if (debug_info_level <= DINFO_LEVEL_TERSE)
20986 break;
20988 /* Output any DIEs that are needed to specify the type of this data
20989 object. */
20990 if (decl_by_reference_p (decl_or_origin))
20991 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
20992 else
20993 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
20995 /* And its containing type. */
20996 class_origin = decl_class_context (decl_or_origin);
20997 if (class_origin != NULL_TREE)
20998 gen_type_die_for_member (class_origin, decl_or_origin, context_die);
21000 /* And its containing namespace. */
21001 context_die = declare_in_namespace (decl_or_origin, context_die);
21003 /* Now output the DIE to represent the data object itself. This gets
21004 complicated because of the possibility that the VAR_DECL really
21005 represents an inlined instance of a formal parameter for an inline
21006 function. */
21007 ultimate_origin = decl_ultimate_origin (decl_or_origin);
21008 if (ultimate_origin != NULL_TREE
21009 && TREE_CODE (ultimate_origin) == PARM_DECL)
21010 gen_formal_parameter_die (decl, origin,
21011 true /* Emit name attribute. */,
21012 context_die);
21013 else
21014 gen_variable_die (decl, origin, context_die);
21015 break;
21017 case FIELD_DECL:
21018 /* Ignore the nameless fields that are used to skip bits but handle C++
21019 anonymous unions and structs. */
21020 if (DECL_NAME (decl) != NULL_TREE
21021 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
21022 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
21024 gen_type_die (member_declared_type (decl), context_die);
21025 gen_field_die (decl, context_die);
21027 break;
21029 case PARM_DECL:
21030 if (DECL_BY_REFERENCE (decl_or_origin))
21031 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
21032 else
21033 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
21034 return gen_formal_parameter_die (decl, origin,
21035 true /* Emit name attribute. */,
21036 context_die);
21038 case NAMESPACE_DECL:
21039 case IMPORTED_DECL:
21040 if (dwarf_version >= 3 || !dwarf_strict)
21041 gen_namespace_die (decl, context_die);
21042 break;
21044 case NAMELIST_DECL:
21045 gen_namelist_decl (DECL_NAME (decl), context_die,
21046 NAMELIST_DECL_ASSOCIATED_DECL (decl));
21047 break;
21049 default:
21050 /* Probably some frontend-internal decl. Assume we don't care. */
21051 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
21052 break;
21055 return NULL;
21058 /* Output debug information for global decl DECL. Called from toplev.c after
21059 compilation proper has finished. */
21061 static void
21062 dwarf2out_global_decl (tree decl)
21064 /* Output DWARF2 information for file-scope tentative data object
21065 declarations, file-scope (extern) function declarations (which
21066 had no corresponding body) and file-scope tagged type declarations
21067 and definitions which have not yet been forced out. */
21068 if ((TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
21069 && !POINTER_BOUNDS_P (decl))
21070 dwarf2out_decl (decl);
21073 /* Output debug information for type decl DECL. Called from toplev.c
21074 and from language front ends (to record built-in types). */
21075 static void
21076 dwarf2out_type_decl (tree decl, int local)
21078 if (!local)
21079 dwarf2out_decl (decl);
21082 /* Output debug information for imported module or decl DECL.
21083 NAME is non-NULL name in the lexical block if the decl has been renamed.
21084 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
21085 that DECL belongs to.
21086 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
21087 static void
21088 dwarf2out_imported_module_or_decl_1 (tree decl,
21089 tree name,
21090 tree lexical_block,
21091 dw_die_ref lexical_block_die)
21093 expanded_location xloc;
21094 dw_die_ref imported_die = NULL;
21095 dw_die_ref at_import_die;
21097 if (TREE_CODE (decl) == IMPORTED_DECL)
21099 xloc = expand_location (DECL_SOURCE_LOCATION (decl));
21100 decl = IMPORTED_DECL_ASSOCIATED_DECL (decl);
21101 gcc_assert (decl);
21103 else
21104 xloc = expand_location (input_location);
21106 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
21108 at_import_die = force_type_die (TREE_TYPE (decl));
21109 /* For namespace N { typedef void T; } using N::T; base_type_die
21110 returns NULL, but DW_TAG_imported_declaration requires
21111 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
21112 if (!at_import_die)
21114 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
21115 gen_typedef_die (decl, get_context_die (DECL_CONTEXT (decl)));
21116 at_import_die = lookup_type_die (TREE_TYPE (decl));
21117 gcc_assert (at_import_die);
21120 else
21122 at_import_die = lookup_decl_die (decl);
21123 if (!at_import_die)
21125 /* If we're trying to avoid duplicate debug info, we may not have
21126 emitted the member decl for this field. Emit it now. */
21127 if (TREE_CODE (decl) == FIELD_DECL)
21129 tree type = DECL_CONTEXT (decl);
21131 if (TYPE_CONTEXT (type)
21132 && TYPE_P (TYPE_CONTEXT (type))
21133 && !should_emit_struct_debug (TYPE_CONTEXT (type),
21134 DINFO_USAGE_DIR_USE))
21135 return;
21136 gen_type_die_for_member (type, decl,
21137 get_context_die (TYPE_CONTEXT (type)));
21139 if (TREE_CODE (decl) == NAMELIST_DECL)
21140 at_import_die = gen_namelist_decl (DECL_NAME (decl),
21141 get_context_die (DECL_CONTEXT (decl)),
21142 NULL_TREE);
21143 else
21144 at_import_die = force_decl_die (decl);
21148 if (TREE_CODE (decl) == NAMESPACE_DECL)
21150 if (dwarf_version >= 3 || !dwarf_strict)
21151 imported_die = new_die (DW_TAG_imported_module,
21152 lexical_block_die,
21153 lexical_block);
21154 else
21155 return;
21157 else
21158 imported_die = new_die (DW_TAG_imported_declaration,
21159 lexical_block_die,
21160 lexical_block);
21162 add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file));
21163 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
21164 if (name)
21165 add_AT_string (imported_die, DW_AT_name,
21166 IDENTIFIER_POINTER (name));
21167 add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
21170 /* Output debug information for imported module or decl DECL.
21171 NAME is non-NULL name in context if the decl has been renamed.
21172 CHILD is true if decl is one of the renamed decls as part of
21173 importing whole module. */
21175 static void
21176 dwarf2out_imported_module_or_decl (tree decl, tree name, tree context,
21177 bool child)
21179 /* dw_die_ref at_import_die; */
21180 dw_die_ref scope_die;
21182 if (debug_info_level <= DINFO_LEVEL_TERSE)
21183 return;
21185 gcc_assert (decl);
21187 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
21188 We need decl DIE for reference and scope die. First, get DIE for the decl
21189 itself. */
21191 /* Get the scope die for decl context. Use comp_unit_die for global module
21192 or decl. If die is not found for non globals, force new die. */
21193 if (context
21194 && TYPE_P (context)
21195 && !should_emit_struct_debug (context, DINFO_USAGE_DIR_USE))
21196 return;
21198 if (!(dwarf_version >= 3 || !dwarf_strict))
21199 return;
21201 scope_die = get_context_die (context);
21203 if (child)
21205 gcc_assert (scope_die->die_child);
21206 gcc_assert (scope_die->die_child->die_tag == DW_TAG_imported_module);
21207 gcc_assert (TREE_CODE (decl) != NAMESPACE_DECL);
21208 scope_die = scope_die->die_child;
21211 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
21212 dwarf2out_imported_module_or_decl_1 (decl, name, context, scope_die);
21216 /* Output debug information for namelists. */
21218 static dw_die_ref
21219 gen_namelist_decl (tree name, dw_die_ref scope_die, tree item_decls)
21221 dw_die_ref nml_die, nml_item_die, nml_item_ref_die;
21222 tree value;
21223 unsigned i;
21225 if (debug_info_level <= DINFO_LEVEL_TERSE)
21226 return NULL;
21228 gcc_assert (scope_die != NULL);
21229 nml_die = new_die (DW_TAG_namelist, scope_die, NULL);
21230 add_AT_string (nml_die, DW_AT_name, IDENTIFIER_POINTER (name));
21232 /* If there are no item_decls, we have a nondefining namelist, e.g.
21233 with USE association; hence, set DW_AT_declaration. */
21234 if (item_decls == NULL_TREE)
21236 add_AT_flag (nml_die, DW_AT_declaration, 1);
21237 return nml_die;
21240 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (item_decls), i, value)
21242 nml_item_ref_die = lookup_decl_die (value);
21243 if (!nml_item_ref_die)
21244 nml_item_ref_die = force_decl_die (value);
21246 nml_item_die = new_die (DW_TAG_namelist_item, nml_die, NULL);
21247 add_AT_die_ref (nml_item_die, DW_AT_namelist_items, nml_item_ref_die);
21249 return nml_die;
21253 /* Write the debugging output for DECL. */
21255 static void
21256 dwarf2out_decl (tree decl)
21258 dw_die_ref context_die = comp_unit_die ();
21260 switch (TREE_CODE (decl))
21262 case ERROR_MARK:
21263 return;
21265 case FUNCTION_DECL:
21266 /* What we would really like to do here is to filter out all mere
21267 file-scope declarations of file-scope functions which are never
21268 referenced later within this translation unit (and keep all of ones
21269 that *are* referenced later on) but we aren't clairvoyant, so we have
21270 no idea which functions will be referenced in the future (i.e. later
21271 on within the current translation unit). So here we just ignore all
21272 file-scope function declarations which are not also definitions. If
21273 and when the debugger needs to know something about these functions,
21274 it will have to hunt around and find the DWARF information associated
21275 with the definition of the function.
21277 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
21278 nodes represent definitions and which ones represent mere
21279 declarations. We have to check DECL_INITIAL instead. That's because
21280 the C front-end supports some weird semantics for "extern inline"
21281 function definitions. These can get inlined within the current
21282 translation unit (and thus, we need to generate Dwarf info for their
21283 abstract instances so that the Dwarf info for the concrete inlined
21284 instances can have something to refer to) but the compiler never
21285 generates any out-of-lines instances of such things (despite the fact
21286 that they *are* definitions).
21288 The important point is that the C front-end marks these "extern
21289 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
21290 them anyway. Note that the C++ front-end also plays some similar games
21291 for inline function definitions appearing within include files which
21292 also contain `#pragma interface' pragmas.
21294 If we are called from dwarf2out_abstract_function output a DIE
21295 anyway. We can end up here this way with early inlining and LTO
21296 where the inlined function is output in a different LTRANS unit
21297 or not at all. */
21298 if (DECL_INITIAL (decl) == NULL_TREE
21299 && ! DECL_ABSTRACT_P (decl))
21300 return;
21302 /* If we're a nested function, initially use a parent of NULL; if we're
21303 a plain function, this will be fixed up in decls_for_scope. If
21304 we're a method, it will be ignored, since we already have a DIE. */
21305 if (decl_function_context (decl)
21306 /* But if we're in terse mode, we don't care about scope. */
21307 && debug_info_level > DINFO_LEVEL_TERSE)
21308 context_die = NULL;
21309 break;
21311 case VAR_DECL:
21312 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
21313 declaration and if the declaration was never even referenced from
21314 within this entire compilation unit. We suppress these DIEs in
21315 order to save space in the .debug section (by eliminating entries
21316 which are probably useless). Note that we must not suppress
21317 block-local extern declarations (whether used or not) because that
21318 would screw-up the debugger's name lookup mechanism and cause it to
21319 miss things which really ought to be in scope at a given point. */
21320 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
21321 return;
21323 /* For local statics lookup proper context die. */
21324 if (TREE_STATIC (decl)
21325 && DECL_CONTEXT (decl)
21326 && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
21327 context_die = lookup_decl_die (DECL_CONTEXT (decl));
21329 /* If we are in terse mode, don't generate any DIEs to represent any
21330 variable declarations or definitions. */
21331 if (debug_info_level <= DINFO_LEVEL_TERSE)
21332 return;
21333 break;
21335 case CONST_DECL:
21336 if (debug_info_level <= DINFO_LEVEL_TERSE)
21337 return;
21338 if (!is_fortran () && !is_ada ())
21339 return;
21340 if (TREE_STATIC (decl) && decl_function_context (decl))
21341 context_die = lookup_decl_die (DECL_CONTEXT (decl));
21342 break;
21344 case NAMESPACE_DECL:
21345 case IMPORTED_DECL:
21346 if (debug_info_level <= DINFO_LEVEL_TERSE)
21347 return;
21348 if (lookup_decl_die (decl) != NULL)
21349 return;
21350 break;
21352 case TYPE_DECL:
21353 /* Don't emit stubs for types unless they are needed by other DIEs. */
21354 if (TYPE_DECL_SUPPRESS_DEBUG (decl))
21355 return;
21357 /* Don't bother trying to generate any DIEs to represent any of the
21358 normal built-in types for the language we are compiling. */
21359 if (DECL_IS_BUILTIN (decl))
21360 return;
21362 /* If we are in terse mode, don't generate any DIEs for types. */
21363 if (debug_info_level <= DINFO_LEVEL_TERSE)
21364 return;
21366 /* If we're a function-scope tag, initially use a parent of NULL;
21367 this will be fixed up in decls_for_scope. */
21368 if (decl_function_context (decl))
21369 context_die = NULL;
21371 break;
21373 case NAMELIST_DECL:
21374 break;
21376 default:
21377 return;
21380 gen_decl_die (decl, NULL, context_die);
21383 /* Write the debugging output for DECL. */
21385 static void
21386 dwarf2out_function_decl (tree decl)
21388 dwarf2out_decl (decl);
21389 call_arg_locations = NULL;
21390 call_arg_loc_last = NULL;
21391 call_site_count = -1;
21392 tail_call_site_count = -1;
21393 block_map.release ();
21394 decl_loc_table->empty ();
21395 cached_dw_loc_list_table->empty ();
21398 /* Output a marker (i.e. a label) for the beginning of the generated code for
21399 a lexical block. */
21401 static void
21402 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
21403 unsigned int blocknum)
21405 switch_to_section (current_function_section ());
21406 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
21409 /* Output a marker (i.e. a label) for the end of the generated code for a
21410 lexical block. */
21412 static void
21413 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
21415 switch_to_section (current_function_section ());
21416 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
21419 /* Returns nonzero if it is appropriate not to emit any debugging
21420 information for BLOCK, because it doesn't contain any instructions.
21422 Don't allow this for blocks with nested functions or local classes
21423 as we would end up with orphans, and in the presence of scheduling
21424 we may end up calling them anyway. */
21426 static bool
21427 dwarf2out_ignore_block (const_tree block)
21429 tree decl;
21430 unsigned int i;
21432 for (decl = BLOCK_VARS (block); decl; decl = DECL_CHAIN (decl))
21433 if (TREE_CODE (decl) == FUNCTION_DECL
21434 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
21435 return 0;
21436 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (block); i++)
21438 decl = BLOCK_NONLOCALIZED_VAR (block, i);
21439 if (TREE_CODE (decl) == FUNCTION_DECL
21440 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
21441 return 0;
21444 return 1;
21447 /* Hash table routines for file_hash. */
21449 bool
21450 dwarf_file_hasher::equal (dwarf_file_data *p1, const char *p2)
21452 return filename_cmp (p1->filename, p2) == 0;
21455 hashval_t
21456 dwarf_file_hasher::hash (dwarf_file_data *p)
21458 return htab_hash_string (p->filename);
21461 /* Lookup FILE_NAME (in the list of filenames that we know about here in
21462 dwarf2out.c) and return its "index". The index of each (known) filename is
21463 just a unique number which is associated with only that one filename. We
21464 need such numbers for the sake of generating labels (in the .debug_sfnames
21465 section) and references to those files numbers (in the .debug_srcinfo
21466 and.debug_macinfo sections). If the filename given as an argument is not
21467 found in our current list, add it to the list and assign it the next
21468 available unique index number. In order to speed up searches, we remember
21469 the index of the filename was looked up last. This handles the majority of
21470 all searches. */
21472 static struct dwarf_file_data *
21473 lookup_filename (const char *file_name)
21475 struct dwarf_file_data * created;
21477 /* Check to see if the file name that was searched on the previous
21478 call matches this file name. If so, return the index. */
21479 if (file_table_last_lookup
21480 && (file_name == file_table_last_lookup->filename
21481 || filename_cmp (file_table_last_lookup->filename, file_name) == 0))
21482 return file_table_last_lookup;
21484 /* Didn't match the previous lookup, search the table. */
21485 dwarf_file_data **slot
21486 = file_table->find_slot_with_hash (file_name, htab_hash_string (file_name),
21487 INSERT);
21488 if (*slot)
21489 return *slot;
21491 created = ggc_alloc<dwarf_file_data> ();
21492 created->filename = file_name;
21493 created->emitted_number = 0;
21494 *slot = created;
21495 return created;
21498 /* If the assembler will construct the file table, then translate the compiler
21499 internal file table number into the assembler file table number, and emit
21500 a .file directive if we haven't already emitted one yet. The file table
21501 numbers are different because we prune debug info for unused variables and
21502 types, which may include filenames. */
21504 static int
21505 maybe_emit_file (struct dwarf_file_data * fd)
21507 if (! fd->emitted_number)
21509 if (last_emitted_file)
21510 fd->emitted_number = last_emitted_file->emitted_number + 1;
21511 else
21512 fd->emitted_number = 1;
21513 last_emitted_file = fd;
21515 if (DWARF2_ASM_LINE_DEBUG_INFO)
21517 fprintf (asm_out_file, "\t.file %u ", fd->emitted_number);
21518 output_quoted_string (asm_out_file,
21519 remap_debug_filename (fd->filename));
21520 fputc ('\n', asm_out_file);
21524 return fd->emitted_number;
21527 /* Schedule generation of a DW_AT_const_value attribute to DIE.
21528 That generation should happen after function debug info has been
21529 generated. The value of the attribute is the constant value of ARG. */
21531 static void
21532 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die, tree arg)
21534 die_arg_entry entry;
21536 if (!die || !arg)
21537 return;
21539 if (!tmpl_value_parm_die_table)
21540 vec_alloc (tmpl_value_parm_die_table, 32);
21542 entry.die = die;
21543 entry.arg = arg;
21544 vec_safe_push (tmpl_value_parm_die_table, entry);
21547 /* Return TRUE if T is an instance of generic type, FALSE
21548 otherwise. */
21550 static bool
21551 generic_type_p (tree t)
21553 if (t == NULL_TREE || !TYPE_P (t))
21554 return false;
21555 return lang_hooks.get_innermost_generic_parms (t) != NULL_TREE;
21558 /* Schedule the generation of the generic parameter dies for the
21559 instance of generic type T. The proper generation itself is later
21560 done by gen_scheduled_generic_parms_dies. */
21562 static void
21563 schedule_generic_params_dies_gen (tree t)
21565 if (!generic_type_p (t))
21566 return;
21568 if (!generic_type_instances)
21569 vec_alloc (generic_type_instances, 256);
21571 vec_safe_push (generic_type_instances, t);
21574 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
21575 by append_entry_to_tmpl_value_parm_die_table. This function must
21576 be called after function DIEs have been generated. */
21578 static void
21579 gen_remaining_tmpl_value_param_die_attribute (void)
21581 if (tmpl_value_parm_die_table)
21583 unsigned i;
21584 die_arg_entry *e;
21586 FOR_EACH_VEC_ELT (*tmpl_value_parm_die_table, i, e)
21587 tree_add_const_value_attribute (e->die, e->arg);
21591 /* Generate generic parameters DIEs for instances of generic types
21592 that have been previously scheduled by
21593 schedule_generic_params_dies_gen. This function must be called
21594 after all the types of the CU have been laid out. */
21596 static void
21597 gen_scheduled_generic_parms_dies (void)
21599 unsigned i;
21600 tree t;
21602 if (!generic_type_instances)
21603 return;
21605 FOR_EACH_VEC_ELT (*generic_type_instances, i, t)
21606 if (COMPLETE_TYPE_P (t))
21607 gen_generic_params_dies (t);
21611 /* Replace DW_AT_name for the decl with name. */
21613 static void
21614 dwarf2out_set_name (tree decl, tree name)
21616 dw_die_ref die;
21617 dw_attr_ref attr;
21618 const char *dname;
21620 die = TYPE_SYMTAB_DIE (decl);
21621 if (!die)
21622 return;
21624 dname = dwarf2_name (name, 0);
21625 if (!dname)
21626 return;
21628 attr = get_AT (die, DW_AT_name);
21629 if (attr)
21631 struct indirect_string_node *node;
21633 node = find_AT_string (dname);
21634 /* replace the string. */
21635 attr->dw_attr_val.v.val_str = node;
21638 else
21639 add_name_attribute (die, dname);
21642 /* True if before or during processing of the first function being emitted. */
21643 static bool in_first_function_p = true;
21644 /* True if loc_note during dwarf2out_var_location call might still be
21645 before first real instruction at address equal to .Ltext0. */
21646 static bool maybe_at_text_label_p = true;
21647 /* One above highest N where .LVLN label might be equal to .Ltext0 label. */
21648 static unsigned int first_loclabel_num_not_at_text_label;
21650 /* Called by the final INSN scan whenever we see a var location. We
21651 use it to drop labels in the right places, and throw the location in
21652 our lookup table. */
21654 static void
21655 dwarf2out_var_location (rtx_insn *loc_note)
21657 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES + 2];
21658 struct var_loc_node *newloc;
21659 rtx_insn *next_real, *next_note;
21660 static const char *last_label;
21661 static const char *last_postcall_label;
21662 static bool last_in_cold_section_p;
21663 static rtx_insn *expected_next_loc_note;
21664 tree decl;
21665 bool var_loc_p;
21667 if (!NOTE_P (loc_note))
21669 if (CALL_P (loc_note))
21671 call_site_count++;
21672 if (SIBLING_CALL_P (loc_note))
21673 tail_call_site_count++;
21675 return;
21678 var_loc_p = NOTE_KIND (loc_note) == NOTE_INSN_VAR_LOCATION;
21679 if (var_loc_p && !DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
21680 return;
21682 /* Optimize processing a large consecutive sequence of location
21683 notes so we don't spend too much time in next_real_insn. If the
21684 next insn is another location note, remember the next_real_insn
21685 calculation for next time. */
21686 next_real = cached_next_real_insn;
21687 if (next_real)
21689 if (expected_next_loc_note != loc_note)
21690 next_real = NULL;
21693 next_note = NEXT_INSN (loc_note);
21694 if (! next_note
21695 || next_note->deleted ()
21696 || ! NOTE_P (next_note)
21697 || (NOTE_KIND (next_note) != NOTE_INSN_VAR_LOCATION
21698 && NOTE_KIND (next_note) != NOTE_INSN_CALL_ARG_LOCATION))
21699 next_note = NULL;
21701 if (! next_real)
21702 next_real = next_real_insn (loc_note);
21704 if (next_note)
21706 expected_next_loc_note = next_note;
21707 cached_next_real_insn = next_real;
21709 else
21710 cached_next_real_insn = NULL;
21712 /* If there are no instructions which would be affected by this note,
21713 don't do anything. */
21714 if (var_loc_p
21715 && next_real == NULL_RTX
21716 && !NOTE_DURING_CALL_P (loc_note))
21717 return;
21719 if (next_real == NULL_RTX)
21720 next_real = get_last_insn ();
21722 /* If there were any real insns between note we processed last time
21723 and this note (or if it is the first note), clear
21724 last_{,postcall_}label so that they are not reused this time. */
21725 if (last_var_location_insn == NULL_RTX
21726 || last_var_location_insn != next_real
21727 || last_in_cold_section_p != in_cold_section_p)
21729 last_label = NULL;
21730 last_postcall_label = NULL;
21733 if (var_loc_p)
21735 decl = NOTE_VAR_LOCATION_DECL (loc_note);
21736 newloc = add_var_loc_to_decl (decl, loc_note,
21737 NOTE_DURING_CALL_P (loc_note)
21738 ? last_postcall_label : last_label);
21739 if (newloc == NULL)
21740 return;
21742 else
21744 decl = NULL_TREE;
21745 newloc = NULL;
21748 /* If there were no real insns between note we processed last time
21749 and this note, use the label we emitted last time. Otherwise
21750 create a new label and emit it. */
21751 if (last_label == NULL)
21753 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
21754 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
21755 loclabel_num++;
21756 last_label = ggc_strdup (loclabel);
21757 /* See if loclabel might be equal to .Ltext0. If yes,
21758 bump first_loclabel_num_not_at_text_label. */
21759 if (!have_multiple_function_sections
21760 && in_first_function_p
21761 && maybe_at_text_label_p)
21763 static rtx_insn *last_start;
21764 rtx_insn *insn;
21765 for (insn = loc_note; insn; insn = previous_insn (insn))
21766 if (insn == last_start)
21767 break;
21768 else if (!NONDEBUG_INSN_P (insn))
21769 continue;
21770 else
21772 rtx body = PATTERN (insn);
21773 if (GET_CODE (body) == USE || GET_CODE (body) == CLOBBER)
21774 continue;
21775 /* Inline asm could occupy zero bytes. */
21776 else if (GET_CODE (body) == ASM_INPUT
21777 || asm_noperands (body) >= 0)
21778 continue;
21779 #ifdef HAVE_attr_length
21780 else if (get_attr_min_length (insn) == 0)
21781 continue;
21782 #endif
21783 else
21785 /* Assume insn has non-zero length. */
21786 maybe_at_text_label_p = false;
21787 break;
21790 if (maybe_at_text_label_p)
21792 last_start = loc_note;
21793 first_loclabel_num_not_at_text_label = loclabel_num;
21798 if (!var_loc_p)
21800 struct call_arg_loc_node *ca_loc
21801 = ggc_cleared_alloc<call_arg_loc_node> ();
21802 rtx_insn *prev = prev_real_insn (loc_note);
21803 rtx x;
21804 ca_loc->call_arg_loc_note = loc_note;
21805 ca_loc->next = NULL;
21806 ca_loc->label = last_label;
21807 gcc_assert (prev
21808 && (CALL_P (prev)
21809 || (NONJUMP_INSN_P (prev)
21810 && GET_CODE (PATTERN (prev)) == SEQUENCE
21811 && CALL_P (XVECEXP (PATTERN (prev), 0, 0)))));
21812 if (!CALL_P (prev))
21813 prev = as_a <rtx_sequence *> (PATTERN (prev))->insn (0);
21814 ca_loc->tail_call_p = SIBLING_CALL_P (prev);
21815 x = get_call_rtx_from (PATTERN (prev));
21816 if (x)
21818 x = XEXP (XEXP (x, 0), 0);
21819 if (GET_CODE (x) == SYMBOL_REF
21820 && SYMBOL_REF_DECL (x)
21821 && TREE_CODE (SYMBOL_REF_DECL (x)) == FUNCTION_DECL)
21822 ca_loc->symbol_ref = x;
21824 ca_loc->block = insn_scope (prev);
21825 if (call_arg_locations)
21826 call_arg_loc_last->next = ca_loc;
21827 else
21828 call_arg_locations = ca_loc;
21829 call_arg_loc_last = ca_loc;
21831 else if (!NOTE_DURING_CALL_P (loc_note))
21832 newloc->label = last_label;
21833 else
21835 if (!last_postcall_label)
21837 sprintf (loclabel, "%s-1", last_label);
21838 last_postcall_label = ggc_strdup (loclabel);
21840 newloc->label = last_postcall_label;
21843 last_var_location_insn = next_real;
21844 last_in_cold_section_p = in_cold_section_p;
21847 /* Note in one location list that text section has changed. */
21850 var_location_switch_text_section_1 (var_loc_list **slot, void *)
21852 var_loc_list *list = *slot;
21853 if (list->first)
21854 list->last_before_switch
21855 = list->last->next ? list->last->next : list->last;
21856 return 1;
21859 /* Note in all location lists that text section has changed. */
21861 static void
21862 var_location_switch_text_section (void)
21864 if (decl_loc_table == NULL)
21865 return;
21867 decl_loc_table->traverse<void *, var_location_switch_text_section_1> (NULL);
21870 /* Create a new line number table. */
21872 static dw_line_info_table *
21873 new_line_info_table (void)
21875 dw_line_info_table *table;
21877 table = ggc_cleared_alloc<dw_line_info_table_struct> ();
21878 table->file_num = 1;
21879 table->line_num = 1;
21880 table->is_stmt = DWARF_LINE_DEFAULT_IS_STMT_START;
21882 return table;
21885 /* Lookup the "current" table into which we emit line info, so
21886 that we don't have to do it for every source line. */
21888 static void
21889 set_cur_line_info_table (section *sec)
21891 dw_line_info_table *table;
21893 if (sec == text_section)
21894 table = text_section_line_info;
21895 else if (sec == cold_text_section)
21897 table = cold_text_section_line_info;
21898 if (!table)
21900 cold_text_section_line_info = table = new_line_info_table ();
21901 table->end_label = cold_end_label;
21904 else
21906 const char *end_label;
21908 if (flag_reorder_blocks_and_partition)
21910 if (in_cold_section_p)
21911 end_label = crtl->subsections.cold_section_end_label;
21912 else
21913 end_label = crtl->subsections.hot_section_end_label;
21915 else
21917 char label[MAX_ARTIFICIAL_LABEL_BYTES];
21918 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
21919 current_function_funcdef_no);
21920 end_label = ggc_strdup (label);
21923 table = new_line_info_table ();
21924 table->end_label = end_label;
21926 vec_safe_push (separate_line_info, table);
21929 if (DWARF2_ASM_LINE_DEBUG_INFO)
21930 table->is_stmt = (cur_line_info_table
21931 ? cur_line_info_table->is_stmt
21932 : DWARF_LINE_DEFAULT_IS_STMT_START);
21933 cur_line_info_table = table;
21937 /* We need to reset the locations at the beginning of each
21938 function. We can't do this in the end_function hook, because the
21939 declarations that use the locations won't have been output when
21940 that hook is called. Also compute have_multiple_function_sections here. */
21942 static void
21943 dwarf2out_begin_function (tree fun)
21945 section *sec = function_section (fun);
21947 if (sec != text_section)
21948 have_multiple_function_sections = true;
21950 if (flag_reorder_blocks_and_partition && !cold_text_section)
21952 gcc_assert (current_function_decl == fun);
21953 cold_text_section = unlikely_text_section ();
21954 switch_to_section (cold_text_section);
21955 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
21956 switch_to_section (sec);
21959 dwarf2out_note_section_used ();
21960 call_site_count = 0;
21961 tail_call_site_count = 0;
21963 set_cur_line_info_table (sec);
21966 /* Helper function of dwarf2out_end_function, called only after emitting
21967 the very first function into assembly. Check if some .debug_loc range
21968 might end with a .LVL* label that could be equal to .Ltext0.
21969 In that case we must force using absolute addresses in .debug_loc ranges,
21970 because this range could be .LVLN-.Ltext0 .. .LVLM-.Ltext0 for
21971 .LVLN == .LVLM == .Ltext0, thus 0 .. 0, which is a .debug_loc
21972 list terminator.
21973 Set have_multiple_function_sections to true in that case and
21974 terminate htab traversal. */
21977 find_empty_loc_ranges_at_text_label (var_loc_list **slot, int)
21979 var_loc_list *entry = *slot;
21980 struct var_loc_node *node;
21982 node = entry->first;
21983 if (node && node->next && node->next->label)
21985 unsigned int i;
21986 const char *label = node->next->label;
21987 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES];
21989 for (i = 0; i < first_loclabel_num_not_at_text_label; i++)
21991 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", i);
21992 if (strcmp (label, loclabel) == 0)
21994 have_multiple_function_sections = true;
21995 return 0;
21999 return 1;
22002 /* Hook called after emitting a function into assembly.
22003 This does something only for the very first function emitted. */
22005 static void
22006 dwarf2out_end_function (unsigned int)
22008 if (in_first_function_p
22009 && !have_multiple_function_sections
22010 && first_loclabel_num_not_at_text_label
22011 && decl_loc_table)
22012 decl_loc_table->traverse<int, find_empty_loc_ranges_at_text_label> (0);
22013 in_first_function_p = false;
22014 maybe_at_text_label_p = false;
22017 /* Add OPCODE+VAL as an entry at the end of the opcode array in TABLE. */
22019 static void
22020 push_dw_line_info_entry (dw_line_info_table *table,
22021 enum dw_line_info_opcode opcode, unsigned int val)
22023 dw_line_info_entry e;
22024 e.opcode = opcode;
22025 e.val = val;
22026 vec_safe_push (table->entries, e);
22029 /* Output a label to mark the beginning of a source code line entry
22030 and record information relating to this source line, in
22031 'line_info_table' for later output of the .debug_line section. */
22032 /* ??? The discriminator parameter ought to be unsigned. */
22034 static void
22035 dwarf2out_source_line (unsigned int line, const char *filename,
22036 int discriminator, bool is_stmt)
22038 unsigned int file_num;
22039 dw_line_info_table *table;
22041 if (debug_info_level < DINFO_LEVEL_TERSE || line == 0)
22042 return;
22044 /* The discriminator column was added in dwarf4. Simplify the below
22045 by simply removing it if we're not supposed to output it. */
22046 if (dwarf_version < 4 && dwarf_strict)
22047 discriminator = 0;
22049 table = cur_line_info_table;
22050 file_num = maybe_emit_file (lookup_filename (filename));
22052 /* ??? TODO: Elide duplicate line number entries. Traditionally,
22053 the debugger has used the second (possibly duplicate) line number
22054 at the beginning of the function to mark the end of the prologue.
22055 We could eliminate any other duplicates within the function. For
22056 Dwarf3, we ought to include the DW_LNS_set_prologue_end mark in
22057 that second line number entry. */
22058 /* Recall that this end-of-prologue indication is *not* the same thing
22059 as the end_prologue debug hook. The NOTE_INSN_PROLOGUE_END note,
22060 to which the hook corresponds, follows the last insn that was
22061 emitted by gen_prologue. What we need is to precede the first insn
22062 that had been emitted after NOTE_INSN_FUNCTION_BEG, i.e. the first
22063 insn that corresponds to something the user wrote. These may be
22064 very different locations once scheduling is enabled. */
22066 if (0 && file_num == table->file_num
22067 && line == table->line_num
22068 && discriminator == table->discrim_num
22069 && is_stmt == table->is_stmt)
22070 return;
22072 switch_to_section (current_function_section ());
22074 /* If requested, emit something human-readable. */
22075 if (flag_debug_asm)
22076 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START, filename, line);
22078 if (DWARF2_ASM_LINE_DEBUG_INFO)
22080 /* Emit the .loc directive understood by GNU as. */
22081 /* "\t.loc %u %u 0 is_stmt %u discriminator %u",
22082 file_num, line, is_stmt, discriminator */
22083 fputs ("\t.loc ", asm_out_file);
22084 fprint_ul (asm_out_file, file_num);
22085 putc (' ', asm_out_file);
22086 fprint_ul (asm_out_file, line);
22087 putc (' ', asm_out_file);
22088 putc ('0', asm_out_file);
22090 if (is_stmt != table->is_stmt)
22092 fputs (" is_stmt ", asm_out_file);
22093 putc (is_stmt ? '1' : '0', asm_out_file);
22095 if (SUPPORTS_DISCRIMINATOR && discriminator != 0)
22097 gcc_assert (discriminator > 0);
22098 fputs (" discriminator ", asm_out_file);
22099 fprint_ul (asm_out_file, (unsigned long) discriminator);
22101 putc ('\n', asm_out_file);
22103 else
22105 unsigned int label_num = ++line_info_label_num;
22107 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL, label_num);
22109 push_dw_line_info_entry (table, LI_set_address, label_num);
22110 if (file_num != table->file_num)
22111 push_dw_line_info_entry (table, LI_set_file, file_num);
22112 if (discriminator != table->discrim_num)
22113 push_dw_line_info_entry (table, LI_set_discriminator, discriminator);
22114 if (is_stmt != table->is_stmt)
22115 push_dw_line_info_entry (table, LI_negate_stmt, 0);
22116 push_dw_line_info_entry (table, LI_set_line, line);
22119 table->file_num = file_num;
22120 table->line_num = line;
22121 table->discrim_num = discriminator;
22122 table->is_stmt = is_stmt;
22123 table->in_use = true;
22126 /* Record the beginning of a new source file. */
22128 static void
22129 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
22131 if (flag_eliminate_dwarf2_dups)
22133 /* Record the beginning of the file for break_out_includes. */
22134 dw_die_ref bincl_die;
22136 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die (), NULL);
22137 add_AT_string (bincl_die, DW_AT_name, remap_debug_filename (filename));
22140 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
22142 macinfo_entry e;
22143 e.code = DW_MACINFO_start_file;
22144 e.lineno = lineno;
22145 e.info = ggc_strdup (filename);
22146 vec_safe_push (macinfo_table, e);
22150 /* Record the end of a source file. */
22152 static void
22153 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
22155 if (flag_eliminate_dwarf2_dups)
22156 /* Record the end of the file for break_out_includes. */
22157 new_die (DW_TAG_GNU_EINCL, comp_unit_die (), NULL);
22159 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
22161 macinfo_entry e;
22162 e.code = DW_MACINFO_end_file;
22163 e.lineno = lineno;
22164 e.info = NULL;
22165 vec_safe_push (macinfo_table, e);
22169 /* Called from debug_define in toplev.c. The `buffer' parameter contains
22170 the tail part of the directive line, i.e. the part which is past the
22171 initial whitespace, #, whitespace, directive-name, whitespace part. */
22173 static void
22174 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
22175 const char *buffer ATTRIBUTE_UNUSED)
22177 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
22179 macinfo_entry e;
22180 /* Insert a dummy first entry to be able to optimize the whole
22181 predefined macro block using DW_MACRO_GNU_transparent_include. */
22182 if (macinfo_table->is_empty () && lineno <= 1)
22184 e.code = 0;
22185 e.lineno = 0;
22186 e.info = NULL;
22187 vec_safe_push (macinfo_table, e);
22189 e.code = DW_MACINFO_define;
22190 e.lineno = lineno;
22191 e.info = ggc_strdup (buffer);
22192 vec_safe_push (macinfo_table, e);
22196 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
22197 the tail part of the directive line, i.e. the part which is past the
22198 initial whitespace, #, whitespace, directive-name, whitespace part. */
22200 static void
22201 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
22202 const char *buffer ATTRIBUTE_UNUSED)
22204 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
22206 macinfo_entry e;
22207 /* Insert a dummy first entry to be able to optimize the whole
22208 predefined macro block using DW_MACRO_GNU_transparent_include. */
22209 if (macinfo_table->is_empty () && lineno <= 1)
22211 e.code = 0;
22212 e.lineno = 0;
22213 e.info = NULL;
22214 vec_safe_push (macinfo_table, e);
22216 e.code = DW_MACINFO_undef;
22217 e.lineno = lineno;
22218 e.info = ggc_strdup (buffer);
22219 vec_safe_push (macinfo_table, e);
22223 /* Helpers to manipulate hash table of CUs. */
22225 struct macinfo_entry_hasher : typed_noop_remove <macinfo_entry>
22227 typedef macinfo_entry value_type;
22228 typedef macinfo_entry compare_type;
22229 static inline hashval_t hash (const value_type *);
22230 static inline bool equal (const value_type *, const compare_type *);
22233 inline hashval_t
22234 macinfo_entry_hasher::hash (const value_type *entry)
22236 return htab_hash_string (entry->info);
22239 inline bool
22240 macinfo_entry_hasher::equal (const value_type *entry1,
22241 const compare_type *entry2)
22243 return !strcmp (entry1->info, entry2->info);
22246 typedef hash_table<macinfo_entry_hasher> macinfo_hash_type;
22248 /* Output a single .debug_macinfo entry. */
22250 static void
22251 output_macinfo_op (macinfo_entry *ref)
22253 int file_num;
22254 size_t len;
22255 struct indirect_string_node *node;
22256 char label[MAX_ARTIFICIAL_LABEL_BYTES];
22257 struct dwarf_file_data *fd;
22259 switch (ref->code)
22261 case DW_MACINFO_start_file:
22262 fd = lookup_filename (ref->info);
22263 file_num = maybe_emit_file (fd);
22264 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
22265 dw2_asm_output_data_uleb128 (ref->lineno,
22266 "Included from line number %lu",
22267 (unsigned long) ref->lineno);
22268 dw2_asm_output_data_uleb128 (file_num, "file %s", ref->info);
22269 break;
22270 case DW_MACINFO_end_file:
22271 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
22272 break;
22273 case DW_MACINFO_define:
22274 case DW_MACINFO_undef:
22275 len = strlen (ref->info) + 1;
22276 if (!dwarf_strict
22277 && len > DWARF_OFFSET_SIZE
22278 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
22279 && (debug_str_section->common.flags & SECTION_MERGE) != 0)
22281 ref->code = ref->code == DW_MACINFO_define
22282 ? DW_MACRO_GNU_define_indirect
22283 : DW_MACRO_GNU_undef_indirect;
22284 output_macinfo_op (ref);
22285 return;
22287 dw2_asm_output_data (1, ref->code,
22288 ref->code == DW_MACINFO_define
22289 ? "Define macro" : "Undefine macro");
22290 dw2_asm_output_data_uleb128 (ref->lineno, "At line number %lu",
22291 (unsigned long) ref->lineno);
22292 dw2_asm_output_nstring (ref->info, -1, "The macro");
22293 break;
22294 case DW_MACRO_GNU_define_indirect:
22295 case DW_MACRO_GNU_undef_indirect:
22296 node = find_AT_string (ref->info);
22297 gcc_assert (node
22298 && ((node->form == DW_FORM_strp)
22299 || (node->form == DW_FORM_GNU_str_index)));
22300 dw2_asm_output_data (1, ref->code,
22301 ref->code == DW_MACRO_GNU_define_indirect
22302 ? "Define macro indirect"
22303 : "Undefine macro indirect");
22304 dw2_asm_output_data_uleb128 (ref->lineno, "At line number %lu",
22305 (unsigned long) ref->lineno);
22306 if (node->form == DW_FORM_strp)
22307 dw2_asm_output_offset (DWARF_OFFSET_SIZE, node->label,
22308 debug_str_section, "The macro: \"%s\"",
22309 ref->info);
22310 else
22311 dw2_asm_output_data_uleb128 (node->index, "The macro: \"%s\"",
22312 ref->info);
22313 break;
22314 case DW_MACRO_GNU_transparent_include:
22315 dw2_asm_output_data (1, ref->code, "Transparent include");
22316 ASM_GENERATE_INTERNAL_LABEL (label,
22317 DEBUG_MACRO_SECTION_LABEL, ref->lineno);
22318 dw2_asm_output_offset (DWARF_OFFSET_SIZE, label, NULL, NULL);
22319 break;
22320 default:
22321 fprintf (asm_out_file, "%s unrecognized macinfo code %lu\n",
22322 ASM_COMMENT_START, (unsigned long) ref->code);
22323 break;
22327 /* Attempt to make a sequence of define/undef macinfo ops shareable with
22328 other compilation unit .debug_macinfo sections. IDX is the first
22329 index of a define/undef, return the number of ops that should be
22330 emitted in a comdat .debug_macinfo section and emit
22331 a DW_MACRO_GNU_transparent_include entry referencing it.
22332 If the define/undef entry should be emitted normally, return 0. */
22334 static unsigned
22335 optimize_macinfo_range (unsigned int idx, vec<macinfo_entry, va_gc> *files,
22336 macinfo_hash_type **macinfo_htab)
22338 macinfo_entry *first, *second, *cur, *inc;
22339 char linebuf[sizeof (HOST_WIDE_INT) * 3 + 1];
22340 unsigned char checksum[16];
22341 struct md5_ctx ctx;
22342 char *grp_name, *tail;
22343 const char *base;
22344 unsigned int i, count, encoded_filename_len, linebuf_len;
22345 macinfo_entry **slot;
22347 first = &(*macinfo_table)[idx];
22348 second = &(*macinfo_table)[idx + 1];
22350 /* Optimize only if there are at least two consecutive define/undef ops,
22351 and either all of them are before first DW_MACINFO_start_file
22352 with lineno {0,1} (i.e. predefined macro block), or all of them are
22353 in some included header file. */
22354 if (second->code != DW_MACINFO_define && second->code != DW_MACINFO_undef)
22355 return 0;
22356 if (vec_safe_is_empty (files))
22358 if (first->lineno > 1 || second->lineno > 1)
22359 return 0;
22361 else if (first->lineno == 0)
22362 return 0;
22364 /* Find the last define/undef entry that can be grouped together
22365 with first and at the same time compute md5 checksum of their
22366 codes, linenumbers and strings. */
22367 md5_init_ctx (&ctx);
22368 for (i = idx; macinfo_table->iterate (i, &cur); i++)
22369 if (cur->code != DW_MACINFO_define && cur->code != DW_MACINFO_undef)
22370 break;
22371 else if (vec_safe_is_empty (files) && cur->lineno > 1)
22372 break;
22373 else
22375 unsigned char code = cur->code;
22376 md5_process_bytes (&code, 1, &ctx);
22377 checksum_uleb128 (cur->lineno, &ctx);
22378 md5_process_bytes (cur->info, strlen (cur->info) + 1, &ctx);
22380 md5_finish_ctx (&ctx, checksum);
22381 count = i - idx;
22383 /* From the containing include filename (if any) pick up just
22384 usable characters from its basename. */
22385 if (vec_safe_is_empty (files))
22386 base = "";
22387 else
22388 base = lbasename (files->last ().info);
22389 for (encoded_filename_len = 0, i = 0; base[i]; i++)
22390 if (ISIDNUM (base[i]) || base[i] == '.')
22391 encoded_filename_len++;
22392 /* Count . at the end. */
22393 if (encoded_filename_len)
22394 encoded_filename_len++;
22396 sprintf (linebuf, HOST_WIDE_INT_PRINT_UNSIGNED, first->lineno);
22397 linebuf_len = strlen (linebuf);
22399 /* The group name format is: wmN.[<encoded filename>.]<lineno>.<md5sum> */
22400 grp_name = XALLOCAVEC (char, 4 + encoded_filename_len + linebuf_len + 1
22401 + 16 * 2 + 1);
22402 memcpy (grp_name, DWARF_OFFSET_SIZE == 4 ? "wm4." : "wm8.", 4);
22403 tail = grp_name + 4;
22404 if (encoded_filename_len)
22406 for (i = 0; base[i]; i++)
22407 if (ISIDNUM (base[i]) || base[i] == '.')
22408 *tail++ = base[i];
22409 *tail++ = '.';
22411 memcpy (tail, linebuf, linebuf_len);
22412 tail += linebuf_len;
22413 *tail++ = '.';
22414 for (i = 0; i < 16; i++)
22415 sprintf (tail + i * 2, "%02x", checksum[i] & 0xff);
22417 /* Construct a macinfo_entry for DW_MACRO_GNU_transparent_include
22418 in the empty vector entry before the first define/undef. */
22419 inc = &(*macinfo_table)[idx - 1];
22420 inc->code = DW_MACRO_GNU_transparent_include;
22421 inc->lineno = 0;
22422 inc->info = ggc_strdup (grp_name);
22423 if (!*macinfo_htab)
22424 *macinfo_htab = new macinfo_hash_type (10);
22425 /* Avoid emitting duplicates. */
22426 slot = (*macinfo_htab)->find_slot (inc, INSERT);
22427 if (*slot != NULL)
22429 inc->code = 0;
22430 inc->info = NULL;
22431 /* If such an entry has been used before, just emit
22432 a DW_MACRO_GNU_transparent_include op. */
22433 inc = *slot;
22434 output_macinfo_op (inc);
22435 /* And clear all macinfo_entry in the range to avoid emitting them
22436 in the second pass. */
22437 for (i = idx; macinfo_table->iterate (i, &cur) && i < idx + count; i++)
22439 cur->code = 0;
22440 cur->info = NULL;
22443 else
22445 *slot = inc;
22446 inc->lineno = (*macinfo_htab)->elements ();
22447 output_macinfo_op (inc);
22449 return count;
22452 /* Save any strings needed by the macinfo table in the debug str
22453 table. All strings must be collected into the table by the time
22454 index_string is called. */
22456 static void
22457 save_macinfo_strings (void)
22459 unsigned len;
22460 unsigned i;
22461 macinfo_entry *ref;
22463 for (i = 0; macinfo_table && macinfo_table->iterate (i, &ref); i++)
22465 switch (ref->code)
22467 /* Match the logic in output_macinfo_op to decide on
22468 indirect strings. */
22469 case DW_MACINFO_define:
22470 case DW_MACINFO_undef:
22471 len = strlen (ref->info) + 1;
22472 if (!dwarf_strict
22473 && len > DWARF_OFFSET_SIZE
22474 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
22475 && (debug_str_section->common.flags & SECTION_MERGE) != 0)
22476 set_indirect_string (find_AT_string (ref->info));
22477 break;
22478 case DW_MACRO_GNU_define_indirect:
22479 case DW_MACRO_GNU_undef_indirect:
22480 set_indirect_string (find_AT_string (ref->info));
22481 break;
22482 default:
22483 break;
22488 /* Output macinfo section(s). */
22490 static void
22491 output_macinfo (void)
22493 unsigned i;
22494 unsigned long length = vec_safe_length (macinfo_table);
22495 macinfo_entry *ref;
22496 vec<macinfo_entry, va_gc> *files = NULL;
22497 macinfo_hash_type *macinfo_htab = NULL;
22499 if (! length)
22500 return;
22502 /* output_macinfo* uses these interchangeably. */
22503 gcc_assert ((int) DW_MACINFO_define == (int) DW_MACRO_GNU_define
22504 && (int) DW_MACINFO_undef == (int) DW_MACRO_GNU_undef
22505 && (int) DW_MACINFO_start_file == (int) DW_MACRO_GNU_start_file
22506 && (int) DW_MACINFO_end_file == (int) DW_MACRO_GNU_end_file);
22508 /* For .debug_macro emit the section header. */
22509 if (!dwarf_strict)
22511 dw2_asm_output_data (2, 4, "DWARF macro version number");
22512 if (DWARF_OFFSET_SIZE == 8)
22513 dw2_asm_output_data (1, 3, "Flags: 64-bit, lineptr present");
22514 else
22515 dw2_asm_output_data (1, 2, "Flags: 32-bit, lineptr present");
22516 dw2_asm_output_offset (DWARF_OFFSET_SIZE,
22517 (!dwarf_split_debug_info ? debug_line_section_label
22518 : debug_skeleton_line_section_label),
22519 debug_line_section, NULL);
22522 /* In the first loop, it emits the primary .debug_macinfo section
22523 and after each emitted op the macinfo_entry is cleared.
22524 If a longer range of define/undef ops can be optimized using
22525 DW_MACRO_GNU_transparent_include, the
22526 DW_MACRO_GNU_transparent_include op is emitted and kept in
22527 the vector before the first define/undef in the range and the
22528 whole range of define/undef ops is not emitted and kept. */
22529 for (i = 0; macinfo_table->iterate (i, &ref); i++)
22531 switch (ref->code)
22533 case DW_MACINFO_start_file:
22534 vec_safe_push (files, *ref);
22535 break;
22536 case DW_MACINFO_end_file:
22537 if (!vec_safe_is_empty (files))
22538 files->pop ();
22539 break;
22540 case DW_MACINFO_define:
22541 case DW_MACINFO_undef:
22542 if (!dwarf_strict
22543 && HAVE_COMDAT_GROUP
22544 && vec_safe_length (files) != 1
22545 && i > 0
22546 && i + 1 < length
22547 && (*macinfo_table)[i - 1].code == 0)
22549 unsigned count = optimize_macinfo_range (i, files, &macinfo_htab);
22550 if (count)
22552 i += count - 1;
22553 continue;
22556 break;
22557 case 0:
22558 /* A dummy entry may be inserted at the beginning to be able
22559 to optimize the whole block of predefined macros. */
22560 if (i == 0)
22561 continue;
22562 default:
22563 break;
22565 output_macinfo_op (ref);
22566 ref->info = NULL;
22567 ref->code = 0;
22570 if (!macinfo_htab)
22571 return;
22573 delete macinfo_htab;
22574 macinfo_htab = NULL;
22576 /* If any DW_MACRO_GNU_transparent_include were used, on those
22577 DW_MACRO_GNU_transparent_include entries terminate the
22578 current chain and switch to a new comdat .debug_macinfo
22579 section and emit the define/undef entries within it. */
22580 for (i = 0; macinfo_table->iterate (i, &ref); i++)
22581 switch (ref->code)
22583 case 0:
22584 continue;
22585 case DW_MACRO_GNU_transparent_include:
22587 char label[MAX_ARTIFICIAL_LABEL_BYTES];
22588 tree comdat_key = get_identifier (ref->info);
22589 /* Terminate the previous .debug_macinfo section. */
22590 dw2_asm_output_data (1, 0, "End compilation unit");
22591 targetm.asm_out.named_section (DEBUG_MACRO_SECTION,
22592 SECTION_DEBUG
22593 | SECTION_LINKONCE,
22594 comdat_key);
22595 ASM_GENERATE_INTERNAL_LABEL (label,
22596 DEBUG_MACRO_SECTION_LABEL,
22597 ref->lineno);
22598 ASM_OUTPUT_LABEL (asm_out_file, label);
22599 ref->code = 0;
22600 ref->info = NULL;
22601 dw2_asm_output_data (2, 4, "DWARF macro version number");
22602 if (DWARF_OFFSET_SIZE == 8)
22603 dw2_asm_output_data (1, 1, "Flags: 64-bit");
22604 else
22605 dw2_asm_output_data (1, 0, "Flags: 32-bit");
22607 break;
22608 case DW_MACINFO_define:
22609 case DW_MACINFO_undef:
22610 output_macinfo_op (ref);
22611 ref->code = 0;
22612 ref->info = NULL;
22613 break;
22614 default:
22615 gcc_unreachable ();
22619 /* Set up for Dwarf output at the start of compilation. */
22621 static void
22622 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
22624 /* This option is currently broken, see (PR53118 and PR46102). */
22625 if (flag_eliminate_dwarf2_dups
22626 && strstr (lang_hooks.name, "C++"))
22628 warning (0, "-feliminate-dwarf2-dups is broken for C++, ignoring");
22629 flag_eliminate_dwarf2_dups = 0;
22632 /* Allocate the file_table. */
22633 file_table = hash_table<dwarf_file_hasher>::create_ggc (50);
22635 /* Allocate the decl_die_table. */
22636 decl_die_table = hash_table<decl_die_hasher>::create_ggc (10);
22638 /* Allocate the decl_loc_table. */
22639 decl_loc_table = hash_table<decl_loc_hasher>::create_ggc (10);
22641 /* Allocate the cached_dw_loc_list_table. */
22642 cached_dw_loc_list_table = hash_table<dw_loc_list_hasher>::create_ggc (10);
22644 /* Allocate the initial hunk of the decl_scope_table. */
22645 vec_alloc (decl_scope_table, 256);
22647 /* Allocate the initial hunk of the abbrev_die_table. */
22648 abbrev_die_table = ggc_cleared_vec_alloc<dw_die_ref>
22649 (ABBREV_DIE_TABLE_INCREMENT);
22650 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
22651 /* Zero-th entry is allocated, but unused. */
22652 abbrev_die_table_in_use = 1;
22654 /* Allocate the pubtypes and pubnames vectors. */
22655 vec_alloc (pubname_table, 32);
22656 vec_alloc (pubtype_table, 32);
22658 vec_alloc (incomplete_types, 64);
22660 vec_alloc (used_rtx_array, 32);
22662 if (!dwarf_split_debug_info)
22664 debug_info_section = get_section (DEBUG_INFO_SECTION,
22665 SECTION_DEBUG, NULL);
22666 debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
22667 SECTION_DEBUG, NULL);
22668 debug_loc_section = get_section (DEBUG_LOC_SECTION,
22669 SECTION_DEBUG, NULL);
22671 else
22673 debug_info_section = get_section (DEBUG_DWO_INFO_SECTION,
22674 SECTION_DEBUG | SECTION_EXCLUDE, NULL);
22675 debug_abbrev_section = get_section (DEBUG_DWO_ABBREV_SECTION,
22676 SECTION_DEBUG | SECTION_EXCLUDE,
22677 NULL);
22678 debug_addr_section = get_section (DEBUG_ADDR_SECTION,
22679 SECTION_DEBUG, NULL);
22680 debug_skeleton_info_section = get_section (DEBUG_INFO_SECTION,
22681 SECTION_DEBUG, NULL);
22682 debug_skeleton_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
22683 SECTION_DEBUG, NULL);
22684 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label,
22685 DEBUG_SKELETON_ABBREV_SECTION_LABEL, 0);
22687 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections stay in
22688 the main .o, but the skeleton_line goes into the split off dwo. */
22689 debug_skeleton_line_section
22690 = get_section (DEBUG_DWO_LINE_SECTION,
22691 SECTION_DEBUG | SECTION_EXCLUDE, NULL);
22692 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label,
22693 DEBUG_SKELETON_LINE_SECTION_LABEL, 0);
22694 debug_str_offsets_section = get_section (DEBUG_STR_OFFSETS_SECTION,
22695 SECTION_DEBUG | SECTION_EXCLUDE,
22696 NULL);
22697 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label,
22698 DEBUG_SKELETON_INFO_SECTION_LABEL, 0);
22699 debug_loc_section = get_section (DEBUG_DWO_LOC_SECTION,
22700 SECTION_DEBUG | SECTION_EXCLUDE, NULL);
22701 debug_str_dwo_section = get_section (DEBUG_STR_DWO_SECTION,
22702 DEBUG_STR_DWO_SECTION_FLAGS, NULL);
22704 debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
22705 SECTION_DEBUG, NULL);
22706 debug_macinfo_section = get_section (dwarf_strict
22707 ? DEBUG_MACINFO_SECTION
22708 : DEBUG_MACRO_SECTION,
22709 DEBUG_MACRO_SECTION_FLAGS, NULL);
22710 debug_line_section = get_section (DEBUG_LINE_SECTION,
22711 SECTION_DEBUG, NULL);
22712 debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
22713 SECTION_DEBUG, NULL);
22714 debug_pubtypes_section = get_section (DEBUG_PUBTYPES_SECTION,
22715 SECTION_DEBUG, NULL);
22716 debug_str_section = get_section (DEBUG_STR_SECTION,
22717 DEBUG_STR_SECTION_FLAGS, NULL);
22718 debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
22719 SECTION_DEBUG, NULL);
22720 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
22721 SECTION_DEBUG, NULL);
22723 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
22724 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
22725 DEBUG_ABBREV_SECTION_LABEL, 0);
22726 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
22727 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
22728 COLD_TEXT_SECTION_LABEL, 0);
22729 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
22731 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
22732 DEBUG_INFO_SECTION_LABEL, 0);
22733 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
22734 DEBUG_LINE_SECTION_LABEL, 0);
22735 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
22736 DEBUG_RANGES_SECTION_LABEL, 0);
22737 ASM_GENERATE_INTERNAL_LABEL (debug_addr_section_label,
22738 DEBUG_ADDR_SECTION_LABEL, 0);
22739 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
22740 dwarf_strict
22741 ? DEBUG_MACINFO_SECTION_LABEL
22742 : DEBUG_MACRO_SECTION_LABEL, 0);
22743 ASM_GENERATE_INTERNAL_LABEL (loc_section_label, DEBUG_LOC_SECTION_LABEL, 0);
22745 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
22746 vec_alloc (macinfo_table, 64);
22748 switch_to_section (text_section);
22749 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
22751 /* Make sure the line number table for .text always exists. */
22752 text_section_line_info = new_line_info_table ();
22753 text_section_line_info->end_label = text_end_label;
22756 /* Called before compile () starts outputtting functions, variables
22757 and toplevel asms into assembly. */
22759 static void
22760 dwarf2out_assembly_start (void)
22762 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE
22763 && dwarf2out_do_cfi_asm ()
22764 && (!(flag_unwind_tables || flag_exceptions)
22765 || targetm_common.except_unwind_info (&global_options) != UI_DWARF2))
22766 fprintf (asm_out_file, "\t.cfi_sections\t.debug_frame\n");
22769 /* A helper function for dwarf2out_finish called through
22770 htab_traverse. Assign a string its index. All strings must be
22771 collected into the table by the time index_string is called,
22772 because the indexing code relies on htab_traverse to traverse nodes
22773 in the same order for each run. */
22776 index_string (indirect_string_node **h, unsigned int *index)
22778 indirect_string_node *node = *h;
22780 find_string_form (node);
22781 if (node->form == DW_FORM_GNU_str_index && node->refcount > 0)
22783 gcc_assert (node->index == NO_INDEX_ASSIGNED);
22784 node->index = *index;
22785 *index += 1;
22787 return 1;
22790 /* A helper function for output_indirect_strings called through
22791 htab_traverse. Output the offset to a string and update the
22792 current offset. */
22795 output_index_string_offset (indirect_string_node **h, unsigned int *offset)
22797 indirect_string_node *node = *h;
22799 if (node->form == DW_FORM_GNU_str_index && node->refcount > 0)
22801 /* Assert that this node has been assigned an index. */
22802 gcc_assert (node->index != NO_INDEX_ASSIGNED
22803 && node->index != NOT_INDEXED);
22804 dw2_asm_output_data (DWARF_OFFSET_SIZE, *offset,
22805 "indexed string 0x%x: %s", node->index, node->str);
22806 *offset += strlen (node->str) + 1;
22808 return 1;
22811 /* A helper function for dwarf2out_finish called through
22812 htab_traverse. Output the indexed string. */
22815 output_index_string (indirect_string_node **h, unsigned int *cur_idx)
22817 struct indirect_string_node *node = *h;
22819 if (node->form == DW_FORM_GNU_str_index && node->refcount > 0)
22821 /* Assert that the strings are output in the same order as their
22822 indexes were assigned. */
22823 gcc_assert (*cur_idx == node->index);
22824 assemble_string (node->str, strlen (node->str) + 1);
22825 *cur_idx += 1;
22827 return 1;
22830 /* A helper function for dwarf2out_finish called through
22831 htab_traverse. Emit one queued .debug_str string. */
22834 output_indirect_string (indirect_string_node **h, void *)
22836 struct indirect_string_node *node = *h;
22838 node->form = find_string_form (node);
22839 if (node->form == DW_FORM_strp && node->refcount > 0)
22841 ASM_OUTPUT_LABEL (asm_out_file, node->label);
22842 assemble_string (node->str, strlen (node->str) + 1);
22845 return 1;
22848 /* Output the indexed string table. */
22850 static void
22851 output_indirect_strings (void)
22853 switch_to_section (debug_str_section);
22854 if (!dwarf_split_debug_info)
22855 debug_str_hash->traverse<void *, output_indirect_string> (NULL);
22856 else
22858 unsigned int offset = 0;
22859 unsigned int cur_idx = 0;
22861 skeleton_debug_str_hash->traverse<void *, output_indirect_string> (NULL);
22863 switch_to_section (debug_str_offsets_section);
22864 debug_str_hash->traverse_noresize
22865 <unsigned int *, output_index_string_offset> (&offset);
22866 switch_to_section (debug_str_dwo_section);
22867 debug_str_hash->traverse_noresize<unsigned int *, output_index_string>
22868 (&cur_idx);
22872 /* Callback for htab_traverse to assign an index to an entry in the
22873 table, and to write that entry to the .debug_addr section. */
22876 output_addr_table_entry (addr_table_entry **slot, unsigned int *cur_index)
22878 addr_table_entry *entry = *slot;
22880 if (entry->refcount == 0)
22882 gcc_assert (entry->index == NO_INDEX_ASSIGNED
22883 || entry->index == NOT_INDEXED);
22884 return 1;
22887 gcc_assert (entry->index == *cur_index);
22888 (*cur_index)++;
22890 switch (entry->kind)
22892 case ate_kind_rtx:
22893 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, entry->addr.rtl,
22894 "0x%x", entry->index);
22895 break;
22896 case ate_kind_rtx_dtprel:
22897 gcc_assert (targetm.asm_out.output_dwarf_dtprel);
22898 targetm.asm_out.output_dwarf_dtprel (asm_out_file,
22899 DWARF2_ADDR_SIZE,
22900 entry->addr.rtl);
22901 fputc ('\n', asm_out_file);
22902 break;
22903 case ate_kind_label:
22904 dw2_asm_output_addr (DWARF2_ADDR_SIZE, entry->addr.label,
22905 "0x%x", entry->index);
22906 break;
22907 default:
22908 gcc_unreachable ();
22910 return 1;
22913 /* Produce the .debug_addr section. */
22915 static void
22916 output_addr_table (void)
22918 unsigned int index = 0;
22919 if (addr_index_table == NULL || addr_index_table->size () == 0)
22920 return;
22922 switch_to_section (debug_addr_section);
22923 addr_index_table
22924 ->traverse_noresize<unsigned int *, output_addr_table_entry> (&index);
22927 #if ENABLE_ASSERT_CHECKING
22928 /* Verify that all marks are clear. */
22930 static void
22931 verify_marks_clear (dw_die_ref die)
22933 dw_die_ref c;
22935 gcc_assert (! die->die_mark);
22936 FOR_EACH_CHILD (die, c, verify_marks_clear (c));
22938 #endif /* ENABLE_ASSERT_CHECKING */
22940 /* Clear the marks for a die and its children.
22941 Be cool if the mark isn't set. */
22943 static void
22944 prune_unmark_dies (dw_die_ref die)
22946 dw_die_ref c;
22948 if (die->die_mark)
22949 die->die_mark = 0;
22950 FOR_EACH_CHILD (die, c, prune_unmark_dies (c));
22953 /* Given DIE that we're marking as used, find any other dies
22954 it references as attributes and mark them as used. */
22956 static void
22957 prune_unused_types_walk_attribs (dw_die_ref die)
22959 dw_attr_ref a;
22960 unsigned ix;
22962 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
22964 if (a->dw_attr_val.val_class == dw_val_class_die_ref)
22966 /* A reference to another DIE.
22967 Make sure that it will get emitted.
22968 If it was broken out into a comdat group, don't follow it. */
22969 if (! AT_ref (a)->comdat_type_p
22970 || a->dw_attr == DW_AT_specification)
22971 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
22973 /* Set the string's refcount to 0 so that prune_unused_types_mark
22974 accounts properly for it. */
22975 if (AT_class (a) == dw_val_class_str)
22976 a->dw_attr_val.v.val_str->refcount = 0;
22980 /* Mark the generic parameters and arguments children DIEs of DIE. */
22982 static void
22983 prune_unused_types_mark_generic_parms_dies (dw_die_ref die)
22985 dw_die_ref c;
22987 if (die == NULL || die->die_child == NULL)
22988 return;
22989 c = die->die_child;
22992 if (is_template_parameter (c))
22993 prune_unused_types_mark (c, 1);
22994 c = c->die_sib;
22995 } while (c && c != die->die_child);
22998 /* Mark DIE as being used. If DOKIDS is true, then walk down
22999 to DIE's children. */
23001 static void
23002 prune_unused_types_mark (dw_die_ref die, int dokids)
23004 dw_die_ref c;
23006 if (die->die_mark == 0)
23008 /* We haven't done this node yet. Mark it as used. */
23009 die->die_mark = 1;
23010 /* If this is the DIE of a generic type instantiation,
23011 mark the children DIEs that describe its generic parms and
23012 args. */
23013 prune_unused_types_mark_generic_parms_dies (die);
23015 /* We also have to mark its parents as used.
23016 (But we don't want to mark our parent's kids due to this,
23017 unless it is a class.) */
23018 if (die->die_parent)
23019 prune_unused_types_mark (die->die_parent,
23020 class_scope_p (die->die_parent));
23022 /* Mark any referenced nodes. */
23023 prune_unused_types_walk_attribs (die);
23025 /* If this node is a specification,
23026 also mark the definition, if it exists. */
23027 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
23028 prune_unused_types_mark (die->die_definition, 1);
23031 if (dokids && die->die_mark != 2)
23033 /* We need to walk the children, but haven't done so yet.
23034 Remember that we've walked the kids. */
23035 die->die_mark = 2;
23037 /* If this is an array type, we need to make sure our
23038 kids get marked, even if they're types. If we're
23039 breaking out types into comdat sections, do this
23040 for all type definitions. */
23041 if (die->die_tag == DW_TAG_array_type
23042 || (use_debug_types
23043 && is_type_die (die) && ! is_declaration_die (die)))
23044 FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1));
23045 else
23046 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
23050 /* For local classes, look if any static member functions were emitted
23051 and if so, mark them. */
23053 static void
23054 prune_unused_types_walk_local_classes (dw_die_ref die)
23056 dw_die_ref c;
23058 if (die->die_mark == 2)
23059 return;
23061 switch (die->die_tag)
23063 case DW_TAG_structure_type:
23064 case DW_TAG_union_type:
23065 case DW_TAG_class_type:
23066 break;
23068 case DW_TAG_subprogram:
23069 if (!get_AT_flag (die, DW_AT_declaration)
23070 || die->die_definition != NULL)
23071 prune_unused_types_mark (die, 1);
23072 return;
23074 default:
23075 return;
23078 /* Mark children. */
23079 FOR_EACH_CHILD (die, c, prune_unused_types_walk_local_classes (c));
23082 /* Walk the tree DIE and mark types that we actually use. */
23084 static void
23085 prune_unused_types_walk (dw_die_ref die)
23087 dw_die_ref c;
23089 /* Don't do anything if this node is already marked and
23090 children have been marked as well. */
23091 if (die->die_mark == 2)
23092 return;
23094 switch (die->die_tag)
23096 case DW_TAG_structure_type:
23097 case DW_TAG_union_type:
23098 case DW_TAG_class_type:
23099 if (die->die_perennial_p)
23100 break;
23102 for (c = die->die_parent; c; c = c->die_parent)
23103 if (c->die_tag == DW_TAG_subprogram)
23104 break;
23106 /* Finding used static member functions inside of classes
23107 is needed just for local classes, because for other classes
23108 static member function DIEs with DW_AT_specification
23109 are emitted outside of the DW_TAG_*_type. If we ever change
23110 it, we'd need to call this even for non-local classes. */
23111 if (c)
23112 prune_unused_types_walk_local_classes (die);
23114 /* It's a type node --- don't mark it. */
23115 return;
23117 case DW_TAG_const_type:
23118 case DW_TAG_packed_type:
23119 case DW_TAG_pointer_type:
23120 case DW_TAG_reference_type:
23121 case DW_TAG_rvalue_reference_type:
23122 case DW_TAG_volatile_type:
23123 case DW_TAG_typedef:
23124 case DW_TAG_array_type:
23125 case DW_TAG_interface_type:
23126 case DW_TAG_friend:
23127 case DW_TAG_variant_part:
23128 case DW_TAG_enumeration_type:
23129 case DW_TAG_subroutine_type:
23130 case DW_TAG_string_type:
23131 case DW_TAG_set_type:
23132 case DW_TAG_subrange_type:
23133 case DW_TAG_ptr_to_member_type:
23134 case DW_TAG_file_type:
23135 if (die->die_perennial_p)
23136 break;
23138 /* It's a type node --- don't mark it. */
23139 return;
23141 default:
23142 /* Mark everything else. */
23143 break;
23146 if (die->die_mark == 0)
23148 die->die_mark = 1;
23150 /* Now, mark any dies referenced from here. */
23151 prune_unused_types_walk_attribs (die);
23154 die->die_mark = 2;
23156 /* Mark children. */
23157 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
23160 /* Increment the string counts on strings referred to from DIE's
23161 attributes. */
23163 static void
23164 prune_unused_types_update_strings (dw_die_ref die)
23166 dw_attr_ref a;
23167 unsigned ix;
23169 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
23170 if (AT_class (a) == dw_val_class_str)
23172 struct indirect_string_node *s = a->dw_attr_val.v.val_str;
23173 s->refcount++;
23174 /* Avoid unnecessarily putting strings that are used less than
23175 twice in the hash table. */
23176 if (s->refcount
23177 == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2))
23179 indirect_string_node **slot
23180 = debug_str_hash->find_slot_with_hash (s->str,
23181 htab_hash_string (s->str),
23182 INSERT);
23183 gcc_assert (*slot == NULL);
23184 *slot = s;
23189 /* Remove from the tree DIE any dies that aren't marked. */
23191 static void
23192 prune_unused_types_prune (dw_die_ref die)
23194 dw_die_ref c;
23196 gcc_assert (die->die_mark);
23197 prune_unused_types_update_strings (die);
23199 if (! die->die_child)
23200 return;
23202 c = die->die_child;
23203 do {
23204 dw_die_ref prev = c;
23205 for (c = c->die_sib; ! c->die_mark; c = c->die_sib)
23206 if (c == die->die_child)
23208 /* No marked children between 'prev' and the end of the list. */
23209 if (prev == c)
23210 /* No marked children at all. */
23211 die->die_child = NULL;
23212 else
23214 prev->die_sib = c->die_sib;
23215 die->die_child = prev;
23217 return;
23220 if (c != prev->die_sib)
23221 prev->die_sib = c;
23222 prune_unused_types_prune (c);
23223 } while (c != die->die_child);
23226 /* Remove dies representing declarations that we never use. */
23228 static void
23229 prune_unused_types (void)
23231 unsigned int i;
23232 limbo_die_node *node;
23233 comdat_type_node *ctnode;
23234 pubname_ref pub;
23235 dw_die_ref base_type;
23237 #if ENABLE_ASSERT_CHECKING
23238 /* All the marks should already be clear. */
23239 verify_marks_clear (comp_unit_die ());
23240 for (node = limbo_die_list; node; node = node->next)
23241 verify_marks_clear (node->die);
23242 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
23243 verify_marks_clear (ctnode->root_die);
23244 #endif /* ENABLE_ASSERT_CHECKING */
23246 /* Mark types that are used in global variables. */
23247 premark_types_used_by_global_vars ();
23249 /* Set the mark on nodes that are actually used. */
23250 prune_unused_types_walk (comp_unit_die ());
23251 for (node = limbo_die_list; node; node = node->next)
23252 prune_unused_types_walk (node->die);
23253 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
23255 prune_unused_types_walk (ctnode->root_die);
23256 prune_unused_types_mark (ctnode->type_die, 1);
23259 /* Also set the mark on nodes referenced from the pubname_table. Enumerators
23260 are unusual in that they are pubnames that are the children of pubtypes.
23261 They should only be marked via their parent DW_TAG_enumeration_type die,
23262 not as roots in themselves. */
23263 FOR_EACH_VEC_ELT (*pubname_table, i, pub)
23264 if (pub->die->die_tag != DW_TAG_enumerator)
23265 prune_unused_types_mark (pub->die, 1);
23266 for (i = 0; base_types.iterate (i, &base_type); i++)
23267 prune_unused_types_mark (base_type, 1);
23269 if (debug_str_hash)
23270 debug_str_hash->empty ();
23271 if (skeleton_debug_str_hash)
23272 skeleton_debug_str_hash->empty ();
23273 prune_unused_types_prune (comp_unit_die ());
23274 for (node = limbo_die_list; node; node = node->next)
23275 prune_unused_types_prune (node->die);
23276 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
23277 prune_unused_types_prune (ctnode->root_die);
23279 /* Leave the marks clear. */
23280 prune_unmark_dies (comp_unit_die ());
23281 for (node = limbo_die_list; node; node = node->next)
23282 prune_unmark_dies (node->die);
23283 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
23284 prune_unmark_dies (ctnode->root_die);
23287 /* Set the parameter to true if there are any relative pathnames in
23288 the file table. */
23290 file_table_relative_p (dwarf_file_data **slot, bool *p)
23292 struct dwarf_file_data *d = *slot;
23293 if (!IS_ABSOLUTE_PATH (d->filename))
23295 *p = true;
23296 return 0;
23298 return 1;
23301 /* Helpers to manipulate hash table of comdat type units. */
23303 struct comdat_type_hasher : typed_noop_remove <comdat_type_node>
23305 typedef comdat_type_node value_type;
23306 typedef comdat_type_node compare_type;
23307 static inline hashval_t hash (const value_type *);
23308 static inline bool equal (const value_type *, const compare_type *);
23311 inline hashval_t
23312 comdat_type_hasher::hash (const value_type *type_node)
23314 hashval_t h;
23315 memcpy (&h, type_node->signature, sizeof (h));
23316 return h;
23319 inline bool
23320 comdat_type_hasher::equal (const value_type *type_node_1,
23321 const compare_type *type_node_2)
23323 return (! memcmp (type_node_1->signature, type_node_2->signature,
23324 DWARF_TYPE_SIGNATURE_SIZE));
23327 /* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref
23328 to the location it would have been added, should we know its
23329 DECL_ASSEMBLER_NAME when we added other attributes. This will
23330 probably improve compactness of debug info, removing equivalent
23331 abbrevs, and hide any differences caused by deferring the
23332 computation of the assembler name, triggered by e.g. PCH. */
23334 static inline void
23335 move_linkage_attr (dw_die_ref die)
23337 unsigned ix = vec_safe_length (die->die_attr);
23338 dw_attr_node linkage = (*die->die_attr)[ix - 1];
23340 gcc_assert (linkage.dw_attr == DW_AT_linkage_name
23341 || linkage.dw_attr == DW_AT_MIPS_linkage_name);
23343 while (--ix > 0)
23345 dw_attr_node *prev = &(*die->die_attr)[ix - 1];
23347 if (prev->dw_attr == DW_AT_decl_line || prev->dw_attr == DW_AT_name)
23348 break;
23351 if (ix != vec_safe_length (die->die_attr) - 1)
23353 die->die_attr->pop ();
23354 die->die_attr->quick_insert (ix, linkage);
23358 /* Helper function for resolve_addr, mark DW_TAG_base_type nodes
23359 referenced from typed stack ops and count how often they are used. */
23361 static void
23362 mark_base_types (dw_loc_descr_ref loc)
23364 dw_die_ref base_type = NULL;
23366 for (; loc; loc = loc->dw_loc_next)
23368 switch (loc->dw_loc_opc)
23370 case DW_OP_GNU_regval_type:
23371 case DW_OP_GNU_deref_type:
23372 base_type = loc->dw_loc_oprnd2.v.val_die_ref.die;
23373 break;
23374 case DW_OP_GNU_convert:
23375 case DW_OP_GNU_reinterpret:
23376 if (loc->dw_loc_oprnd1.val_class == dw_val_class_unsigned_const)
23377 continue;
23378 /* FALLTHRU */
23379 case DW_OP_GNU_const_type:
23380 base_type = loc->dw_loc_oprnd1.v.val_die_ref.die;
23381 break;
23382 case DW_OP_GNU_entry_value:
23383 mark_base_types (loc->dw_loc_oprnd1.v.val_loc);
23384 continue;
23385 default:
23386 continue;
23388 gcc_assert (base_type->die_parent == comp_unit_die ());
23389 if (base_type->die_mark)
23390 base_type->die_mark++;
23391 else
23393 base_types.safe_push (base_type);
23394 base_type->die_mark = 1;
23399 /* Comparison function for sorting marked base types. */
23401 static int
23402 base_type_cmp (const void *x, const void *y)
23404 dw_die_ref dx = *(const dw_die_ref *) x;
23405 dw_die_ref dy = *(const dw_die_ref *) y;
23406 unsigned int byte_size1, byte_size2;
23407 unsigned int encoding1, encoding2;
23408 if (dx->die_mark > dy->die_mark)
23409 return -1;
23410 if (dx->die_mark < dy->die_mark)
23411 return 1;
23412 byte_size1 = get_AT_unsigned (dx, DW_AT_byte_size);
23413 byte_size2 = get_AT_unsigned (dy, DW_AT_byte_size);
23414 if (byte_size1 < byte_size2)
23415 return 1;
23416 if (byte_size1 > byte_size2)
23417 return -1;
23418 encoding1 = get_AT_unsigned (dx, DW_AT_encoding);
23419 encoding2 = get_AT_unsigned (dy, DW_AT_encoding);
23420 if (encoding1 < encoding2)
23421 return 1;
23422 if (encoding1 > encoding2)
23423 return -1;
23424 return 0;
23427 /* Move base types marked by mark_base_types as early as possible
23428 in the CU, sorted by decreasing usage count both to make the
23429 uleb128 references as small as possible and to make sure they
23430 will have die_offset already computed by calc_die_sizes when
23431 sizes of typed stack loc ops is computed. */
23433 static void
23434 move_marked_base_types (void)
23436 unsigned int i;
23437 dw_die_ref base_type, die, c;
23439 if (base_types.is_empty ())
23440 return;
23442 /* Sort by decreasing usage count, they will be added again in that
23443 order later on. */
23444 base_types.qsort (base_type_cmp);
23445 die = comp_unit_die ();
23446 c = die->die_child;
23449 dw_die_ref prev = c;
23450 c = c->die_sib;
23451 while (c->die_mark)
23453 remove_child_with_prev (c, prev);
23454 /* As base types got marked, there must be at least
23455 one node other than DW_TAG_base_type. */
23456 gcc_assert (c != c->die_sib);
23457 c = c->die_sib;
23460 while (c != die->die_child);
23461 gcc_assert (die->die_child);
23462 c = die->die_child;
23463 for (i = 0; base_types.iterate (i, &base_type); i++)
23465 base_type->die_mark = 0;
23466 base_type->die_sib = c->die_sib;
23467 c->die_sib = base_type;
23468 c = base_type;
23472 /* Helper function for resolve_addr, attempt to resolve
23473 one CONST_STRING, return true if successful. Similarly verify that
23474 SYMBOL_REFs refer to variables emitted in the current CU. */
23476 static bool
23477 resolve_one_addr (rtx *addr)
23479 rtx rtl = *addr;
23481 if (GET_CODE (rtl) == CONST_STRING)
23483 size_t len = strlen (XSTR (rtl, 0)) + 1;
23484 tree t = build_string (len, XSTR (rtl, 0));
23485 tree tlen = size_int (len - 1);
23486 TREE_TYPE (t)
23487 = build_array_type (char_type_node, build_index_type (tlen));
23488 rtl = lookup_constant_def (t);
23489 if (!rtl || !MEM_P (rtl))
23490 return false;
23491 rtl = XEXP (rtl, 0);
23492 if (GET_CODE (rtl) == SYMBOL_REF
23493 && SYMBOL_REF_DECL (rtl)
23494 && !TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl)))
23495 return false;
23496 vec_safe_push (used_rtx_array, rtl);
23497 *addr = rtl;
23498 return true;
23501 if (GET_CODE (rtl) == SYMBOL_REF
23502 && SYMBOL_REF_DECL (rtl))
23504 if (TREE_CONSTANT_POOL_ADDRESS_P (rtl))
23506 if (!TREE_ASM_WRITTEN (DECL_INITIAL (SYMBOL_REF_DECL (rtl))))
23507 return false;
23509 else if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl)))
23510 return false;
23513 if (GET_CODE (rtl) == CONST)
23515 subrtx_ptr_iterator::array_type array;
23516 FOR_EACH_SUBRTX_PTR (iter, array, &XEXP (rtl, 0), ALL)
23517 if (!resolve_one_addr (*iter))
23518 return false;
23521 return true;
23524 /* For STRING_CST, return SYMBOL_REF of its constant pool entry,
23525 if possible, and create DW_TAG_dwarf_procedure that can be referenced
23526 from DW_OP_GNU_implicit_pointer if the string hasn't been seen yet. */
23528 static rtx
23529 string_cst_pool_decl (tree t)
23531 rtx rtl = output_constant_def (t, 1);
23532 unsigned char *array;
23533 dw_loc_descr_ref l;
23534 tree decl;
23535 size_t len;
23536 dw_die_ref ref;
23538 if (!rtl || !MEM_P (rtl))
23539 return NULL_RTX;
23540 rtl = XEXP (rtl, 0);
23541 if (GET_CODE (rtl) != SYMBOL_REF
23542 || SYMBOL_REF_DECL (rtl) == NULL_TREE)
23543 return NULL_RTX;
23545 decl = SYMBOL_REF_DECL (rtl);
23546 if (!lookup_decl_die (decl))
23548 len = TREE_STRING_LENGTH (t);
23549 vec_safe_push (used_rtx_array, rtl);
23550 ref = new_die (DW_TAG_dwarf_procedure, comp_unit_die (), decl);
23551 array = ggc_vec_alloc<unsigned char> (len);
23552 memcpy (array, TREE_STRING_POINTER (t), len);
23553 l = new_loc_descr (DW_OP_implicit_value, len, 0);
23554 l->dw_loc_oprnd2.val_class = dw_val_class_vec;
23555 l->dw_loc_oprnd2.v.val_vec.length = len;
23556 l->dw_loc_oprnd2.v.val_vec.elt_size = 1;
23557 l->dw_loc_oprnd2.v.val_vec.array = array;
23558 add_AT_loc (ref, DW_AT_location, l);
23559 equate_decl_number_to_die (decl, ref);
23561 return rtl;
23564 /* Helper function of resolve_addr_in_expr. LOC is
23565 a DW_OP_addr followed by DW_OP_stack_value, either at the start
23566 of exprloc or after DW_OP_{,bit_}piece, and val_addr can't be
23567 resolved. Replace it (both DW_OP_addr and DW_OP_stack_value)
23568 with DW_OP_GNU_implicit_pointer if possible
23569 and return true, if unsuccessful, return false. */
23571 static bool
23572 optimize_one_addr_into_implicit_ptr (dw_loc_descr_ref loc)
23574 rtx rtl = loc->dw_loc_oprnd1.v.val_addr;
23575 HOST_WIDE_INT offset = 0;
23576 dw_die_ref ref = NULL;
23577 tree decl;
23579 if (GET_CODE (rtl) == CONST
23580 && GET_CODE (XEXP (rtl, 0)) == PLUS
23581 && CONST_INT_P (XEXP (XEXP (rtl, 0), 1)))
23583 offset = INTVAL (XEXP (XEXP (rtl, 0), 1));
23584 rtl = XEXP (XEXP (rtl, 0), 0);
23586 if (GET_CODE (rtl) == CONST_STRING)
23588 size_t len = strlen (XSTR (rtl, 0)) + 1;
23589 tree t = build_string (len, XSTR (rtl, 0));
23590 tree tlen = size_int (len - 1);
23592 TREE_TYPE (t)
23593 = build_array_type (char_type_node, build_index_type (tlen));
23594 rtl = string_cst_pool_decl (t);
23595 if (!rtl)
23596 return false;
23598 if (GET_CODE (rtl) == SYMBOL_REF && SYMBOL_REF_DECL (rtl))
23600 decl = SYMBOL_REF_DECL (rtl);
23601 if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
23603 ref = lookup_decl_die (decl);
23604 if (ref && (get_AT (ref, DW_AT_location)
23605 || get_AT (ref, DW_AT_const_value)))
23607 loc->dw_loc_opc = DW_OP_GNU_implicit_pointer;
23608 loc->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
23609 loc->dw_loc_oprnd1.val_entry = NULL;
23610 loc->dw_loc_oprnd1.v.val_die_ref.die = ref;
23611 loc->dw_loc_oprnd1.v.val_die_ref.external = 0;
23612 loc->dw_loc_next = loc->dw_loc_next->dw_loc_next;
23613 loc->dw_loc_oprnd2.v.val_int = offset;
23614 return true;
23618 return false;
23621 /* Helper function for resolve_addr, handle one location
23622 expression, return false if at least one CONST_STRING or SYMBOL_REF in
23623 the location list couldn't be resolved. */
23625 static bool
23626 resolve_addr_in_expr (dw_loc_descr_ref loc)
23628 dw_loc_descr_ref keep = NULL;
23629 for (dw_loc_descr_ref prev = NULL; loc; prev = loc, loc = loc->dw_loc_next)
23630 switch (loc->dw_loc_opc)
23632 case DW_OP_addr:
23633 if (!resolve_one_addr (&loc->dw_loc_oprnd1.v.val_addr))
23635 if ((prev == NULL
23636 || prev->dw_loc_opc == DW_OP_piece
23637 || prev->dw_loc_opc == DW_OP_bit_piece)
23638 && loc->dw_loc_next
23639 && loc->dw_loc_next->dw_loc_opc == DW_OP_stack_value
23640 && !dwarf_strict
23641 && optimize_one_addr_into_implicit_ptr (loc))
23642 break;
23643 return false;
23645 break;
23646 case DW_OP_GNU_addr_index:
23647 case DW_OP_GNU_const_index:
23648 if (loc->dw_loc_opc == DW_OP_GNU_addr_index
23649 || (loc->dw_loc_opc == DW_OP_GNU_const_index && loc->dtprel))
23651 rtx rtl = loc->dw_loc_oprnd1.val_entry->addr.rtl;
23652 if (!resolve_one_addr (&rtl))
23653 return false;
23654 remove_addr_table_entry (loc->dw_loc_oprnd1.val_entry);
23655 loc->dw_loc_oprnd1.val_entry =
23656 add_addr_table_entry (rtl, ate_kind_rtx);
23658 break;
23659 case DW_OP_const4u:
23660 case DW_OP_const8u:
23661 if (loc->dtprel
23662 && !resolve_one_addr (&loc->dw_loc_oprnd1.v.val_addr))
23663 return false;
23664 break;
23665 case DW_OP_plus_uconst:
23666 if (size_of_loc_descr (loc)
23667 > size_of_int_loc_descriptor (loc->dw_loc_oprnd1.v.val_unsigned)
23669 && loc->dw_loc_oprnd1.v.val_unsigned > 0)
23671 dw_loc_descr_ref repl
23672 = int_loc_descriptor (loc->dw_loc_oprnd1.v.val_unsigned);
23673 add_loc_descr (&repl, new_loc_descr (DW_OP_plus, 0, 0));
23674 add_loc_descr (&repl, loc->dw_loc_next);
23675 *loc = *repl;
23677 break;
23678 case DW_OP_implicit_value:
23679 if (loc->dw_loc_oprnd2.val_class == dw_val_class_addr
23680 && !resolve_one_addr (&loc->dw_loc_oprnd2.v.val_addr))
23681 return false;
23682 break;
23683 case DW_OP_GNU_implicit_pointer:
23684 case DW_OP_GNU_parameter_ref:
23685 if (loc->dw_loc_oprnd1.val_class == dw_val_class_decl_ref)
23687 dw_die_ref ref
23688 = lookup_decl_die (loc->dw_loc_oprnd1.v.val_decl_ref);
23689 if (ref == NULL)
23690 return false;
23691 loc->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
23692 loc->dw_loc_oprnd1.v.val_die_ref.die = ref;
23693 loc->dw_loc_oprnd1.v.val_die_ref.external = 0;
23695 break;
23696 case DW_OP_GNU_const_type:
23697 case DW_OP_GNU_regval_type:
23698 case DW_OP_GNU_deref_type:
23699 case DW_OP_GNU_convert:
23700 case DW_OP_GNU_reinterpret:
23701 while (loc->dw_loc_next
23702 && loc->dw_loc_next->dw_loc_opc == DW_OP_GNU_convert)
23704 dw_die_ref base1, base2;
23705 unsigned enc1, enc2, size1, size2;
23706 if (loc->dw_loc_opc == DW_OP_GNU_regval_type
23707 || loc->dw_loc_opc == DW_OP_GNU_deref_type)
23708 base1 = loc->dw_loc_oprnd2.v.val_die_ref.die;
23709 else if (loc->dw_loc_oprnd1.val_class
23710 == dw_val_class_unsigned_const)
23711 break;
23712 else
23713 base1 = loc->dw_loc_oprnd1.v.val_die_ref.die;
23714 if (loc->dw_loc_next->dw_loc_oprnd1.val_class
23715 == dw_val_class_unsigned_const)
23716 break;
23717 base2 = loc->dw_loc_next->dw_loc_oprnd1.v.val_die_ref.die;
23718 gcc_assert (base1->die_tag == DW_TAG_base_type
23719 && base2->die_tag == DW_TAG_base_type);
23720 enc1 = get_AT_unsigned (base1, DW_AT_encoding);
23721 enc2 = get_AT_unsigned (base2, DW_AT_encoding);
23722 size1 = get_AT_unsigned (base1, DW_AT_byte_size);
23723 size2 = get_AT_unsigned (base2, DW_AT_byte_size);
23724 if (size1 == size2
23725 && (((enc1 == DW_ATE_unsigned || enc1 == DW_ATE_signed)
23726 && (enc2 == DW_ATE_unsigned || enc2 == DW_ATE_signed)
23727 && loc != keep)
23728 || enc1 == enc2))
23730 /* Optimize away next DW_OP_GNU_convert after
23731 adjusting LOC's base type die reference. */
23732 if (loc->dw_loc_opc == DW_OP_GNU_regval_type
23733 || loc->dw_loc_opc == DW_OP_GNU_deref_type)
23734 loc->dw_loc_oprnd2.v.val_die_ref.die = base2;
23735 else
23736 loc->dw_loc_oprnd1.v.val_die_ref.die = base2;
23737 loc->dw_loc_next = loc->dw_loc_next->dw_loc_next;
23738 continue;
23740 /* Don't change integer DW_OP_GNU_convert after e.g. floating
23741 point typed stack entry. */
23742 else if (enc1 != DW_ATE_unsigned && enc1 != DW_ATE_signed)
23743 keep = loc->dw_loc_next;
23744 break;
23746 break;
23747 default:
23748 break;
23750 return true;
23753 /* Helper function of resolve_addr. DIE had DW_AT_location of
23754 DW_OP_addr alone, which referred to DECL in DW_OP_addr's operand
23755 and DW_OP_addr couldn't be resolved. resolve_addr has already
23756 removed the DW_AT_location attribute. This function attempts to
23757 add a new DW_AT_location attribute with DW_OP_GNU_implicit_pointer
23758 to it or DW_AT_const_value attribute, if possible. */
23760 static void
23761 optimize_location_into_implicit_ptr (dw_die_ref die, tree decl)
23763 if (TREE_CODE (decl) != VAR_DECL
23764 || lookup_decl_die (decl) != die
23765 || DECL_EXTERNAL (decl)
23766 || !TREE_STATIC (decl)
23767 || DECL_INITIAL (decl) == NULL_TREE
23768 || DECL_P (DECL_INITIAL (decl))
23769 || get_AT (die, DW_AT_const_value))
23770 return;
23772 tree init = DECL_INITIAL (decl);
23773 HOST_WIDE_INT offset = 0;
23774 /* For variables that have been optimized away and thus
23775 don't have a memory location, see if we can emit
23776 DW_AT_const_value instead. */
23777 if (tree_add_const_value_attribute (die, init))
23778 return;
23779 if (dwarf_strict)
23780 return;
23781 /* If init is ADDR_EXPR or POINTER_PLUS_EXPR of ADDR_EXPR,
23782 and ADDR_EXPR refers to a decl that has DW_AT_location or
23783 DW_AT_const_value (but isn't addressable, otherwise
23784 resolving the original DW_OP_addr wouldn't fail), see if
23785 we can add DW_OP_GNU_implicit_pointer. */
23786 STRIP_NOPS (init);
23787 if (TREE_CODE (init) == POINTER_PLUS_EXPR
23788 && tree_fits_shwi_p (TREE_OPERAND (init, 1)))
23790 offset = tree_to_shwi (TREE_OPERAND (init, 1));
23791 init = TREE_OPERAND (init, 0);
23792 STRIP_NOPS (init);
23794 if (TREE_CODE (init) != ADDR_EXPR)
23795 return;
23796 if ((TREE_CODE (TREE_OPERAND (init, 0)) == STRING_CST
23797 && !TREE_ASM_WRITTEN (TREE_OPERAND (init, 0)))
23798 || (TREE_CODE (TREE_OPERAND (init, 0)) == VAR_DECL
23799 && !DECL_EXTERNAL (TREE_OPERAND (init, 0))
23800 && TREE_OPERAND (init, 0) != decl))
23802 dw_die_ref ref;
23803 dw_loc_descr_ref l;
23805 if (TREE_CODE (TREE_OPERAND (init, 0)) == STRING_CST)
23807 rtx rtl = string_cst_pool_decl (TREE_OPERAND (init, 0));
23808 if (!rtl)
23809 return;
23810 decl = SYMBOL_REF_DECL (rtl);
23812 else
23813 decl = TREE_OPERAND (init, 0);
23814 ref = lookup_decl_die (decl);
23815 if (ref == NULL
23816 || (!get_AT (ref, DW_AT_location)
23817 && !get_AT (ref, DW_AT_const_value)))
23818 return;
23819 l = new_loc_descr (DW_OP_GNU_implicit_pointer, 0, offset);
23820 l->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
23821 l->dw_loc_oprnd1.v.val_die_ref.die = ref;
23822 l->dw_loc_oprnd1.v.val_die_ref.external = 0;
23823 add_AT_loc (die, DW_AT_location, l);
23827 /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to
23828 an address in .rodata section if the string literal is emitted there,
23829 or remove the containing location list or replace DW_AT_const_value
23830 with DW_AT_location and empty location expression, if it isn't found
23831 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer
23832 to something that has been emitted in the current CU. */
23834 static void
23835 resolve_addr (dw_die_ref die)
23837 dw_die_ref c;
23838 dw_attr_ref a;
23839 dw_loc_list_ref *curr, *start, loc;
23840 unsigned ix;
23842 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
23843 switch (AT_class (a))
23845 case dw_val_class_loc_list:
23846 start = curr = AT_loc_list_ptr (a);
23847 loc = *curr;
23848 gcc_assert (loc);
23849 /* The same list can be referenced more than once. See if we have
23850 already recorded the result from a previous pass. */
23851 if (loc->replaced)
23852 *curr = loc->dw_loc_next;
23853 else if (!loc->resolved_addr)
23855 /* As things stand, we do not expect or allow one die to
23856 reference a suffix of another die's location list chain.
23857 References must be identical or completely separate.
23858 There is therefore no need to cache the result of this
23859 pass on any list other than the first; doing so
23860 would lead to unnecessary writes. */
23861 while (*curr)
23863 gcc_assert (!(*curr)->replaced && !(*curr)->resolved_addr);
23864 if (!resolve_addr_in_expr ((*curr)->expr))
23866 dw_loc_list_ref next = (*curr)->dw_loc_next;
23867 dw_loc_descr_ref l = (*curr)->expr;
23869 if (next && (*curr)->ll_symbol)
23871 gcc_assert (!next->ll_symbol);
23872 next->ll_symbol = (*curr)->ll_symbol;
23874 if (dwarf_split_debug_info)
23875 remove_loc_list_addr_table_entries (l);
23876 *curr = next;
23878 else
23880 mark_base_types ((*curr)->expr);
23881 curr = &(*curr)->dw_loc_next;
23884 if (loc == *start)
23885 loc->resolved_addr = 1;
23886 else
23888 loc->replaced = 1;
23889 loc->dw_loc_next = *start;
23892 if (!*start)
23894 remove_AT (die, a->dw_attr);
23895 ix--;
23897 break;
23898 case dw_val_class_loc:
23900 dw_loc_descr_ref l = AT_loc (a);
23901 /* For -gdwarf-2 don't attempt to optimize
23902 DW_AT_data_member_location containing
23903 DW_OP_plus_uconst - older consumers might
23904 rely on it being that op instead of a more complex,
23905 but shorter, location description. */
23906 if ((dwarf_version > 2
23907 || a->dw_attr != DW_AT_data_member_location
23908 || l == NULL
23909 || l->dw_loc_opc != DW_OP_plus_uconst
23910 || l->dw_loc_next != NULL)
23911 && !resolve_addr_in_expr (l))
23913 if (dwarf_split_debug_info)
23914 remove_loc_list_addr_table_entries (l);
23915 if (l != NULL
23916 && l->dw_loc_next == NULL
23917 && l->dw_loc_opc == DW_OP_addr
23918 && GET_CODE (l->dw_loc_oprnd1.v.val_addr) == SYMBOL_REF
23919 && SYMBOL_REF_DECL (l->dw_loc_oprnd1.v.val_addr)
23920 && a->dw_attr == DW_AT_location)
23922 tree decl = SYMBOL_REF_DECL (l->dw_loc_oprnd1.v.val_addr);
23923 remove_AT (die, a->dw_attr);
23924 ix--;
23925 optimize_location_into_implicit_ptr (die, decl);
23926 break;
23928 remove_AT (die, a->dw_attr);
23929 ix--;
23931 else
23932 mark_base_types (l);
23934 break;
23935 case dw_val_class_addr:
23936 if (a->dw_attr == DW_AT_const_value
23937 && !resolve_one_addr (&a->dw_attr_val.v.val_addr))
23939 if (AT_index (a) != NOT_INDEXED)
23940 remove_addr_table_entry (a->dw_attr_val.val_entry);
23941 remove_AT (die, a->dw_attr);
23942 ix--;
23944 if (die->die_tag == DW_TAG_GNU_call_site
23945 && a->dw_attr == DW_AT_abstract_origin)
23947 tree tdecl = SYMBOL_REF_DECL (a->dw_attr_val.v.val_addr);
23948 dw_die_ref tdie = lookup_decl_die (tdecl);
23949 if (tdie == NULL
23950 && DECL_EXTERNAL (tdecl)
23951 && DECL_ABSTRACT_ORIGIN (tdecl) == NULL_TREE)
23953 force_decl_die (tdecl);
23954 tdie = lookup_decl_die (tdecl);
23956 if (tdie)
23958 a->dw_attr_val.val_class = dw_val_class_die_ref;
23959 a->dw_attr_val.v.val_die_ref.die = tdie;
23960 a->dw_attr_val.v.val_die_ref.external = 0;
23962 else
23964 if (AT_index (a) != NOT_INDEXED)
23965 remove_addr_table_entry (a->dw_attr_val.val_entry);
23966 remove_AT (die, a->dw_attr);
23967 ix--;
23970 break;
23971 default:
23972 break;
23975 FOR_EACH_CHILD (die, c, resolve_addr (c));
23978 /* Helper routines for optimize_location_lists.
23979 This pass tries to share identical local lists in .debug_loc
23980 section. */
23982 /* Iteratively hash operands of LOC opcode into HSTATE. */
23984 static void
23985 hash_loc_operands (dw_loc_descr_ref loc, inchash::hash &hstate)
23987 dw_val_ref val1 = &loc->dw_loc_oprnd1;
23988 dw_val_ref val2 = &loc->dw_loc_oprnd2;
23990 switch (loc->dw_loc_opc)
23992 case DW_OP_const4u:
23993 case DW_OP_const8u:
23994 if (loc->dtprel)
23995 goto hash_addr;
23996 /* FALLTHRU */
23997 case DW_OP_const1u:
23998 case DW_OP_const1s:
23999 case DW_OP_const2u:
24000 case DW_OP_const2s:
24001 case DW_OP_const4s:
24002 case DW_OP_const8s:
24003 case DW_OP_constu:
24004 case DW_OP_consts:
24005 case DW_OP_pick:
24006 case DW_OP_plus_uconst:
24007 case DW_OP_breg0:
24008 case DW_OP_breg1:
24009 case DW_OP_breg2:
24010 case DW_OP_breg3:
24011 case DW_OP_breg4:
24012 case DW_OP_breg5:
24013 case DW_OP_breg6:
24014 case DW_OP_breg7:
24015 case DW_OP_breg8:
24016 case DW_OP_breg9:
24017 case DW_OP_breg10:
24018 case DW_OP_breg11:
24019 case DW_OP_breg12:
24020 case DW_OP_breg13:
24021 case DW_OP_breg14:
24022 case DW_OP_breg15:
24023 case DW_OP_breg16:
24024 case DW_OP_breg17:
24025 case DW_OP_breg18:
24026 case DW_OP_breg19:
24027 case DW_OP_breg20:
24028 case DW_OP_breg21:
24029 case DW_OP_breg22:
24030 case DW_OP_breg23:
24031 case DW_OP_breg24:
24032 case DW_OP_breg25:
24033 case DW_OP_breg26:
24034 case DW_OP_breg27:
24035 case DW_OP_breg28:
24036 case DW_OP_breg29:
24037 case DW_OP_breg30:
24038 case DW_OP_breg31:
24039 case DW_OP_regx:
24040 case DW_OP_fbreg:
24041 case DW_OP_piece:
24042 case DW_OP_deref_size:
24043 case DW_OP_xderef_size:
24044 hstate.add_object (val1->v.val_int);
24045 break;
24046 case DW_OP_skip:
24047 case DW_OP_bra:
24049 int offset;
24051 gcc_assert (val1->val_class == dw_val_class_loc);
24052 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
24053 hstate.add_object (offset);
24055 break;
24056 case DW_OP_implicit_value:
24057 hstate.add_object (val1->v.val_unsigned);
24058 switch (val2->val_class)
24060 case dw_val_class_const:
24061 hstate.add_object (val2->v.val_int);
24062 break;
24063 case dw_val_class_vec:
24065 unsigned int elt_size = val2->v.val_vec.elt_size;
24066 unsigned int len = val2->v.val_vec.length;
24068 hstate.add_int (elt_size);
24069 hstate.add_int (len);
24070 hstate.add (val2->v.val_vec.array, len * elt_size);
24072 break;
24073 case dw_val_class_const_double:
24074 hstate.add_object (val2->v.val_double.low);
24075 hstate.add_object (val2->v.val_double.high);
24076 break;
24077 case dw_val_class_wide_int:
24078 hstate.add (val2->v.val_wide->get_val (),
24079 get_full_len (*val2->v.val_wide)
24080 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR);
24081 break;
24082 case dw_val_class_addr:
24083 inchash::add_rtx (val2->v.val_addr, hstate);
24084 break;
24085 default:
24086 gcc_unreachable ();
24088 break;
24089 case DW_OP_bregx:
24090 case DW_OP_bit_piece:
24091 hstate.add_object (val1->v.val_int);
24092 hstate.add_object (val2->v.val_int);
24093 break;
24094 case DW_OP_addr:
24095 hash_addr:
24096 if (loc->dtprel)
24098 unsigned char dtprel = 0xd1;
24099 hstate.add_object (dtprel);
24101 inchash::add_rtx (val1->v.val_addr, hstate);
24102 break;
24103 case DW_OP_GNU_addr_index:
24104 case DW_OP_GNU_const_index:
24106 if (loc->dtprel)
24108 unsigned char dtprel = 0xd1;
24109 hstate.add_object (dtprel);
24111 inchash::add_rtx (val1->val_entry->addr.rtl, hstate);
24113 break;
24114 case DW_OP_GNU_implicit_pointer:
24115 hstate.add_int (val2->v.val_int);
24116 break;
24117 case DW_OP_GNU_entry_value:
24118 hstate.add_object (val1->v.val_loc);
24119 break;
24120 case DW_OP_GNU_regval_type:
24121 case DW_OP_GNU_deref_type:
24123 unsigned int byte_size
24124 = get_AT_unsigned (val2->v.val_die_ref.die, DW_AT_byte_size);
24125 unsigned int encoding
24126 = get_AT_unsigned (val2->v.val_die_ref.die, DW_AT_encoding);
24127 hstate.add_object (val1->v.val_int);
24128 hstate.add_object (byte_size);
24129 hstate.add_object (encoding);
24131 break;
24132 case DW_OP_GNU_convert:
24133 case DW_OP_GNU_reinterpret:
24134 if (val1->val_class == dw_val_class_unsigned_const)
24136 hstate.add_object (val1->v.val_unsigned);
24137 break;
24139 /* FALLTHRU */
24140 case DW_OP_GNU_const_type:
24142 unsigned int byte_size
24143 = get_AT_unsigned (val1->v.val_die_ref.die, DW_AT_byte_size);
24144 unsigned int encoding
24145 = get_AT_unsigned (val1->v.val_die_ref.die, DW_AT_encoding);
24146 hstate.add_object (byte_size);
24147 hstate.add_object (encoding);
24148 if (loc->dw_loc_opc != DW_OP_GNU_const_type)
24149 break;
24150 hstate.add_object (val2->val_class);
24151 switch (val2->val_class)
24153 case dw_val_class_const:
24154 hstate.add_object (val2->v.val_int);
24155 break;
24156 case dw_val_class_vec:
24158 unsigned int elt_size = val2->v.val_vec.elt_size;
24159 unsigned int len = val2->v.val_vec.length;
24161 hstate.add_object (elt_size);
24162 hstate.add_object (len);
24163 hstate.add (val2->v.val_vec.array, len * elt_size);
24165 break;
24166 case dw_val_class_const_double:
24167 hstate.add_object (val2->v.val_double.low);
24168 hstate.add_object (val2->v.val_double.high);
24169 break;
24170 case dw_val_class_wide_int:
24171 hstate.add (val2->v.val_wide->get_val (),
24172 get_full_len (*val2->v.val_wide)
24173 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR);
24174 break;
24175 default:
24176 gcc_unreachable ();
24179 break;
24181 default:
24182 /* Other codes have no operands. */
24183 break;
24187 /* Iteratively hash the whole DWARF location expression LOC into HSTATE. */
24189 static inline void
24190 hash_locs (dw_loc_descr_ref loc, inchash::hash &hstate)
24192 dw_loc_descr_ref l;
24193 bool sizes_computed = false;
24194 /* Compute sizes, so that DW_OP_skip/DW_OP_bra can be checksummed. */
24195 size_of_locs (loc);
24197 for (l = loc; l != NULL; l = l->dw_loc_next)
24199 enum dwarf_location_atom opc = l->dw_loc_opc;
24200 hstate.add_object (opc);
24201 if ((opc == DW_OP_skip || opc == DW_OP_bra) && !sizes_computed)
24203 size_of_locs (loc);
24204 sizes_computed = true;
24206 hash_loc_operands (l, hstate);
24210 /* Compute hash of the whole location list LIST_HEAD. */
24212 static inline void
24213 hash_loc_list (dw_loc_list_ref list_head)
24215 dw_loc_list_ref curr = list_head;
24216 inchash::hash hstate;
24218 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
24220 hstate.add (curr->begin, strlen (curr->begin) + 1);
24221 hstate.add (curr->end, strlen (curr->end) + 1);
24222 if (curr->section)
24223 hstate.add (curr->section, strlen (curr->section) + 1);
24224 hash_locs (curr->expr, hstate);
24226 list_head->hash = hstate.end ();
24229 /* Return true if X and Y opcodes have the same operands. */
24231 static inline bool
24232 compare_loc_operands (dw_loc_descr_ref x, dw_loc_descr_ref y)
24234 dw_val_ref valx1 = &x->dw_loc_oprnd1;
24235 dw_val_ref valx2 = &x->dw_loc_oprnd2;
24236 dw_val_ref valy1 = &y->dw_loc_oprnd1;
24237 dw_val_ref valy2 = &y->dw_loc_oprnd2;
24239 switch (x->dw_loc_opc)
24241 case DW_OP_const4u:
24242 case DW_OP_const8u:
24243 if (x->dtprel)
24244 goto hash_addr;
24245 /* FALLTHRU */
24246 case DW_OP_const1u:
24247 case DW_OP_const1s:
24248 case DW_OP_const2u:
24249 case DW_OP_const2s:
24250 case DW_OP_const4s:
24251 case DW_OP_const8s:
24252 case DW_OP_constu:
24253 case DW_OP_consts:
24254 case DW_OP_pick:
24255 case DW_OP_plus_uconst:
24256 case DW_OP_breg0:
24257 case DW_OP_breg1:
24258 case DW_OP_breg2:
24259 case DW_OP_breg3:
24260 case DW_OP_breg4:
24261 case DW_OP_breg5:
24262 case DW_OP_breg6:
24263 case DW_OP_breg7:
24264 case DW_OP_breg8:
24265 case DW_OP_breg9:
24266 case DW_OP_breg10:
24267 case DW_OP_breg11:
24268 case DW_OP_breg12:
24269 case DW_OP_breg13:
24270 case DW_OP_breg14:
24271 case DW_OP_breg15:
24272 case DW_OP_breg16:
24273 case DW_OP_breg17:
24274 case DW_OP_breg18:
24275 case DW_OP_breg19:
24276 case DW_OP_breg20:
24277 case DW_OP_breg21:
24278 case DW_OP_breg22:
24279 case DW_OP_breg23:
24280 case DW_OP_breg24:
24281 case DW_OP_breg25:
24282 case DW_OP_breg26:
24283 case DW_OP_breg27:
24284 case DW_OP_breg28:
24285 case DW_OP_breg29:
24286 case DW_OP_breg30:
24287 case DW_OP_breg31:
24288 case DW_OP_regx:
24289 case DW_OP_fbreg:
24290 case DW_OP_piece:
24291 case DW_OP_deref_size:
24292 case DW_OP_xderef_size:
24293 return valx1->v.val_int == valy1->v.val_int;
24294 case DW_OP_skip:
24295 case DW_OP_bra:
24296 /* If splitting debug info, the use of DW_OP_GNU_addr_index
24297 can cause irrelevant differences in dw_loc_addr. */
24298 gcc_assert (valx1->val_class == dw_val_class_loc
24299 && valy1->val_class == dw_val_class_loc
24300 && (dwarf_split_debug_info
24301 || x->dw_loc_addr == y->dw_loc_addr));
24302 return valx1->v.val_loc->dw_loc_addr == valy1->v.val_loc->dw_loc_addr;
24303 case DW_OP_implicit_value:
24304 if (valx1->v.val_unsigned != valy1->v.val_unsigned
24305 || valx2->val_class != valy2->val_class)
24306 return false;
24307 switch (valx2->val_class)
24309 case dw_val_class_const:
24310 return valx2->v.val_int == valy2->v.val_int;
24311 case dw_val_class_vec:
24312 return valx2->v.val_vec.elt_size == valy2->v.val_vec.elt_size
24313 && valx2->v.val_vec.length == valy2->v.val_vec.length
24314 && memcmp (valx2->v.val_vec.array, valy2->v.val_vec.array,
24315 valx2->v.val_vec.elt_size
24316 * valx2->v.val_vec.length) == 0;
24317 case dw_val_class_const_double:
24318 return valx2->v.val_double.low == valy2->v.val_double.low
24319 && valx2->v.val_double.high == valy2->v.val_double.high;
24320 case dw_val_class_wide_int:
24321 return *valx2->v.val_wide == *valy2->v.val_wide;
24322 case dw_val_class_addr:
24323 return rtx_equal_p (valx2->v.val_addr, valy2->v.val_addr);
24324 default:
24325 gcc_unreachable ();
24327 case DW_OP_bregx:
24328 case DW_OP_bit_piece:
24329 return valx1->v.val_int == valy1->v.val_int
24330 && valx2->v.val_int == valy2->v.val_int;
24331 case DW_OP_addr:
24332 hash_addr:
24333 return rtx_equal_p (valx1->v.val_addr, valy1->v.val_addr);
24334 case DW_OP_GNU_addr_index:
24335 case DW_OP_GNU_const_index:
24337 rtx ax1 = valx1->val_entry->addr.rtl;
24338 rtx ay1 = valy1->val_entry->addr.rtl;
24339 return rtx_equal_p (ax1, ay1);
24341 case DW_OP_GNU_implicit_pointer:
24342 return valx1->val_class == dw_val_class_die_ref
24343 && valx1->val_class == valy1->val_class
24344 && valx1->v.val_die_ref.die == valy1->v.val_die_ref.die
24345 && valx2->v.val_int == valy2->v.val_int;
24346 case DW_OP_GNU_entry_value:
24347 return compare_loc_operands (valx1->v.val_loc, valy1->v.val_loc);
24348 case DW_OP_GNU_const_type:
24349 if (valx1->v.val_die_ref.die != valy1->v.val_die_ref.die
24350 || valx2->val_class != valy2->val_class)
24351 return false;
24352 switch (valx2->val_class)
24354 case dw_val_class_const:
24355 return valx2->v.val_int == valy2->v.val_int;
24356 case dw_val_class_vec:
24357 return valx2->v.val_vec.elt_size == valy2->v.val_vec.elt_size
24358 && valx2->v.val_vec.length == valy2->v.val_vec.length
24359 && memcmp (valx2->v.val_vec.array, valy2->v.val_vec.array,
24360 valx2->v.val_vec.elt_size
24361 * valx2->v.val_vec.length) == 0;
24362 case dw_val_class_const_double:
24363 return valx2->v.val_double.low == valy2->v.val_double.low
24364 && valx2->v.val_double.high == valy2->v.val_double.high;
24365 case dw_val_class_wide_int:
24366 return *valx2->v.val_wide == *valy2->v.val_wide;
24367 default:
24368 gcc_unreachable ();
24370 case DW_OP_GNU_regval_type:
24371 case DW_OP_GNU_deref_type:
24372 return valx1->v.val_int == valy1->v.val_int
24373 && valx2->v.val_die_ref.die == valy2->v.val_die_ref.die;
24374 case DW_OP_GNU_convert:
24375 case DW_OP_GNU_reinterpret:
24376 if (valx1->val_class != valy1->val_class)
24377 return false;
24378 if (valx1->val_class == dw_val_class_unsigned_const)
24379 return valx1->v.val_unsigned == valy1->v.val_unsigned;
24380 return valx1->v.val_die_ref.die == valy1->v.val_die_ref.die;
24381 case DW_OP_GNU_parameter_ref:
24382 return valx1->val_class == dw_val_class_die_ref
24383 && valx1->val_class == valy1->val_class
24384 && valx1->v.val_die_ref.die == valy1->v.val_die_ref.die;
24385 default:
24386 /* Other codes have no operands. */
24387 return true;
24391 /* Return true if DWARF location expressions X and Y are the same. */
24393 static inline bool
24394 compare_locs (dw_loc_descr_ref x, dw_loc_descr_ref y)
24396 for (; x != NULL && y != NULL; x = x->dw_loc_next, y = y->dw_loc_next)
24397 if (x->dw_loc_opc != y->dw_loc_opc
24398 || x->dtprel != y->dtprel
24399 || !compare_loc_operands (x, y))
24400 break;
24401 return x == NULL && y == NULL;
24404 /* Hashtable helpers. */
24406 struct loc_list_hasher : typed_noop_remove <dw_loc_list_struct>
24408 typedef dw_loc_list_struct value_type;
24409 typedef dw_loc_list_struct compare_type;
24410 static inline hashval_t hash (const value_type *);
24411 static inline bool equal (const value_type *, const compare_type *);
24414 /* Return precomputed hash of location list X. */
24416 inline hashval_t
24417 loc_list_hasher::hash (const value_type *x)
24419 return x->hash;
24422 /* Return true if location lists A and B are the same. */
24424 inline bool
24425 loc_list_hasher::equal (const value_type *a, const compare_type *b)
24427 if (a == b)
24428 return 1;
24429 if (a->hash != b->hash)
24430 return 0;
24431 for (; a != NULL && b != NULL; a = a->dw_loc_next, b = b->dw_loc_next)
24432 if (strcmp (a->begin, b->begin) != 0
24433 || strcmp (a->end, b->end) != 0
24434 || (a->section == NULL) != (b->section == NULL)
24435 || (a->section && strcmp (a->section, b->section) != 0)
24436 || !compare_locs (a->expr, b->expr))
24437 break;
24438 return a == NULL && b == NULL;
24441 typedef hash_table<loc_list_hasher> loc_list_hash_type;
24444 /* Recursively optimize location lists referenced from DIE
24445 children and share them whenever possible. */
24447 static void
24448 optimize_location_lists_1 (dw_die_ref die, loc_list_hash_type *htab)
24450 dw_die_ref c;
24451 dw_attr_ref a;
24452 unsigned ix;
24453 dw_loc_list_struct **slot;
24455 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
24456 if (AT_class (a) == dw_val_class_loc_list)
24458 dw_loc_list_ref list = AT_loc_list (a);
24459 /* TODO: perform some optimizations here, before hashing
24460 it and storing into the hash table. */
24461 hash_loc_list (list);
24462 slot = htab->find_slot_with_hash (list, list->hash, INSERT);
24463 if (*slot == NULL)
24464 *slot = list;
24465 else
24466 a->dw_attr_val.v.val_loc_list = *slot;
24469 FOR_EACH_CHILD (die, c, optimize_location_lists_1 (c, htab));
24473 /* Recursively assign each location list a unique index into the debug_addr
24474 section. */
24476 static void
24477 index_location_lists (dw_die_ref die)
24479 dw_die_ref c;
24480 dw_attr_ref a;
24481 unsigned ix;
24483 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
24484 if (AT_class (a) == dw_val_class_loc_list)
24486 dw_loc_list_ref list = AT_loc_list (a);
24487 dw_loc_list_ref curr;
24488 for (curr = list; curr != NULL; curr = curr->dw_loc_next)
24490 /* Don't index an entry that has already been indexed
24491 or won't be output. */
24492 if (curr->begin_entry != NULL
24493 || (strcmp (curr->begin, curr->end) == 0 && !curr->force))
24494 continue;
24496 curr->begin_entry
24497 = add_addr_table_entry (xstrdup (curr->begin),
24498 ate_kind_label);
24502 FOR_EACH_CHILD (die, c, index_location_lists (c));
24505 /* Optimize location lists referenced from DIE
24506 children and share them whenever possible. */
24508 static void
24509 optimize_location_lists (dw_die_ref die)
24511 loc_list_hash_type htab (500);
24512 optimize_location_lists_1 (die, &htab);
24515 /* Output stuff that dwarf requires at the end of every file,
24516 and generate the DWARF-2 debugging info. */
24518 static void
24519 dwarf2out_finish (const char *filename)
24521 limbo_die_node *node, *next_node;
24522 comdat_type_node *ctnode;
24523 unsigned int i;
24524 dw_die_ref main_comp_unit_die;
24526 /* PCH might result in DW_AT_producer string being restored from the
24527 header compilation, so always fill it with empty string initially
24528 and overwrite only here. */
24529 dw_attr_ref producer = get_AT (comp_unit_die (), DW_AT_producer);
24530 producer_string = gen_producer_string ();
24531 producer->dw_attr_val.v.val_str->refcount--;
24532 producer->dw_attr_val.v.val_str = find_AT_string (producer_string);
24534 gen_scheduled_generic_parms_dies ();
24535 gen_remaining_tmpl_value_param_die_attribute ();
24537 /* Add the name for the main input file now. We delayed this from
24538 dwarf2out_init to avoid complications with PCH.
24539 For LTO produced units use a fixed artificial name to avoid
24540 leaking tempfile names into the dwarf. */
24541 if (!in_lto_p)
24542 add_name_attribute (comp_unit_die (), remap_debug_filename (filename));
24543 else
24544 add_name_attribute (comp_unit_die (), "<artificial>");
24545 if (!IS_ABSOLUTE_PATH (filename) || targetm.force_at_comp_dir)
24546 add_comp_dir_attribute (comp_unit_die ());
24547 else if (get_AT (comp_unit_die (), DW_AT_comp_dir) == NULL)
24549 bool p = false;
24550 file_table->traverse<bool *, file_table_relative_p> (&p);
24551 if (p)
24552 add_comp_dir_attribute (comp_unit_die ());
24555 if (deferred_locations_list)
24556 for (i = 0; i < deferred_locations_list->length (); i++)
24558 add_location_or_const_value_attribute (
24559 (*deferred_locations_list)[i].die,
24560 (*deferred_locations_list)[i].variable,
24561 false,
24562 DW_AT_location);
24565 /* Traverse the limbo die list, and add parent/child links. The only
24566 dies without parents that should be here are concrete instances of
24567 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
24568 For concrete instances, we can get the parent die from the abstract
24569 instance. */
24570 for (node = limbo_die_list; node; node = next_node)
24572 dw_die_ref die = node->die;
24573 next_node = node->next;
24575 if (die->die_parent == NULL)
24577 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
24579 if (origin && origin->die_parent)
24580 add_child_die (origin->die_parent, die);
24581 else if (is_cu_die (die))
24583 else if (seen_error ())
24584 /* It's OK to be confused by errors in the input. */
24585 add_child_die (comp_unit_die (), die);
24586 else
24588 /* In certain situations, the lexical block containing a
24589 nested function can be optimized away, which results
24590 in the nested function die being orphaned. Likewise
24591 with the return type of that nested function. Force
24592 this to be a child of the containing function.
24594 It may happen that even the containing function got fully
24595 inlined and optimized out. In that case we are lost and
24596 assign the empty child. This should not be big issue as
24597 the function is likely unreachable too. */
24598 gcc_assert (node->created_for);
24600 if (DECL_P (node->created_for))
24601 origin = get_context_die (DECL_CONTEXT (node->created_for));
24602 else if (TYPE_P (node->created_for))
24603 origin = scope_die_for (node->created_for, comp_unit_die ());
24604 else
24605 origin = comp_unit_die ();
24607 add_child_die (origin, die);
24612 limbo_die_list = NULL;
24614 #if ENABLE_ASSERT_CHECKING
24616 dw_die_ref die = comp_unit_die (), c;
24617 FOR_EACH_CHILD (die, c, gcc_assert (! c->die_mark));
24619 #endif
24620 resolve_addr (comp_unit_die ());
24621 move_marked_base_types ();
24623 for (node = deferred_asm_name; node; node = node->next)
24625 tree decl = node->created_for;
24626 /* When generating LTO bytecode we can not generate new assembler
24627 names at this point and all important decls got theirs via
24628 free-lang-data. */
24629 if (((!flag_generate_lto && !flag_generate_offload)
24630 || DECL_ASSEMBLER_NAME_SET_P (decl))
24631 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
24633 add_linkage_attr (node->die, decl);
24634 move_linkage_attr (node->die);
24638 deferred_asm_name = NULL;
24640 /* Walk through the list of incomplete types again, trying once more to
24641 emit full debugging info for them. */
24642 retry_incomplete_types ();
24644 if (flag_eliminate_unused_debug_types)
24645 prune_unused_types ();
24647 /* Generate separate COMDAT sections for type DIEs. */
24648 if (use_debug_types)
24650 break_out_comdat_types (comp_unit_die ());
24652 /* Each new type_unit DIE was added to the limbo die list when created.
24653 Since these have all been added to comdat_type_list, clear the
24654 limbo die list. */
24655 limbo_die_list = NULL;
24657 /* For each new comdat type unit, copy declarations for incomplete
24658 types to make the new unit self-contained (i.e., no direct
24659 references to the main compile unit). */
24660 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
24661 copy_decls_for_unworthy_types (ctnode->root_die);
24662 copy_decls_for_unworthy_types (comp_unit_die ());
24664 /* In the process of copying declarations from one unit to another,
24665 we may have left some declarations behind that are no longer
24666 referenced. Prune them. */
24667 prune_unused_types ();
24670 /* Generate separate CUs for each of the include files we've seen.
24671 They will go into limbo_die_list. */
24672 if (flag_eliminate_dwarf2_dups)
24673 break_out_includes (comp_unit_die ());
24675 /* Traverse the DIE's and add add sibling attributes to those DIE's
24676 that have children. */
24677 add_sibling_attributes (comp_unit_die ());
24678 for (node = limbo_die_list; node; node = node->next)
24679 add_sibling_attributes (node->die);
24680 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
24681 add_sibling_attributes (ctnode->root_die);
24683 /* When splitting DWARF info, we put some attributes in the
24684 skeleton compile_unit DIE that remains in the .o, while
24685 most attributes go in the DWO compile_unit_die. */
24686 if (dwarf_split_debug_info)
24687 main_comp_unit_die = gen_compile_unit_die (NULL);
24688 else
24689 main_comp_unit_die = comp_unit_die ();
24691 /* Output a terminator label for the .text section. */
24692 switch_to_section (text_section);
24693 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
24694 if (cold_text_section)
24696 switch_to_section (cold_text_section);
24697 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
24700 /* We can only use the low/high_pc attributes if all of the code was
24701 in .text. */
24702 if (!have_multiple_function_sections
24703 || (dwarf_version < 3 && dwarf_strict))
24705 /* Don't add if the CU has no associated code. */
24706 if (text_section_used)
24707 add_AT_low_high_pc (main_comp_unit_die, text_section_label,
24708 text_end_label, true);
24710 else
24712 unsigned fde_idx;
24713 dw_fde_ref fde;
24714 bool range_list_added = false;
24716 if (text_section_used)
24717 add_ranges_by_labels (main_comp_unit_die, text_section_label,
24718 text_end_label, &range_list_added, true);
24719 if (cold_text_section_used)
24720 add_ranges_by_labels (main_comp_unit_die, cold_text_section_label,
24721 cold_end_label, &range_list_added, true);
24723 FOR_EACH_VEC_ELT (*fde_vec, fde_idx, fde)
24725 if (DECL_IGNORED_P (fde->decl))
24726 continue;
24727 if (!fde->in_std_section)
24728 add_ranges_by_labels (main_comp_unit_die, fde->dw_fde_begin,
24729 fde->dw_fde_end, &range_list_added,
24730 true);
24731 if (fde->dw_fde_second_begin && !fde->second_in_std_section)
24732 add_ranges_by_labels (main_comp_unit_die, fde->dw_fde_second_begin,
24733 fde->dw_fde_second_end, &range_list_added,
24734 true);
24737 if (range_list_added)
24739 /* We need to give .debug_loc and .debug_ranges an appropriate
24740 "base address". Use zero so that these addresses become
24741 absolute. Historically, we've emitted the unexpected
24742 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
24743 Emit both to give time for other tools to adapt. */
24744 add_AT_addr (main_comp_unit_die, DW_AT_low_pc, const0_rtx, true);
24745 if (! dwarf_strict && dwarf_version < 4)
24746 add_AT_addr (main_comp_unit_die, DW_AT_entry_pc, const0_rtx, true);
24748 add_ranges (NULL);
24752 if (debug_info_level >= DINFO_LEVEL_TERSE)
24753 add_AT_lineptr (main_comp_unit_die, DW_AT_stmt_list,
24754 debug_line_section_label);
24756 if (have_macinfo)
24757 add_AT_macptr (comp_unit_die (),
24758 dwarf_strict ? DW_AT_macro_info : DW_AT_GNU_macros,
24759 macinfo_section_label);
24761 if (dwarf_split_debug_info)
24763 /* optimize_location_lists calculates the size of the lists,
24764 so index them first, and assign indices to the entries.
24765 Although optimize_location_lists will remove entries from
24766 the table, it only does so for duplicates, and therefore
24767 only reduces ref_counts to 1. */
24768 index_location_lists (comp_unit_die ());
24770 if (addr_index_table != NULL)
24772 unsigned int index = 0;
24773 addr_index_table
24774 ->traverse_noresize<unsigned int *, index_addr_table_entry>
24775 (&index);
24779 if (have_location_lists)
24780 optimize_location_lists (comp_unit_die ());
24782 save_macinfo_strings ();
24784 if (dwarf_split_debug_info)
24786 unsigned int index = 0;
24788 /* Add attributes common to skeleton compile_units and
24789 type_units. Because these attributes include strings, it
24790 must be done before freezing the string table. Top-level
24791 skeleton die attrs are added when the skeleton type unit is
24792 created, so ensure it is created by this point. */
24793 add_top_level_skeleton_die_attrs (main_comp_unit_die);
24794 debug_str_hash->traverse_noresize<unsigned int *, index_string> (&index);
24797 /* Output all of the compilation units. We put the main one last so that
24798 the offsets are available to output_pubnames. */
24799 for (node = limbo_die_list; node; node = node->next)
24800 output_comp_unit (node->die, 0);
24802 hash_table<comdat_type_hasher> comdat_type_table (100);
24803 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
24805 comdat_type_node **slot = comdat_type_table.find_slot (ctnode, INSERT);
24807 /* Don't output duplicate types. */
24808 if (*slot != HTAB_EMPTY_ENTRY)
24809 continue;
24811 /* Add a pointer to the line table for the main compilation unit
24812 so that the debugger can make sense of DW_AT_decl_file
24813 attributes. */
24814 if (debug_info_level >= DINFO_LEVEL_TERSE)
24815 add_AT_lineptr (ctnode->root_die, DW_AT_stmt_list,
24816 (!dwarf_split_debug_info
24817 ? debug_line_section_label
24818 : debug_skeleton_line_section_label));
24820 output_comdat_type_unit (ctnode);
24821 *slot = ctnode;
24824 /* The AT_pubnames attribute needs to go in all skeleton dies, including
24825 both the main_cu and all skeleton TUs. Making this call unconditional
24826 would end up either adding a second copy of the AT_pubnames attribute, or
24827 requiring a special case in add_top_level_skeleton_die_attrs. */
24828 if (!dwarf_split_debug_info)
24829 add_AT_pubnames (comp_unit_die ());
24831 if (dwarf_split_debug_info)
24833 int mark;
24834 unsigned char checksum[16];
24835 struct md5_ctx ctx;
24837 /* Compute a checksum of the comp_unit to use as the dwo_id. */
24838 md5_init_ctx (&ctx);
24839 mark = 0;
24840 die_checksum (comp_unit_die (), &ctx, &mark);
24841 unmark_all_dies (comp_unit_die ());
24842 md5_finish_ctx (&ctx, checksum);
24844 /* Use the first 8 bytes of the checksum as the dwo_id,
24845 and add it to both comp-unit DIEs. */
24846 add_AT_data8 (main_comp_unit_die, DW_AT_GNU_dwo_id, checksum);
24847 add_AT_data8 (comp_unit_die (), DW_AT_GNU_dwo_id, checksum);
24849 /* Add the base offset of the ranges table to the skeleton
24850 comp-unit DIE. */
24851 if (ranges_table_in_use)
24852 add_AT_lineptr (main_comp_unit_die, DW_AT_GNU_ranges_base,
24853 ranges_section_label);
24855 switch_to_section (debug_addr_section);
24856 ASM_OUTPUT_LABEL (asm_out_file, debug_addr_section_label);
24857 output_addr_table ();
24860 /* Output the main compilation unit if non-empty or if .debug_macinfo
24861 or .debug_macro will be emitted. */
24862 output_comp_unit (comp_unit_die (), have_macinfo);
24864 if (dwarf_split_debug_info && info_section_emitted)
24865 output_skeleton_debug_sections (main_comp_unit_die);
24867 /* Output the abbreviation table. */
24868 if (abbrev_die_table_in_use != 1)
24870 switch_to_section (debug_abbrev_section);
24871 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
24872 output_abbrev_section ();
24875 /* Output location list section if necessary. */
24876 if (have_location_lists)
24878 /* Output the location lists info. */
24879 switch_to_section (debug_loc_section);
24880 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
24881 output_location_lists (comp_unit_die ());
24884 output_pubtables ();
24886 /* Output the address range information if a CU (.debug_info section)
24887 was emitted. We output an empty table even if we had no functions
24888 to put in it. This because the consumer has no way to tell the
24889 difference between an empty table that we omitted and failure to
24890 generate a table that would have contained data. */
24891 if (info_section_emitted)
24893 unsigned long aranges_length = size_of_aranges ();
24895 switch_to_section (debug_aranges_section);
24896 output_aranges (aranges_length);
24899 /* Output ranges section if necessary. */
24900 if (ranges_table_in_use)
24902 switch_to_section (debug_ranges_section);
24903 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
24904 output_ranges ();
24907 /* Have to end the macro section. */
24908 if (have_macinfo)
24910 switch_to_section (debug_macinfo_section);
24911 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
24912 output_macinfo ();
24913 dw2_asm_output_data (1, 0, "End compilation unit");
24916 /* Output the source line correspondence table. We must do this
24917 even if there is no line information. Otherwise, on an empty
24918 translation unit, we will generate a present, but empty,
24919 .debug_info section. IRIX 6.5 `nm' will then complain when
24920 examining the file. This is done late so that any filenames
24921 used by the debug_info section are marked as 'used'. */
24922 switch_to_section (debug_line_section);
24923 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
24924 if (! DWARF2_ASM_LINE_DEBUG_INFO)
24925 output_line_info (false);
24927 if (dwarf_split_debug_info && info_section_emitted)
24929 switch_to_section (debug_skeleton_line_section);
24930 ASM_OUTPUT_LABEL (asm_out_file, debug_skeleton_line_section_label);
24931 output_line_info (true);
24934 /* If we emitted any indirect strings, output the string table too. */
24935 if (debug_str_hash || skeleton_debug_str_hash)
24936 output_indirect_strings ();
24939 /* Reset all state within dwarf2out.c so that we can rerun the compiler
24940 within the same process. For use by toplev::finalize. */
24942 void
24943 dwarf2out_c_finalize (void)
24945 last_var_location_insn = NULL;
24946 cached_next_real_insn = NULL;
24947 used_rtx_array = NULL;
24948 incomplete_types = NULL;
24949 decl_scope_table = NULL;
24950 debug_info_section = NULL;
24951 debug_skeleton_info_section = NULL;
24952 debug_abbrev_section = NULL;
24953 debug_skeleton_abbrev_section = NULL;
24954 debug_aranges_section = NULL;
24955 debug_addr_section = NULL;
24956 debug_macinfo_section = NULL;
24957 debug_line_section = NULL;
24958 debug_skeleton_line_section = NULL;
24959 debug_loc_section = NULL;
24960 debug_pubnames_section = NULL;
24961 debug_pubtypes_section = NULL;
24962 debug_str_section = NULL;
24963 debug_str_dwo_section = NULL;
24964 debug_str_offsets_section = NULL;
24965 debug_ranges_section = NULL;
24966 debug_frame_section = NULL;
24967 fde_vec = NULL;
24968 debug_str_hash = NULL;
24969 skeleton_debug_str_hash = NULL;
24970 dw2_string_counter = 0;
24971 have_multiple_function_sections = false;
24972 text_section_used = false;
24973 cold_text_section_used = false;
24974 cold_text_section = NULL;
24975 current_unit_personality = NULL;
24977 deferred_locations_list = NULL;
24979 next_die_offset = 0;
24980 single_comp_unit_die = NULL;
24981 comdat_type_list = NULL;
24982 limbo_die_list = NULL;
24983 deferred_asm_name = NULL;
24984 file_table = NULL;
24985 decl_die_table = NULL;
24986 common_block_die_table = NULL;
24987 decl_loc_table = NULL;
24988 call_arg_locations = NULL;
24989 call_arg_loc_last = NULL;
24990 call_site_count = -1;
24991 tail_call_site_count = -1;
24992 //block_map = NULL;
24993 cached_dw_loc_list_table = NULL;
24994 abbrev_die_table = NULL;
24995 abbrev_die_table_allocated = 0;
24996 abbrev_die_table_in_use = 0;
24997 line_info_label_num = 0;
24998 cur_line_info_table = NULL;
24999 text_section_line_info = NULL;
25000 cold_text_section_line_info = NULL;
25001 separate_line_info = NULL;
25002 info_section_emitted = false;
25003 pubname_table = NULL;
25004 pubtype_table = NULL;
25005 macinfo_table = NULL;
25006 ranges_table = NULL;
25007 ranges_table_allocated = 0;
25008 ranges_table_in_use = 0;
25009 ranges_by_label = 0;
25010 ranges_by_label_allocated = 0;
25011 ranges_by_label_in_use = 0;
25012 have_location_lists = false;
25013 loclabel_num = 0;
25014 poc_label_num = 0;
25015 last_emitted_file = NULL;
25016 label_num = 0;
25017 file_table_last_lookup = NULL;
25018 tmpl_value_parm_die_table = NULL;
25019 generic_type_instances = NULL;
25020 frame_pointer_fb_offset = 0;
25021 frame_pointer_fb_offset_valid = false;
25022 base_types.release ();
25023 XDELETEVEC (producer_string);
25024 producer_string = NULL;
25027 #include "gt-dwarf2out.h"